Related Articles
Minimize increment/decrement of Array elements to make each modulo K equal
• Last Updated : 24 Sep, 2020

Given an array arr[] of length N and an integer K. In each operation any element(say arr[i]) can be selected from the array and can be changed to arr[i] + 1 or arr[i] – 1. The task is to find the minimum number of operations required to perform on the array such that each value of the array modulo K remains the same.
Examples:

Input: arr[] = {4, 5, 8, 3, 12},  k =5
Output: 4
Explanation:
Operation 1: { 3, 5, 8, 3, 12 }, decrease 4 at index 0 by 1.
Operation 2: { 3, 4, 8, 3, 12 }, decrease 5 at index 1 by 1.
Operation 3: { 3, 3, 8, 3, 12 }, decrease 4 at index 1 by 1.
Operation 4: { 3, 3, 8, 3, 13 }, increase 12 at index 4 by 1.
The modulo of each number is equal to 3 and minimum steps required were 4.

Input: arr[] = {2, 35, 48, 23, 52},  k =3
Output: 2
Explanation:
Minimum number of steps required to make modulo of each number equal is 2.

Approach: The idea is to use Hashing that keeps the count of each modulo that has been obtained.

• Now iterate for each value of i, in range 0 <= i < k, and find the number of operation required to make the modulo of all numbers equal.
• If it is less than the value obtained than the currently stored value then update it.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the minimum operations` `// required to make the modulo of each` `// element of the array equal to each other` `int` `Find_min(set<``int``>& diff_mod,` `             ``map<``int``, ``int``> count_mod, ``int` `k)` `{` `    ``// Variable to store minimum` `    ``// operation required` `    ``int` `min_oprn = INT_MAX;`   `    ``// To store operation required to` `    ``// make all modulo equal` `    ``int` `oprn = 0;`   `    ``// Iterating through all` `    ``// possible modulo value` `    ``for` `(``int` `x = 0; x < k; x++) {` `        ``oprn = 0;`   `        ``// Iterating through all different` `        ``// modulo obtained so far` `        ``for` `(``auto` `w : diff_mod) {`   `            ``// Caculating oprn required` `            ``// to make all modulos equal` `            ``// to x` `            ``if` `(w != x) {`   `                ``if` `(w == 0) {`   `                    ``// Checking the operations` `                    ``// that will cost less` `                    ``oprn += min(x, k - x)` `                            ``* count_mod[w];` `                ``}`   `                ``else` `{`   `                    ``// Check operation that` `                    ``// will cost less` `                    ``oprn += min(` `                                ``abs``(x - w),` `                                ``k + x - w)` `                            ``* count_mod[w];` `                ``}` `            ``}` `        ``}`   `        ``// Update the minimum` `        ``// number of operations` `        ``if` `(oprn < min_oprn)` `            ``min_oprn = oprn;` `    ``}`   `    ``// Returing the answer` `    ``return` `min_oprn;` `}`   `// Function to store different modulos` `int` `Cal_min(``int` `arr[], ``int` `n, ``int` `k)` `{` `    ``// Set to store all` `    ``// different modulo` `    ``set<``int``> diff_mod;`   `    ``// Map to store count` `    ``// of all different  modulo` `    ``// obtained` `    ``map<``int``, ``int``> count_mod;`   `    ``// Storing all different` `    ``// modulo count` `    ``for` `(``int` `i = 0; i < n; i++) {`   `        ``// Insert into the set` `        ``diff_mod.insert(arr[i] % k);`   `        ``// Increment count` `        ``count_mod[arr[i] % k]++;` `    ``}`   `    ``// Function call to return value of` `    ``// min oprn required` `    ``return` `Find_min(diff_mod, count_mod, k);` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 2, 35, 48, 23, 52 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `k = 3;` `    ``cout << Cal_min(arr, n, k);` `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{` `    `  `// Function to find the minimum operations` `// required to make the modulo of each` `// element of the array equal to each other` `static` `int` `Find_min(HashSet diff_mod,` `                    ``HashMap count_mod,` `                    ``int` `k)` `{` `    `  `    ``// Variable to store minimum` `    ``// operation required` `    ``int` `min_oprn = Integer.MAX_VALUE;`   `    ``// To store operation required to` `    ``// make all modulo equal` `    ``int` `oprn = ``0``;`   `    ``// Iterating through all` `    ``// possible modulo value` `    ``for``(``int` `x = ``0``; x < k; x++)` `    ``{` `        ``oprn = ``0``;`   `        ``// Iterating through all different` `        ``// modulo obtained so far` `        ``for``(``int` `w : diff_mod) ` `        ``{`   `            ``// Caculating oprn required` `            ``// to make all modulos equal` `            ``// to x` `            ``if` `(w != x) ` `            ``{` `                ``if` `(w == ``0``)` `                ``{` `                    `  `                    ``// Checking the operations` `                    ``// that will cost less` `                    ``oprn += Math.min(x, k - x) *` `                            ``count_mod.get(w);` `                ``}` `                ``else` `                ``{` `                    `  `                    ``// Check operation that` `                    ``// will cost less` `                    ``oprn += Math.min(Math.abs(x - w), ` `                                     ``k + x - w) * ` `                                     ``count_mod.get(w);` `                ``}` `            ``}` `        ``}`   `        ``// Update the minimum` `        ``// number of operations` `        ``if` `(oprn < min_oprn)` `            ``min_oprn = oprn;` `    ``}`   `    ``// Returing the answer` `    ``return` `min_oprn;` `}`   `// Function to store different modulos` `static` `int` `Cal_min(``int` `arr[], ``int` `n, ``int` `k)` `{` `    `  `    ``// Set to store all` `    ``// different modulo` `    ``HashSet diff_mod = ``new` `HashSet<>();`   `    ``// Map to store count` `    ``// of all different modulo` `    ``// obtained` `    ``HashMap count_mod = ``new` `HashMap<>();`   `    ``// Storing all different` `    ``// modulo count` `    ``for``(``int` `i = ``0``; i < n; i++) ` `    ``{` `        `  `        ``// Insert into the set` `        ``diff_mod.add(arr[i] % k);`   `        ``// Increment count` `        ``count_mod.put(arr[i] % k, ` `        ``count_mod.getOrDefault(arr[i] % k, ``0``) + ``1``);` `    ``}`   `    ``// Function call to return value of` `    ``// min oprn required` `    ``return` `Find_min(diff_mod, count_mod, k);` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `arr[] = { ``2``, ``35``, ``48``, ``23``, ``52` `};` `    ``int` `n = arr.length;` `    ``int` `k = ``3``;` `    `  `    ``System.out.print(Cal_min(arr, n, k));` `}` `}`   `// This code is contributed by jrishabh99`

## Python3

 `# Python3 program for ` `# the above approach` `import` `sys` `from` `collections ``import` `defaultdict`   `# Function to find the minimum operations` `# required to make the modulo of each` `# element of the array equal to each other` `def` `Find_min(diff_mod,` `             ``count_mod, k):`   `    ``# Variable to store minimum` `    ``# operation required` `    ``min_oprn ``=` `sys.maxsize`   `    ``# To store operation required to` `    ``# make all modulo equal` `    ``oprn ``=` `0`   `    ``# Iterating through all` `    ``# possible modulo value` `    ``for` `x ``in` `range` `(k):` `        ``oprn ``=` `0`   `        ``# Iterating through all different` `        ``# modulo obtained so far` `        ``for` `w ``in` `diff_mod:`   `            ``# Caculating oprn required` `            ``# to make all modulos equal` `            ``# to x` `            ``if` `(w !``=` `x):`   `                ``if` `(w ``=``=` `0``):`   `                    ``# Checking the operations` `                    ``# that will cost less` `                    ``oprn ``+``=` `(``min``(x, k ``-` `x) ``*` `                             ``count_mod[w])` `               `  `                ``else``:`   `                    ``# Check operation that` `                    ``# will cost less` `                    ``oprn ``+``=` `(``min``(``abs``(x ``-` `w), ` `                                     ``k ``+` `x ``-` `w) ``*` `                                     ``count_mod[w])` `          `  `        ``# Update the minimum` `        ``# number of operations` `        ``if` `(oprn < min_oprn):` `            ``min_oprn ``=` `oprn` `   `  `    ``# Returing the answer` `    ``return` `min_oprn`   `# Function to store different modulos` `def` `Cal_min(arr,  n, k):`   `    ``# Set to store all` `    ``# different modulo` `    ``diff_mod ``=` `set``([])`   `    ``# Map to store count` `    ``# of all different  modulo` `    ``# obtained` `    ``count_mod ``=` `defaultdict (``int``)`   `    ``# Storing all different` `    ``# modulo count` `    ``for` `i ``in` `range` `(n):`   `        ``# Insert into the set` `        ``diff_mod.add(arr[i] ``%` `k)`   `        ``# Increment count` `        ``count_mod[arr[i] ``%` `k] ``+``=` `1` `   `  `    ``# Function call to return value of` `    ``# min oprn required` `    ``return` `Find_min(diff_mod, count_mod, k)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:  ` `    ``arr ``=` `[``2``, ``35``, ``48``, ``23``, ``52``]` `    ``n ``=` `len``(arr)` `    ``k ``=` `3` `    ``print``( Cal_min(arr, n, k))` `    `  `# This code is contributed by Chitranayal`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{` `    `  `// Function to find the minimum operations` `// required to make the modulo of each` `// element of the array equal to each other` `static` `int` `Find_min(HashSet<``int``> diff_mod,` `                    ``Dictionary<``int``, ` `                               ``int``> count_mod,` `                    ``int` `k)` `{` `    `  `    ``// Variable to store minimum` `    ``// operation required` `    ``int` `min_oprn = ``int``.MaxValue;`   `    ``// To store operation required to` `    ``// make all modulo equal` `    ``int` `oprn = 0;`   `    ``// Iterating through all` `    ``// possible modulo value` `    ``for``(``int` `x = 0; x < k; x++)` `    ``{` `        ``oprn = 0;`   `        ``// Iterating through all different` `        ``// modulo obtained so far` `        ``foreach``(``int` `w ``in` `diff_mod) ` `        ``{`   `            ``// Caculating oprn required` `            ``// to make all modulos equal` `            ``// to x` `            ``if` `(w != x) ` `            ``{` `                ``if` `(w == 0)` `                ``{` `                    `  `                    ``// Checking the operations` `                    ``// that will cost less` `                    ``oprn += Math.Min(x, k - x) *` `                            ``count_mod[w];` `                ``}` `                ``else` `                ``{` `                    `  `                    ``// Check operation that` `                    ``// will cost less` `                    ``oprn += Math.Min(Math.Abs(x - w), ` `                                     ``k + x - w) * ` `                                     ``count_mod[w];` `                ``}` `            ``}` `        ``}`   `        ``// Update the minimum` `        ``// number of operations` `        ``if` `(oprn < min_oprn)` `            ``min_oprn = oprn;` `    ``}`   `    ``// Returing the answer` `    ``return` `min_oprn;` `}`   `// Function to store different modulos` `static` `int` `Cal_min(``int` `[]arr, ``int` `n, ``int` `k)` `{` `    `  `    ``// Set to store all` `    ``// different modulo` `    ``HashSet<``int``> diff_mod = ``new` `HashSet<``int``>();`   `    ``// Map to store count` `    ``// of all different modulo` `    ``// obtained` `    ``Dictionary<``int``, ` `               ``int``> count_mod = ``new` `Dictionary<``int``,` `                                               ``int``>();`   `    ``// Storing all different` `    ``// modulo count` `    ``for``(``int` `i = 0; i < n; i++) ` `    ``{` `        `  `        ``// Insert into the set` `        ``diff_mod.Add(arr[i] % k);`   `        ``// Increment count` `        ``if``(count_mod.ContainsKey((arr[i] % k)))` `            ``count_mod[arr[i] % k] = count_mod[(arr[i] % k)]+1;` `        ``else` `            ``count_mod.Add(arr[i] % k, 1);` `    ``}`   `    ``// Function call to return value of` `    ``// min oprn required` `    ``return` `Find_min(diff_mod, count_mod, k);` `}`   `// Driver Code` `public` `static` `void` `Main(String[] args)` `{` `    ``int` `[]arr = { 2, 35, 48, 23, 52 };` `    ``int` `n = arr.Length;` `    ``int` `k = 3;` `    `  `    ``Console.Write(Cal_min(arr, n, k));` `}` `}`   `// This code is contributed by Amit Katiyar `

Output:

```2

```

Time Complexity: O(N*K)

My Personal Notes arrow_drop_up
Recommended Articles
Page :