Least Number of Unique Integers after K Removals

class Solution {
public:
    int findLeastNumOfUniqueInts(vector<int>& arr, int k) {
        unordered_map<int,int> freq;
        for (int x : arr) ++freq[x];
        vector<int> counts;
        for (auto& [_, c] : freq) counts.push_back(c);
        sort(counts.begin(), counts.end());
        int removed = 0, i = 0;
        while (i < (int)counts.size() && removed + counts[i] <= k) {
            removed += counts[i++];
        }
        return counts.size() - i;
    }
};

import "sort"

func findLeastNumOfUniqueInts(arr []int, k int) int {
    freq := map[int]int{}
    for _, x := range arr {
        freq[x]++
    }
    counts := make([]int, 0, len(freq))
    for _, c := range freq {
        counts = append(counts, c)
    }
    sort.Ints(counts)
    removed, i := 0, 0
    for i < len(counts) && removed+counts[i] <= k {
        removed += counts[i]
        i++
    }
    return len(counts) - i
}

from typing import List
from collections import Counter

class Solution:
    def findLeastNumOfUniqueInts(self, arr: List[int], k: int) -> int:
        counts = sorted(Counter(arr).values())
        removed, i = 0, 0
        while i < len(counts) and removed + counts[i] <= k:
            removed += counts[i]
            i += 1
        return len(counts) - i

function findLeastNumOfUniqueInts(arr, k) {
    const freq = new Map();
    for (const x of arr) freq.set(x, (freq.get(x) ?? 0) + 1);
    const counts = [...freq.values()].sort((a, b) => a - b);
    let removed = 0, i = 0;
    while (i < counts.length && removed + counts[i] <= k) {
        removed += counts[i++];
    }
    return counts.length - i;
}

class Solution {
    public int findLeastNumOfUniqueInts(int[] arr, int k) {
        Map<Integer, Integer> freq = new HashMap<>();
        for (int x : arr) freq.merge(x, 1, Integer::sum);
        int[] counts = new int[freq.size()];
        int idx = 0;
        for (int c : freq.values()) counts[idx++] = c;
        Arrays.sort(counts);
        int removed = 0, i = 0;
        while (i < counts.length && removed + counts[i] <= k) {
            removed += counts[i++];
        }
        return counts.length - i;
    }
}

function findLeastNumOfUniqueInts(arr: number[], k: number): number {
    const freq = new Map<number, number>();
    for (const x of arr) freq.set(x, (freq.get(x) ?? 0) + 1);
    const counts = [...freq.values()].sort((a, b) => a - b);
    let removed = 0, i = 0;
    while (i < counts.length && removed + counts[i] <= k) {
        removed += counts[i++];
    }
    return counts.length - i;
}