Skip to content
Related Articles

Related Articles

Check if Array forms an increasing-decreasing sequence or vice versa

View Discussion
Improve Article
Save Article
  • Difficulty Level : Medium
  • Last Updated : 01 Apr, 2022

Given an array arr[] of N integers, the task is to find if the array can be divided into 2 sub-array such that the first sub-array is strictly increasing and the second sub-array is strictly decreasing or vice versa. If the given array can be divided then print “Yes” else print “No”.

Examples: 

Input: arr[] = {3, 1, -2, -2, -1, 3} 
Output: Yes 
Explanation: 
First sub-array {3, 1, -2} which is strictly decreasing and second sub-array is {-2, 1, 3} is strictly increasing.

Input: arr[] = {1, 1, 2, 3, 4, 5} 
Output: No 
Explanation: 
The entire array is increasing. 
 

Naive Approach: The naive idea is to divide the array into two subarrays at every possible index and explicitly check if the first subarray is strictly increasing and the second subarray is strictly decreasing or vice-versa. If we can break any subarray then print “Yes” else print “No”. 
Time Complexity: O(N2) 
Auxiliary Space: O(1)

Efficient Approach: To optimize the above approach, traverse the array and check for the strictly increasing sequence and then check for strictly decreasing subsequence or vice-versa. Below are the steps: 

  1. If arr[1] > arr[0], then check for strictly increasing then strictly decreasing as: 
    • Check for every consecutive pair until at any index i arr[i + 1] is less than arr[i].
    • Now from index i + 1 check for every consecutive pair check if arr[i + 1] is less than arr[i] till the end of the array or not. If at any index i, arr[i] is less than arr[i + 1] then break the loop.
    • If we reach the end in the above step then print “Yes” Else print “No”.
  2. If arr[1] < arr[0], then check for strictly decreasing then strictly increasing as: 
    • Check for every consecutive pair until at any index i arr[i + 1] is greater than arr[i].
    • Now from index i + 1 check for every consecutive pair check if arr[i + 1] is greater than arr[i] till the end of the array or not. If at any index i, arr[i] is greater than arr[i + 1] then break the loop.
    • If we reach the end in the above step then print “Yes” Else print “No”.

Below is the implementation of above approach: 

C++




// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to check if the given array
// forms an increasing decreasing
// sequence or vice versa
bool canMake(int n, int ar[])
{
    // Base Case
    if (n == 1)
        return true;
    else {
 
        // First subarray is
        // strictly increasing
        if (ar[0] < ar[1]) {
 
            int i = 1;
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i < n
                   && ar[i - 1] < ar[i]) {
                i++;
            }
 
            // Check for strictly
            // decreasing condition
            // & find the break point
            while (i + 1 < n
                   && ar[i] > ar[i + 1]) {
                i++;
            }
 
            // If i is equal to
            // length of array
            if (i >= n - 1)
                return true;
            else
                return false;
        }
 
        // First subarray is
        // strictly Decreasing
        else if (ar[0] > ar[1]) {
            int i = 1;
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i < n
                   && ar[i - 1] > ar[i]) {
                i++;
            }
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i + 1 < n
                   && ar[i] < ar[i + 1]) {
                i++;
            }
 
            // If i is equal to
            // length of array - 1
            if (i >= n - 1)
                return true;
            else
                return false;
        }
 
        // Condition if ar[0] == ar[1]
        else {
            for (int i = 2; i < n; i++) {
                if (ar[i - 1] <= ar[i])
                    return false;
            }
            return true;
        }
    }
}
 
// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 1, 2, 3, 4, 5 };
    int n = sizeof arr / sizeof arr[0];
 
    // Function Call
    if (canMake(n, arr)) {
        cout << "Yes";
    }
    else {
        cout << "No";
    }
 
    return 0;
}

Java



// Java program for the above approach
import java.util.*;
class GFG{
 
// Function to check if the given array
// forms an increasing decreasing
// sequence or vice versa
static boolean canMake(int n, int ar[])
{
    // Base Case
    if (n == 1)
        return true;
    else
    {
 
        // First subarray is
        // strictly increasing
        if (ar[0] < ar[1])
        {
 
            int i = 1;
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i < n && ar[i - 1] < ar[i])
            {
                i++;
            }
 
            // Check for strictly
            // decreasing condition
            // & find the break point
            while (i + 1 < n && ar[i] > ar[i + 1])
            {
                i++;
            }
 
            // If i is equal to
            // length of array
            if (i >= n - 1)
                return true;
            else
                return false;
        }
 
        // First subarray is
        // strictly Decreasing
        else if (ar[0] > ar[1])
        {
            int i = 1;
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i < n && ar[i - 1] > ar[i])
            {
                i++;
            }
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i + 1 < n && ar[i] < ar[i + 1])
            {
                i++;
            }
 
            // If i is equal to
            // length of array - 1
            if (i >= n - 1)
                return true;
            else
                return false;
        }
 
        // Condition if ar[0] == ar[1]
        else
        {
            for (int i = 2; i < n; i++)
            {
                if (ar[i - 1] <= ar[i])
                    return false;
            }
            return true;
        }
    }
}
 
// Driver Code
public static void main(String[] args)
{
    // Given array arr[]
    int arr[] = { 1, 2, 3, 4, 5 };
    int n = arr.length;
 
    // Function Call
    if (!canMake(n, arr)) {
        System.out.print("Yes");
    }
    else
    {
        System.out.print("No");
    }
}
}
 
// This code is contributed by Rohit_ranjan
Python3



# Python3 program for the above approach
 
# Function to check if the given array
# forms an increasing decreasing
# sequence or vice versa
def canMake(n, ar):
     
    # Base Case
    if (n == 1):
        return True;
    else:
 
        # First subarray is
        # strictly increasing
        if (ar[0] < ar[1]):
 
            i = 1;
 
            # Check for strictly
            # increasing condition
            # & find the break point
            while (i < n and ar[i - 1] < ar[i]):
                i += 1;
 
            # Check for strictly
            # decreasing condition
            # & find the break point
            while (i + 1 < n and ar[i] > ar[i + 1]):
                i += 1;
 
            # If i is equal to
            # length of array
            if (i >= n - 1):
                return True;
            else:
                return False;
 
        # First subarray is
        # strictly Decreasing
        elif (ar[0] > ar[1]):
            i = 1;
 
            # Check for strictly
            # increasing condition
            # & find the break point
            while (i < n and ar[i - 1] > ar[i]):
                i += 1;
 
            # Check for strictly
            # increasing condition
            # & find the break point
            while (i + 1 < n and ar[i] < ar[i + 1]):
                i += 1;
 
            # If i is equal to
            # length of array - 1
            if (i >= n - 1):
                return True;
            else:
                return False;
 
        # Condition if ar[0] == ar[1]
        else:
            for i in range(2, n):
                if (ar[i - 1] <= ar[i]):
                    return False;
 
            return True;
 
# Driver Code
 
# Given array arr
arr = [1, 2, 3, 4, 5];
n = len(arr);
 
# Function Call
if (canMake(n, arr)==False):
    print("Yes");
else:
    print("No");
 
# This code is contributed by PrinciRaj1992
C#



// C# program for the above approach
using System;
class GFG{
 
// Function to check if the given array
// forms an increasing decreasing
// sequence or vice versa
static bool canMake(int n, int []ar)
{
    // Base Case
    if (n == 1)
        return true;
    else
    {
 
        // First subarray is
        // strictly increasing
        if (ar[0] < ar[1])
        {
 
            int i = 1;
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i < n && ar[i - 1] < ar[i])
            {
                i++;
            }
 
            // Check for strictly
            // decreasing condition
            // & find the break point
            while (i + 1 < n && ar[i] > ar[i + 1])
            {
                i++;
            }
 
            // If i is equal to
            // length of array
            if (i >= n - 1)
                return true;
            else
                return false;
        }
 
        // First subarray is
        // strictly Decreasing
        else if (ar[0] > ar[1])
        {
            int i = 1;
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i < n && ar[i - 1] > ar[i])
            {
                i++;
            }
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i + 1 < n && ar[i] < ar[i + 1])
            {
                i++;
            }
 
            // If i is equal to
            // length of array - 1
            if (i >= n - 1)
                return true;
            else
                return false;
        }
 
        // Condition if ar[0] == ar[1]
        else
        {
            for (int i = 2; i < n; i++)
            {
                if (ar[i - 1] <= ar[i])
                    return false;
            }
            return true;
        }
    }
}
 
// Driver Code
public static void Main(String[] args)
{
    // Given array []arr
    int []arr = { 1, 2, 3, 4, 5 };
    int n = arr.Length;
 
    // Function Call
    if (!canMake(n, arr))
    {
        Console.Write("Yes");
    }
    else
    {
        Console.Write("No");
    }
}
}
 
// This code is contributed by Rajput-Ji
Javascript



<script>
 
// Javascript program for the above approach
 
// Function to check if the given array
// forms an increasing decreasing
// sequence or vice versa
function canMake(n, ar)
{
     
    // Base Case
    if (n == 1)
        return true;
    else
    {
         
        // First subarray is
        // strictly increasing
        if (ar[0] < ar[1])
        {
            let i = 1;
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i < n && ar[i - 1] < ar[i])
            {
                i++;
            }
 
            // Check for strictly
            // decreasing condition
            // & find the break point
            while (i + 1 < n && ar[i] > ar[i + 1])
            {
                i++;
            }
 
            // If i is equal to
            // length of array
            if (i >= n - 1)
                return true;
            else
                return false;
        }
 
        // First subarray is
        // strictly Decreasing
        else if (ar[0] > ar[1])
        {
            let i = 1;
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i < n && ar[i - 1] > ar[i])
            {
                i++;
            }
 
            // Check for strictly
            // increasing condition
            // & find the break point
            while (i + 1 < n && ar[i] < ar[i + 1])
            {
                i++;
            }
 
            // If i is equal to
            // length of array - 1
            if (i >= n - 1)
                return true;
            else
                return false;
        }
 
        // Condition if ar[0] == ar[1]
        else
        {
            for(let i = 2; i < n; i++)
            {
                if (ar[i - 1] <= ar[i])
                    return false;
            }
            return true;
        }
    }
}
 
// Driver Code
 
// Given array arr[]
let arr = [ 1, 2, 3, 4, 5 ];
let n = arr.length;
 
// Function Call
if (!canMake(n, arr))
{
    document.write("Yes");
}
else
{
    document.write("No");
}
 
// This code is contributed by sravan kumar
 
</script>
Output: 
No
 
Time Complexity: O(N) 
Auxiliary Space: O(1)
 

My Personal Notes
arrow_drop_up
Next

Check if an array is increasing or decreasing
Recommended Articles
Page :
Check if array sum of first half is divisible by sum of other half or vice versa
10, Nov 21
Minimize cost to modify the Array such that even indices have even elements and vice versa
15, Oct 21
When to use Array over Linked List and vice versa?
03, Jun 22
Count subarrays with elements in alternate increasing-decreasing order or vice-versa
29, Jan 22
Find original sequence from Array containing the sequence merged many times in order
07, Aug 20
Queries to check if array elements from indices [L, R] forms an Arithmetic Progression or not
09, Apr 21
Check if concatenation of first and last digits forms a prime number or not for each array element
02, Mar 21
Minimum operations required to transform a sequence of numbers to a sequence where a[i]=a[i+2]
30, Oct 18
k-th missing element in increasing sequence which is not present in a given sequence
17, Oct 17
Check if longest connected component forms a palindrome in undirected graph
07, May 20
Check if 2 * K + 1 non-empty strings exists whose concatenation forms the given string
26, Apr 21
Count of subarrays which forms a permutation from given Array elements
21, Jul 20
Longest increasing subsequence which forms a subarray in the sorted representation of the array
21, Sep 20
Find the Array which when sorted forms an AP and has minimum maximum
17, Nov 21
Find elements in Array whose positions forms Arithmetic Progression
15, Mar 22
Largest lexicographic triplet from a given Array that forms a triangle
23, Jul 20
Find all triplets in a sorted array that forms Geometric Progression
05, Aug 16
Check if given Array can be rearranged as increasing, decreasing or a hill sequence
13, Jan 22
Check if array can be converted into strictly decreasing sequence
09, May 20
Check if sequence of removed middle elements from an array is sorted or not
23, Mar 21
Subarray of length K whose concatenation forms a palindrome
06, Oct 20
Construct an array whose Prefix XOR array starting from X is an N-length increasing sequence
29, Jul 21
Check if a Sequence is a concatenation of two permutations
04, Apr 20
Check if a Regular Bracket Sequence can be formed with concatenation of given strings
20, Sep 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
angelina20
@angelina20
Vote for difficulty
Current difficulty :
Medium





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!