Skip to content
Related Articles

Related Articles

Minimum removals required to make frequency of all remaining array elements equal
  • Last Updated : 12 Mar, 2021

Given an array arr[] of size N, the task is to find the minimum number of array elements required to be removed such that the frequency of the remaining array elements become equal.

Examples :

Input: arr[] = {2, 4, 3, 2, 5, 3}
Output: 2
Explanation: Following two possibilities exists:
1) Either remove an occurrence of 2 and 3. The array arr[] modifies to {2, 4, 3, 5}. Therefore, frequency of all the elements become equal.
2) Or, remove an occurrence of 4 and 5. The array arr[] modifies to {2, 3, 2, 3}. Therefore, frequency of all the elements become equal.

Input: arr[] = {1, 1, 2, 1}
Output: 1

Approach: Follow the steps below to solve the problem:



Below is the implementation of the above approach:

C++




// C++ program for the above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to count the minimum
// removals required to make frequency
// of all array elements equal
int minDeletions(int arr[], int N)
{
    // Stores frequency of
    // all array elements
    map<int, int> freq;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
        freq[arr[i]]++;
    }
 
    // Stores all the frequencies
    vector<int> v;
 
    // Traverse the map
    for (auto z : freq) {
        v.push_back(z.second);
    }
 
    // Sort the frequencies
    sort(v.begin(), v.end());
 
    // Count of frequencies
    int size = v.size();
 
    // Stores the final count
    int ans = N - (v[0] * size);
 
    // Traverse the vector
    for (int i = 1; i < v.size(); i++) {
 
        // Count the number of removals
        // for each frequency and update
        // the minimum removals required
        if (v[i] != v[i - 1]) {
            int safe = v[i] * (size - i);
            ans = min(ans, N - safe);
        }
    }
 
    // Print the final count
    cout << ans;
}
 
// Driver Code
int main()
{
    // Given array
    int arr[] = { 2, 4, 3, 2, 5, 3 };
 
    // Size of the array
    int N = sizeof(arr) / sizeof(arr[0]);
 
    // Function call to print the minimum
    // number of removals required
    minDeletions(arr, N);
}

Java




/*package whatever //do not write package name here */
 
import java.io.*;
import java.util.HashMap;
import java.util.Map;
import java.util.ArrayList;
import java.util.Collections;
 
class GFG {
  public static void minDeletions(int arr[], int N)
  {
     
    // Stores frequency of
    // all array elements
    HashMap<Integer, Integer> map = new HashMap<>();
    ;
 
    // Traverse the array
    for (int i = 0; i < N; i++) {
      Integer k = map.get(arr[i]);
      map.put(arr[i], (k == null) ? 1 : k + 1);
    }
 
    // Stores all the frequencies
    ArrayList<Integer> v = new ArrayList<>();
 
    // Traverse the map
    for (Map.Entry<Integer, Integer> e :
         map.entrySet()) {
      v.add(e.getValue());
    }
 
    // Sort the frequencies
    Collections.sort(v);
 
    // Count of frequencies
    int size = v.size();
 
    // Stores the final count
    int ans = N - (v.get(0) * size);
 
    // Traverse the vector
    for (int i = 1; i < v.size(); i++) {
 
      // Count the number of removals
      // for each frequency and update
      // the minimum removals required
      if (v.get(i) != v.get(i - 1)) {
        int safe = v.get(i) * (size - i);
        ans = Math.min(ans, N - safe);
      }
    }
 
    // Print the final count
    System.out.println(ans);
  }
 
  // Driver code
  public static void main(String[] args)
  {
     
    // Given array
    int arr[] = { 2, 4, 3, 2, 5, 3 };
 
    // Size of the array
    int N = 6;
 
    // Function call to print the minimum
    // number of removals required
    minDeletions(arr, N);
  }
}
 
// This code is contributed by aditya7409.

Python3




# Python 3 program for the above approach
from collections import defaultdict
 
# Function to count the minimum
# removals required to make frequency
# of all array elements equal
def minDeletions(arr, N):
   
    # Stores frequency of
    # all array elements
    freq = defaultdict(int)
 
    # Traverse the array
    for i in range(N):
        freq[arr[i]] += 1
 
    # Stores all the frequencies
    v = []
 
    # Traverse the map
    for z in freq.keys():
        v.append(freq[z])
 
    # Sort the frequencies
    v.sort()
 
    # Count of frequencies
    size = len(v)
 
    # Stores the final count
    ans = N - (v[0] * size)
 
    # Traverse the vector
    for i in range(1, len(v)):
 
        # Count the number of removals
        # for each frequency and update
        # the minimum removals required
        if (v[i] != v[i - 1]):
            safe = v[i] * (size - i)
            ans = min(ans, N - safe)
 
    # Print the final count
    print(ans)
 
 
# Driver Code
if __name__ == "__main__":
 
    # Given array
    arr = [2, 4, 3, 2, 5, 3]
 
    # Size of the array
    N = len(arr)
 
    # Function call to print the minimum
    # number of removals required
    minDeletions(arr, N)
 
    # This code is contributed by chitranayal.

C#




// C# program for the above approach
using System;
using System.Collections.Generic;
class GFG{
 
  // Function to count the minimum
  // removals required to make frequency
  // of all array elements equal
  static void minDeletions(int []arr, int N)
  {
 
    // Stores frequency of
    // all array elements
    Dictionary<int,int> freq = new Dictionary<int,int>();
 
    // Traverse the array
    for (int i = 0; i < N; i++)
    {
      if(freq.ContainsKey(arr[i]))
        freq[arr[i]]++;
      else
        freq[arr[i]] = 1;
    }
 
    // Stores all the frequencies
    List<int> v = new List<int>();
 
    // Traverse the map
    foreach (var z in freq) {
      v.Add(z.Value);
    }
 
    // Sort the frequencies
    int sz = v.Count;
    int []temp = new int[sz];
    for(int i = 0; i < v.Count; i++)
      temp[i] = v[i];
    Array.Sort(temp);
    for(int i = 0; i < v.Count; i++)
      v[i] = temp[i];
 
    // Count of frequencies
    int size = v.Count;
 
    // Stores the final count
    int ans = N - (v[0] * size);
 
    // Traverse the vector
    for (int i = 1; i < v.Count; i++) {
 
      // Count the number of removals
      // for each frequency and update
      // the minimum removals required
      if (v[i] != v[i - 1]) {
        int safe = v[i] * (size - i);
        ans = Math.Min(ans, N - safe);
      }
    }
 
    // Print the final count
    Console.WriteLine(ans);
  }
 
  // Driver Code
  public static void Main()
  {
 
    // Given array
    int []arr = { 2, 4, 3, 2, 5, 3 };
 
    // Size of the array
    int N = arr.Length;
 
    // Function call to print the minimum
    // number of removals required
    minDeletions(arr, N);
  }
}
 
// This code is contributed by SURENDRA_GANGWAR.

 
 

Output: 
2

 

 

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

 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :