# Count clockwise array rotations required to maximize count of array elements present at indices same as their value

• Last Updated : 01 Jun, 2021

Given an array arr[] consisting of a permutation of first N natural numbers, the task is to find the minimum number of clockwise circular rotations of the array required to maximise the number of elements satisfying the condition arr[i] = i ( 1-based indexing ) where 1 ≤ i ≤ N.

Examples:

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.

Input: arr[] = {4, 5, 1, 2, 3}
Output: 3
Explanation: Rotating the array thrice, the array modifies to {1, 2, 3, 4, 5}. All the array elements satisfy the condition arr[i] = i.

Input: arr[] = {3, 4, 1, 5, 2}
Output: 2
Explanation: Rotating the array twice, the array modifies to {5, 2, 3, 4, 1}. Three array elements satisfy the condition arr[i] = i, which is the maximum possible for the given array.

Approach: Follow the steps below to solve the problem:

• Initialize two integers maxi and ans, and two arrays new_arr[] and freq[].
• Traverse the array arr[] an for each element, count the number of indices separating it from its correct position, i.e |(arr[i] – i + N) % N|.
• Store the counts for each array element in a new array new_arr[].
• Store the count of frequencies of each element in new_arr[] in the array freq[].
• Print the element ith maximum frequency as the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ``using` `namespace` `std;` `// Function to count the number of``// clockwise array rotations required``// to maximize count of array elements``// present at indices same as their value``void` `find_min_rot(``int` `arr[], ``int` `n)``{``    ``// Stores count of indices separating``    ``// elements from its correct position``    ``int` `new_arr[n + 1];``    ``int` `maxi = 1, ans = 0;` `    ``// Stores frequencies of counts of``    ``// indices separating``    ``int` `freq[n + 1];``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``freq[i] = 0;``    ``}` `    ``// Count indices separating each``    ``// element from its correct position``    ``for` `(``int` `i = 1; i <= n; i++) {` `        ``new_arr[i] = (arr[i] - i + n) % n;``    ``}` `    ``// Update frequencies of counts obtained``    ``for` `(``int` `i = 1; i <= n; i++) {` `        ``freq[new_arr[i]]++;``    ``}` `    ``// Find the count with maximum frequency``    ``for` `(``int` `i = 1; i <= n; i++) {``        ``if` `(freq[i] > maxi) {``            ``maxi = freq[i];``            ``ans = i;``        ``}``    ``}` `    ``// Print the answer``    ``cout << ans << endl;``}` `// Driver Code``int` `main()``{` `    ``int` `N = 5;``    ``int` `arr[] = { -1, 3, 4, 1, 5, 2 };` `    ``// Find minimum number of``    ``// array rotations required``    ``find_min_rot(arr, N);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;``   ` `class` `GFG{``   ` `// Function to count the number of``// clockwise array rotations required``// to maximize count of array elements``// present at indices same as their value``static` `void` `find_min_rot(``int` `arr[], ``int` `n)``{``    ` `    ``// Stores count of indices separating``    ``// elements from its correct position``    ``int``[] new_arr = ``new` `int``[n + ``1``];``    ``int` `maxi = ``1``, ans = ``0``;`` ` `    ``// Stores frequencies of counts of``    ``// indices separating``    ``int``[] freq = ``new` `int``[n + ``1``];``    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ``freq[i] = ``0``;``    ``}`` ` `    ``// Count indices separating each``    ``// element from its correct position``    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ``new_arr[i] = (arr[i] - i + n) % n;``    ``}`` ` `    ``// Update frequencies of counts obtained``    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ``freq[new_arr[i]]++;``    ``}`` ` `    ``// Find the count with maximum frequency``    ``for``(``int` `i = ``1``; i <= n; i++)``    ``{``        ``if` `(freq[i] > maxi)``        ``{``            ``maxi = freq[i];``            ``ans = i;``        ``}``    ``}`` ` `    ``// Print the answer``    ``System.out.print(ans);``}``   ` `// Driver Code``public` `static` `void` `main(String[] args)``{``    ``int` `N = ``5``;``    ``int``[] arr = { -``1``, ``3``, ``4``, ``1``, ``5``, ``2` `};`` ` `    ``// Find minimum number of``    ``// array rotations required``    ``find_min_rot(arr, N);``}``}` `// This code is contributed by sanjoy_62`

## Python3

 `# Python3 program for the above approach`` ` `# Function to count the number of``# clockwise array rotations required``# to maximize count of array elements``# present at indices same as their value``def` `find_min_rot(arr, n):``    ` `    ``# Stores count of indices separating``    ``# elements from its correct position``    ``new_arr ``=` `[``0``] ``*` `(n ``+` `1``)``    ``maxi ``=` `1``    ``ans ``=` `0`` ` `    ``# Stores frequencies of counts of``    ``# indices separating``    ``freq ``=` `[``0``] ``*` `(n ``+` `1``)``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``freq[i] ``=` `0`` ` `    ``# Count indices separating each``    ``# element from its correct position``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``         ``new_arr[i] ``=` `(arr[i] ``-` `i ``+` `n) ``%` `n`` ` `    ``# Update frequencies of counts obtained``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``freq[new_arr[i]] ``+``=` `1`` ` `    ``# Find the count with maximum frequency``    ``for` `i ``in` `range``(``1``, n ``+` `1``):``        ``if` `(freq[i] > maxi):``            ``maxi ``=` `freq[i]``            ``ans ``=` `i``            ` `    ``# Print the answer``    ``print``(ans)`` ` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:`` ` `    ``N ``=` `5``    ``arr ``=` `[ ``-``1``, ``3``, ``4``, ``1``, ``5``, ``2` `]`` ` `    ``# Find minimum number of``    ``# array rotations required``    ``find_min_rot(arr, N)``    ` `# This code is contributed by jana_sayantan`

## C#

 `// C# program for the above approach``using` `System;` `class` `GFG``{``   ` `// Function to count the number of``// clockwise array rotations required``// to maximize count of array elements``// present at indices same as their value``static` `void` `find_min_rot(``int` `[]arr, ``int` `n)``{``    ` `    ``// Stores count of indices separating``    ``// elements from its correct position``    ``int``[] new_arr = ``new` `int``[n + 1];``    ``int` `maxi = 1, ans = 0;`` ` `    ``// Stores frequencies of counts of``    ``// indices separating``    ``int``[] freq = ``new` `int``[n + 1];``    ``for``(``int` `i = 1; i <= n; i++)``    ``{``        ``freq[i] = 0;``    ``}`` ` `    ``// Count indices separating each``    ``// element from its correct position``    ``for``(``int` `i = 1; i <= n; i++)``    ``{``        ``new_arr[i] = (arr[i] - i + n) % n;``    ``}`` ` `    ``// Update frequencies of counts obtained``    ``for``(``int` `i = 1; i <= n; i++)``    ``{``        ``freq[new_arr[i]]++;``    ``}`` ` `    ``// Find the count with maximum frequency``    ``for``(``int` `i = 1; i <= n; i++)``    ``{``        ``if` `(freq[i] > maxi)``        ``{``            ``maxi = freq[i];``            ``ans = i;``        ``}``    ``}`` ` `    ``// Print the answer``    ``Console.Write(ans);``}``   ` `// Driver Code``public` `static` `void` `Main(String[] args)``{``    ``int` `N = 5;``    ``int``[] arr = { -1, 3, 4, 1, 5, 2 };`` ` `    ``// Find minimum number of``    ``// array rotations required``    ``find_min_rot(arr, N);``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``
Output:
`2`

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

My Personal Notes arrow_drop_up