Skip to content
Related Articles

Related Articles

Improve Article
Minimum number of distinct elements after removing m items
  • Difficulty Level : Medium
  • Last Updated : 08 Jun, 2021

Given an array of items, an i-th index element denotes the item id’s, and given a number m, the task is to remove m elements such that there should be minimum distinct id’s left. Print the number of distinct id’s.
Examples: 
 

Input : arr[] = { 2, 2, 1, 3, 3, 3} 
            m = 3
Output : 1
Remove 1 and both 2's.So, only 3 will be 
left that's why distinct id is 1.

Input : arr[] = { 2, 4, 1, 5, 3, 5, 1, 3} 
            m = 2
Output : 3
Remove 2 and 4 completely. So, remaining ids 
are 1, 3 and 5 i.e. 3

Asked in: Morgan Stanley
 

1- Count the occurrence of elements and store them in the hash. 
2- Sort the hash. 
3- Start removing elements from the hash. 
4- Return the number of values left in the hash.
 

C++




// C++ program for above implementation
#include <bits/stdc++.h>
using namespace std;
 
// Function to find distintc id's
int distinctIds(int arr[], int n, int mi)
{
    unordered_map<int, int> m;
    vector<pair<int, int> > v;
    int count = 0;
 
    // Store the occurrence of ids
    for (int i = 0; i < n; i++)
        m[arr[i]]++;
 
    // Store into the vector second as first and vice-versa
    for (auto it = m.begin(); it != m.end(); it++)
        v.push_back(make_pair(it->second, it->first));
 
    // Sort the vector
    sort(v.begin(), v.end());
 
    int size = v.size();
 
    // Start removing elements from the beginning
    for (int i = 0; i < size; i++) {
 
        // Remove if current value is less than
        // or equal to mi
        if (v[i].first <= mi) {
            mi -= v[i].first;
            count++;
        }
 
        // Return the remaining size
        else
            return size - count;
    }
    return size - count;
}
 
// Driver code
int main()
{
    int arr[] = { 2, 3, 1, 2, 3, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    int m = 3;
 
    cout << distinctIds(arr, n, m);
    return 0;
}

Java




//Java program for Minimum number of
//distinct elements after removing m items
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
 
public class DistinctIds
{
    // Function to find distintc id's
    static int distinctIds(int arr[], int n, int mi)
    {
 
        Map<Integer, Integer> m = new HashMap<Integer, Integer>();
        int count = 0;
        int size = 0;
 
        // Store the occurrence of ids
        for (int i = 0; i < n; i++)
        {
 
            // If the key is not add it to map
            if (m.containsKey(arr[i]) == false)
            {
                m.put(arr[i], 1);
                size++;
            }
 
            // If it is present then increase the value by 1
            else m.put(arr[i], m.get(arr[i]) + 1);
        }
 
        // Start removing elements from the beginning
        for (Entry<Integer, Integer> mp:m.entrySet())
        {
            // Remove if current value is less than
            // or equal to mi
            if (mp.getKey() <= mi)
            {
                mi -= mp.getKey();
                count++;
            }
            // Return the remaining size
            else return size - count;
        }
 
        return size - count;
    }
 
    //Driver method to test above function
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        int arr[] = {2, 3, 1, 2, 3, 3};
        int m = 3;
 
        System.out.println(distinctIds(arr, arr.length, m));
    }
}
//This code is contributed by Sumit Ghosh

Python3




# Python program for above implementation
 
# Function to find distintc id's
def distinctIds(arr, n, mi):
  m = {}
  v = []
  count = 0
 
  # Store the occurrence of ids
  for i in range(n):
    if arr[i] in m:
      m[arr[i]] += 1
    else:
      m[arr[i]] = 1
 
  # Store into the list value as key and vice-versa
  for i in m:
    v.append([m[i],i])
 
  v.sort()
  size = len(v)
 
  # Start removing elements from the beginning
  for i in range(size):
     
    # Remove if current value is less than
    # or equal to mi
    if (v[i][0] <= mi):
      mi -= v[i][0]
      count += 1
         
    else:   # Return the remaining size
      return size - count
  return size - count
 
# Driver code
arr = [ 2, 3, 1, 2, 3, 3 ]
n = len(arr)
 
m = 3
 
# To display the result
print(distinctIds(arr, n, m))
 
# This code is contributed by rohitsingh07052

C#




// C# program for Minimum number of
// distinct elements after removing m items
using System;
using System.Collections.Generic; 
class GFG
{
 
  // Function to find distintc id's
  static int distinctIds(int[] arr, int n, int mi)
  {
 
    Dictionary<int, int> m = new Dictionary<int, int>(); 
    int count = 0;
    int size = 0;
 
    // Store the occurrence of ids
    for (int i = 0; i < n; i++)
    {
 
      // If the key is not add it to map
      if (m.ContainsKey(arr[i]) == false)
      {
        m[arr[i]] = 1;
        size++;
      }
 
      // If it is present then increase the value by 1
      else
      {
        m[arr[i]]++;
      }
    }
 
    // Start removing elements from the beginning
    foreach(KeyValuePair<int, int> mp in m)
    {
 
      // Remove if current value is less than
      // or equal to mi
      if (mp.Key <= mi)
      {
        mi -= mp.Key;
        count++;
      }
    }
    return size - count;
  }
 
  // Driver code
  static void Main()
  {
 
    // TODO Auto-generated method stub
    int[] arr = {2, 3, 1, 2, 3, 3};
    int m = 3;
 
    Console.WriteLine(distinctIds(arr, arr.Length, m));
  }
}
 
// This code is contributed by divyeshrabadiya07

Javascript




<script>
 
// Javascript program for above implementation
 
// Function to find distintc id's
function distinctIds(arr, n, mi)
{
    var m = new Map();
    var v = [];
    var count = 0;
 
    // Store the occurrence of ids
    for (var i = 0; i < n; i++)
    {
        if(m.has(arr[i]))
            m.set(arr[i], m.get(arr[i])+1)
        else
            m.set(arr[i], 1)
    }
 
    // Store into the vector second as first and vice-versa
    m.forEach((value, key) => {
         
        v.push([value, key]);
    });
 
    // Sort the vector
    v.sort()
 
    var size = v.length;
 
    // Start removing elements from the beginning
    for (var i = 0; i < size; i++) {
 
        // Remove if current value is less than
        // or equal to mi
        if (v[i][0] <= mi) {
            mi -= v[i][0];
            count++;
        }
 
        // Return the remaining size
        else
            return size - count;
    }
    return size - count;
}
 
// Driver code
var arr = [2, 3, 1, 2, 3, 3 ];
var n = arr.length;
var m = 3;
document.write( distinctIds(arr, n, m));
 
// This code is contributed by immportantly.
</script>

Output: 
 

1

Time Complexity: O(n log n)
This article is contributed by Sahil Chhabra. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer DSA Live Classes




My Personal Notes arrow_drop_up
Recommended Articles
Page :