Python3 Program to Count of rotations required to generate a sorted array
Last Updated :
06 Sep, 2024
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:
Python
# 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
Time Complexity: O(N)
Auxiliary Space: O(1)
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:
Python
# 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
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.
Please refer complete article on
Count of rotations required to generate a sorted array for more details!
Similar Reads
Python3 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: 2Explan
3 min read
Python3 Program to Count rotations in sorted and rotated linked list Given a linked list of n nodes which is first sorted, then rotated by k elements. Find the value of k.The idea is to traverse singly linked list to check condition whether current node value is greater than value of next node. If the given condition is true, then break the loop. Otherwise increase t
3 min read
Python3 Program to Generate all rotations of a number Given an integer n, the task is to generate all the left shift numbers possible. A left shift number is a number that is generated when all the digits of the number are shifted one position to the left and the digit at the first position is shifted to the last.Examples: Input: n = 123 Output: 231 31
2 min read
Python3 Program to Find the Mth element of the Array after K left rotations Given non-negative integers K, M, and an array arr[] with N elements find the Mth element of the array after K left rotations.Examples:Input: arr[] = {3, 4, 5, 23}, K = 2, M = 1Output: 5Explanation: The array after first left rotation a1[ ] = {4, 5, 23, 3}The array after second left rotation a2[ ] =
2 min read
Python3 Program for Minimum rotations required to get the same string Given a string, we need to find the minimum number of rotations required to get the same string.Examples:Input : s = "geeks"Output : 5Input : s = "aaaa"Output : 1Method 1: The idea is based on below post.A Program to check if strings are rotations of each other or notStep 1 : Initialize result = 0 (
2 min read
Python Program to Count Inversions of size three in a given array Given an array arr[] of size n. Three elements arr[i], arr[j] and arr[k] form an inversion of size 3 if a[i] > a[j] >a[k] and i < j < k. Find total number of inversions of size 3.Example : Input: {8, 4, 2, 1} Output: 4 The four inversions are (8,4,2), (8,4,1), (4,2,1) and (8,2,1). Input:
4 min read
Python3 Program to Find Mth element after K Right Rotations of an Array Python3 # Python3 program to implement # the above approach # Function to return Mth element of # array after k right rotations def getFirstElement(a, N, K, M): # The array comes to original state # after N rotations K %= N # If K is greater or equal to M if (K >= M): # Mth element after k right
1 min read
Python3 Program to Check if it is possible to sort the array after rotating it Given an array of size N, the task is to determine whether its possible to sort the array or not by just one shuffle. In one shuffle, we can shift some contiguous elements from the end of the array and place it in the front of the array.For eg: A = {2, 3, 1, 2}, we can shift {1, 2} from the end of t
3 min read
Python3 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: YesExplanation: After 2
3 min read
Python3 Program for Check if an array is sorted and rotated Given an array of N distinct integers. The task is to write a program to check if this array is sorted and rotated counter-clockwise. A sorted array is not considered as sorted and rotated, i.e., there should at least one rotation.Examples: Input : arr[] = { 3, 4, 5, 1, 2 }Output : YESThe above arra
3 min read