# Javascript Program to Maximize count of corresponding same elements in given permutations using cyclic rotations

Given two permutations **P1** and **P2** of numbers from **1 to N**, the task is to find the maximum count of corresponding same elements in the given permutations by performing a cyclic left or right shift on **P1**. **Examples:**

Input:P1 = [5 4 3 2 1], P2 = [1 2 3 4 5]Output:1Explanation:

We have a matching pair at index 2 for element 3.Input:P1 = [1 3 5 2 4 6], P2 = [1 5 2 4 3 6]Output:3Explanation:

Cyclic shift of second permutation towards right would give 6 1 5 2 4 3, and we get a match of 5, 2, 4. Hence, the answer is 3 matching pairs.

**Naive Approach:** The naive approach is to check for every possible shift in both the left and right direction count the number of matching pairs by looping through all the permutations formed. **Time Complexity:** O(N^{2}) **Auxiliary Space:** O(1)**Efficient Approach:** The above naive approach can be optimized. The idea is for every element to **store the smaller distance** between positions of this element from the left and right sides in separate arrays. Hence, the solution to the problem will be calculated as the **maximum frequency** of an element from the two separated arrays. Below are the steps:

- Store the position of all the elements of the permutation
**P2**in an array(say**store[]**). - For each element in the permutation
**P1**, do the following:- Find the difference(say
**diff**) between the position of the current element in**P2**with the position in**P1**. - If diff is less than 0 then update diff to
**(N – diff)**. - Store the frequency of current difference diff in a map.

- Find the difference(say
- After the above steps, the maximum frequency stored in the map is the maximum number of equal elements after rotation on
**P1**.

Below is the implementation of the above approach:

## Javascript

`<script>` ` ` `// Javascript program for the above approach` ` ` `// Function to maximize the matching` `// pairs between two permutation` `// using left and right rotation` `function` `maximumMatchingPairs(perm1, perm2, n)` `{` ` ` `// Left array store distance of element` ` ` `// from left side and right array store` ` ` `// distance of element from right side` ` ` `var` `left = Array(n);` ` ` `var` `right = Array(n);` ` ` ` ` `// Map to store index of elements` ` ` `var` `mp1 = ` `new` `Map(), mp2 = ` `new` `Map();` ` ` `for` `(` `var` `i = 0; i < n; i++) {` ` ` `mp1.set(perm1[i], i);` ` ` `}` ` ` `for` `(` `var` `j = 0; j < n; j++) {` ` ` `mp2.set(perm2[j], j);` ` ` `}` ` ` ` ` `for` `(` `var` `i = 0; i < n; i++) {` ` ` ` ` `// idx1 is index of element` ` ` `// in first permutation` ` ` ` ` `// idx2 is index of element` ` ` `// in second permutation` ` ` `var` `idx2 = mp2.get(perm1[i]);` ` ` `var` `idx1 = i;` ` ` ` ` `if` `(idx1 == idx2) {` ` ` ` ` `// If element if present on same` ` ` `// index on both permutations then` ` ` `// distance is zero` ` ` `left[i] = 0;` ` ` `right[i] = 0;` ` ` `}` ` ` `else` `if` `(idx1 < idx2) {` ` ` ` ` `// Calculate distance from left` ` ` `// and right side` ` ` `left[i] = (n - (idx2 - idx1));` ` ` `right[i] = (idx2 - idx1);` ` ` `}` ` ` `else` `{` ` ` ` ` `// Calculate distance from left` ` ` `// and right side` ` ` `left[i] = (idx1 - idx2);` ` ` `right[i] = (n - (idx1 - idx2));` ` ` `}` ` ` `}` ` ` ` ` `// Maps to store frequencies of elements` ` ` `// present in left and right arrays` ` ` `var` `freq1 = ` `new` `Map(), freq2 = ` `new` `Map();` ` ` `for` `(` `var` `i = 0; i < n; i++) {` ` ` `if` `(freq1.has(left[i]))` ` ` `freq1.set(left[i], freq1.get(left[i])+1)` ` ` `else` ` ` `freq1.set(left[i], 1)` ` ` ` ` `if` `(freq2.has(right[i]))` ` ` `freq2.set(right[i], freq2.get(right[i])+1)` ` ` `else` ` ` `freq2.set(right[i], 1)` ` ` `}` ` ` ` ` `var` `ans = 0;` ` ` ` ` `for` `(` `var` `i = 0; i < n; i++) {` ` ` ` ` `// Find maximum frequency` ` ` `ans = Math.max(ans, Math.max(freq1.get(left[i]),` ` ` `freq2.get(right[i])));` ` ` `}` ` ` ` ` `// Return the result` ` ` `return` `ans;` `}` ` ` `// Driver Code` `// Given permutations P1 and P2` `var` `P1 = [5, 4, 3, 2, 1];` `var` `P2 = [1, 2, 3, 4, 5];` `var` `n = P1.length;` `// Function Call` `document.write( maximumMatchingPairs(P1, P2, n));` ` ` `</script>` |

**Output:**

1

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

Please refer complete article on Maximize count of corresponding same elements in given permutations using cyclic rotations for more details!