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.
1#include <stdio.h>
2#include <stdbool.h>
3#include <stdlib.h>
4
5bool uniqueOccurrences(int* arr, int arrSize) {
6 int count[2001] = {0};
7 int hash[1001] = {0};
8
9 for(int i = 0; i < arrSize; i++) {
10 count[arr[i] + 1000]++;
11 }
12
13 for(int i = 0; i < 2001; i++) {
14 if(count[i] > 0) {
15 if(hash[count[i]])
16 return false;
17 hash[count[i]] = 1;
18 }
19 }
20
21 return true;
22}
23
24int main() {
25 int arr[] = {1, 2, 2, 1, 1, 3};
26 int arrSize = sizeof(arr) / sizeof(arr[0]);
27 printf("%s\n", uniqueOccurrences(arr, arrSize) ? "true" : "false");
28 return 0;
29}In the C implementation, we use an array count to store the frequency of each element adjusted by 1000 to handle negative indices. The hash array is used to ensure all frequencies are unique.
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.