# 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 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[0] = 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.`

## Javascript

 ``

Output

`YES`

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

My Personal Notes arrow_drop_up
Recommended Articles
Page :