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

• Difficulty Level : Easy
• Last Updated : 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.

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++

 `// C++ implementation of above approach``#include ``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);` `    ``int` `ele = findElement(arr, n);` `    ``if` `(ele == -1)``        ``cout << ``"No such element exist"``;``    ``else``        ``cout << ele;``    ``return` `0;``}`

## Java

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

 `# 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)`

## C#

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

## PHP

 ` ``\$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``?>`

## Javascript

 ``

Output:

`1`

Time Complexity: O(n)

Auxiliary Space: O(1)

My Personal Notes arrow_drop_up