Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Easy
  • Last Updated : 07 Dec, 2021

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[3] = 2, freq[2]  = 2 and freq[1] = 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 <bits/stdc++.h>
#include <iostream>
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
    // freaquency 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[0]);
    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
        // freaquency map
        Map<Integer, Integer> 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
    # freaquency 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
    // freaquency 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



<script>
// Javascript implementation of above approach
 
// Function to find minimum insertions or
// deletions required to make frequency
// of each element equal to its value
function minOperations(arr, n)
{
   
    // Initializing Hash Map for making
    // freaquency map
    var mp = new Map();
  
    // Traverse through array elements and
    // count frequencies
    for (var i = 0; i < n; i++)
    {
        if(mp.has(arr[i]))
            mp.set(arr[i], mp.get(arr[i])+1)
        else
            mp.set(arr[i], 1)
    }
 
    // Stores the final count of operations
    var count = 0;
    var keys = [];
     
    mp.forEach((value, key) => {
        keys.push(key);
    });
    // Traversing Hash Map
    keys.forEach((key) => {
 
        // Updating the operation count
        if (mp.get(key) >= key)
            count += (mp.get(key) - key);
        else
            count += Math.min(key - mp.get(key), mp.get(key));
    });
 
    // Return Answer
    return count;
}
 
// Driver Code
var arr = [ 3, 3, 4, 3, 1, 2 ];
var n = arr.length;
var count = minOperations(arr, n);
document.write(count);
 
// This code is contributed by Samim Hossain Mondal.
</script>
Output
2
Time complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes
arrow_drop_up
Previous
Minimize count of repositioning of characters to make all given Strings equal
Next

Arrays in Java
Recommended Articles
Page :
Minimize cost of insertions and deletions required to make all array elements equal
19, Jan 21
Minimize insertions and deletions in given array A[] to make it identical to array B[]
18, Nov 21
Minimum insertions or deletions required to make two strings K-equivalent
19, Jan 21
Minimum removals required to make frequency of each array element equal to its value
08, Dec 20
Minimum deletions required to make frequency of each letter unique
17, Sep 19
Minimum insertions to make XOR of an Array equal to half of its sum
31, May 20
Minimize insertions required to make all characters of a given string equal
03, Feb 21
Minimize operations required to make each element of Array equal to it's index value
03, Jul 20
Minimize insertions to make sum of every pair of consecutive array elements at most K
02, Mar 21
Minimize insertions required to make ratio of maximum and minimum of all pairs of adjacent array elements at most K
03, Mar 21
Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset
03, Jan 21
Check if frequency of each digit in a number is equal to its value
03, Nov 21
Minimum deletions required to make GCD of the array equal to 1
20, Jun 19
Minimum number of deletions from front and back of given Array to make count of 0 and 1 equal
03, Jan 22
Minimize deletions in Array by deleting all occurrences of any number such that array size is reduced to at least half
03, Sep 21
Minimize swaps to make remainder equal when an element and its index is divided by K
10, Nov 21
Minimize insertions in an array to obtain all sums upto N
17, Jun 20
Minimize deletions from either end to remove Minimum and Maximum from Array
02, Dec 21
Check if frequency of each character is equal to its position in English Alphabet
20, May 20
Minimize the maximum difference of adjacent elements after at most K insertions
07, May 20
Minimize deletions in a Binary String to remove all subsequences of the form "0101"
19, Oct 20
Minimize deletions to reduce String to size 1 wherein ith deletion, N/2^i occurrences of (X+i-1)th character can be deleted
30, Nov 21
Maximum element in an array which is equal to its frequency
17, Apr 20
Maximize sum of each element raised to power of its frequency in K sized subarray
14, Dec 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Kdheeraj
@Kdheeraj
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!