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

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:

  1. First start traversing the array and keep traversing till the elements are in strictly decreasing order.
  2. If next elements is greater than the previous element store that element in point variable.
  3. Start traversing the elements from that point and keep traversing till the elements are in the strictly increasing order.
  4. After step 3, if all the elements get traversed then print that point.
  5. 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of above approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to check such sequence
int 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 code
int 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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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
}
   

chevron_right


Python

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python implementation of above approach
def 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)

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of above approach 
using System;
  
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()
{
    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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php 
// PHP implementation of above approach
  
// Function to check such sequence
function 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
?>

chevron_right


Output:

1


My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.



Improved By : Ryuga, Shashank12, Ita_c



Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.