Unique Number of Occurrences

class Solution {
public:
    bool uniqueOccurrences(vector<int>& arr) {
        unordered_map<int,int> cnt;
        for (int v : arr) ++cnt[v];
        unordered_set<int> seen;
        for (auto& [_, c] : cnt) {
            if (!seen.insert(c).second) return false;
        }
        return true;
    }
};

func uniqueOccurrences(arr []int) bool {
    cnt := map[int]int{}
    for _, v := range arr {
        cnt[v]++
    }
    seen := map[int]bool{}
    for _, c := range cnt {
        if seen[c] {
            return false
        }
        seen[c] = true
    }
    return true
}

from collections import Counter
from typing import List

class Solution:
    def uniqueOccurrences(self, arr: List[int]) -> bool:
        counts = Counter(arr).values()
        return len(set(counts)) == len(counts)

function uniqueOccurrences(arr) {
    const cnt = new Map();
    for (const v of arr) cnt.set(v, (cnt.get(v) ?? 0) + 1);
    const seen = new Set();
    for (const c of cnt.values()) {
        if (seen.has(c)) return false;
        seen.add(c);
    }
    return true;
}

class Solution {
    public boolean uniqueOccurrences(int[] arr) {
        Map<Integer, Integer> cnt = new HashMap<>();
        for (int v : arr) cnt.merge(v, 1, Integer::sum);
        Set<Integer> seen = new HashSet<>();
        for (int c : cnt.values()) {
            if (!seen.add(c)) return false;
        }
        return true;
    }
}

function uniqueOccurrences(arr: number[]): boolean {
    const cnt = new Map<number, number>();
    for (const v of arr) cnt.set(v, (cnt.get(v) ?? 0) + 1);
    const seen = new Set<number>();
    for (const c of cnt.values()) {
        if (seen.has(c)) return false;
        seen.add(c);
    }
    return true;
}