 Open in App
Not now

# Minimum operations required to make all Array elements divisible by K

• Difficulty Level : Medium
• Last Updated : 23 May, 2022

Given an array a[], integer K and an integer X (which is initially initialized to 0). Our task is to find the minimum number of moves required to update the array such that each of its elements is divisible by K by performing the following operations:

• Choose one index i from 1 to N and increase ai by X and then increase X by 1. This operation cannot be applied more than once to each element of the array
• Only increase the value of X by 1.

Examples:

Input: K = 3, a = [1, 2, 2, 18]
Output:
Explanation:
Initially X = 0 hence update X to 1.
For X = 1 add X to the second element of array to make the array [1, 3, 2, 18] and increase X by 1.
For X = 2 add X to the first element of array [3, 3, 2, 18] and increase X by 1.
For X = 3 just increase X by 1.
For X = 4 add X to the third element of array to make the array [3, 3, 6, 18] and increase X by 1.
At last, the array becomes [3, 3, 6, 18] where all the elements are divisible by K = 3.
Input: K = 5, a[] = [15, 25, 5, 10, 20, 1005, 70, 80, 90, 100]
Output:
Explanation:
Here all elements are already divisible by 5.

Approach: The main idea is to find the maximum value of X that is needed to update the elements of the array to make it divisible by K.

• To do this we need to find the maximum value of (K – (ai mod K)) to add to the array elements to make it divisible by K.
• However, there can be equal elements so keep track of the number of such elements, using map data structures.
• When found another such element in the array then update the answer with (K – (ai mod K)) + (K * number of Equal Elements) because with every move we increase X by 1.

Below is the implementation of the above approach:

## C++

 `// C++ implementation to find the``// Minimum number of moves required to``// update the array such that each of``// its element is divisible by K` `#include ``using` `namespace` `std;` `// Function to find the``// Minimum number of moves required to``// update the array such that each of``// its element is divisible by K``void` `compute(``int` `a[], ``int` `N, ``int` `K)``{``    ``// Initialize Map data structure``    ``map<``long``, ``long``> eqVal;` `    ``long` `maxX = 0;` `    ``// Iterate for all the elements``    ``// of the array``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// Calculate the``        ``// value to be added``        ``long` `val = a[i] % K;` `        ``val = (val == 0 ? 0 : K - val);` `        ``// Check if the value equals``        ``// to 0 then simply continue``        ``if` `(val == 0)``            ``continue``;` `        ``// Check if the value to be``        ``// added is present in the map``        ``if` `(eqVal.find(val) != eqVal.end()) {` `            ``long` `numVal = eqVal[val];``            ``// Update the answer``            ``maxX = max(maxX,``                    ``val + (K * numVal));` `            ``eqVal[val]++;``        ``}` `        ``else` `{``            ``eqVal[val]++;``            ``maxX = max(maxX, val);``        ``}``    ``}` `    ``// Print the required result``    ``// We need to add 1 to maxX``    ``// because we cant ignore the``    ``// first move where initially X=0``    ``// and we need to increase it by 1``    ``// to make some changes in array``    ``cout << (maxX == 0 ? 0 : maxX + 1)``        ``<< endl;``}` `// Driver code``int` `main()``{``    ``int` `K = 3;``    ``int` `a[] = { 1, 2, 2, 18 };``    ``int` `N = ``sizeof``(a) / ``sizeof``(a);``    ``compute(a, N, K);``    ``return` `0;``}`

## Java

 `// Java implementation to find the``// minimum number of moves required to``// update the array such that each of``// its element is divisible by K``import` `java.util.*;` `class` `GFG{``    ` `// Function to find the minimum``// number of moves required to``// update the array such that each of``// its element is divisible by K``static` `void` `compute(``int` `a[], ``int` `N, ``int` `K)``{``    ` `    ``// Initialize Map data structure``    ``Map eqVal = ``new` `HashMap();` `    ``long` `maxX = ``0``;` `    ``// Iterate for all the elements``    ``// of the array``    ``for``(``int` `i = ``0``; i < N; i++)``    ``{``        ` `        ``// Calculate the``        ``// value to be added``        ``long` `val = a[i] % K;` `        ``val = (val == ``0` `? ``0` `: K - val);` `        ``// Check if the value equals``        ``// to 0 then simply continue``        ``if` `(val == ``0``)``            ``continue``;` `        ``// Check if the value to be``        ``// added is present in the map``        ``if` `(eqVal.containsKey(val))``        ``{``            ``long` `numVal = eqVal.get(val);``            ` `            ``// Update the answer``            ``maxX = Math.max(maxX,``                            ``val + (K * numVal));` `            ``eqVal.put(val,``            ``eqVal.getOrDefault(val, 0l) + 1l);``        ``}``        ``else``        ``{``            ``eqVal.put(val, 1l);``            ``maxX = Math.max(maxX, val);``        ``}``    ``}` `    ``// Print the required result``    ``// We need to add 1 to maxX``    ``// because we cant ignore the``    ``// first move where initially X=0``    ``// and we need to increase it by 1``    ``// to make some changes in array``    ``System.out.println(maxX == ``0` `? ``0` `: maxX + ``1``);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `K = ``3``;``    ``int` `a[] = { ``1``, ``2``, ``2``, ``18` `};``    ``int` `N = a.length;``    ` `    ``compute(a, N, K);``}``}` `// This code is contributed by offbeat`

## Python3

 `# Python3 implementation to find the``# Minimum number of moves required to``# update the array such that each of``# its element is divisible by K``from` `collections ``import` `defaultdict` `# Function to find the Minimum number``# of moves required to update the``# array such that each of its``# element is divisible by K``def` `compute(a, N, K):` `    ``# Initialize Map data structure``    ``eqVal ``=` `defaultdict(``int``)` `    ``maxX ``=` `0` `    ``# Iterate for all the elements``    ``# of the array``    ``for` `i ``in` `range``(N):` `        ``# Calculate the``        ``# value to be added``        ``val ``=` `a[i] ``%` `K` `        ``if` `(val !``=` `0``):``            ``val ``=` `K ``-` `val` `        ``# Check if the value equals``        ``# to 0 then simply continue``        ``if` `(val ``=``=` `0``):``            ``continue` `        ``# Check if the value to be``        ``# added is present in the map``        ``if` `(val ``in` `eqVal):``            ``numVal ``=` `eqVal[val]``            ` `            ``# Update the answer``            ``maxX ``=` `max``(maxX,``                    ``val ``+` `(K ``*` `numVal))` `            ``eqVal[val] ``+``=` `1``        ``else``:``            ``eqVal[val] ``+``=` `1``            ``maxX ``=` `max``(maxX, val)` `    ``# Print the required result``    ``# We need to add 1 to maxX``    ``# because we cant ignore the``    ``# first move where initially X=0``    ``# and we need to increase it by 1``    ``# to make some changes in array``    ``if` `maxX ``=``=` `0``:``        ``print``(``0``)``    ``else``:``        ``print``(maxX ``+` `1``)``    ` `# Driver code``if` `__name__ ``=``=` `"__main__"``:` `    ``K ``=` `3``    ``a ``=` `[ ``1``, ``2``, ``2``, ``18` `]``    ``N ``=` `len``(a)``    ` `    ``compute(a, N, K)` `# This code is contributed by chitranayal`

## C#

 `// C# implementation to find the``// minimum number of moves required to``// update the array such that each of``// its element is divisible by K``using` `System;``using` `System.Collections.Generic;` `class` `GFG{``    ` `// Function to find the minimum``// number of moves required to``// update the array such that each of``// its element is divisible by K``static` `void` `compute(``int` `[]a, ``int` `N, ``int` `K)``{``    ` `    ``// Initialize Map data structure``    ``Dictionary<``long``,``               ``long``> eqVal = ``new` `Dictionary<``long``,``                                            ``long``>();` `    ``long` `maxX = 0;` `    ``// Iterate for all the elements``    ``// of the array``    ``for``(``int` `i = 0; i < N; i++)``    ``{``        ` `        ``// Calculate the``        ``// value to be added``        ``long` `val = a[i] % K;` `        ``val = (val == 0 ? 0 : K - val);` `        ``// Check if the value equals``        ``// to 0 then simply continue``        ``if` `(val == 0)``            ``continue``;` `        ``// Check if the value to be``        ``// added is present in the map``        ``if` `(eqVal.ContainsKey(val))``        ``{``            ``long` `numVal = eqVal[val];``            ` `            ``// Update the answer``            ``maxX = Math.Max(maxX,``                            ``val + (K * numVal));``                    ` `            ``eqVal[val] = 1 +``            ``eqVal.GetValueOrDefault(val, 0);``        ``}``        ``else``        ``{``            ``eqVal.Add(val, 1);``            ``maxX = Math.Max(maxX, val);``        ``}``    ``}` `    ``// Print the required result``    ``// We need to add 1 to maxX``    ``// because we cant ignore the``    ``// first move where initially X=0``    ``// and we need to increase it by 1``    ``// to make some changes in array``    ``Console.Write(maxX == 0 ? 0 : maxX + 1);``}` `// Driver code``public` `static` `void` `Main(``string``[] args)``{``    ``int` `K = 3;``    ``int` `[]a = { 1, 2, 2, 18 };``    ``int` `N = a.Length;``    ` `    ``compute(a, N, K);``}``}` `// This code is contributed by rutvik_56`

## Javascript

 ``

Output:

`5`

Time Complexity: O(N*logN), where N represents the size of the given array.
Auxiliary Space: O(N), where N represents the size of the given array.

My Personal Notes arrow_drop_up