### LeetCode Challenge #1207. Unique Number of Occurrences

Given an array of integers `arr`, return `true` if the number of occurrences of each value in the array is unique or `false` otherwise.

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`
##### Video Solution
###### C++ Solution
```				```
class Solution {
public:
bool uniqueOccurrences(vector<int>& arr) {

unordered_map<int,int> freq;

for(int i=0; i<arr.size(); i++)
{
freq[arr[i]]++;
}

unordered_set<int> check;

for(auto num:freq)
{
check.insert(num.second);
}

return (check.size()==freq.size());
}
};
```
```
###### Code Explanation

In this program, we have to determine whether the number of occurrences of each element in the input vector ‘arr’ is itself unique. Or, the function checks if the frequency or occurrences for each distinct element are distinct.

1. For handling a frequency we will use an unordered map named ‘freq’ which will be used to store the frequency of each element in the input array ‘arr’.
2. It then iterates through the array, and for each element, it increments the corresponding frequency ‘freq’ map.
3. For calculating the number of times each element occurs in a frequency array, we have incremented the value of frequency ‘freq[ arr [ i ] ] ++’
4. Now we will create an unordered set by the name ‘check’ ( which stores the elements in a unique form) and it stores no repeated elements.
5. Now, we will iterate through the frequency stores in the ‘freq’ map.
• And for each frequency, we will insert the frequency into the ‘check’ set.
1. Finally, we will compare the results. The function returns whether the size of the ‘check’ set is equal to the size of the ‘freq’ map. If they are equal, it means that the frequencies of occurrences for each unique element are distinct.