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++
// C++ program to find the
// count of rotations
#include <bits/stdc++.h>
using namespace std;
// Function to return the count
// of rotations
int countRotation(int arr[], int n)
{
for(int i = 1; i < n; i++)
{
// Find the smallest element
if (arr[i] < arr[i - 1])
{
// Return its index
return i;
}
}
// If array is not
// rotated at all
return 0;
}
// Driver Code
int main()
{
int arr1[] = { 4, 5, 1, 2, 3 };
int n = sizeof(arr1) / sizeof(int);
cout << countRotation(arr1, n);
}
// This code is contributed by jrishabh99
// Java Program to find the
// count of rotations
public class GFG {
// Function to return the count of
// rotations
public static int countRotation(int[] arr,
int n)
{
for (int i = 1; i < n; i++) {
// Find the smallest element
if (arr[i] < arr[i - 1]) {
// Return its index
return i;
}
}
// If array is not
// rotated at all
return 0;
}
// Driver Code
public static void main(String[] args)
{
int[] arr1 = { 4, 5, 1, 2, 3 };
System.out.println(
countRotation(
arr1,
arr1.length));
}
}
# Python3 program to find the
# count of rotations
# Function to return the count
# of rotations
def countRotation(arr, n):
for i in range (1, n):
# Find the smallest element
if (arr[i] < arr[i - 1]):
# Return its index
return i
# If array is not
# rotated at all
return 0
# Driver Code
if __name__ == "__main__":
arr1 = [ 4, 5, 1, 2, 3 ]
n = len(arr1)
print(countRotation(arr1, n))
# This code is contributed by chitranayal
// C# program to find the count of rotations
using System;
class GFG{
// Function to return the count of
// rotations
public static int countRotation(int[] arr,
int n)
{
for(int i = 1; i < n; i++)
{
// Find the smallest element
if (arr[i] < arr[i - 1])
{
// Return its index
return i;
}
}
// If array is not
// rotated at all
return 0;
}
// Driver Code
public static void Main(String[] args)
{
int[] arr1 = { 4, 5, 1, 2, 3 };
Console.WriteLine(countRotation(arr1,
arr1.Length));
}
}
// This code is contributed by gauravrajput1
<script>
// JavaScript program to find the
// count of rotations
// Function to return the count of
// rotations
function countRotation(arr, n)
{
for(let i = 1; i < n; i++)
{
// Find the smallest element
if (arr[i] < arr[i - 1])
{
// Return its index
return i;
}
}
// If array is not
// rotated at all
return 0;
}
// Driver Code
let arr1 = [ 4, 5, 1, 2, 3 ];
document.write(countRotation(
arr1, arr1.length));
// This code is contributed by sanjoy_62
</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++
// C++ program to implement the
// above approach
#include <bits/stdc++.h>
using namespace std;
// Function to return the
// count of rotations
int countRotation(int arr[], int low,
int high)
{
// If array is not rotated
if (low > high)
{
return 0;
}
int mid = low + (high - low) / 2;
// Check if current element is
// greater than the next
// element
if (mid < high && arr[mid] > arr[mid + 1])
{
// The next element is
// the smallest
return mid + 1;
}
// Check if current element is
// smaller than it's previous
// element
if (mid > low && arr[mid] < arr[mid - 1])
{
// Current element is
// the smallest
return mid;
}
// Check if current element is
// greater than lower bound
if (arr[mid] > arr[low])
{
// The sequence is increasing
// so far
// Search for smallest
// element on the right
// subarray
return countRotation(arr, mid + 1,
high);
}
if (arr[mid] < arr[high])
{
// Smallest element lies on the
// left subarray
return countRotation(arr, low,
mid - 1);
}
else
{
// Search for the smallest
// element on both subarrays
int rightIndex = countRotation(arr,
mid + 1,
high);
int leftIndex = countRotation(arr, low,
mid - 1);
if (rightIndex == 0)
{
return leftIndex;
}
return rightIndex;
}
}
// Driver code
int main()
{
int arr1[] = { 4, 5, 1, 2, 3 };
int N = sizeof(arr1) / sizeof(arr1[0]);
cout << countRotation(arr1, 0, N - 1);
return 0;
}
// This code is contributed by divyeshrabadiya07
// Java Program to implement
// the above approach
public class GFG {
// Function to return the
// count of rotations
public static int countRotation(int[] arr,
int low,
int high)
{
// If array is not rotated
if (low > high) {
return 0;
}
int mid = low + (high - low) / 2;
// Check if current element is
// greater than the next
// element
if (mid < high
&& arr[mid] > arr[mid + 1]) {
// the next element is
// the smallest
return mid + 1;
}
// Check if current element is
// smaller than it's previous
// element
if (mid > low
&& arr[mid] < arr[mid - 1]) {
// Current element is
// the smallest
return mid;
}
// Check if current element is
// greater than lower bound
if (arr[mid] > arr[low]) {
// The sequence is increasing
// so far
// Search for smallest
// element on the right
// subarray
return countRotation(arr,
mid + 1,
high);
}
if (arr[mid] < arr[high]) {
// Smallest element lies on the
// left subarray
return countRotation(arr,
low,
mid - 1);
}
else {
// Search for the smallest
// element on both subarrays
int rightIndex = countRotation(arr,
mid + 1,
high);
int leftIndex = countRotation(arr,
low,
mid - 1);
if (rightIndex == 0) {
return leftIndex;
}
return rightIndex;
}
}
// Driver Program
public static void main(String[] args)
{
int[] arr1 = { 4, 5, 1, 2, 3 };
System.out.println(
countRotation(
arr1,
0, arr1.length
- 1));
}
}
# Python3 program to implement the
# above approach
# Function to return the
# count of rotations
def countRotation(arr, low, high):
# If array is not rotated
if (low > high):
return 0
mid = low + (high - low) // 2
# Check if current element is
# greater than the next
# element
if (mid < high and arr[mid] > arr[mid + 1]):
# The next element is
# the smallest
return mid + 1
# Check if current element is
# smaller than it's previous
# element
if (mid > low and arr[mid] < arr[mid - 1]):
# Current element is
# the smallest
return mid
# Check if current element is
# greater than lower bound
if (arr[mid] > arr[low]):
# The sequence is increasing
# so far
# Search for smallest
# element on the right
# subarray
return countRotation(arr, mid + 1, high)
if (arr[mid] < arr[high]):
# Smallest element lies on the
# left subarray
return countRotation(arr, low, mid - 1)
else:
# Search for the smallest
# element on both subarrays
rightIndex = countRotation(arr,
mid + 1,
high)
leftIndex = countRotation(arr, low,
mid - 1)
if (rightIndex == 0):
return leftIndex
return rightIndex
# Driver code
if __name__ == '__main__':
arr1 = [ 4, 5, 1, 2, 3 ]
N = len(arr1)
print(countRotation(arr1, 0, N - 1))
# This code is contributed by mohit kumar 29
// C# program to implement
// the above approach
using System;
class GFG{
// Function to return the
// count of rotations
public static int countRotation(int[] arr,
int low,
int high)
{
// If array is not rotated
if (low > high)
{
return 0;
}
int mid = low + (high - low) / 2;
// Check if current element is
// greater than the next
// element
if (mid < high &&
arr[mid] > arr[mid + 1])
{
// The next element is
// the smallest
return mid + 1;
}
// Check if current element is
// smaller than it's previous
// element
if (mid > low &&
arr[mid] < arr[mid - 1])
{
// Current element is
// the smallest
return mid;
}
// Check if current element is
// greater than lower bound
if (arr[mid] > arr[low])
{
// The sequence is increasing
// so far
// Search for smallest
// element on the right
// subarray
return countRotation(arr,
mid + 1,
high);
}
if (arr[mid] < arr[high])
{
// Smallest element lies on the
// left subarray
return countRotation(arr, low,
mid - 1);
}
else
{
// Search for the smallest
// element on both subarrays
int rightIndex = countRotation(arr,
mid + 1,
high);
int leftIndex = countRotation(arr, low,
mid - 1);
if (rightIndex == 0)
{
return leftIndex;
}
return rightIndex;
}
}
// Driver code
public static void Main(String[] args)
{
int[] arr1 = { 4, 5, 1, 2, 3 };
Console.WriteLine(countRotation(arr1, 0,
arr1.Length - 1));
}
}
// This code is contributed by 29AjayKumar
<script>
// Javascript Program to implement
// the above approach
// Function to return the
// count of rotations
function countRotation(arr,low,high)
{
// If array is not rotated
if (low > high) {
return 0;
}
let mid = low + Math.floor((high - low) / 2);
// Check if current element is
// greater than the next
// element
if (mid < high
&& arr[mid] > arr[mid + 1]) {
// the next element is
// the smallest
return mid + 1;
}
// Check if current element is
// smaller than it's previous
// element
if (mid > low
&& arr[mid] < arr[mid - 1]) {
// Current element is
// the smallest
return mid;
}
// Check if current element is
// greater than lower bound
if (arr[mid] > arr[low]) {
// The sequence is increasing
// so far
// Search for smallest
// element on the right
// subarray
return countRotation(arr,
mid + 1,
high);
}
if (arr[mid] < arr[high])
{
// Smallest element lies on the
// left subarray
return countRotation(arr,
low,
mid - 1);
}
else
{
// Search for the smallest
// element on both subarrays
let rightIndex = countRotation(arr,
mid + 1,
high);
let leftIndex = countRotation(arr,
low,
mid - 1);
if (rightIndex == 0) {
return leftIndex;
}
return rightIndex;
}
}
// Driver Program
let arr1=[4, 5, 1, 2, 3 ];
document.write(
countRotation(
arr1,
0, arr1.length
- 1));
// This code is contributed by avanitrachhadiya2155
</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}Ou
12 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
Minimum number of swaps required to sort an array | Set 2
Given an array of N distinct elements, find the minimum number of swaps required to sort the array. Note: The problem is not asking to sort the array by the minimum number of swaps. The problem is to find the minimum swaps in which the array can be sorted. Examples: Input: arr[] = {4, 3, 2, 1} Outpu
7 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