Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Count the elements having frequency equals to its value | Set 2

  • Last Updated : 13 Sep, 2021

Given an array of integers arr[] of size N, the task is to count all the elements of the array which have a frequency equals to its value.
Examples: 

Input: arr[] = {3, 2, 2, 3, 4, 3} 
Output: 2 
Explanation : 
Frequency of element 2 is 2 
Frequency of element 3 is 3 
Frequency of element 4 is 1 
2 and 3 are elements which have same frequency as it’s value 

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {1, 2, 3, 4, 5, 6} 
Output: 1 



Approach:  Follow the steps below to solve the problem: 

  1. Store the frequencies of every array element with the value less than equal to the given array size in freq[] array.
  2. The reason for the above step is that the frequency of an element can be at most equal to the size of the given array. Hence, there is no need to store the frequency of an element, whose value is greater than the given array size.
  3. Count the integers having frequencies equal to its value.
  4. Print the final count.

Below is the implementation of the above approach:
 

C++




// C++ program of the
// above approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find the integer
// which has a frequency in the
// array equal to its value.
void solve(int arr[], int n)
{
    // Store frequency of array
    // elements
    int freq[n+1] ={0};
 
    for (int i = 0; i < n; i++) {
 
        // Store the frequency
        // only if arr[i]<=n
        if (arr[i] <= n)
            freq[arr[i]]++;
    }
 
    // Initially the count is zero
    int count = 0;
 
    for (int i = 1; i <= n; i++) {
        // If the freq[i] is equal
        // to i, then increment
        // the count by 1
        if (i == freq[i]) {
            count++;
        }
    }
 
    // Print the final count
    cout << count << "\n";
}
 
// Driver Code
int main()
{
    int arr[] = { 3, 1, 1, 3, 2, 2, 3 };
    int N = sizeof(arr) / sizeof(arr[0]);
 
    solve(arr, N);
    return 0;
}
Java



// Java program of the
// above approach
class GFG{
 
// Function to find the integer
// which has a frequency in the
// array equal to its value.
static void solve(int arr[],
                  int n)
{
  // Store frequency of array
  // elements
  int []freq = new int[n + 1];
 
  for (int i = 0; i < n; i++)
  {
    // Store the frequency
    // only if arr[i]<=n
    if (arr[i] <= n)
      freq[arr[i]]++;
  }
 
  // Initially the count is zero
  int count = 0;
 
  for (int i = 1; i <= n; i++)
  {
    // If the freq[i] is equal
    // to i, then increment
    // the count by 1
    if (i == freq[i])
    {
      count++;
    }
  }
 
  // Print the final count
  System.out.print(count + "\n");
}
 
// Driver Code
public static void main(String[] args)
{
  int arr[] = {3, 1, 1, 3, 2, 2, 3};
  int N = arr.length;
  solve(arr, N);
}
}
 
// This code is contributed by shikhasingrajput
Python3



# Python3 program of the
# above approach
 
# Function to find the integer
# which has a frequency in the
# array equal to its value.
def solve(arr, n):
   
    # Store frequency of array
    # elements
    freq = [0] * (n + 1);
 
    for i in range(n):
       
        # Store the frequency
        # only if arr[i]<=n
        if (arr[i] <= n):
            freq[arr[i]] += 1;
 
    # Initially the count is zero
    count = 0;
 
    for i in range(1, n + 1):
       
        # If the freq[i] is equal
        # to i, then increment
        # the count by 1
        if (i == freq[i]):
            count += 1;
 
    # Print final count
    print(count , "");
 
 
# Driver Code
if __name__ == '__main__':
   
    arr = [3, 1, 1, 3,
           2, 2, 3];
    N = len(arr);
    solve(arr, N);
 
# This code is contributed by shikhasingrajput
C#



// C# program of the
// above approach
using System;
class GFG{
 
// Function to find the integer
// which has a frequency in the
// array equal to its value.
static void solve(int []arr,
                  int n)
{
  // Store frequency of array
  // elements
  int []freq = new int[n + 1];
 
  for (int i = 0; i < n; i++)
  {
    // Store the frequency
    // only if arr[i]<=n
    if (arr[i] <= n)
      freq[arr[i]]++;
  }
 
  // Initially the count is zero
  int count = 0;
 
  for (int i = 1; i <= n; i++)
  {
    // If the freq[i] is equal
    // to i, then increment
    // the count by 1
    if (i == freq[i])
    {
      count++;
    }
  }
 
  // Print the readonly count
  Console.Write(count + "\n");
}
 
// Driver Code
public static void Main(String[] args)
{
  int []arr = {3, 1, 1, 3, 2, 2, 3};
  int N = arr.Length;
  solve(arr, N);
}
}
 
// This code is contributed by shikhasingrajput
Javascript



<script>
 
// Javascript program for
// the above approach
 
// Function to find the integer
// which has a frequency in the
// array equal to its value.
function solve(arr, n)
{
 
  // Store frequency of array
  // elements
  let freq = Array.from({length: n+1}, (_, i) => 0);
  
  for (let i = 0; i < n; i++)
  {
   
    // Store the frequency
    // only if arr[i]<=n
    if (arr[i] <= n)
      freq[arr[i]]++;
  }
  
  // Initially the count is zero
  let count = 0;
  
  for (let i = 1; i <= n; i++)
  {
   
    // If the freq[i] is equal
    // to i, then increment
    // the count by 1
    if (i == freq[i])
    {
      count++;
    }
  }
  
  // Print the final count
  document.write(count + "<br/>");
}
 
// Driver code
     
  let arr = [ 3, 1, 1, 3, 2, 2, 3 ];
  let N = arr.length;
  solve(arr, N);
  
 // This code is contributed by souravghosh0416.
</script>
Output
2
Time Complexity: O(N) 
Auxiliary Space: O(N)
Refer to the previous post for O(N*log(N)) approach.



My Personal Notes
arrow_drop_up
Previous
Count pairs in an array containing at least one even value
Next

Last two digits of powers of 7
Recommended Articles
Page :
Count the elements having frequency equals to its value
19, Apr 20
Maximum difference between frequency of two elements such that element having greater frequency is also greater
13, Feb 17
Find the index having sum of elements on its left equal to reverse of the sum of elements on its right
13, Jan 21
Count of Array elements greater than all elements on its left and at least K elements on its right
29, Jul 20
Count of Array elements greater than all elements on its left and next K elements on its right
05, Aug 20
Value to be subtracted from array elements to make sum of all elements equals K
18, Dec 19
Count of Binary Strings of length N such that frequency of 1's exceeds frequency of 0's
12, Aug 20
Minimum removals required to make frequency of each array element equal to its value
08, Dec 20
Check if frequency of each digit in a number is equal to its value
03, Nov 21
Minimize insertions or deletions to make frequency of each array element equal to its value
18, Nov 21
Largest number in the Array having frequency same as value
11, May 20
Replace every elements in the array by its frequency in the array
10, Nov 18
Lexicographically largest array possible from first N natural numbers such that every repetition is present at distance equal to its value from its previous occurrence
15, Feb 21
Generate a number such that the frequency of each digit is digit times the frequency in given number
26, Oct 18
Check if frequency of character in one string is a factor or multiple of frequency of same character in other string
16, Nov 18
Maximum length prefix such that frequency of each character is atmost number of characters with minimum frequency
30, Mar 20
Count array elements having at least one smaller element on its left and right side
09, Nov 20
Count subsequences having average of its elements equal to K
27, Jan 21
Find the element having different frequency than other array elements
08, Dec 18
Smallest subarray having an element with frequency greater than that of other elements
18, Jul 20
Sum of elements in an array having prime frequency
29, Nov 18
Product of elements in an array having prime frequency
17, Sep 19
XOR of elements in an array having prime frequency
20, Sep 19
Bitwise XOR of elements having odd frequency
04, Oct 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
manoj_n
@manoj_n
Vote for difficulty





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!