Check if it is possible to make array increasing or decreasing by rotating the array

Given an array arr[] of N distinct elements, the task is to check if it is possible to make the array increasing or decreasing by rotating the array in any direction.

Examples:

Input: arr[] = {4, 5, 6, 2, 3}
Output: Yes
Array can be rotated as {2, 3, 4, 5, 6}



Input: arr[] = {1, 2, 4, 3, 5}
Output: No

Approach: There are four possibilities:

  • If the array is already increasing then the answer is Yes.
  • If the array is already decreasing then the answer is Yes.
  • If the array can be made increasing, this can be possible if the given array is first increasing up to the maximum element and then decreasing.
  • If the array can be made decreasing, this can be possible if the given array is first decreasing up to the minimum element and then increasing.

If it is not possible to make the array increasing or decreasing then print No.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function that returns true if the array
// can be made increasing or decreasing
// after rotating it in any direction
bool isPossible(int a[], int n)
{
    // If size of the array is less than 3
    if (n <= 2)
        return true;
  
    int flag = 0;
    // Check if the array is already decreasing
    for (int i = 0; i < n - 2; i++) {
        if (!(a[i] > a[i + 1] and a[i + 1] > a[i + 2])) {
            flag = 1;
            break;
        }
    }
  
    // If the array is already decreasing
    if (flag == 0)
        return true;
  
    flag = 0;
    // Check if the array is already increasing
    for (int i = 0; i < n - 2; i++) {
        if (!(a[i] < a[i + 1] and a[i + 1] < a[i + 2])) {
            flag = 1;
            break;
        }
    }
  
    // If the array is already increasing
    if (flag == 0)
        return true;
  
    // Find the indices of the minimum
    // and the maximum value
    int val1 = INT_MAX, mini = -1, val2 = INT_MIN, maxi;
    for (int i = 0; i < n; i++) {
        if (a[i] < val1) {
            mini = i;
            val1 = a[i];
        }
        if (a[i] > val2) {
            maxi = i;
            val2 = a[i];
        }
    }
  
    flag = 1;
    // Check if we can make array increasing
    for (int i = 0; i < maxi; i++) {
        if (a[i] > a[i + 1]) {
            flag = 0;
            break;
        }
    }
  
    // If the array is increasing upto max index
    // and minimum element is right to maximum
    if (flag == 1 and maxi + 1 == mini) {
        flag = 1;
        // Check if array increasing again or not
        for (int i = mini; i < n - 1; i++) {
            if (a[i] > a[i + 1]) {
                flag = 0;
                break;
            }
        }
        if (flag == 1)
            return true;
    }
  
    flag = 1;
    // Check if we can make array decreasing
    for (int i = 0; i < mini; i++) {
        if (a[i] < a[i + 1]) {
            flag = 0;
            break;
        }
    }
  
    // If the array is decreasing upto min index
    // and minimum element is left to maximum
    if (flag == 1 and maxi - 1 == mini) {
        flag = 1;
  
        // Check if array decreasing again or not
        for (int i = maxi; i < n - 1; i++) {
            if (a[i] < a[i + 1]) {
                flag = 0;
                break;
            }
        }
        if (flag == 1)
            return true;
    }
  
    // If it is not possible to make the
    // array inreasing or decreasing
    return false;
}
  
// Driver code
int main()
{
    int a[] = { 4, 5, 6, 2, 3 };
    int n = sizeof(a) / sizeof(a[0]);
  
    if (isPossible(a, n))
        cout << "Yes";
    else
        cout << "No";
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
class GFG
{
      
// Function that returns true if the array
// can be made increasing or decreasing
// after rotating it in any direction
static boolean isPossible(int a[], int n)
{
    // If size of the array is less than 3
    if (n <= 2)
        return true;
  
    int flag = 0;
      
    // Check if the array is already decreasing
    for (int i = 0; i < n - 2; i++) 
    {
        if (!(a[i] > a[i + 1] && 
              a[i + 1] > a[i + 2]))
        {
            flag = 1;
            break;
        }
    }
  
    // If the array is already decreasing
    if (flag == 0)
        return true;
  
    flag = 0;
      
    // Check if the array is already increasing
    for (int i = 0; i < n - 2; i++)
    {
        if (!(a[i] < a[i + 1] && 
              a[i + 1] < a[i + 2]))
        {
            flag = 1;
            break;
        }
    }
  
    // If the array is already increasing
    if (flag == 0)
        return true;
  
    // Find the indices of the minimum
    // && the maximum value
    int val1 = Integer.MAX_VALUE, mini = -1
        val2 = Integer.MIN_VALUE, maxi = 0;
    for (int i = 0; i < n; i++)
    {
        if (a[i] < val1) 
        {
            mini = i;
            val1 = a[i];
        }
        if (a[i] > val2)
        {
            maxi = i;
            val2 = a[i];
        }
    }
  
    flag = 1;
      
    // Check if we can make array increasing
    for (int i = 0; i < maxi; i++) 
    {
        if (a[i] > a[i + 1]) 
        {
            flag = 0;
            break;
        }
    }
  
    // If the array is increasing upto max index
    // && minimum element is right to maximum
    if (flag == 1 && maxi + 1 == mini)
    {
        flag = 1;
          
        // Check if array increasing again or not
        for (int i = mini; i < n - 1; i++) 
        {
            if (a[i] > a[i + 1]) 
            {
                flag = 0;
                break;
            }
        }
        if (flag == 1)
            return true;
    }
  
    flag = 1;
      
    // Check if we can make array decreasing
    for (int i = 0; i < mini; i++) 
    {
        if (a[i] < a[i + 1])
        {
            flag = 0;
            break;
        }
    }
  
    // If the array is decreasing upto min index
    // && minimum element is left to maximum
    if (flag == 1 && maxi - 1 == mini)
    {
        flag = 1;
  
        // Check if array decreasing again or not
        for (int i = maxi; i < n - 1; i++) 
        {
            if (a[i] < a[i + 1]) 
            {
                flag = 0;
                break;
            }
        }
        if (flag == 1)
            return true;
    }
  
    // If it is not possible to make the
    // array inreasing or decreasing
    return false;
}
  
// Driver code
public static void main(String args[])
{
    int a[] = { 4, 5, 6, 2, 3 };
    int n = a.length;
  
    if (isPossible(a, n))
        System.out.println( "Yes");
    else
        System.out.println( "No");
}
}
  
// This code is contributed by Arnab Kundu

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
import sys
  
# Function that returns True if the array
# can be made increasing or decreasing
# after rotating it in any direction
def isPossible(a, n):
  
    # If size of the array is less than 3
    if (n <= 2):
        return True;
  
    flag = 0;
      
    # Check if the array is already decreasing
    for i in range(n - 2):
        if (not(a[i] > a[i + 1] and 
                a[i + 1] > a[i + 2])): 
            flag = 1;
            break;
          
    # If the array is already decreasing
    if (flag == 0):
        return True;
  
    flag = 0;
      
    # Check if the array is already increasing
    for i in range(n - 2): 
        if (not(a[i] < a[i + 1] and 
                a[i + 1] < a[i + 2])): 
            flag = 1;
            break;
          
    # If the array is already increasing
    if (flag == 0):
        return True;
  
    # Find the indices of the minimum
    # and the maximum value
    val1 = sys.maxsize; mini = -1
    val2 = -sys.maxsize; maxi = -1;
    for i in range(n): 
        if (a[i] < val1): 
            mini = i;
            val1 = a[i];
          
        if (a[i] > val2): 
            maxi = i;
            val2 = a[i];
      
    flag = 1;
      
    # Check if we can make array increasing
    for i in range(maxi):
        if (a[i] > a[i + 1]): 
            flag = 0;
            break;
  
    # If the array is increasing upto max index
    # and minimum element is right to maximum
    if (flag == 1 and maxi + 1 == mini): 
        flag = 1;
          
        # Check if array increasing again or not
        for i in range(mini, n - 1):
            if (a[i] > a[i + 1]): 
                flag = 0;
                break;
              
        if (flag == 1):
            return True;
      
    flag = 1;
      
    # Check if we can make array decreasing
    for i in range(mini):
        if (a[i] < a[i + 1]): 
            flag = 0;
            break;
          
    # If the array is decreasing upto min index
    # and minimum element is left to maximum
    if (flag == 1 and maxi - 1 == mini): 
        flag = 1;
  
        # Check if array decreasing again or not
        for i in range(maxi, n - 1):
            if (a[i] < a[i + 1]): 
                flag = 0;
                break;
          
        if (flag == 1):
            return True;
      
    # If it is not possible to make the
    # array inreasing or decreasing
    return False;
  
# Driver code
a = [ 4, 5, 6, 2, 3 ];
n = len(a);
  
if (isPossible(a, n)):
    print("Yes");
else:
    print("No");
  
# This code is contributed by Rajput-Ji

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach 
using System;
  
class GFG 
          
    // Function that returns true if the array 
    // can be made increasing or decreasing 
    // after rotating it in any direction 
    static bool isPossible(int []a, int n) 
    
        // If size of the array is less than 3 
        if (n <= 2) 
            return true
      
        int flag = 0; 
          
        // Check if the array is already decreasing 
        for (int i = 0; i < n - 2; i++) 
        
            if (!(a[i] > a[i + 1] && 
                  a[i + 1] > a[i + 2])) 
            
                flag = 1; 
                break
            
        
      
        // If the array is already decreasing 
        if (flag == 0) 
            return true
      
        flag = 0; 
          
        // Check if the array is already increasing 
        for (int i = 0; i < n - 2; i++) 
        
            if (!(a[i] < a[i + 1] && 
                  a[i + 1] < a[i + 2])) 
            
                flag = 1; 
                break
            
        
      
        // If the array is already increasing 
        if (flag == 0) 
            return true
      
        // Find the indices of the minimum 
        // && the maximum value 
        int val1 = int.MaxValue, mini = -1, 
            val2 = int.MinValue, maxi = 0; 
        for (int i = 0; i < n; i++) 
        
            if (a[i] < val1) 
            
                mini = i; 
                val1 = a[i]; 
            
            if (a[i] > val2) 
            
                maxi = i; 
                val2 = a[i]; 
            
        
      
        flag = 1; 
          
        // Check if we can make array increasing 
        for (int i = 0; i < maxi; i++) 
        
            if (a[i] > a[i + 1]) 
            
                flag = 0; 
                break
            
        
      
        // If the array is increasing upto max index 
        // && minimum element is right to maximum 
        if (flag == 1 && maxi + 1 == mini) 
        
            flag = 1; 
              
            // Check if array increasing again or not 
            for (int i = mini; i < n - 1; i++) 
            
                if (a[i] > a[i + 1]) 
                
                    flag = 0; 
                    break
                
            
            if (flag == 1) 
                return true
        
      
        flag = 1; 
          
        // Check if we can make array decreasing 
        for (int i = 0; i < mini; i++) 
        
            if (a[i] < a[i + 1]) 
            
                flag = 0; 
                break
            
        
      
        // If the array is decreasing upto min index 
        // && minimum element is left to maximum 
        if (flag == 1 && maxi - 1 == mini) 
        
            flag = 1; 
      
            // Check if array decreasing again or not 
            for (int i = maxi; i < n - 1; i++) 
            
                if (a[i] < a[i + 1]) 
                
                    flag = 0; 
                    break
                
            
            if (flag == 1) 
                return true
        
      
        // If it is not possible to make the 
        // array inreasing or decreasing 
        return false
    
      
    // Driver code 
    public static void Main() 
    
        int []a = { 4, 5, 6, 2, 3 }; 
        int n = a.Length; 
      
        if (isPossible(a, n)) 
            Console.WriteLine( "Yes"); 
        else
            Console.WriteLine( "No"); 
    
}
  
// This code is contributed by AnkitRai01

chevron_right


Output:

Yes



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.