# Minimize insertions or deletions to make frequency of each array element equal to its value

• Difficulty Level : Easy
• Last Updated : 23 Mar, 2022

Given an array arr[] of N integers, the task is to find the minimum insertion or deletion operations required to make the frequency of each element equal to its value.

Example:

Input: arr = {3, 2, 3, 1, 2}
Output: 1
Explanation: Initially, the frequency of integers in the array is freq = 2, freq  = 2 and freq = 1. In the 1st operation, insert 3 into the array. Hence the array becomes arr[] = {3, 2, 3, 1, 2, 3} having frequency of each element equal to its value.

Input: [3, 3, 4, 3, 1, 2]
Output: 2
Explanation: In 1st operation, delete 4 from the array. In 2nd operation, insert 2 into the array. Hence the array becomes arr[] = {3, 3, 3, 1, 2, 2} having frequency of each element equal to its value.

Approach: The given problem can be solved using a Greedy Approach. Follow the steps below to solve the given problem:

• Create a hash map freq, to store the frequency of all elements of the array.
• Iterate over all the values of the map using a variable key. If freq[key] > key, it will contribute (freq[key] – key) to the total operation count, otherwise, it will contribute min(freq[key], key – freq[key]) to the total operation count.
• Create a variable count which stores the operation count of all the possible key values which will be the required answer.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of above approach` `#include ` `#include ` `using` `namespace` `std;`   `// Function to find minimum insertions or` `// deletions required to make frequency` `// of each element equal to its value` `int` `minOperations(``int` `arr[], ``int` `n)` `{` `  `  `    ``// Initializing Hash Map for making` `    ``// frequency map` `    ``map<``int``, ``int``> mp;`   `    ``// Making frequency map` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``mp[arr[i]]++;` `    ``}`   `    ``// Stores the final count of operations` `    ``int` `count = 0;`   `    ``// Traversing Hash Map` `    ``for` `(``auto` `it : mp) {`   `        ``// Updating the operation count` `        ``if` `(it.second >= it.first)` `            ``count += (it.second - it.first);` `        ``else` `            ``count += min(it.first - it.second, it.second);` `    ``}`   `    ``// Return Answer` `    ``return` `count;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 3, 3, 4, 3, 1, 2 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr);` `    ``int` `count = minOperations(arr, n);` `    ``cout << count;` `    ``return` `0;` `}`   `// This code is contributed by kdheraj.`

## Java

 `// Java implementation of the above approach`   `import` `java.util.*;`   `class` `GFG {`   `    ``// Function to find minimum insertions or` `    ``// deletions required to make frequency` `    ``// of each element equal to its value` `    ``public` `static` `int` `minOperations(``int``[] arr, ``int` `n)` `    ``{` `        ``// Initializing Hash Map for making` `        ``// frequency map` `        ``Map freq = ``new` `HashMap<>();`   `        ``// Making frequency map` `        ``for` `(``int` `val : arr)` `            ``freq.put(val, freq.getOrDefault(val, ``0``) + ``1``);`   `        ``// Stores the final count of operations` `        ``int` `count = ``0``;`   `        ``// Traversing Hash Map` `        ``for` `(Map.Entry mp : freq.entrySet()) {`   `            ``int` `key = (``int``)mp.getKey();` `            ``int` `val = (``int``)mp.getValue();`   `            ``// Updating the operation count` `            ``if` `(val >= key)` `                ``count += val - key;` `            ``else` `                ``count += Math.min(key - val, val);` `        ``}`   `        ``// Return Answer` `        ``return` `count;` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int``[] arr = { ``3``, ``3``, ``4``, ``3``, ``1``, ``2` `};` `        ``int` `n = arr.length;` `        ``System.out.println(minOperations(arr, n));` `    ``}` `}`

## Python3

 `# Python 3 implementation of above approach` `from` `collections ``import` `defaultdict`   `# Function to find minimum insertions or` `# deletions required to make frequency` `# of each element equal to its value` `def` `minOperations(arr, n):`   `    ``# Initializing Hash Map for making` `    ``# frequency map` `    ``mp ``=` `defaultdict(``int``)`   `    ``# Making frequency map` `    ``for` `i ``in` `range``(n):` `        ``mp[arr[i]] ``+``=` `1`   `    ``# Stores the final count of operations` `    ``count ``=` `0`   `    ``# Traversing Hash Map` `    ``for` `it ``in` `mp:`   `        ``# Updating the operation count` `        ``if` `(mp[it] >``=` `it):` `            ``count ``+``=` `(mp[it] ``-` `it)`   `        ``else``:` `            ``count ``+``=` `min``(it ``-` `mp[it], mp[it])`   `    ``# Return Answer` `    ``return` `count`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:`   `    ``arr ``=` `[``3``, ``3``, ``4``, ``3``, ``1``, ``2``]` `    ``n ``=` `len``(arr)` `    ``count ``=` `minOperations(arr, n)` `    ``print``(count)`   `    ``# This code is contributed by ukasp.`

## C#

 `// C# implementation of the above approach`   `using` `System;` `using` `System.Collections;` `using` `System.Collections.Generic;`   `class` `GFG {`   `// Function to find minimum insertions or` `// deletions required to make frequency` `// of each element equal to its value` `static` `int` `minOperations(``int` `[]arr, ``int` `n)` `{` `  `  `    ``// Initializing Hash Map for making` `    ``// frequency map` `    ``Dictionary<``int``, ``int``> mp =` `          ``new` `Dictionary<``int``, ``int``>();` ` `    `    ``// Making frequency map` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``if` `(mp.ContainsKey(arr[i])) {` `              ``int` `val = mp[arr[i]];` `              ``mp.Remove(arr[i]);` `              ``mp.Add(arr[i], val + 1);` `        ``}` `        ``else` `{` `          ``mp.Add(arr[i], 1);` `        ``}` `    ``}`   `    ``// Stores the final count of operations` `    ``int` `count = 0;`   `    ``// Traversing Hash Map` `    ``foreach``(KeyValuePair<``int``, ``int``> it ``in` `mp) {`   `        ``// Updating the operation count` `        ``if` `(it.Value >= it.Key)` `            ``count += (it.Value - it.Key);` `        ``else` `            ``count += Math.Min(it.Key - it.Value, it.Value);` `    ``}`   `    ``// Return Answer` `    ``return` `count;` `}`     `// Driver code` `public` `static` `void` `Main()` `{` `    ``int``[] arr = { 3, 3, 4, 3, 1, 2 };` `    ``int` `n = arr.Length;` `    ``Console.Write(minOperations(arr, n));` `}` `}` `// This code is contributed by Samim Hossain Mondal.`

## Javascript

 ``

Output

`2`

Time complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :