GFG App
Open App
Browser
Continue

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

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