Count of rotations required to generate a sorted array
Last Updated :
21 Jul, 2022
Given an array arr[], the task is to find the number of rotations required to convert the given array to sorted form.
Examples:
Input: arr[] = {4, 5, 1, 2, 3}
Output: 2
Explanation:
Sorted array {1, 2, 3, 4, 5} after 2 anti-clockwise rotations.
Input: arr[] = {2, 1, 2, 2, 2}
Output: 1
Explanation:
Sorted array {1, 2, 2, 2, 2} after 1 anti-clockwise rotations.
Naive Approach:
To solve the problem mentioned above the first observation is if we have n elements in the array then after sorting, the largest element is at (n – 1)th position. After k number of anti-clockwise rotations, the largest element will be at index (k – 1) (kth element from start). Another thing to note here is that, after rotation, the next element of the largest element will always be the smallest element, (unless the largest element is at last index, possible if there was no rotation).
Hence,
Number of rotations (k) = index of smallest element (k) in the array
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int countRotation(int arr[], int n)
{
for(int i = 1; i < n; i++)
{
if (arr[i] < arr[i - 1])
{
return i;
}
}
return 0;
}
int main()
{
int arr1[] = { 4, 5, 1, 2, 3 };
int n = sizeof(arr1) / sizeof(int);
cout << countRotation(arr1, n);
}
|
Java
public class GFG {
public static int countRotation(int[] arr,
int n)
{
for (int i = 1; i < n; i++) {
if (arr[i] < arr[i - 1]) {
return i;
}
}
return 0;
}
public static void main(String[] args)
{
int[] arr1 = { 4, 5, 1, 2, 3 };
System.out.println(
countRotation(
arr1,
arr1.length));
}
}
|
Python3
def countRotation(arr, n):
for i in range (1, n):
if (arr[i] < arr[i - 1]):
return i
return 0
if __name__ == "__main__":
arr1 = [ 4, 5, 1, 2, 3 ]
n = len(arr1)
print(countRotation(arr1, n))
|
C#
using System;
class GFG{
public static int countRotation(int[] arr,
int n)
{
for(int i = 1; i < n; i++)
{
if (arr[i] < arr[i - 1])
{
return i;
}
}
return 0;
}
public static void Main(String[] args)
{
int[] arr1 = { 4, 5, 1, 2, 3 };
Console.WriteLine(countRotation(arr1,
arr1.Length));
}
}
|
Javascript
<script>
function countRotation(arr, n)
{
for(let i = 1; i < n; i++)
{
if (arr[i] < arr[i - 1])
{
return i;
}
}
return 0;
}
let arr1 = [ 4, 5, 1, 2, 3 ];
document.write(countRotation(
arr1, arr1.length));
</script>
|
Time Complexity: O(N)
Auxiliary Space: O(1), since no extra space has been taken.
Efficient Approach:
To optimize the above approach, we will use Binary Search. We can notice that, after being sorted and rotated, the given array is divided into two halves with non-decreasing elements, which is the only pre-requisite for binary search. Perform a recursive binary search in the array to find the index of the smallest element.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
int countRotation(int arr[], int low,
int high)
{
if (low > high)
{
return 0;
}
int mid = low + (high - low) / 2;
if (mid < high && arr[mid] > arr[mid + 1])
{
return mid + 1;
}
if (mid > low && arr[mid] < arr[mid - 1])
{
return mid;
}
if (arr[mid] > arr[low])
{
return countRotation(arr, mid + 1,
high);
}
if (arr[mid] < arr[high])
{
return countRotation(arr, low,
mid - 1);
}
else
{
int rightIndex = countRotation(arr,
mid + 1,
high);
int leftIndex = countRotation(arr, low,
mid - 1);
if (rightIndex == 0)
{
return leftIndex;
}
return rightIndex;
}
}
int main()
{
int arr1[] = { 4, 5, 1, 2, 3 };
int N = sizeof(arr1) / sizeof(arr1[0]);
cout << countRotation(arr1, 0, N - 1);
return 0;
}
|
Java
public class GFG {
public static int countRotation(int[] arr,
int low,
int high)
{
if (low > high) {
return 0;
}
int mid = low + (high - low) / 2;
if (mid < high
&& arr[mid] > arr[mid + 1]) {
return mid + 1;
}
if (mid > low
&& arr[mid] < arr[mid - 1]) {
return mid;
}
if (arr[mid] > arr[low]) {
return countRotation(arr,
mid + 1,
high);
}
if (arr[mid] < arr[high]) {
return countRotation(arr,
low,
mid - 1);
}
else {
int rightIndex = countRotation(arr,
mid + 1,
high);
int leftIndex = countRotation(arr,
low,
mid - 1);
if (rightIndex == 0) {
return leftIndex;
}
return rightIndex;
}
}
public static void main(String[] args)
{
int[] arr1 = { 4, 5, 1, 2, 3 };
System.out.println(
countRotation(
arr1,
0, arr1.length
- 1));
}
}
|
Python3
def countRotation(arr, low, high):
if (low > high):
return 0
mid = low + (high - low) // 2
if (mid < high and arr[mid] > arr[mid + 1]):
return mid + 1
if (mid > low and arr[mid] < arr[mid - 1]):
return mid
if (arr[mid] > arr[low]):
return countRotation(arr, mid + 1, high)
if (arr[mid] < arr[high]):
return countRotation(arr, low, mid - 1)
else:
rightIndex = countRotation(arr,
mid + 1,
high)
leftIndex = countRotation(arr, low,
mid - 1)
if (rightIndex == 0):
return leftIndex
return rightIndex
if __name__ == '__main__':
arr1 = [ 4, 5, 1, 2, 3 ]
N = len(arr1)
print(countRotation(arr1, 0, N - 1))
|
C#
using System;
class GFG{
public static int countRotation(int[] arr,
int low,
int high)
{
if (low > high)
{
return 0;
}
int mid = low + (high - low) / 2;
if (mid < high &&
arr[mid] > arr[mid + 1])
{
return mid + 1;
}
if (mid > low &&
arr[mid] < arr[mid - 1])
{
return mid;
}
if (arr[mid] > arr[low])
{
return countRotation(arr,
mid + 1,
high);
}
if (arr[mid] < arr[high])
{
return countRotation(arr, low,
mid - 1);
}
else
{
int rightIndex = countRotation(arr,
mid + 1,
high);
int leftIndex = countRotation(arr, low,
mid - 1);
if (rightIndex == 0)
{
return leftIndex;
}
return rightIndex;
}
}
public static void Main(String[] args)
{
int[] arr1 = { 4, 5, 1, 2, 3 };
Console.WriteLine(countRotation(arr1, 0,
arr1.Length - 1));
}
}
|
Javascript
<script>
function countRotation(arr,low,high)
{
if (low > high) {
return 0;
}
let mid = low + Math.floor((high - low) / 2);
if (mid < high
&& arr[mid] > arr[mid + 1]) {
return mid + 1;
}
if (mid > low
&& arr[mid] < arr[mid - 1]) {
return mid;
}
if (arr[mid] > arr[low]) {
return countRotation(arr,
mid + 1,
high);
}
if (arr[mid] < arr[high])
{
return countRotation(arr,
low,
mid - 1);
}
else
{
let rightIndex = countRotation(arr,
mid + 1,
high);
let leftIndex = countRotation(arr,
low,
mid - 1);
if (rightIndex == 0) {
return leftIndex;
}
return rightIndex;
}
}
let arr1=[4, 5, 1, 2, 3 ];
document.write(
countRotation(
arr1,
0, arr1.length
- 1));
</script>
|
Time Complexity: O(N)
The complexity will be O(logN) for an array without duplicates. But if the array contains duplicates, then it will recursively call the search for both halves. So the worst-case complexity will be O(N).
Auxiliary Space:O(N)
At worst case, the recursion call stack will have N/2 recursion calls at a time.
Similar Reads
Javascript Program to Count of rotations required to generate a sorted array
Given an array arr[], the task is to find the number of rotations required to convert the given array to sorted form.Examples: Input: arr[] = {4, 5, 1, 2, 3}Â Output: 2Â Explanation:Â Sorted array {1, 2, 3, 4, 5} after 2 anti-clockwise rotations. Input: arr[] = {2, 1, 2, 2, 2}Â Output: 1Â Explanation:Â So
4 min read
Rotation Count in a Rotated Sorted array
Given an array arr[] having distinct numbers sorted in increasing order and the array has been right rotated (i.e, the last element will be cyclically shifted to the starting position of the array) k number of times, the task is to find the value of k. Examples: Input: arr[] = {15, 18, 2, 3, 6, 12}O
13 min read
Count rotations required to sort given array in non-increasing order
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: 2Expl
7 min read
Javascript Program to Count rotations required to sort given array in non-increasing order
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: 2Expl
3 min read
Count of Pairs with given sum in Rotated Sorted Array
Given an array arr[] of distinct elements size N that is sorted and then around an unknown point, the task is to count the number of pairs in the array having a given sum X. Examples: Input: arr[] = {11, 15, 26, 38, 9, 10}, X = 35Output: 1Explanation: There is a pair (26, 9) with sum 35 Input: arr[]
13 min read
Minimum number of rotations required to convert given Matrix to another
Given two 2D arrays arr[][] and brr[][] of equal size. The task is to find the minimum number of rotations required either clockwise or anticlockwise to convert arr[][] to brr[][], in the following manner: +x means x rotation in clockwise direction-x means x rotation in anti-clockwise direction0 mea
8 min read
Top Interview Questions and Answers on Counting Sort
Counting Sort is a non-comparison-based sorting algorithm that works well when there is a limited range of input values. It is particularly efficient when the range of input values is not significantly greater compared to the number of elements to be sorted. The basic idea behind Counting Sort is to
5 min read
Quickly find multiple left rotations of an array | Set 1
Given an array of size n and multiple values around which we need to left rotate the array. How to quickly find multiple left rotations? Examples: Input: arr[] = {1, 3, 5, 7, 9} k1 = 1 k2 = 3 k3 = 4 k4 = 6Output: 3 5 7 9 1 7 9 1 3 5 9 1 3 5 7 3 5 7 9 1 Input: arr[] = {1, 3, 5, 7, 9} k1 = 14 Output:
15 min read
Print k different sorted permutations of a given array
Given an array arr[] containing N integers, the task is to print k different permutations of indices such that the values at those indices form a non-decreasing sequence. Print -1 if it is not possible. Examples: Input: arr[] = {1, 3, 3, 1}, k = 3 Output: 0 3 1 2 3 0 1 2 3 0 2 1 For every permutatio
8 min read
Count all the permutation of an array
Given an array of integer A[] with no duplicate elements, write a function that returns the count of all the permutations of an array having no subarray of [i, i+1] for every i in A[]. Examples: Input: 1 3 9 Output: 3Explanation: All the permutations of 1 3 9 are : [1, 3, 9], [1, 9, 3], [3, 9, 1], [
10 min read