# 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:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

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.`

## Javascript

 ``
Output
`YES`

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

My Personal Notes arrow_drop_up