Algorithms to Determine Unique Number of Occurrences

Given an array of integers arr, write a function that returns true if and only if the number of occurrences of each value in the array is unique.

Example 1:
Input: arr = [1,2,2,1,1,3]
Output: true
Explanation: The value 1 has 3 occurrences, 2 has 2 and 3 has 1. No two values have the same number of occurrences.

Example 2:
Input: arr = [1,2]
Output: false

Example 3:
Input: arr = [-3,0,1,-3,1,1,1,-3,10,0]
Output: true

Constraints:
1 <= arr.length <= 1000
-1000 <= arr[i] <= 1000

Using Hashmap and Hashset

We can use hashmap e.g. the unordered_map in C++ to record the number of occurencies for the numbers. Then we can use a hash set to determine if an occurence has appeared or not – return false immediately once we found at least one occurence is not unique.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Solution {
public:
    bool uniqueOccurrences(vector<int>& arr) {
        unordered_map<int, int> data;
        for (const auto &n: arr) {
            data[n] ++;
        }
        unordered_set<int> hash;
        for (auto it = data.begin(); it != data.end(); it ++) {
            if (hash.count(it->second)) {
                return false;
            }
            hash.insert(it->second);
        }
        return true;
    }
};

class Solution {
public:
    bool uniqueOccurrences(vector<int>& arr) {
        unordered_map<int, int> data;
        for (const auto &n: arr) {
            data[n] ++;
        }
        unordered_set<int> hash;
        for (auto it = data.begin(); it != data.end(); it ++) {
            if (hash.count(it->second)) {
                return false;
            }
            hash.insert(it->second);
        }
        return true;
    }
};

Alternatively, we can push all the occurrences values into the set and compare the sizes of both hash map and hash set.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

class Solution {
public:
    bool uniqueOccurrences(vector<int>& arr) {
        unordered_map<int, int> data;
        for (const auto &n: arr) {
            data[n] ++;
        }
        unordered_set<int> hash;
        for (auto it = data.begin(); it != data.end(); it ++) {
            hash.insert(it->second);
        }
        return hash.size() == data.size();
    }
};

class Solution {
public:
    bool uniqueOccurrences(vector<int>& arr) {
        unordered_map<int, int> data;
        for (const auto &n: arr) {
            data[n] ++;
        }
        unordered_set<int> hash;
        for (auto it = data.begin(); it != data.end(); it ++) {
            hash.insert(it->second);
        }
        return hash.size() == data.size();
    }
};

Apparently, both algorithms are O(N) time and O(N) space. The first approach may be slightly faster due to early exit while the second implementation looks concise.

–EOF (The Ultimate Computing & Technology Blog) —