# Find frequency of each element in a limited range array in less than O(n) time

• Difficulty Level : Medium
• Last Updated : 22 Mar, 2023

Given a sorted array arr[] of positive integers, the task is to find the frequency for each element in the array. Assume all elements in the array are less than some constant M

Note: Do this without traversing the complete array. i.e. expected time complexity is less than O(n)

Examples:

Input: arr[] = [1, 1, 1, 2, 3, 3, 5, 5, 8, 8, 8, 9, 9, 10]
Output:
Element 1 occurs 3 times
Element 2 occurs 1 times
Element 3 occurs 2 times
Element 5 occurs 2 times
Element 8 occurs 3 times
Element 9 occurs 2 times
Element 10 occurs 1 times

Input: arr[] = [2, 2, 6, 6, 7, 7, 7, 11]
Output:
Element 2 occurs 2 times
Element 6 occurs 2 times
Element 7 occurs 3 times
Element 11 occurs 1 times

## Frequency of each element in a limited range array using linear search:

To solve the problem follow the below idea:

Traverse the input array and increment the frequency of the element if the current element and the previous element are the same, otherwise reset the frequency and print the element and its frequency

Follow the given steps to solve the problem:

• Initialize frequency to 1 and index to 1.
• Traverse the array from the index position and check if the current element is equal to the previous element.
• If yes, increment the frequency and index and repeat step 2. Otherwise, print the element and its frequency and repeat step 2.
• At last(corner case), print the last element and its frequency.

Below is the implementation of the above approach:

## C++

 `// C++ program to count number of occurrences of``// each element in the array in O(n) time and O(1) space` `#include ``using` `namespace` `std;` `void` `findFrequencies(``int` `ele[], ``int` `n)``{``    ``int` `freq = 1;``    ``int` `idx = 1;``    ``int` `element = ele[0];``    ``while` `(idx < n) {` `        ``// check if the current element is equal to``        ``// previous element.``        ``if` `(ele[idx - 1] == ele[idx]) {``            ``freq++;``            ``idx++;``        ``}``        ``else` `{``            ``cout << element << ``" "` `<< freq << endl;``            ``element = ele[idx];``            ``idx++;` `            ``// reset the frequency``            ``freq = 1;``        ``}``    ``}` `    ``// print the last element and its frequency``    ``cout << element << ``" "` `<< freq;``}` `// Driver code``int` `main()``{``    ``cout << ``"---frequencies in a sorted array----"` `<< endl;``    ``int` `arr[]``        ``= { 10, 20, 30, 30, 30, 40, 50, 50, 50, 50, 70 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function call``    ``findFrequencies(arr, n);``}` `// This code is contributed by anushkaseehh`

## Java

 `// Java program to count number of occurrences of``// each element in the array in O(n) time and O(1) space` `import` `java.io.*;``import` `java.util.*;``class` `GFG {``    ``public` `static` `void` `findFrequencies(``int``[] ele, ``int` `n)``    ``{``        ``int` `freq = ``1``;``        ``int` `idx = ``1``;``        ``int` `element = ele[``0``];``        ``while` `(idx < n) {``            ``// check if the current element is equal to``            ``// previous element.``            ``if` `(ele[idx - ``1``] == ele[idx]) {``                ``freq++;``                ``idx++;``            ``}``            ``else` `{``                ``System.out.println(element + ``" "` `+ freq);``                ``element = ele[idx];``                ``idx++;` `                ``// reset the frequency``                ``freq = ``1``;``            ``}``        ``}` `        ``// print the last element and its frequency``        ``System.out.println(element + ``" "` `+ freq);``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``System.out.println(``            ``"---frequencies in a sorted array----"``);``        ``int``[] arr = { ``10``, ``20``, ``30``, ``30``, ``30``, ``40``,``                      ``50``, ``50``, ``50``, ``50``, ``70` `};``        ``int` `n = arr.length;` `        ``// Function call``        ``findFrequencies(arr, n);``    ``}``}` `// This code is contributed by Pushpesh raj.`

## Python3

 `# python3 program to count number of occurrences of``# each element in the array in O(n) time and O(1) space`  `def` `findFrequencies(ele, n):` `    ``freq ``=` `1``    ``idx ``=` `1``    ``element ``=` `ele[``0``]``    ``while` `(idx < n):` `        ``# check if the current element is equal to``        ``# previous element.``        ``if` `(ele[idx ``-` `1``] ``=``=` `ele[idx]):``            ``freq ``+``=` `1``            ``idx ``+``=` `1` `        ``else``:``            ``print``(element, ``" "``, freq)``            ``element ``=` `ele[idx]``            ``idx ``+``=` `1` `            ``# reset the frequency``            ``freq ``=` `1` `    ``# print the last element and its frequency``    ``print``(element, ``" "``, freq)`  `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``print``(``"---frequencies in a sorted array----"``)``    ``arr ``=` `[``10``, ``20``, ``30``, ``30``, ``30``, ``40``, ``50``, ``50``, ``50``, ``50``, ``70``]``    ``n ``=` `len``(arr)` `    ``# Function call``    ``findFrequencies(arr, n)` `# This code is contributed by shivanisinghss2110`

## C#

 `// C# program to count number of occurrences of``// each element in the array in O(n) time and O(1) space``using` `System;``class` `GFG {` `    ``public` `static` `void` `findFrequencies(``int``[] ele)``    ``{``        ``int` `freq = 1;``        ``int` `idx = 1;``        ``int` `element = ele[0];``        ``while` `(idx < ele.Length) {` `            ``// check if the current element is equal to``            ``// previous element.``            ``if` `(ele[idx - 1] == ele[idx]) {``                ``freq++;``                ``idx++;``            ``}``            ``else` `{``                ``Console.WriteLine(element + ``" "` `+ freq);``                ``element = ele[idx];``                ``idx++;` `                ``// reset the frequency``                ``freq = 1;``            ``}``        ``}` `        ``// print the last element and its frequency``        ``Console.WriteLine(element + ``" "` `+ freq);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``Console.WriteLine(``            ``"---frequencies in a sorted array----"``);` `        ``// Function call``        ``findFrequencies(``new` `int``[] { 10, 20, 30, 30, 30, 40,``                                    ``50, 50, 50, 50, 70 });``    ``}``}`

## Javascript

 ``

Output

```---frequencies in a sorted array----
10 1
20 1
30 3
40 1
50 4
70 1```

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

## Frequency of each element in a limited range array using Hash-Map:

To solve the problem follow the below idea:

The idea is to traverse the input array and for each distinct element of the array, store its frequency in a HashMap, and finally print the HashMap.

Follow the given steps to solve the problem:

• Create a HashMap to map the frequency to the element, i.e to store the element-frequency pair.
• Traverse the array from start to end.
• For each element in the array update the frequency, i.e hm[array[i]]++
• Traverse the HashMap and print the element frequency pair

Below is the implementation of the above approach:

## C++

 `// C++ program to count number of occurrences of``// each element in the array #include ``#include ``using` `namespace` `std;` `// It prints number of``// occurrences of each element in the array.``void` `findFrequency(``int` `arr[], ``int` `n)``{``    ``// HashMap to store frequencies``    ``unordered_map<``int``, ``int``> mp;` `    ``// traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {``        ``// update the frequency``        ``mp[arr[i]]++;``    ``}` `    ``// traverse the hashmap``    ``for` `(``auto` `i : mp) {``        ``cout << ``"Element "` `<< i.first << ``" occurs "``             ``<< i.second << ``" times"` `<< endl;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr[]``        ``= { 1, 1, 1, 2, 3, 3, 5, 5, 8, 8, 8, 9, 9, 10 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function call``    ``findFrequency(arr, n);` `    ``return` `0;``}`

## Java

 `// Java program to count number``// of occurrences of each``// element in the array``import` `java.io.*;``import` `java.util.*;``class` `GFG {` `    ``// It prints number of``    ``// occurrences of each``    ``// element in the array.``    ``static` `void` `findFrequency(``int``[] arr, ``int` `n)``    ``{``        ``Map mp``            ``= ``new` `HashMap();` `        ``// traverse the array``        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// update the frequency``            ``if` `(!mp.containsKey(arr[i]))``                ``mp.put(arr[i], ``0``);` `            ``mp.put(arr[i], mp.get(arr[i]) + ``1``);``        ``}` `        ``// traverse the hashmap``        ``for` `(Map.Entry kvp :``             ``mp.entrySet()) {``            ``System.out.println(``"Element "` `+ kvp.getKey()``                               ``+ ``" occurs "` `+ kvp.getValue()``                               ``+ ``" times"``);``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{` `        ``int``[] arr``            ``= { ``1``, ``1``, ``1``, ``2``, ``3``, ``3``, ``5``, ``5``, ``8``, ``8``, ``8``, ``9``, ``9``, ``10` `};``        ``int` `n = arr.length;` `        ``// Function call``        ``findFrequency(arr, n);``    ``}``}` `// This code is contributed by avanitrachhadiya2155`

## Python3

 `# Python program to count number of occurrences of``# each element in the array #include ` `# It prints number of``# occurrences of each element in the array.`  `def` `findFrequency(arr, n):` `    ``# HashMap to store frequencies``    ``mp ``=` `{}` `    ``# traverse the array``    ``for` `i ``in` `range``(n):` `        ``# update the frequency``        ``if` `arr[i] ``not` `in` `mp:``            ``mp[arr[i]] ``=` `0``        ``mp[arr[i]] ``+``=` `1` `    ``# traverse the hashmap``    ``for` `i ``in` `mp:``        ``print``(``"Element"``, i, ``"occurs"``, mp[i], ``"times"``)`  `# Driver function``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``1``, ``1``, ``1``, ``2``, ``3``, ``3``, ``5``, ``5``, ``8``, ``8``, ``8``, ``9``, ``9``, ``10``]``    ``n ``=` `len``(arr)` `    ``findFrequency(arr, n)` `# This code is contributed by shubhamsingh10`

## C#

 `// C# program to count number``// of occurrences of each``// element in the array``using` `System;``using` `System.Collections.Generic;``class` `GFG {` `    ``// It prints number of``    ``// occurrences of each``    ``// element in the array.``    ``static` `void` `findFrequency(``int``[] arr, ``int` `n)``    ``{``        ``// HashMap to store frequencies``        ``Dictionary<``int``, ``int``> mp``            ``= ``new` `Dictionary<``int``, ``int``>();` `        ``// traverse the array``        ``for` `(``int` `i = 0; i < n; i++) {``            ``// update the frequency``            ``if` `(!mp.ContainsKey(arr[i]))``                ``mp[arr[i]] = 0;` `            ``mp[arr[i]]++;``        ``}` `        ``// traverse the hashmap``        ``foreach``(KeyValuePair<``int``, ``int``> kvp ``in` `mp)``            ``Console.WriteLine(``"Element "` `+ kvp.Key``                              ``+ ``" occurs "` `+ kvp.Value``                              ``+ ``" times"``);``    ``}` `    ``// Driver code``    ``public` `static` `void` `Main()``    ``{``        ``int``[] arr``            ``= { 1, 1, 1, 2, 3, 3, 5, 5, 8, 8, 8, 9, 9, 10 };``        ``int` `n = arr.Length;` `        ``// Function call``        ``findFrequency(arr, n);``    ``}``}` `// This code is contributed by Chitranayal`

## Javascript

 ``

Output

```Element 10 occurs 1 times
Element 9 occurs 2 times
Element 8 occurs 3 times
Element 5 occurs 2 times
Element 3 occurs 2 times
Element 2 occurs 1 times
Element 1 occurs 3 times```

Time Complexity: O(N), only one traversal of the array is needed.
Auxiliary Space: O(N), to store the elements in the HashMap O(N) extra space is needed.

## Frequency of each element in a limited range array using binary search:

The problem can be solved in less than O(n) time if all its elements are sorted, i.e. if similar elements exist in the array then the elements are in a contiguous subarray or it can be said that if the ends of a subarray are the same then all the elements inside the subarray are equal. So the count of that element is the size of the subarray and all the elements of that subarray need not be counted.

Follow the given steps to solve the problem:

• Create a HashMap (hm) to store the frequency of elements.
• Create a recursive function that accepts an array and size.
• Check if the first element of the array is equal to the last element. If equal then all the elements are the same and update the frequency by hm[array[0]+=size
• Else divide the array into two equal halves and call the function recursively for both halves.
• Traverse the hashmap and print the element frequency pair.

Below is the implementation of the above approach:

## C++

 `// C++ program to count number of occurrences of``// each element in the array in less than O(n) time``#include ``using` `namespace` `std;` `// A recursive function to count number of occurrences``// for each element in the array without traversing``// the whole array``void` `findFrequencyUtil(``int` `arr[], ``int` `low, ``int` `high,``                       ``vector<``int``>& freq)``{``    ``// If element at index low is equal to element``    ``// at index high in the array``    ``if` `(arr[low] == arr[high]) {``        ``// increment the frequency of the element``        ``// by count of elements between high and low``        ``freq[arr[low]] += high - low + 1;``    ``}``    ``else` `{``        ``// Find mid and recurse for left and right``        ``// subarray``        ``int` `mid = (low + high) / 2;``        ``findFrequencyUtil(arr, low, mid, freq);``        ``findFrequencyUtil(arr, mid + 1, high, freq);``    ``}``}` `// A wrapper over recursive function``// findFrequencyUtil(). It print number of``// occurrences of each element in the array.``void` `findFrequency(``int` `arr[], ``int` `n)``{``    ``// create a empty vector to store frequencies``    ``// and initialize it by 0. Size of vector is``    ``// maximum value (which is last value in sorted``    ``// array) plus 1.``    ``vector<``int``> freq(arr[n - 1] + 1, 0);` `    ``// Fill the vector with frequency``    ``findFrequencyUtil(arr, 0, n - 1, freq);` `    ``// Print the frequencies``    ``for` `(``int` `i = 0; i <= arr[n - 1]; i++)``        ``if` `(freq[i] != 0)``            ``cout << ``"Element "` `<< i << ``" occurs "` `<< freq[i]``                 ``<< ``" times"` `<< endl;``}` `// Driver code``int` `main()``{``    ``int` `arr[]``        ``= { 1, 1, 1, 2, 3, 3, 5, 5, 8, 8, 8, 9, 9, 10 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function call``    ``findFrequency(arr, n);` `    ``return` `0;``}`

## Java

 `// Java program to count number of occurrences of``// each element in the array in less than O(n) time``import` `java.util.*;` `class` `GFG {` `    ``// A recursive function to count number of occurrences``    ``// for each element in the array without traversing``    ``// the whole array``    ``static` `void` `findFrequencyUtil(``int` `arr[], ``int` `low,``                                  ``int` `high, ``int``[] freq)``    ``{``        ``// If element at index low is equal to element``        ``// at index high in the array``        ``if` `(arr[low] == arr[high]) {``            ``// increment the frequency of the element``            ``// by count of elements between high and low``            ``freq[arr[low]] += high - low + ``1``;``        ``}``        ``else` `{``            ``// Find mid and recurse for left and right``            ``// subarray``            ``int` `mid = (low + high) / ``2``;``            ``findFrequencyUtil(arr, low, mid, freq);``            ``findFrequencyUtil(arr, mid + ``1``, high, freq);``        ``}``    ``}` `    ``// A wrapper over recursive function``    ``// findFrequencyUtil(). It print number of``    ``// occurrences of each element in the array.``    ``static` `void` `findFrequency(``int` `arr[], ``int` `n)``    ``{``        ``// create a empty vector to store frequencies``        ``// and initialize it by 0. Size of vector is``        ``// maximum value (which is last value in sorted``        ``// array) plus 1.``        ``int``[] freq = ``new` `int``[arr[n - ``1``] + ``1``];` `        ``// Fill the vector with frequency``        ``findFrequencyUtil(arr, ``0``, n - ``1``, freq);` `        ``// Print the frequencies``        ``for` `(``int` `i = ``0``; i <= arr[n - ``1``]; i++)``            ``if` `(freq[i] != ``0``)``                ``System.out.println(``"Element "` `+ i``                                   ``+ ``" occurs "` `+ freq[i]``                                   ``+ ``" times"``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[]``            ``= { ``1``, ``1``, ``1``, ``2``, ``3``, ``3``, ``5``, ``5``, ``8``, ``8``, ``8``, ``9``, ``9``, ``10` `};``        ``int` `n = arr.length;` `        ``// Function call``        ``findFrequency(arr, n);``    ``}``}` `// This code is contributed by 29AjayKumar`

## Python3

 `# Python 3 program to count number of occurrences of``# each element in the array in less than O(n) time` `# A recursive function to count number of occurrences``# for each element in the array without traversing``# the whole array`  `def` `findFrequencyUtil(arr, low, high, freq):` `    ``# If element at index low is equal to element``    ``# at index high in the array``    ``if` `(arr[low] ``=``=` `arr[high]):` `        ``# increment the frequency of the element``        ``# by count of elements between high and low``        ``freq[arr[low]] ``+``=` `high ``-` `low ``+` `1` `    ``else``:` `        ``# Find mid and recurse for left``        ``# and right subarray``        ``mid ``=` `int``((low ``+` `high) ``/` `2``)``        ``findFrequencyUtil(arr, low, mid, freq)``        ``findFrequencyUtil(arr, mid ``+` `1``, high, freq)` `# A wrapper over recursive function``# findFrequencyUtil(). It print number of``# occurrences of each element in the array.`  `def` `findFrequency(arr, n):` `    ``# create a empty vector to store frequencies``    ``# and initialize it by 0. Size of vector is``    ``# maximum value (which is last value in sorted``    ``# array) plus 1.``    ``freq ``=` `[``0` `for` `i ``in` `range``(n ``-` `1` `+` `1``)]` `    ``# Fill the vector with frequency``    ``findFrequencyUtil(arr, ``0``, n ``-` `1``, freq)` `    ``# Print the frequencies``    ``for` `i ``in` `range``(``0``, arr[n ``-` `1``] ``+` `1``, ``1``):``        ``if` `(freq[i] !``=` `0``):``            ``print``(``"Element"``, i, ``"occurs"``,``                  ``freq[i], ``"times"``)`  `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``1``, ``1``, ``1``, ``2``, ``3``, ``3``, ``5``,``           ``5``, ``8``, ``8``, ``8``, ``9``, ``9``, ``10``]``    ``n ``=` `len``(arr)` `    ``# Function call``    ``findFrequency(arr, n)` `# This code is contributed by``# Surendra_Gangwar`

## C#

 `// C# program to count number of occurrences of``// each element in the array in less than O(n) time``using` `System;` `class` `GFG {` `    ``// A recursive function to count number of occurrences``    ``// for each element in the array without traversing``    ``// the whole array``    ``static` `void` `findFrequencyUtil(``int``[] arr, ``int` `low,``                                  ``int` `high, ``int``[] freq)``    ``{``        ``// If element at index low is equal to element``        ``// at index high in the array``        ``if` `(arr[low] == arr[high]) {``            ``// increment the frequency of the element``            ``// by count of elements between high and low``            ``freq[arr[low]] += high - low + 1;``        ``}``        ``else` `{``            ``// Find mid and recurse for left and right``            ``// subarray``            ``int` `mid = (low + high) / 2;``            ``findFrequencyUtil(arr, low, mid, freq);``            ``findFrequencyUtil(arr, mid + 1, high, freq);``        ``}``    ``}` `    ``// A wrapper over recursive function``    ``// findFrequencyUtil(). It print number of``    ``// occurrences of each element in the array.``    ``static` `void` `findFrequency(``int``[] arr, ``int` `n)``    ``{``        ``// create a empty vector to store frequencies``        ``// and initialize it by 0. Size of vector is``        ``// maximum value (which is last value in sorted``        ``// array) plus 1.``        ``int``[] freq = ``new` `int``[arr[n - 1] + 1];` `        ``// Fill the vector with frequency``        ``findFrequencyUtil(arr, 0, n - 1, freq);` `        ``// Print the frequencies``        ``for` `(``int` `i = 0; i <= arr[n - 1]; i++)``            ``if` `(freq[i] != 0)``                ``Console.WriteLine(``"Element "` `+ i``                                  ``+ ``" occurs "` `+ freq[i]``                                  ``+ ``" times"``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr``            ``= { 1, 1, 1, 2, 3, 3, 5, 5, 8, 8, 8, 9, 9, 10 };``        ``int` `n = arr.Length;` `        ``// Function call``        ``findFrequency(arr, n);``    ``}``}` `// This code is contributed by Princi Singh`

## Javascript

 ``

Output

```Element 1 occurs 3 times
Element 2 occurs 1 times
Element 3 occurs 2 times
Element 5 occurs 2 times
Element 8 occurs 3 times
Element 9 occurs 2 times
Element 10 occurs 1 times```

Time Complexity: O(m log N). Where m is the number of distinct elements in the array of size N. Since m <= M (a constant) (elements are in a limited range), the time complexity of this solution is O(log N)
Auxiliary Space: O(N). To store the elements in the HashMap O(n) extra space is needed.

## Frequency of each element in a limited range array using the input array as a Hash-Map:

In this method, we use the same array as the hash map by modifying its content:

Dry run of this approach:

Input: arr = { 1, 1, 1, 2, 3, 3, 5, 5, 8, 8, 8, 9, 9, 10 };

Step 1: Subtract 1 from each element of the array
arr  = {0 ,0 ,0 ,1 ,2 ,2 ,4 ,4 ,7 ,7 ,7 ,8 ,8 ,9 }

Step 2: Add n to the index at which the current array element points.
for example :-
when i=0, arr[arr[0]%n] = 0 adding n to the arr[0], arr[0] =  14;
when i=1, arr[arr[1]%n] = 14 adding n to arr[0] ,arr[0] = 28;
Similarly finding the modified array in the same way we will get array as
arr = {42 ,14 ,28 ,1 ,30, 2, 4, 46, 35, 21, 7, 8, 8, 9}

Step 3: Now in step 2 if you have noticed we added the n value to the index at which a particular element points to. So if we have more than one time have a element that point to the same index then in that case the division of the modified number with the n gives us the frequency of the number.
for example
at i=0; arr[0] =42; arr[0] / n = 3 it means that 0  appeared three times in the modified array as you can see in the arr of step 1.
at i=1; arr[1] =14; arr[1]/14 = 1 it means that 1 appeared once in the modified array as you can see in the arr of step 1 .
and similarly for other values we can calculate.

Below is the implementation of the above approach:

## C++

 `// C++ program to count number of occurrences of``// each element in the array #include ``#include ``using` `namespace` `std;` `// It prints number of occurrences of each element in the``// array.``void` `findFrequency(``int` `input[], ``int` `n)``{``    ``for` `(``int` `i = 0; i < n; i++)``        ``input[i]--;` `    ``for` `(``int` `i = 0; i < n; i++)``        ``input[input[i] % n] += n;` `    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(input[i] / n)``            ``cout << ``"Element "` `<< (i + 1) << ``" occurs "``                 ``<< input[i] / n << ``" times"` `<< endl;``        ``// Change the element back to original value``        ``input[i] = input[i] % n + 1;``    ``}``}` `// Driver code``int` `main()``{``    ``int` `arr[]``        ``= { 1, 1, 1, 2, 3, 3, 5, 5, 8, 8, 8, 9, 9, 10 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``// Function call``    ``findFrequency(arr, n);` `    ``return` `0;``}` `// This code is contributed by aditya kumar(adiyakumar129)`

## Java

 `// Java program to count number of occurrences of each``// element in the array``import` `java.io.*;``import` `java.util.*;``class` `GFG {` `    ``// It prints number of occurrences of each element in``    ``// the array.``    ``static` `void` `findFrequency(``int``[] input, ``int` `n)``    ``{``        ``for` `(``int` `i = ``0``; i < n; i++)``            ``input[i]--;` `        ``for` `(``int` `i = ``0``; i < n; i++)``            ``input[input[i] % n] += n;` `        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `((input[i] / n) != ``0``)``                ``System.out.println(``                    ``"Element "` `+ (i + ``1``) + ``" occurs "``                    ``+ input[i] / n + ``" times"``);``            ``// Change the element back to original value``            ``input[i] = input[i] % n + ``1``;``        ``}``    ``}` `    ``// Driver code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] arr``            ``= { ``1``, ``1``, ``1``, ``2``, ``3``, ``3``, ``5``, ``5``, ``8``, ``8``, ``8``, ``9``, ``9``, ``10` `};``        ``int` `n = arr.length;` `        ``// Function call``        ``findFrequency(arr, n);``    ``}``}` `// This code is contributed by aditya kumar(adiyakumar129)`

## Python3

 `# Javascript program to count number of occurrences of``# each element in the array` `# It prints number of``# occurrences of each element in the array.`  `def` `findFrequency(``input``, n):``    ``for` `i ``in` `range``(n):``        ``input``[i] ``-``=` `1` `    ``for` `i ``in` `range``(n):``        ``input``[``input``[i] ``%` `n] ``+``=` `n` `    ``for` `i ``in` `range``(n):``        ``if` `input``[i] ``/``/` `n:``            ``print``(``"Element"``, i ``+` `1``, ``"occurs"``, ``input``[i] ``/``/` `n, ``"times"``)` `        ``# change element back to original value``        ``input``[i] ``=` `input``[i] ``%` `n ``+` `1`  `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``1``, ``1``, ``1``, ``2``, ``3``, ``3``, ``5``, ``5``, ``8``, ``8``, ``8``, ``9``, ``9``, ``10``]``    ``n ``=` `len``(arr)` `    ``# Function call``    ``findFrequency(arr, n)` `# This code is contributed by phasing17`

## C#

 `// C# program to count number of occurrences of each element``// in the array``using` `System;` `public` `class` `GFG {` `    ``// It prints number of occurrences of each element in``    ``// the array.``    ``static` `void` `findFrequency(``int``[] input, ``int` `n)``    ``{``        ``for` `(``int` `i = 0; i < n; i++)``            ``input[i]--;` `        ``for` `(``int` `i = 0; i < n; i++)``            ``input[input[i] % n] += n;` `        ``for` `(``int` `i = 0; i < n; i++) {``            ``if` `((input[i] / n) != 0)``                ``Console.WriteLine(``                    ``"Element "` `+ (i + 1) + ``" occurs "``                    ``+ input[i] / n + ``" times"``);``            ``// Change the element back to original value``            ``input[i] = input[i] % n + 1;``        ``}``    ``}` `    ``// Driver function``    ``public` `static` `void` `Main(String[] args)``    ``{``        ``int``[] arr``            ``= { 1, 1, 1, 2, 3, 3, 5, 5, 8, 8, 8, 9, 9, 10 };``        ``int` `n = arr.Length;` `        ``// Function call``        ``findFrequency(arr, n);``    ``}``}` `// This code is contributed by shikhasingrajput`

## Javascript

 ``

Output

```Element 1 occurs 3 times
Element 2 occurs 1 times
Element 3 occurs 2 times
Element 5 occurs 2 times
Element 8 occurs 3 times
Element 9 occurs 2 times
Element 10 occurs 1 times```

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

## C

 `#include ` `int``* frequencyCount(``int` `arr[], ``int` `n, ``int` `p) {``    ``int``* freq = ``calloc``(p, ``sizeof``(``int``));``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(arr[i] >= 1 && arr[i] <= p) {``            ``freq[arr[i]-1]++;``        ``}``    ``}``    ``for` `(``int` `i = 0; i < p; i++) {``        ``printf``(``"%d occurring %d times.\n"``, i+1, freq[i]);``    ``}``    ``return` `freq;``}` `int` `main() {``    ``int` `arr[] = {2, 2, 6, 6, 7, 7, 7, 11};``    ``int` `n = 8;``    ``int` `p = 11;``    ``int``* freq = frequencyCount(arr, n, p);``  ``for` `(``int` `i = 0; i < p; i++) {``       ``printf``(``"%d "``,freq[i] );``    ``}``    ``free``(freq);``    ``return` `0;``}`

## C++

 `#include `  `using` `namespace` `std;` `vector<``int``> frequencyCount(``int` `arr[], ``int` `n, ``int` `p) {``    ``vector<``int``> freq(p, 0);``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(arr[i] >= 1 && arr[i] <= p) {``            ``freq[arr[i]-1]++;``        ``}``    ``}``    ``for` `(``int` `i = 0; i < p; i++) {``        ``cout << i+1 << ``" occurring "` `<< freq[i] << ``" times."` `<< endl;``    ``}``    ``return` `freq;``}` `int` `main() {``    ``int` `arr[] = {2, 2, 6, 6, 7, 7, 7, 11};``    ``int` `n = 8;``    ``int` `p = 11;``    ``vector<``int``> freq = frequencyCount(arr, n, p);``    ``for` `(``int` `i = 0; i < freq.size(); i++) {``        ``cout <

## Python3

 `def` `frequencyCount(arr, n, p):``    ``freq ``=` `[``0``] ``*` `p``    ``for` `i ``in` `range``(n):``        ``if` `arr[i] >``=` `1` `and` `arr[i] <``=` `p:``            ``freq[arr[i]``-``1``] ``+``=` `1``    ``for` `i ``in` `range``(p):``        ``print``(i``+``1``, ``"occurring"``, freq[i], ``"times."``)``    ``return` `freq`  `if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``2``, ``2``, ``6``, ``6``, ``7``, ``7``, ``7``, ``11``]``    ``n ``=` `len``(arr)``    ``p ``=` `11``    ``freq ``=` `frequencyCount(arr, n, p)``    ``print``(freq)`

## Java

 `import` `java.util.Arrays;` `public` `class` `Solution {``    ``public` `int``[] frequencyCount(``int``[] arr, ``int` `n, ``int` `p) {``        ``int``[] freq = ``new` `int``[p];``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `(arr[i] >= ``1` `&& arr[i] <= p) {``                ``freq[arr[i]-``1``]++;``            ``}``        ``}``        ``for` `(``int` `i = ``0``; i < p; i++) {``            ``System.out.println((i+``1``) + ``" occurring "` `+ freq[i] + ``" times."``);``        ``}``        ``return` `freq;``    ``}` `    ``public` `static` `void` `main(String[] args) {``        ``int``[] arr = {``2``, ``2``, ``6``, ``6``, ``7``, ``7``, ``7``, ``11``};``        ``int` `n = ``8``;``        ``int` `p = ``11``;``        ``Solution solution = ``new` `Solution();``        ``int``[] freq = solution.frequencyCount(arr, n, p);``        ``System.out.println(Arrays.toString(freq));``    ``}``}`

## Javascript

 `// Defining a function to count the frequency of numbers in an array``function` `frequencyCount(arr, n, p) {``    ``// Creating a vector of size p with all elements initialized to 0``    ``let freq = ``new` `Array(p).fill(0);``    ``for` `(let i = 0; i < n; i++) {``        ``if` `(arr[i] >= 1 && arr[i] <= p) {``            ``freq[arr[i] - 1]++;``        ``}``    ``}``    ``for` `(let i = 0; i < p; i++) {``        ``console.log(i + 1 + ``" occurring "` `+ freq[i] + ``" times."``);``    ``}``    ``return` `freq;``}` `// Defining the main function``function` `main() {``    ``let arr = [2, 2, 6, 6, 7, 7, 7, 11];``    ``let n = 8;``    ``let p = 11;``    ``let freq = frequencyCount(arr, n, p);` `    ``console.log(freq.join(``" "``));` `}` `// Calling the main function``main();`

Output

```1 occurring 0 times.
2 occurring 2 times.
3 occurring 0 times.
4 occurring 0 times.
5 occurring 0 times.
6 occurring 2 times.
7 occurring 3 times.
8 occurring 0 times.
9 occurring 0 times.
10 occurring 0 times.
11 occurring 1 times.```

The time complexity of the frequencyCount function is O(n), where n is the length of the input array arr. This is because the function iterates over the entire array once to calculate the frequency of each element.

The Auxiliary space of the frequencyCount function is O(p), where p is the range of the elements in the input array. This is because the function creates a new list freq of size p to store the frequency of each element in the range 1 to p.

https://youtu.be/B2hI-QPoisk