# Maximize count of corresponding same elements in given Arrays by Rotation

Given two arrays arr1[] and arr2[] of N integers and array arr1[] has distinct elements. The task is to find the maximum count of corresponding same elements in the given arrays by performing cyclic left or right shift on array arr1[].

Examples:

Input: arr1[] = { 6, 7, 3, 9, 5 }, arr2[] = { 7, 3, 9, 5, 6 }
Output: 5
Explanation:
By performing cyclic left shift on array arr1[] by 1.
Updated array arr1[] = {7, 3, 9, 5, 6}.
This rotation contains a maximum number of equal elements between array arr1[] and arr2[].

Input: arr1[] = {1, 3, 2, 4}, arr2[] = {4, 2, 3, 1}
Output: 2
Explanation:
By performing cyclic left shift on array arr1[] by 1.
Updated array arr1[] = {3, 2, 4, 1}
This rotation contains a maximum number of equal elements between array arr1[] and arr2[].

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Approach: This problem can be solved using Greedy Approach. Below are the steps:

1. Store the position of all the elements of the array arr2[] in an array(say store[]).
2. For each element in the array arr1[], do the following:
• Find the difference(say diff) between the position of the current element in arr2[] with the position in arr1[].
• If diff is less than 0 then update diff to (N – diff).
• Store the frequency of current difference diff in a map.
3. After the above steps, the maximum frequency stored in map is the maximum number of equal elements after rotation on arr1[].

Below is the implementation of the above approach:

## C++

 `// C++ program of the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function that prints maximum ` `// equal elements ` `void` `maximumEqual(``int` `a[], ``int` `b[], ` `                  ``int` `n) ` `{ ` ` `  `    ``// Vector to store the index ` `    ``// of elements of array b ` `    ``vector<``int``> store(1e5); ` ` `  `    ``// Storing the positions of ` `    ``// array B ` `    ``for` `(``int` `i = 0; i < n; i++) { ` `        ``store[b[i]] = i + 1; ` `    ``} ` ` `  `    ``// frequency array to keep count ` `    ``// of elements with similar ` `    ``// difference in distances ` `    ``vector<``int``> ans(1e5); ` ` `  `    ``// Iterate through all element in arr1[] ` `    ``for` `(``int` `i = 0; i < n; i++) { ` ` `  `        ``// Calculate number of ` `        ``// shift required to ` `        ``// make current element ` `        ``// equal ` `        ``int` `d = ``abs``(store[a[i]] ` `                    ``- (i + 1)); ` ` `  `        ``// If d is less than 0 ` `        ``if` `(store[a[i]] < i + 1) { ` `            ``d = n - d; ` `        ``} ` ` `  `        ``// Store the frequency ` `        ``// of current diff ` `        ``ans[d]++; ` `    ``} ` ` `  `    ``int` `finalans = 0; ` ` `  `    ``// Compute the maximum frequency ` `    ``// stored ` `    ``for` `(``int` `i = 0; i < 1e5; i++) ` `        ``finalans = max(finalans, ` `                       ``ans[i]); ` ` `  `    ``// Printing the maximum number ` `    ``// of equal elements ` `    ``cout << finalans << ``"\n"``; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given two arrays ` `    ``int` `A[] = { 6, 7, 3, 9, 5 }; ` `    ``int` `B[] = { 7, 3, 9, 5, 6 }; ` ` `  `    ``int` `size = ``sizeof``(A) / ``sizeof``(A[0]); ` ` `  `    ``// Function Call ` `    ``maximumEqual(A, B, size); ` `    ``return` `0; ` `} `

## Java

 `// Java program of the above approach ` `import` `java.util.*; ` `class` `GFG{ ` ` `  `// Function that prints maximum ` `// equal elements ` `static` `void` `maximumEqual(``int` `a[],  ` `                         ``int` `b[], ``int` `n) ` `{ ` ` `  `    ``// Vector to store the index ` `    ``// of elements of array b ` `    ``int` `store[] = ``new` `int``[(``int``) 1e5]; ` ` `  `    ``// Storing the positions of ` `    ``// array B ` `    ``for` `(``int` `i = ``0``; i < n; i++)  ` `    ``{ ` `        ``store[b[i]] = i + ``1``; ` `    ``} ` ` `  `    ``// frequency array to keep count ` `    ``// of elements with similar ` `    ``// difference in distances ` `    ``int` `ans[] = ``new` `int``[(``int``) 1e5]; ` ` `  `    ``// Iterate through all element in arr1[] ` `    ``for` `(``int` `i = ``0``; i < n; i++) ` `    ``{ ` ` `  `        ``// Calculate number of ` `        ``// shift required to ` `        ``// make current element ` `        ``// equal ` `        ``int` `d = Math.abs(store[a[i]] - (i + ``1``)); ` ` `  `        ``// If d is less than 0 ` `        ``if` `(store[a[i]] < i + ``1``)  ` `        ``{ ` `            ``d = n - d; ` `        ``} ` ` `  `        ``// Store the frequency ` `        ``// of current diff ` `        ``ans[d]++; ` `    ``} ` ` `  `    ``int` `finalans = ``0``; ` ` `  `    ``// Compute the maximum frequency ` `    ``// stored ` `    ``for` `(``int` `i = ``0``; i < 1e5; i++) ` `        ``finalans = Math.max(finalans, ` `                            ``ans[i]); ` ` `  `    ``// Printing the maximum number ` `    ``// of equal elements ` `    ``System.out.print(finalans + ``"\n"``); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `    ``// Given two arrays ` `    ``int` `A[] = { ``6``, ``7``, ``3``, ``9``, ``5` `}; ` `    ``int` `B[] = { ``7``, ``3``, ``9``, ``5``, ``6` `}; ` ` `  `    ``int` `size = A.length; ` ` `  `    ``// Function Call ` `    ``maximumEqual(A, B, size); ` `} ` `} ` ` `  `// This code is contributed by sapnasingh4991 `

## Python3

 `# Python3 program for the above approach ` ` `  `# Function that prints maximum ` `# equal elements ` `def` `maximumEqual(a, b, n): ` ` `  `    ``# List to store the index ` `    ``# of elements of array b ` `    ``store ``=` `[``0``] ``*` `10` `*``*` `5` `     `  `    ``# Storing the positions of ` `    ``# array B ` `    ``for` `i ``in` `range``(n): ` `        ``store[b[i]] ``=` `i ``+` `1` ` `  `    ``# Frequency array to keep count ` `    ``# of elements with similar ` `    ``# difference in distances  ` `    ``ans ``=` `[``0``] ``*` `10` `*``*` `5` ` `  `    ``# Iterate through all element  ` `    ``# in arr1[] ` `    ``for` `i ``in` `range``(n): ` ` `  `        ``# Calculate number of shift  ` `        ``# required to make current  ` `        ``# element equal ` `        ``d ``=` `abs``(store[a[i]] ``-` `(i ``+` `1``)) ` ` `  `        ``# If d is less than 0 ` `        ``if` `(store[a[i]] < i ``+` `1``): ` `            ``d ``=` `n ``-` `d ` ` `  `        ``# Store the frequency ` `        ``# of current diff ` `        ``ans[d] ``+``=` `1` `         `  `    ``finalans ``=` `0` ` `  `    ``# Compute the maximum frequency ` `    ``# stored ` `    ``for` `i ``in` `range``(``10` `*``*` `5``): ` `        ``finalans ``=` `max``(finalans, ans[i]) ` ` `  `    ``# Printing the maximum number ` `    ``# of equal elements ` `    ``print``(finalans) ` ` `  `# Driver Code ` `if` `__name__ ``=``=` `'__main__'``: ` ` `  `    ``# Given two arrays ` `    ``A ``=` `[ ``6``, ``7``, ``3``, ``9``, ``5` `] ` `    ``B ``=` `[ ``7``, ``3``, ``9``, ``5``, ``6` `] ` ` `  `    ``size ``=` `len``(A) ` ` `  `    ``# Function Call ` `    ``maximumEqual(A, B, size) ` ` `  ` `  `# This code is contributed by Shivam Singh `

## C#

 `// C# program of the above approach ` `using` `System; ` `class` `GFG{ ` ` `  `// Function that prints maximum ` `// equal elements ` `static` `void` `maximumEqual(``int``[] a,  ` `                         ``int``[] b, ``int` `n) ` `{ ` ` `  `    ``// Vector to store the index ` `    ``// of elements of array b ` `    ``int``[] store = ``new` `int``[(``int``) 1e5]; ` ` `  `    ``// Storing the positions of ` `    ``// array B ` `    ``for``(``int` `i = 0; i < n; i++)  ` `    ``{ ` `       ``store[b[i]] = i + 1; ` `    ``} ` ` `  `    ``// Frequency array to keep count ` `    ``// of elements with similar ` `    ``// difference in distances ` `    ``int``[] ans = ``new` `int``[(``int``) 1e5]; ` ` `  `    ``// Iterate through all element in arr1[] ` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{ ` `        `  `       ``// Calculate number of ` `       ``// shift required to ` `       ``// make current element ` `       ``// equal ` `       ``int` `d = Math.Abs(store[a[i]] - (i + 1)); ` `        `  `       ``// If d is less than 0 ` `       ``if` `(store[a[i]] < i + 1)  ` `       ``{ ` `           ``d = n - d; ` `       ``} ` `        `  `       ``// Store the frequency ` `       ``// of current diff ` `       ``ans[d]++; ` `    ``} ` `     `  `    ``int` `finalans = 0; ` ` `  `    ``// Compute the maximum frequency ` `    ``// stored ` `    ``for``(``int` `i = 0; i < 1e5; i++) ` `       ``finalans = Math.Max(finalans, ans[i]); ` ` `  `    ``// Printing the maximum number ` `    ``// of equal elements ` `    ``Console.Write(finalans + ``"\n"``); ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main() ` `{ ` `     `  `    ``// Given two arrays ` `    ``int``[]A = { 6, 7, 3, 9, 5 }; ` `    ``int``[]B = { 7, 3, 9, 5, 6 }; ` ` `  `    ``int` `size = A.Length; ` ` `  `    ``// Function Call ` `    ``maximumEqual(A, B, size); ` `} ` `} ` ` `  `// This code is contributed by chitranayal `

Output:

```5
```

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

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.

My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Article Tags :
Practice Tags :

3

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.