Modify given array to a non-decreasing array by rotation

• Difficulty Level : Medium
• Last Updated : 01 Jul, 2021

Given an array arr[] of size N (consisting of duplicates), the task is to check if the given array can be converted to a non-decreasing array by rotating it. If it’s not possible to do so, then print “No“. Otherwise, print “Yes“.

Examples:

Input: arr[] = {3, 4, 5, 1, 2}
Output: Yes
Explanation: After 2 right rotations, the array arr[] modifies to {1, 2, 3, 4, 5}

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

Approach: The idea is based on the fact that a maximum of N distinct arrays can be obtained by rotating the given array and check for each individual rotated array, whether it is non-decreasing or not. Follow the steps below to solve the problem:

• Initialize a vector, say v, and copy all the elements of the original array into it.
• Sort the vector v.
• Traverse the original array and perform the following steps:
• Rotate by 1 in each iteration.
• If the array becomes equal to vector v, print “Yes“. Otherwise, print “No“.

Below is the implementation of the above approach:

C++

 // C++ program for the above approach #include using namespace std; // Function to check if a// non-decreasing array can be obtained// by rotating the original arrayvoid rotateArray(vector& arr, int N){    // Stores copy of original array    vector v = arr;     // Sort the given vector    sort(v.begin(), v.end());     // Traverse the array    for (int i = 1; i <= N; ++i) {         // Rotate the array by 1        rotate(arr.begin(),               arr.begin() + 1, arr.end());         // If array is sorted        if (arr == v) {             cout << "YES" << endl;            return;        }    }     // If it is not possible to    // sort the array    cout << "NO" << endl;} // Driver Codeint main(){    // Given array    vector arr = { 3, 4, 5, 1, 2 };     // Size of the array    int N = arr.size();     // Function call to check if it is possible    // to make array non-decreasing by rotating    rotateArray(arr, N);}

Java

 // Java program for the above approachimport java.util.*; class GFG{   // Function to check if a  // non-decreasing array can be obtained  // by rotating the original array  static void rotateArray(int[] arr, int N)  {    // Stores copy of original array    int[] v = arr;     // Sort the given vector    Arrays.sort(v);     // Traverse the array    for (int i = 1; i <= N; ++i) {       // Rotate the array by 1      int x = arr[N - 1];      i = N - 1;      while(i > 0){        arr[i] = arr[i - 1];        arr = x;        i -= 1;      }       // If array is sorted      if (arr == v) {         System.out.print("YES");        return;      }    }     // If it is not possible to    // sort the array    System.out.print("NO");  }   // Driver Code  public static void main(String[] args)  {     // Given array    int[] arr = { 3, 4, 5, 1, 2 };     // Size of the array    int N = arr.length;     // Function call to check if it is possible    // to make array non-decreasing by rotating    rotateArray(arr, N);  }} // This code is contributed by splevel62.

Python3

 # Python 3 program for the above approach  # Function to check if a# non-decreasing array can be obtained# by rotating the original arraydef rotateArray(arr, N):       # Stores copy of original array    v = arr     # Sort the given vector    v.sort(reverse = False)     # Traverse the array    for i in range(1, N + 1, 1):               # Rotate the array by 1        x = arr[N - 1]        i = N - 1        while(i > 0):            arr[i] = arr[i - 1]            arr = x            i -= 1                     # If array is sorted        if (arr == v):            print("YES")            return     # If it is not possible to    # sort the array    print("NO") # Driver Codeif __name__ == '__main__':       # Given array    arr =  [3, 4, 5, 1, 2]     # Size of the array    N = len(arr)     # Function call to check if it is possible    # to make array non-decreasing by rotating    rotateArray(arr, N)         # This code is contributed by ipg2016107.

C#

 // C# program to implement// the above approachusing System;class GFG{     // Function to check if a  // non-decreasing array can be obtained  // by rotating the original array  static void rotateArray(int[] arr, int N)  {         // Stores copy of original array    int[] v = arr;     // Sort the given vector    Array.Sort(v);     // Traverse the array    for (int i = 1; i <= N; ++i) {       // Rotate the array by 1      int x = arr[N - 1];      i = N - 1;      while(i > 0){        arr[i] = arr[i - 1];        arr = x;        i -= 1;      }       // If array is sorted      if (arr == v) {         Console.Write("YES");        return;      }    }     // If it is not possible to    // sort the array    Console.Write("NO");  }  // Driver codepublic static void Main(){    // Given array    int[] arr = { 3, 4, 5, 1, 2 };     // Size of the array    int N = arr.Length;     // Function call to check if it is possible    // to make array non-decreasing by rotating    rotateArray(arr, N);}} // This code is contributed by susmitakundugoaldanga.

Javascript


Output
YES

Time Complexity: O(N2)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up