# Minimum operations to make counts of remainders same in an array

Given an array arr[] of N integers and an integer M where N % M = 0. The task is to find the minimum number of operations that need to be performed on the array to make c0 = c1 = ….. = cM – 1 = N / M where cr is the number of elements in the given array having remainder r when divided by M. In each operation, any array element can be incremented by 1.

Examples:

Input: arr[] = {1, 2, 3}, M = 3
Output: 0
After performing the modulus operation on the given array, the array becomes {0, 1, 2}
And count of c0 = c1 = c2 = n / m = 1.
So, no any additional operations are required.

Input: arr[] = {3, 2, 0, 6, 10, 12}, M = 3
Output: 3
After performing the modulus operation on the given array, the array becomes {0, 2, 0, 0, 1, 0}
And count of c0 = 4, c1 = 1 and c2 = 1. To make c0 = c1 = c2 = n / m = 2.
Add 1 to 6 and 2 to 12 then the array becomes {3, 2, 0, 7, 10, 14} and c0 = c1 = c2 = n / m = 2.

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

Approach: For each i from 0 to m – 1, find all the elements of the array that are congruent to i modulo m and store their indices in a list. Also, create a vector called extra, and let k = n / m.

We have to cycle from 0 to m – 1 twice. For each i from 0 to m – 1, if there are more elements than k in the list, remove the extra elements from this list and add them to extra. If instead there are lesser elements than k then remove the last few elements from the vector extra. For every removed index idx, increase arr[idx] by (i – arr[idx]) % m.

It is obvious that after the first m iterations, every list will have size at most k and after m more iterations all lists will have the same sizes i.e. k.

Below is the implementation of the above approach:

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to return the minimum ` `// number of operations required ` `int` `minOperations(``int` `n, ``int` `a[], ``int` `m) ` `{ ` `    ``int` `k = n / m; ` ` `  `    ``// To store modulos values ` `    ``vector > val(m); ` `    ``for` `(``int` `i = 0; i < n; ++i) { ` `        ``val[a[i] % m].push_back(i); ` `    ``} ` ` `  `    ``long` `long` `ans = 0; ` `    ``vector > extra; ` ` `  `    ``for` `(``int` `i = 0; i < 2 * m; ++i) { ` `        ``int` `cur = i % m; ` ` `  `        ``// If it's size greater than k ` `        ``// it needed to be decreased ` `        ``while` `(``int``(val[cur].size()) > k) { ` `            ``int` `elem = val[cur].back(); ` `            ``val[cur].pop_back(); ` `            ``extra.push_back(make_pair(elem, i)); ` `        ``} ` ` `  `        ``// If it's size is less than k ` `        ``// it needed to be increased ` `        ``while` `(``int``(val[cur].size()) < k && !extra.empty()) { ` `            ``int` `elem = extra.back().first; ` `            ``int` `mmod = extra.back().second; ` `            ``extra.pop_back(); ` `            ``val[cur].push_back(elem); ` `            ``ans += i - mmod; ` `        ``} ` `    ``} ` ` `  `    ``return` `ans; ` `} ` ` `  `// Drive code ` `int` `main() ` `{ ` `    ``int` `m = 3; ` ` `  `    ``int` `a[] = { 3, 2, 0, 6, 10, 12 }; ` `    ``int` `n = ``sizeof``(a) / ``sizeof``(a[0]); ` `    ``cout << minOperations(n, a, m); ` ` `  `    ``return` `0; ` `} `

Output:

```3
```

My Personal Notes arrow_drop_up