Check if frequency of each element in given array is unique or not

Given an array arr[] of N positive integers where the integers are in the range from 1 to N, the task is to check whether the frequency of the elements in the array is unique or not. If all the frequency is unique then print “Yes”, else print “No”.

Examples:

Input: N = 5, arr[] = {1, 1, 2, 5, 5}
Output: No
Explanation: 
The array contains 2 (1’s), 1 (2’s) and 2 (5’s), since the number of frequency of 1 and 5 are the same i.e. 2 times. Therefore, this array does not satisfy the condition.

Input: N = 10, arr[] = {2, 2, 5, 10, 1, 2, 10, 5, 10, 2}
Output: Yes
Explanation: 
Number of 1’s -> 1
Number of 2’s -> 4
Number of 5’s -> 2
Number of 10’s -> 3.
Since, the number of occurrences of elements present in the array is unique. Therefore, this array satisfy the condition.

Naive Approach: The idea is to check for every number from 1 to N whether it is present in the array or not. If yes, then count the frequency of that element in the array, and store the frequency in an array. At last, just check for any duplicate element in the array and print the output accordingly.

• Iterate over every number in the range from 1 to N
  • Counting the frequency of each element in frequency[] array
• Iterate over the frequency array
  • Checking if the frequency[] array contains any duplicates or not
  • If any duplicate frequency is found then return false.
• If no duplicate frequency is found, then return true

Below is the implementation of the above approach:

C++

// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to check whether the
// frequency of elements in array
// is unique or not.
bool checkUniqueFrequency(int arr[], int n)
{

    vector<int> frequency(n + 1);

    // For counting the frequency of each element
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < n; j++) {
            if (arr[j] == i) {
                frequency[i - 1]++;
            }
        }
    }

    // Checking if frequency array contains any duplicate
    // or not
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j || frequency[i] == 0)
                continue;
            if (frequency[i] == frequency[j]) {

                // If any duplicate frequency then return
                // false
                return false;
            }
        }
    }

    // If no duplicate frequency found, then return true
    return true;
}

// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 2, 2, 5, 10, 1, 2, 10, 5, 10, 2 };
    int n = sizeof arr / sizeof arr[0];

    // Function Call
    bool res = checkUniqueFrequency(arr, n);

    // Print the result
    if (res)
        cout << "Yes" << endl;
    else
        cout << "No" << endl;
    return 0;
}

Java

/*package whatever //do not write package name here */
import java.io.*;
class GFG {

// Function to check whether the
// frequency of elements in array
// is unique or not.
static boolean checkUniqueFrequency(int arr[], int n)
{

    int[] frequency = new int[n + 1];

    // For counting the frequency of each element
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < n; j++) {
            if (arr[j] == i) {
                frequency[i - 1]++;
            }
        }
    }

    // Checking if frequency array contains any duplicate
    // or not
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            if (i == j || frequency[i] == 0)
                continue;
            if (frequency[i] == frequency[j]) {

                // If any duplicate frequency then return
                // false
                return false;
            }
        }
    }

    // If no duplicate frequency found, then return true
    return true;
}

    public static void main (String[] args) {
        // Given array arr[]
    int arr[] = { 2, 2, 5, 10, 1, 2, 10, 5, 10, 2 };
    int n = arr.length;

    // Function Call
    boolean res = checkUniqueFrequency(arr, n);

    // Print the result
    if (res)
        System.out.println("Yes");
    else
        System.out.println("No");
    }
}

// This code is contributed by aadityaburujwale.

Python3

# Python code for the above approach

# Function to check whether the
# frequency of elements in array
# is unique or not.
def checkUniqueFrequency(arr, n):
    frequency=[0]*(n + 1);

    # For counting the frequency of each element
    for i in range(1,n+1):
        for j in range(0,n):
            if (arr[j] == i):
                frequency[i - 1]+=1;

    # Checking if frequency array contains any duplicate
    # or not
    for i in range(0, n):
        for j in range(0, n):
            if (i == j or frequency[i] == 0):
                continue;
            if (frequency[i] == frequency[j]):

                # If any duplicate frequency then return
                # false
                return False;

    # If no duplicate frequency found, then return true
    return True;

# Driver Code
# Given array arr[]
arr = [ 2, 2, 5, 10, 1, 2, 10, 5, 10, 2 ];
n = len(arr);

# Function Call
res = checkUniqueFrequency(arr, n);

# Print the result
if (res):
    print("Yes");
else:
    print("No");

C#

using System;

public class GFG {

    static bool CheckUniqueFrequency(int[] arr, int n)
    {
        int[] frequency = new int[n + 1];
        // For counting the frequency of each element
        for (int i = 1; i <= n; i++) {
            for (int j = 0; j < n; j++) {
                if (arr[j] == i) {
                    frequency[i - 1]++;
                }
            }
        }

        // Checking if frequency array contains any
        // duplicate or not
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (i == j || frequency[i] == 0)
                    continue;
                if (frequency[i] == frequency[j]) {
                    // If any duplicate frequency then
                    // return false
                    return false;
                }
            }
        }

        // If no duplicate frequency found, then return true
        return true;
    }

    static void Main(string[] args)
    {
        // Given array arr[]
        int[] arr = { 2, 2, 5, 10, 1, 2, 10, 5, 10, 2 };
        int n = arr.Length;

        // Function Call
        bool res = CheckUniqueFrequency(arr, n);

        // Print the result
        if (res)
            Console.WriteLine("Yes");
        else
            Console.WriteLine("No");
    }
}

Javascript

<script>

    // Function to check whether the
    // frequency of elements in array
    // is unique or not.
    function checkUniqueFrequency(arr, n)
    {
        var frequency = Array(n + 1).fill(0);
        // For counting the frequency of each element
        for (var i = 1; i <= n; i++)
        {
            for (var j = 0; j < n; j++)
            {
                if (arr[j] == i)
                {
                    frequency[i - 1]++;
                }
            }
        }
        // Checking if frequency array contains any duplicate
        // or not
        for (var i = 0; i < n; i++)
        {
            for (var j = 0; j < n; j++)
            {
                if (i == j || frequency[i] == 0)
                {
                    continue;
                }
                if (frequency[i] == frequency[j])
                {
                    // If any duplicate frequency then return
                    // false
                    return false;
                }
            }
        }
        // If no duplicate frequency found, then return true
        return true;
    }

        // Given array arr[]
        let arr = [ 2, 2, 5, 10, 1, 2, 10, 5, 10, 2 ];
        let n = arr.length;

        // Function call
        let res = checkUniqueFrequency(arr, n);

        // Print the result
        if (res)
              document.write("Yes");
        else
               document.write("No");

 </script>

Output

Yes

Time Complexity: O(N²)
Auxiliary Space: O(N) 

Efficient Approach: The idea is to use Hashing. Below are the steps:

1. Traverse the given array arr[] and store the frequency of each element in a Map.
2. Now traverse the map and check if the count of any element occurred more than once.
3. If the count of any element in the above steps is more than one then print “No”, else print “Yes”.

Below is the implementation of the above approach:

C++

// C++ code for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to check whether the
// frequency of elements in array
// is unique or not.
bool checkUniqueFrequency(int arr[],
                          int n)
{

    // Freq map will store the frequency
    // of each element of the array
    unordered_map<int, int> freq;

    // Store the frequency of each
    // element from the array
    for (int i = 0; i < n; i++) {
        freq[arr[i]]++;
    }

    unordered_set<int> uniqueFreq;

    // Check whether frequency of any
    // two or more elements are same
    // or not. If yes, return false
    for (auto& i : freq) {
        if (uniqueFreq.count(i.second))
            return false;
        else
            uniqueFreq.insert(i.second);
    }

    // Return true if each
    // frequency is unique
    return true;
}

// Driver Code
int main()
{
    // Given array arr[]
    int arr[] = { 1, 1, 2, 5, 5 };
    int n = sizeof arr / sizeof arr[0];

    // Function Call
    bool res = checkUniqueFrequency(arr, n);

    // Print the result
    if (res)
        cout << "Yes" << endl;
    else
        cout << "No" << endl;
    return 0;
}

Java

// Java code for the above approach
import java.util.*;

class GFG{

// Function to check whether the
// frequency of elements in array
// is unique or not.
static boolean checkUniqueFrequency(int arr[],
                                    int n)
{

    // Freq map will store the frequency
    // of each element of the array
    HashMap<Integer,
            Integer> freq = new HashMap<Integer,
                                        Integer>();

    // Store the frequency of each
    // element from the array
    for(int i = 0; i < n; i++)
    {
        if(freq.containsKey(arr[i]))
        {
            freq.put(arr[i], freq.get(arr[i]) + 1);
        }else
        {
            freq.put(arr[i], 1);
        }
    }

    HashSet<Integer> uniqueFreq = new HashSet<Integer>();

    // Check whether frequency of any
    // two or more elements are same
    // or not. If yes, return false
    for(Map.Entry<Integer,
                  Integer> i : freq.entrySet())
    {
        if (uniqueFreq.contains(i.getValue()))
            return false;
        else
            uniqueFreq.add(i.getValue());
    }

    // Return true if each
    // frequency is unique
    return true;
}

// Driver Code
public static void main(String[] args)
{

    // Given array arr[]
    int arr[] = { 1, 1, 2, 5, 5 };
    int n = arr.length;

    // Function call
    boolean res = checkUniqueFrequency(arr, n);

    // Print the result
    if (res)
        System.out.print("Yes" + "\n");
    else
        System.out.print("No" + "\n");
}
}

// This code is contributed by PrinciRaj1992

Python3

# Python3 code for
# the above approach
from collections import defaultdict

# Function to check whether the
# frequency of elements in array
# is unique or not.
def checkUniqueFrequency(arr, n):

    # Freq map will store the frequency
    # of each element of the array
    freq = defaultdict (int)

    # Store the frequency of each
    # element from the array
    for i in range (n):
        freq[arr[i]] += 1

    uniqueFreq = set([])

    # Check whether frequency of any
    # two or more elements are same
    # or not. If yes, return false
    for i in freq:
        if (freq[i] in uniqueFreq):
            return False
        else:
            uniqueFreq.add(freq[i])

    # Return true if each
    # frequency is unique
    return True

# Driver Code
if __name__ == "__main__":

    # Given array arr[]
    arr = [1, 1, 2, 5, 5]
    n = len(arr)

    # Function Call
    res = checkUniqueFrequency(arr, n)

    # Print the result
    if (res):
        print ("Yes")
    else:
        print ("No")

# This code is contributed by Chitranayal

C#

// C# code for the above approach
using System;
using System.Collections.Generic;
class GFG{

// Function to check whether the
// frequency of elements in array
// is unique or not.
static bool checkUniqueFrequency(int []arr,
                                 int n)
{

    // Freq map will store the frequency
    // of each element of the array
    Dictionary<int,
               int> freq = new Dictionary<int,
                                          int>();

    // Store the frequency of each
    // element from the array
    for(int i = 0; i < n; i++)
    {
        if(freq.ContainsKey(arr[i]))
        {
            freq[arr[i]] = freq[arr[i]] + 1;
        }else
        {
            freq.Add(arr[i], 1);
        }
    }

    HashSet<int> uniqueFreq = new HashSet<int>();

    // Check whether frequency of any
    // two or more elements are same
    // or not. If yes, return false
    foreach(KeyValuePair<int,
                         int> i in freq)
    {
        if (uniqueFreq.Contains(i.Value))
            return false;
        else
            uniqueFreq.Add(i.Value);
    }

    // Return true if each
    // frequency is unique
    return true;
}

// Driver Code
public static void Main(String[] args)
{

    // Given array []arr
    int []arr = { 1, 1, 2, 5, 5 };
    int n = arr.Length;

    // Function call
    bool res = checkUniqueFrequency(arr, n);

    // Print the result
    if (res)
        Console.Write("Yes" + "\n");
    else
        Console.Write("No" + "\n");
}
}

// This code is contributed by sapnasingh4991

Javascript

<script>

// Javascript code for the above approach

// Function to check whether the
// frequency of elements in array
// is unique or not.
function checkUniqueFrequency(arr, n)
{

    // Freq map will store the frequency
    // of each element of the array
    let freq = new Map();

    // Store the frequency of each
    // element from the array
    for(let i = 0; i < n; i++)
    {
        if (freq.has(arr[i]))
        {
            freq.set(arr[i],
            freq.get(arr[i]) + 1);
        }
        else
        {
            freq.set(arr[i], 1);
        }
    }

    let uniqueFreq = new Set();

    // Check whether frequency of any
    // two or more elements are same
    // or not. If yes, return false
    for(let [key, value] of freq.entries())
    {
        if (uniqueFreq.has(value))
            return false;
        else
            uniqueFreq.add(value);
    }

    // Return true if each
    // frequency is unique
    return true;
}

// Driver Code

// Given array arr[]
let arr = [ 1, 1, 2, 5, 5 ];
let n = arr.length;

// Function call
let res = checkUniqueFrequency(arr, n);

// Print the result
if (res)
    document.write("Yes" + "<br>");
else
    document.write("No" + "<br>");

// This code is contributed by avanitrachhadiya2155

</script>

Output

No

Time Complexity: O(N), where N is the number of elements in the array.
Auxiliary Space: O(N) 

Another Approach (set):

We can traverse the array and count the frequency of each element using a hash map. Then, we can insert the frequencies into a set and check if the size of the set is equal to the number of distinct frequencies. If yes, then all the frequencies are unique, otherwise not.

Below is the implementation of the above approach:

C++

#include <bits/stdc++.h>
using namespace std;

bool checkUniqueFrequency(int arr[], int n)
{
    unordered_map<int, int> freq;
    set<int> freqSet;

    for(int i = 0; i < n; i++)
        freq[arr[i]]++;

    for(auto it : freq)
        freqSet.insert(it.second);

    return (freqSet.size() == freq.size());
}

int main()
{
    int arr[] = { 2, 2, 5, 10, 1, 2, 10, 5, 10, 2 };
    int n = sizeof arr / sizeof arr[0];

    bool res = checkUniqueFrequency(arr, n);

    if (res)
        cout << "Yes" << endl;
    else
        cout << "No" << endl;
    return 0;
}

Java

import java.util.*;

public class Main {
    // Function to check the unique frequency of the array
    public static boolean checkUniqueFrequency(int[] arr)
    {
        // Create an empty HashMap to store element
        // frequencies
        Map<Integer, Integer> freq = new HashMap<>();
        // Create an empty HashSet to store unique
        // frequencies
        Set<Integer> freqSet = new HashSet<>();

        // Loop through each element in the array
        for (int i : arr) {
            // Increment element frequency in HashMap
            freq.put(i, freq.getOrDefault(i, 0) + 1);
        }

        // Loop through each frequency in HashMap
        for (int f : freq.values()) {
            // Add frequency to HashSet
            freqSet.add(f);
        }

        // Return true if number of unique frequencies
        // equals number of element frequencies
        return freqSet.size() == freq.size();
    }

    public static void main(String[] args)
    {
        int[] arr = { 2, 2, 5, 10, 1, 2, 10, 5, 10, 2 };
        boolean res = checkUniqueFrequency(arr);

        if (res) {
            System.out.println("Yes");
        }
        else {
            System.out.println("No");
        }
    }
}

Python3

# Python program for the above approach

# Function to check the unique frequency
# of the array
def checkUniqueFrequency(arr):
    freq = {}
    freqSet = set()

    for i in arr:
        freq[i] = freq.get(i, 0) + 1

    for f in freq.values():
        freqSet.add(f)

    return len(freqSet) == len(freq)

# Driver Code
arr = [2, 2, 5, 10, 1, 2, 10, 5, 10, 2]
res = checkUniqueFrequency(arr)

if res:
    print("Yes")
else:
    print("No")

Output

Yes

Time Complexity: O(nlogn) due to the insertion operation in the set. 

Auxiliary Space: O(N)