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

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
    // 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[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
        // frequency 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
    # 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

<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
    // frequency 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)