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

• Last Updated : 18 Apr, 2022

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:

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