Sunday, February 22, 2026
HomeLanguagesJavaJava Program to Modify given array to a non-decreasing array by rotation

Java Program to Modify given array to a non-decreasing array by rotation

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:

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.


Output

YES

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

Please refer complete article on Modify given array to a non-decreasing array by rotation for more details!

RELATED ARTICLES

Most Popular

Dominic
32506 POSTS0 COMMENTS
Milvus
131 POSTS0 COMMENTS
Nango Kala
6882 POSTS0 COMMENTS
Nicole Veronica
12005 POSTS0 COMMENTS
Nokonwaba Nkukhwana
12099 POSTS0 COMMENTS
Shaida Kate Naidoo
7011 POSTS0 COMMENTS
Ted Musemwa
7255 POSTS0 COMMENTS
Thapelo Manthata
6967 POSTS0 COMMENTS
Umr Jansen
6956 POSTS0 COMMENTS