In this approach, we will first traverse the array to count the occurrences of each element using a hash map. Then, we will use a set to check if these occurrences are unique. If the size of the set matches the size of the occurrence counts, it implies all occurrences are unique.
Time Complexity: O(n), where n is the length of the array.
Space Complexity: O(1), since we're using fixed-size arrays.
1def uniqueOccurrences(arr):
2 from collections import Counter
3 count = Counter(arr)
4 occurrences = set(count.values())
5 return len(occurrences) == len(count)
6
7arr = [1, 2, 2, 1, 1, 3]
8print(uniqueOccurrences(arr))The Python version uses a Counter from collections to count occurrences and then compares the size of the set of these counts to ensure uniqueness.
This alternative approach starts by counting occurrences just like the first one. After that, it stores these counts in a list, sorts the list, and then checks for any consecutive equal elements, which would indicate duplicate occurrences.
Time Complexity: O(n log n), due to sorting.
Space Complexity: O(1), since we work within fixed-sized arrays.
1function uniqueOccurrences(arr) {
2 const countMap = new Map();
3 for (const num of arr) {
4 countMap.set(num, (countMap.get(num) || 0) + 1);
5 }
6 const occurrences = Array.from(countMap.values()).sort((a, b) => a - b);
7 for (let i = 1; i < occurrences.length; i++) {
8 if (occurrences[i] === occurrences[i - 1]) {
9 return false;
10 }
11 }
12 return true;
13}
14
15const arr = [1, 2, 2, 1, 1, 3];
16console.log(uniqueOccurrences(arr));The JavaScript sorting approach involves sorting the list of occurrence counts and checking for any duplicates in consecutive elements.