Given an array arr[] of length N, the task is to check whether the given array forms a valley or not. An array is said to be a valley if there is a point till which the array is non-increasing and after that increases in nature. Formally arr[0] ? arr[1] ? . . . ? arr[i] ? arr[i+1] ? . . . ? arr[N-1] and arr[0] > arr[i] and arr[i] < arr[N-1], where i is any index in the range [1, N-2].
Note: An array with only a single element is also considered to be a valley.
Input: N = 6 arr[] = {5, 4, 4, 3, 2, 2}
Output: NoInput: N = 8 arr[] = {5, 4, 4, 3, 4, 4, 5, 6}
Output: YesInput: N = 5 arr[] = {4, 5, 5, 6, 4}
Output: No
Approach: The problem can be solved using linear iteration based on the following idea:
Find any index i, such that all the elements before that are in non-increasing order and after that all the elements are in non-decreasing order.
Follow the steps to solve the problem:
- Traverse from the start to the index (say idx) where the current element becomes greater than the previous.
- From that index traverse till the end and check if they are in non-decreasing order.
- Finally, check if arr[idx-1] is less than both arr[0] and arr[N-1].
- If the above conditions are satisfied, return “Yes”. Otherwise, the array does not form a valley.
Below is the code for the discussed approach:
// C++ code to implement the approach #include <bits/stdc++.h> using namespace std;
// Function for checking if the given array // forms a valley or not int isValley(vector< int >& a, int n)
{ int idx = 0;
for ( int i = 1; i < n; i++) {
// Index where monoticity
// of the given array changes
if (a[i] > a[i - 1]) {
idx = i;
break ;
}
}
if (idx == 0)
return 0;
for ( int i = idx + 1; i < n; i++) {
if (a[i] < a[i - 1])
return 0;
}
if (a[idx - 1] >= a[0] or a[idx - 1] >= a[n - 1])
return 0;
return 1;
} // Driver Code int main()
{ vector< int > arr = { 5, 4, 4, 3, 2, 2 };
int N = arr.size();
int sol = isValley(arr, N);
if (sol)
cout << "Yes\n" ;
else
cout << "No\n" ;
return 0;
} |
// Java code to implement the approach import java.io.*;
class GFG {
// Function for checking if the given array
// forms a valley or not
static boolean isValley( int [] a, int n)
{
int idx = 0 ;
for ( int i = 1 ; i < n; i++) {
if (a[i] > a[i - 1 ]) {
idx = i;
break ;
}
}
if (idx == 0 ) {
return false ;
}
for ( int i = idx + 1 ; i < n; i++) {
if (a[i] < a[i - 1 ])
return false ;
}
if (a[idx - 1 ] >= a[ 0 ] || a[idx - 1 ] >= a[n - 1 ])
return false ;
return true ;
}
public static void main(String[] args)
{
int [] arr = { 5 , 4 , 4 , 3 , 2 , 2 };
int N = arr.length;
boolean sol = isValley(arr, N);
if (sol) {
System.out.println( "Yes" );
}
else {
System.out.println( "No" );
}
}
} // This code is contributed by lokesh. |
// C# code to implement the approach using System;
class GFG {
// Function for checking if the given array // forms a valley or not static bool isValley( int [] a, int n)
{ int idx = 0;
for ( int i = 1; i < n; i++) {
if (a[i] > a[i - 1]) {
idx = i;
break ;
}
}
if (idx == 0) {
return false ;
}
for ( int i = idx + 1; i < n; i++) {
if (a[i] < a[i - 1])
return false ;
}
if (a[idx - 1] >= a[0] || a[idx - 1] >= a[n - 1])
return false ;
return true ;
} public static void Main()
{ int [] arr = { 5, 4, 4, 3, 2, 2 };
int N = arr.Length;
bool sol = isValley(arr, N);
if (sol) {
Console.Write( "Yes" );
}
else {
Console.Write( "No" );
}
} } // This code is contributed by Pushpesh Raj. |
// JavaScript code to implement the approach // Function for checking if the given array // forms a valley or not function isValley(a, n)
{ let idx = 0;
for (let i = 1; i < n; i++) {
// Index where monoticity
// of the given array changes
if (a[i] > a[i - 1]) {
idx = i;
break ;
}
}
if (idx == 0)
return 0;
for (let i = idx + 1; i < n; i++) {
if (a[i] < a[i - 1])
return 0;
}
if (a[idx - 1] >= a[0] || a[idx - 1] >= a[n - 1])
return 0;
return 1;
} // Driver Code let arr = [5, 4, 4, 3, 2, 2];
let N = arr.length;
let sol = isValley(arr, N);
if (sol)
console.log( "Yes" );
else
console.log( "No" );
// This code is contributed by poojaagarwal2. |
# Python3 code for the above approach # Function for checking if the given array forms a valley or not def isValley(a, n):
idx = 0
# Index where monoticity of the given array changes
for i in range ( 1 , n):
if a[i] > a[i - 1 ]:
idx = i
break
if idx = = 0 :
return 0
for i in range (idx + 1 , n):
if a[i] < a[i - 1 ]:
return 0
if a[idx - 1 ] > = a[ 0 ] or a[idx - 1 ] > = a[n - 1 ]:
return 0
return 1
# Driver Code
arr = [ 5 , 4 , 4 , 3 , 2 , 2 ]
N = len (arr)
sol = isValley(arr, N)
if sol:
print ( "Yes" )
else :
print ( "No" )
#This code is contributed by Potta Lokesh |
No
Time Complexity: O(N)
Auxiliary Space: O(1)
Related Articles:
- Introduction to Arrays – Data Structures and Algorithms Tutorials
- Find whether given Array is in form of a mountain or not