Find an element in an array such that elements form a strictly decreasing and increasing sequence - GeeksforGeeks

19 Jan, 2022
Given an array of positive integers, the task is to find a point/element up to which elements form a strictly decreasing sequence first followed by a sequence of strictly increasing integers.  
Both of the sequences must at least be of length 2 (considering the common element).
The last value of the decreasing sequence is the first value of the increasing sequence.
Note: Print “No such element exist”, if not found.Examples:  
Input: arr[] = {3, 2, 1, 2}
Output: 1
{3, 2, 1} is strictly decreasing 
then {1, 2} is strictly increasing.

Input: arr[] = {3, 2, 1}
Output: No such element exist
 
Approach:  
First start traversing the array and keep traversing till the elements are in strictly decreasing order.If next elements is greater than the previous element store that element in point variable.Start traversing the elements from that point and keep traversing till the elements are in the strictly increasing order.After step 3, if all the elements get traversed then print that point.Else print “No such element exist.”
First start traversing the array and keep traversing till the elements are in strictly decreasing order.
If next elements is greater than the previous element store that element in point variable.
Start traversing the elements from that point and keep traversing till the elements are in the strictly increasing order.
After step 3, if all the elements get traversed then print that point.
Else print “No such element exist.”
Note: If any of the two elements are equal then also print “No such element exist” as it should be strictly decreasing and increasing. Below is the implementation of above approach:  
C++
Java
Python
C#
PHP
Javascript
// C++ implementation of above approach#include <bits/stdc++.h>using namespace std; // Function to check such sequenceint findElement(int a[], int n){     // set increasing/decreasing sequence counter to 1    int inc = 1, dec = 1, point;     // for loop counter from 1 to last index of list    for (int i = 1; i < n; i++) {         // check if current int is        // smaller than previous int        if (a[i] < a[i - 1]) {             // if inc is 1, i.e., increasing            // seq. never started            if (inc == 1)                // increase dec by 1                dec++;             else                return -1;        }         // check if current int is greater than previous int        else if (a[i] > a[i - 1]) {             // if inc is 1, i.e., increasing seq.            // starting for first time,            if (inc == 1)                 // store a[i-1] in point                point = a[i - 1];             // only if decreasing seq. minimum            // count has been met,            if (dec >= 2)                 // increase inc by 1                inc++;             else                 // return -1 as decreasing seq.                // min. count must be 2                return -1;        }         // check if current int is equal        // to previous int, if so,        else if (a[i] == a[i - 1])            return -1;    }     // check if inc >= 2 and dec >= 2    // return point    if (inc >= 2 && dec >= 2)        return point;     // otherwise return -1    else        return -1;} // Driver codeint main(){     int arr[] = { 3, 2, 1, 2 };    int n = sizeof(arr) / sizeof(arr[0]);     int ele = findElement(arr, n);     if (ele == -1)        cout << "No such element exist";    else        cout << ele;    return 0;}
// Java implementation of above approach  public class GFG {         // Function to check such sequence    static int findElement(int a[], int n)    {               // set increasing/decreasing sequence counter to 1        int inc = 1, dec = 1, point = 0;               // for loop counter from 1 to last index of list        for (int i = 1; i < n; i++) {                   // check if current int is            // smaller than previous int            if (a[i] < a[i - 1]) {                       // if inc is 1, i.e., increasing                // seq. never started                if (inc == 1)                    // increase dec by 1                    dec++;                       else                    return -1;            }                   // check if current int is greater than previous int            else if (a[i] > a[i - 1]) {                       // if inc is 1, i.e., increasing seq.                // starting for first time,                if (inc == 1)                           // store a[i-1] in point                    point = a[i - 1];                       // only if decreasing seq. minimum                // count has been met,                if (dec >= 2)                           // increase inc by 1                    inc++;                       else                           // return -1 as decreasing seq.                    // min. count must be 2                    return -1;            }                   // check if current int is equal            // to previous int, if so,            else if (a[i] == a[i - 1])                return -1;        }               // check if inc >= 2 and dec >= 2        // return point        if (inc >= 2 && dec >= 2)            return point;               // otherwise return -1        else            return -1;    }           // Driver code    public static void main(String args[])    {          int arr[] = { 3, 2, 1, 2 };            int n = arr.length ;                       int ele = findElement(arr, n);                       if (ele == -1)                 System.out.println("No such element exist");            else                System.out.println(ele);         }    // This Code is contributed by ANKITRAI1}  
# Python implementation of above approachdef findElement(a, n):     # set increasing sequence counter to 1    inc = 1     # set decreasing sequence counter to 1    dec = 1     # for loop counter from 1 to last    # index of list [len(array)-1]    for i in range(1, n):         # check if current int is smaller than previous int        if(a[i] < a[i-1]):             # if inc is 1, i.e., increasing seq. never started,            if inc == 1:                 # increase dec by 1                dec = dec + 1            else:                 # return -1 since if increasing seq. has started,                # there cannot be a decreasing seq. in a valley                return -1         # check if current int is greater than previous int        elif(a[i] > a[i-1]):             # if inc is 1, i.e., increasing seq.            # starting for first time,            if inc == 1:                 # store a[i-1] in point                point = a[i-1]             # only if decreasing seq. minimum count has been met,            if dec >= 2:                # increase inc by 1                inc = inc + 1            else:                 # return -1 as decreasing seq. min. count must be 2                return -1         # check if current int is equal to previous int, if so,        elif(a[i] == a[i-1]):             # return false as valley is always            # strictly increasing / decreasing            return -1     # check if inc >= 2 and dec >= 2,    if(inc >= 2 and dec >= 2):         # return point        return point    else:         # otherwise return -1        return -1 a = [2, 1, 2]n = len(a)ele = findElement(a, n)if ( ele == -1 ):    print("No such element exist")else:    print(ele)
// C# implementation of above approachusing System; class GFG{ // Function to check such sequencestatic int findElement(int []a, int n){     // set increasing/decreasing    // sequence counter to 1    int inc = 1, dec = 1, point = 0;     // for loop counter from 1 to    // last index of list    for (int i = 1; i < n; i++)    {         // check if current int is        // smaller than previous int        if (a[i] < a[i - 1])        {             // if inc is 1, i.e., increasing            // seq. never started            if (inc == 1)                // increase dec by 1                dec++;             else                return -1;        }         // check if current int is greater        // than previous int        else if (a[i] > a[i - 1])        {             // if inc is 1, i.e., increasing            // seq. starting for first time,            if (inc == 1)                 // store a[i-1] in point                point = a[i - 1];             // only if decreasing seq.            // minimum count has been met,            if (dec >= 2)                 // increase inc by 1                inc++;             else                 // return -1 as decreasing                 // seq. min. count must be 2                return -1;        }         // check if current int is equal        // to previous int, if so,        else if (a[i] == a[i - 1])            return -1;    }     // check if inc >= 2 and    // dec >= 2, return point    if (inc >= 2 && dec >= 2)        return point;     // otherwise return -1    else        return -1;} // Driver codepublic static void Main(){    int []arr = { 3, 2, 1, 2 };    int n = arr.Length ;     int ele = findElement(arr, n);     if (ele == -1)        Console.WriteLine("No such element exist");    else        Console.WriteLine(ele); }} // This code is contributed by Shashank
<?php// PHP implementation of above approach // Function to check such sequencefunction findElement(&$a, $n){     // set increasing/decreasing    // sequence counter to 1    $inc = 1;    $dec = 1;     // for loop counter from 1    // to last index of list    for ($i = 1; $i < $n; $i++)    {         // check if current int is        // smaller than previous int        if ($a[$i] < $a[$i - 1])        {             // if inc is 1, i.e., increasing            // seq. never started            if ($inc == 1)                             // increase dec by 1                $dec++;             else                return -1;        }         // check if current int is greater        // than previous int        else if ($a[$i] > $a[$i - 1])        {             // if inc is 1, i.e., increasing            // seq. starting for first time,            if ($inc == 1)                 // store a[i-1] in point                $point = $a[$i - 1];             // only if decreasing seq.            // minimum count has been met,            if ($dec >= 2)                 // increase inc by 1                $inc++;             else                 // return -1 as decreasing                // seq. min. count must be 2                return -1;        }         // check if current int is equal        // to previous int, if so,        else if ($a[$i] == $a[$i - 1])            return -1;    }     // check if inc >= 2 and    // dec >= 2, return point    if ($inc >= 2 && $dec >= 2)        return $point;     // otherwise return -1    else        return -1;} // Driver code$arr = array(3, 2, 1, 2);$n = sizeof($arr); $ele = findElement($arr, $n); if ($ele == -1)    echo "No such element exist";else    echo $ele; // This code is contributed// by ChitraNayal?>
<script>// Java Script implementation of above approach      // Function to check such sequence    function findElement(a,n)    {                 // set increasing/decreasing sequence counter to 1        let inc = 1, dec = 1, point = 0;                 // for loop counter from 1 to last index of list        for (let i = 1; i < n; i++) {                     // check if current int is            // smaller than previous int            if (a[i] < a[i - 1]) {                         // if inc is 1, i.e., increasing                // seq. never started                if (inc == 1)                    // increase dec by 1                    dec++;                         else                    return -1;            }                     // check if current int is greater than previous int            else if (a[i] > a[i - 1]) {                         // if inc is 1, i.e., increasing seq.                // starting for first time,                if (inc == 1)                             // store a[i-1] in point                    point = a[i - 1];                         // only if decreasing seq. minimum                // count has been met,                if (dec >= 2)                             // increase inc by 1                    inc++;                         else                             // return -1 as decreasing seq.                    // min. count must be 2                    return -1;            }                     // check if current int is equal            // to previous int, if so,            else if (a[i] == a[i - 1])                return -1;        }                 // check if inc >= 2 and dec >= 2        // return point        if (inc >= 2 && dec >= 2)            return point;                 // otherwise return -1        else            return -1;    }             // Driver code             let arr = [3, 2, 1, 2 ];            let n = arr.length ;                         let ele = findElement(arr, n);                         if (ele == -1)                document.write("No such element exist");            else                document.write(ele);       // This code is contributed by sravan kumar Gottumukkala</script>
1
 
Time Complexity: O(n)  
Auxiliary Space: O(1)
ankthon
Shashank12
ukasp
sravankumar8128
samim2000
Traversal
Arrays
Arrays
Traversal
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stack Data Structure (Introduction and Program)
Top 50 Array Coding Problems for Interviews
Multidimensional Arrays in Java
Introduction to Arrays
Linear Search
Maximum and minimum of an array using minimum number of comparisons
Python | Using 2D arrays/lists the right way
Linked List vs Array
Queue | Set 1 (Introduction and Array Implementation)
Find the Missing Number