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++ program for the above approach #include <bits/stdc++.h> 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) {
// Calculating 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;
}
// Returning 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 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<Integer> diff_mod,
HashMap<Integer,
Integer> 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)
{
// Calculating 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;
}
// Returning 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<Integer> diff_mod = new HashSet<>();
// Map to store count
// of all different modulo
// obtained
HashMap<Integer,
Integer> 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 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:
# Calculating 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
# Returning 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# 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)
{
// Calculating 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;
}
// Returning 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 |
<script> // Javascript program for the above approach // Function to find the minimum operations // required to make the modulo of each // element of the array equal to each other function Find_min(diff_mod, count_mod, k)
{ // Variable to store minimum
// operation required
let min_oprn = Number.MAX_VALUE;
// To store operation required to
// make all modulo equal
let oprn = 0;
// Iterating through all
// possible modulo value
for (let x = 0; x < k; x++)
{
oprn = 0;
// Iterating through all different
// modulo obtained so far
for (let w of diff_mod.values())
{
// Calculating 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;
}
// Returning the answer
return min_oprn;
} // Function to store different modulos function Cal_min(arr, n, k)
{ // Set to store all
// different modulo
let diff_mod = new Set();
// Map to store count
// of all different modulo
// obtained
let count_mod = new Map();
// Storing all different
// modulo count
for (let i = 0; i < n; i++)
{
// Insert into the set
diff_mod.add(arr[i] % k);
// Increment count
// Increment count
if (count_mod.has((arr[i] % k)))
count_mod.set(arr[i] % k,
count_mod.get(arr[i] % k) + 1);
else
count_mod.set(arr[i] % k, 1);
}
// Function call to return value of
// min oprn required
return Find_min(diff_mod, count_mod, k);
} // Driver Code let arr = [ 2, 35, 48, 23, 52 ]; let n = arr.length; let k = 3; document.write(Cal_min(arr, n, k)); // This code is contributed by avanitrachhadiya2155 </script> |
2
Time Complexity: O(N*K), where N is the length of the given array and K is the given value.
Auxiliary Space: O(N+K), where N is the length of the given array and K is the given value.