# Smallest number to be added in first Array modulo M to make frequencies of both Arrays equal

Given two arrays A[] and B[] consisting of N positive integers and a integer M, the task is to find the minimum value of X such that operation (A[i] + X) % M performed on every element of array A[] results in the formation of an array with frequency of elements same as that in another given array B[].

Examples:

Input: N = 4, M = 3, A[] = {0, 0, 2, 1}, B[] = {2, 0, 1, 1}
Output:
Explanation:
Modifying the given array A[] to { (0+1)%3, (0+1)%3, (2+1)%3, (1+1)%3 }
= { 1%3, 1%3, 3%3, 2%3 },
= { 1, 1, 0, 2 }, which is equivalent to B[] in terms of frequency of distinct elements.

Input: N = 5, M = 10, A[] = {0, 0, 0, 1, 2}, B[] = {2, 1, 0, 0, 0}
Output:
Explanation:
Frequency of elements in both the arrays are already equal.

Approach: This problem can be solved by using Greedy Approach. Follow the steps below:

• There will be at least one possible value of X such that for every index i, ( A[i] + X ) % M = B[0].
• Find all the possible values of X that convert each element of A[] to the first element of B[].
• Check whether these possible X values satisfy the other remaining values of B[].
• If there are multiple answers, take the minimum value of X.

Below is the implementation of the above approach:

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Utility function to find` `// the answer` `int` `moduloEquality(``int` `A[], ``int` `B[],` `                   ``int` `n, ``int` `m)` `{`   `    ``// Stores the frequncies of` `    ``// array elements` `    ``map<``int``, ``int``> mapA, mapB;`   `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``mapA[A[i]]++;` `        ``mapB[B[i]]++;` `    ``}`   `    ``// Stores the possible values` `    ``// of X` `    ``set<``int``> possibleValues;`   `    ``int` `FirstElement = B[0];` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``int` `cur = A[i];`   `        ``// Generate possible positive` `        ``// values of X` `        ``possibleValues` `            ``.insert(` `                ``cur > FirstElement` `                    ``? m - cur + FirstElement` `                    ``: FirstElement - cur);` `    ``}`   `    ``// Initialize answer` `    ``// to MAX value` `    ``int` `ans = INT_MAX;`   `    ``for` `(``auto` `it :` `         ``possibleValues) {`   `        ``// Flag to check if the` `        ``// current element of the` `        ``// set can be considered` `        ``bool` `posible = ``true``;`   `        ``for` `(``auto` `it2 : mapA) {`   `            ``// If the frequency of an element` `            ``// in A[] is not equal to that` `            ``// in B[] after the operation` `            ``if` `(it2.second` `                ``!= mapB[(it2.first + it) % m]) {`   `                ``// Current set element` `                ``// cannot be considered` `                ``posible = ``false``;` `                ``break``;` `            ``}` `        ``}`   `        ``// Update minimum value of X` `        ``if` `(posible) {` `            ``ans = min(ans, it);` `        ``}` `    ``}` `    ``return` `ans;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `n = 4;` `    ``int` `m = 3;`   `    ``int` `A[] = { 0, 0, 2, 1 };` `    ``int` `B[] = { 2, 0, 1, 1 };`   `    ``cout << moduloEquality(A, B, n, m)` `         ``<< endl;`   `    ``return` `0;` `}`

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Utility function to find` `// the answer` `static` `int` `moduloEquality(``int` `A[], ``int` `B[],` `                          ``int` `n, ``int` `m)` `{` `    `  `    ``// Stores the frequncies of` `    ``// array elements` `    ``HashMap mapA = ``new` `HashMap();` `    ``HashMap mapB = ``new` `HashMap();`   `    ``for``(``int` `i = ``0``; i < n; i++)` `    ``{` `        ``if` `(mapA.containsKey(A[i]))` `        ``{` `            ``mapA.put(A[i], mapA.get(A[i]) + ``1``);` `        ``}` `        ``else` `        ``{` `            ``mapA.put(A[i], ``1``);` `        ``}` `        ``if` `(mapB.containsKey(B[i]))` `        ``{` `            ``mapB.put(B[i], mapB.get(B[i]) + ``1``);` `        ``}` `        ``else` `        ``{` `            ``mapB.put(B[i], ``1``);` `        ``}` `    ``}`   `    ``// Stores the possible values` `    ``// of X` `    ``HashSet possibleValues = ``new` `HashSet();`   `    ``int` `FirstElement = B[``0``];` `    ``for``(``int` `i = ``0``; i < n; i++) ` `    ``{` `        ``int` `cur = A[i];`   `        ``// Generate possible positive` `        ``// values of X` `        ``possibleValues.add(cur > FirstElement ? ` `                       ``m - cur + FirstElement :` `                  ``FirstElement - cur);` `    ``}`   `    ``// Initialize answer` `    ``// to MAX value` `    ``int` `ans = Integer.MAX_VALUE;`   `    ``for``(``int` `it : possibleValues)` `    ``{` `        `  `        ``// Flag to check if the` `        ``// current element of the` `        ``// set can be considered` `        ``boolean` `posible = ``true``;`   `        ``for``(Map.Entry it2 : mapA.entrySet())` `        ``{` `            `  `            ``// If the frequency of an element` `            ``// in A[] is not equal to that` `            ``// in B[] after the operation` `            ``if` `(it2.getValue() != ` `                ``mapB.get((it2.getKey() + it) % m)) ` `            ``{` `                `  `                ``// Current set element` `                ``// cannot be considered` `                ``posible = ``false``;` `                ``break``;` `            ``}` `        ``}`   `        ``// Update minimum value of X` `        ``if` `(posible)` `        ``{` `            ``ans = Math.min(ans, it);` `        ``}` `    ``}` `    ``return` `ans;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `n = ``4``;` `    ``int` `m = ``3``;`   `    ``int` `A[] = { ``0``, ``0``, ``2``, ``1` `};` `    ``int` `B[] = { ``2``, ``0``, ``1``, ``1` `};`   `    ``System.out.print(moduloEquality(A, B, n, m) + ``"\n"``);` `}` `}`   `// This code is contributed by Amit Katiyar`

 `# Python3 program for the above approach` `import` `sys` `from` `collections ``import` `defaultdict`   `# Utility function to find` `# the answer` `def` `moduloEquality(A, B, n, m):`   `    ``# Stores the frequncies of` `    ``# array elements` `    ``mapA ``=` `defaultdict(``int``)` `    ``mapB ``=` `defaultdict(``int``)`   `    ``for` `i ``in` `range``(n):` `        ``mapA[A[i]] ``+``=` `1` `        ``mapB[B[i]] ``+``=` `1`   `    ``# Stores the possible values` `    ``# of X` `    ``possibleValues ``=` `set``()`   `    ``FirstElement ``=` `B[``0``]` `    ``for` `i ``in` `range``(n):` `        ``cur ``=` `A[i]`   `        ``# Generate possible positive` `        ``# values of X` `        ``if` `cur > FirstElement:` `            ``possibleValues.add(m ``-` `cur ``+` `FirstElement)` `        ``else``:` `            ``possibleValues.add(FirstElement ``-` `cur)`   `    ``# Initialize answer` `    ``# to MAX value` `    ``ans ``=` `sys.maxsize`   `    ``for` `it ``in` `possibleValues:`   `        ``# Flag to check if the` `        ``# current element of the` `        ``# set can be considered` `        ``posible ``=` `True`   `        ``for` `it2 ``in` `mapA:`   `            ``# If the frequency of an element` `            ``# in A[] is not equal to that` `            ``# in B[] after the operation` `            ``if` `(mapA[it2] !``=` `                ``mapB[(it2 ``+` `it) ``%` `m]):`   `                ``# Current set element` `                ``# cannot be considered` `                ``posible ``=` `False` `                ``break`   `        ``# Update minimum value of X` `        ``if` `(posible):` `            ``ans ``=` `min``(ans, it)` `            `  `    ``return` `ans`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    `  `    ``n ``=` `4` `    ``m ``=` `3`   `    ``A ``=` `[ ``0``, ``0``, ``2``, ``1` `]` `    ``B ``=` `[ ``2``, ``0``, ``1``, ``1` `]`   `    ``print``(moduloEquality(A, B, n, m))`   `# This code is contributed by chitranayal`

 `// C# program for the above approach ` `using` `System;` `using` `System.Collections.Generic; `   `class` `GFG{` `    `  `// Utility function to find` `// the answer` `static` `int` `moduloEquality(``int``[] A, ``int``[] B, ` `                          ``int` `n, ``int` `m)` `{` `    `  `    ``// Stores the frequncies of` `    ``// array elements` `    ``Dictionary<``int``, ` `               ``int``> mapA = ``new` `Dictionary<``int``,` `                                          ``int``>();` `                   `  `    ``Dictionary<``int``, ` `               ``int``> mapB = ``new` `Dictionary<``int``,` `                                          ``int``>();` ` `  `    ``for``(``int` `i = 0; i < n; i++)` `    ``{` `        ``if` `(mapA.ContainsKey(A[i]))` `        ``{` `            ``mapA[A[i]] = mapA[A[i]] + 1;` `        ``}` `        ``else` `        ``{` `            ``mapA.Add(A[i], 1);` `        ``}` `        ``if` `(mapB.ContainsKey(B[i]))` `        ``{` `            ``mapB[B[i]] = mapB[B[i]] + 1;` `        ``}` `        ``else` `        ``{` `            ``mapB.Add(B[i], 1);` `        ``}` `    ``}` ` `  `    ``// Stores the possible values` `    ``// of X` `    ``HashSet<``int``> possibleValues = ``new` `HashSet<``int``>(); ` ` `  `    ``int` `FirstElement = B[0];` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{` `        ``int` `cur = A[i];` ` `  `        ``// Generate possible positive` `        ``// values of X` `        ``possibleValues.Add(cur > FirstElement ? ` `                       ``m - cur + FirstElement :` `                  ``FirstElement - cur);` `    ``}` ` `  `    ``// Initialize answer` `    ``// to MAX value` `    ``int` `ans = Int32.MaxValue;` `   `  `    ``foreach``(``int` `it ``in` `possibleValues)` `    ``{` `         `  `        ``// Flag to check if the` `        ``// current element of the` `        ``// set can be considered` `        ``bool` `posible = ``true``;` `        `  `        ``foreach``(KeyValuePair<``int``, ``int``> it2 ``in` `mapA)` `        ``{` `             `  `            ``// If the frequency of an element` `            ``// in A[] is not equal to that` `            ``// in B[] after the operation` `            ``if` `(it2.Value != mapB[(it2.Key + it) % m])` `            ``{` `                 `  `                ``// Current set element` `                ``// cannot be considered` `                ``posible = ``false``;` `                ``break``;` `            ``}` `        ``}` ` `  `        ``// Update minimum value of X` `        ``if` `(posible)` `        ``{` `            ``ans = Math.Min(ans, it);` `        ``}` `    ``}` `    ``return` `ans;` `} `   `// Driver code` `static` `void` `Main()` `{` `    ``int` `n = 4;` `    ``int` `m = 3;` ` `  `    ``int``[] A = { 0, 0, 2, 1 };` `    ``int``[] B = { 2, 0, 1, 1 };` `  `  `    ``Console.WriteLine(moduloEquality(A, B, n, m));` `}` `}`   `// This code is contributed by divyeshrabadiya07`

Output:
```1

```

Time Complexity: O(N2
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.

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.