Related Articles

# 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 ≤ 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 ≤ 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 ``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 <= 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);` `    ``// 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 <= 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

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