Skip to content
Related Articles

Related Articles

Improve Article

Count rotations required to sort given array in non-increasing order

  • Last Updated : 19 May, 2021

Given an array arr[] consisting of N integers, the task is to sort the array in non-increasing order by minimum number of anti-clockwise rotations. If it is not possible to sort the array, then print “-1”. Otherwise, print the count of rotations.

Examples:

Input: arr[] = {2, 1, 5, 4, 3}
Output: 2
Explanation: Two anti-clockwise rotations are required to sort the array in decreasing order, i.e. {5, 4, 3, 2, 1}

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

Approach: The idea is to traverse the given array arr[] and count the number of indices satisfying arr[i + 1] > arr[i]. Follow the steps below to solve the problem:



  • Store the count of arr[i + 1] > arr[i] in a variable and also store the index when arr[i+1] > arr[i].
  • If the value of count is N – 1, then the array is sorted in non-decreasing order. The required steps are exactly (N – 1).
  • If the value of count is 0, then the array is already sorted in non-increasing order.
  • If the value of count is 1 and arr[0] ≤ arr[N – 1], then the required number of rotations is equal to (index + 1), by performing shifting of all the numbers upto that index. Also, check if arr[0] ≤ arr[N – 1] to ensure if the sequence is non-increasing.
  • Otherwise, it is not possible to sort the array in non-increasing order.

Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count minimum anti-
// clockwise rotations required to
// sort the array in non-increasing order
void minMovesToSort(int arr[], int N)
{
    // Stores count of arr[i + 1] > arr[i]
    int count = 0;
 
    // Store last index of arr[i+1] > arr[i]
    int index;
 
    // Traverse the given array
    for (int i = 0; i < N - 1; i++) {
 
        // If the adjacent elements are
        // in increasing order
        if (arr[i] < arr[i + 1]) {
 
            // Increment count
            count++;
 
            // Update index
            index = i;
        }
    }
 
    // Print the result according
    // to the following conditions
    if (count == 0) {
        cout << "0";
    }
    else if (count == N - 1) {
        cout << N - 1;
    }
    else if (count == 1
             && arr[0] <= arr[N - 1]) {
        cout << index + 1;
    }
 
    // Otherwise, it is not
    // possible to sort the array
    else {
        cout << "-1";
    }
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 2, 1, 5, 4, 2 };
    int N = sizeof(arr)
            / sizeof(arr[0]);
 
    // Function Call
    minMovesToSort(arr, N);
 
    return 0;
}

Java




// Java program for the above approach
import java.util.*;
   
class GFG{
   
// Function to count minimum anti-
// clockwise rotations required to
// sort the array in non-increasing order
static void minMovesToSort(int arr[], int N)
{
     
    // Stores count of arr[i + 1] > arr[i]
    int count = 0;
  
    // Store last index of arr[i+1] > arr[i]
    int index = 0;
  
    // Traverse the given array
    for(int i = 0; i < N - 1; i++)
    {
         
        // If the adjacent elements are
        // in increasing order
        if (arr[i] < arr[i + 1])
        {
             
            // Increment count
            count++;
  
            // Update index
            index = i;
        }
    }
  
    // Print the result according
    // to the following conditions
    if (count == 0)
    {
        System.out.print("0");
    }
    else if (count == N - 1)
    {
        System.out.print(N - 1);
    }
    else if (count == 1 &&
            arr[0] <= arr[N - 1])
    {
        System.out.print(index + 1);
    }
  
    // Otherwise, it is not
    // possible to sort the array
    else
    {
        System.out.print("-1");
    }
}
   
// Driver Code
public static void main(String[] args)
{
     
    // Given array
    int[] arr = { 2, 1, 5, 4, 2 };
    int N = arr.length;
     
    // Function Call
    minMovesToSort(arr, N);
}
}
 
// This code is contributed by susmitakundugoaldanga

Python3




# Python program for the above approach
  
# Function to count minimum anti-
# clockwise rotations required to
# sort the array in non-increasing order
def minMovesToSort(arr, N) :
     
    # Stores count of arr[i + 1] > arr[i]
    count = 0
  
    # Store last index of arr[i+1] > arr[i]
    index = 0
  
    # Traverse the given array
    for i in range(N-1):
  
        # If the adjacent elements are
        # in increasing order
        if (arr[i] < arr[i + 1]) :
  
            # Increment count
            count += 1
  
            # Update index
            index = i
         
    # Prthe result according
    # to the following conditions
    if (count == 0) :
        print("0")
     
    elif (count == N - 1) :
        print( N - 1)
     
    elif (count == 1
            and arr[0] <= arr[N - 1]) :
        print(index + 1)
     
    # Otherwise, it is not
    # possible to sort the array
    else :
        print("-1")
  
# Driver Code
 
# Given array
arr = [ 2, 1, 5, 4, 2 ]
N = len(arr)
  
# Function Call
minMovesToSort(arr, N)
 
# This code i contributed by sanjoy_62.

C#




// C# program for the above approach
using System;
    
class GFG{
    
// Function to count minimum anti-
// clockwise rotations required to
// sort the array in non-increasing order
static void minMovesToSort(int[] arr, int N)
{
     
    // Stores count of arr[i + 1] > arr[i]
    int count = 0;
   
    // Store last index of arr[i+1] > arr[i]
    int index = 0;
   
    // Traverse the given array
    for(int i = 0; i < N - 1; i++)
    {
         
        // If the adjacent elements are
        // in increasing order
        if (arr[i] < arr[i + 1])
        {
             
            // Increment count
            count++;
   
            // Update index
            index = i;
        }
    }
   
    // Print the result according
    // to the following conditions
    if (count == 0)
    {
        Console.Write("0");
    }
    else if (count == N - 1)
    {
        Console.Write(N - 1);
    }
    else if (count == 1 &&
             arr[0] <= arr[N - 1])
    {
        Console.Write(index + 1);
    }
   
    // Otherwise, it is not
    // possible to sort the array
    else
    {
        Console.Write("-1");
    }
}
    
// Driver Code
public static void Main()
{
     
    // Given array
    int[] arr = { 2, 1, 5, 4, 2 };
    int N = arr.Length;
      
    // Function Call
    minMovesToSort(arr, N);
}
}
 
// This code is contributed by code_hunt

Javascript




<script>
 
// JavaScript program for the above approach
 
    
// Function to count minimum anti-
// clockwise rotations required to
// sort the array in non-increasing order
function minMovesToSort(arr, N)
{
     
    // Stores count of arr[i + 1] > arr[i]
    let count = 0;
   
    // Store last index of arr[i+1] > arr[i]
    let index = 0;
   
    // Traverse the given array
    for(let i = 0; i < N - 1; i++)
    {
         
        // If the adjacent elements are
        // in increasing order
        if (arr[i] < arr[i + 1])
        {
             
            // Increment count
            count++;
   
            // Update index
            index = i;
        }
    }
   
    // Print result according
    // to the following conditions
    if (count == 0)
    {
        document.write("0");
    }
    else if (count == N - 1)
    {
        document.write(N - 1);
    }
    else if (count == 1 &&
             arr[0] <= arr[N - 1])
    {
        document.write(index + 1);
    }
   
    // Otherwise, it is not
    // possible to sort the array
    else
    {
        document.write("-1");
    }
}
    
// Driver Code
 
// Given array
let arr = [2, 1, 5, 4, 2];
let N = arr.length;
  
// Function Call
minMovesToSort(arr, N);
 
 
</script>
Output: 
2

 

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

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.




My Personal Notes arrow_drop_up
Recommended Articles
Page :