Related Articles
Modify given array to a non-decreasing array by rotation
• Difficulty Level : Medium
• Last Updated : 03 Mar, 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 array``void` `rotateArray(vector<``int``>& arr, ``int` `N)``{``    ``// Stores copy of original array``    ``vector<``int``> 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 Code``int` `main()``{``    ``// Given array``    ``vector<``int``> 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 approach``import` `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[``0``] = 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 array``def` `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[``0``] ``=` `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 Code``if` `__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 approach``using` `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 code``public` `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.`
Output
```YES
```

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

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up