GeeksforGeeks App
Open App
Browser
Continue

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

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 <bits/stdc++.h>
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

```<script>
// JavaScript program to count number of occurrences of
// each element in the array in O(n) time and O(1) space
function void findFrequencies(ele)
{
var freq = 1;
var idx = 1;
var 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
{
document.write(element + " " + freq);
element = ele[idx];
idx++;

// reset the frequency
freq = 1;
}
}

// print the last element and its frequency
document.write(element + " " + freq);
}

// Driver code
document.write(
"---frequencies in a sorted array----");
findFrequencies(new var[] { 10, 20, 30, 30, 30, 40,
50, 50, 50, 50, 70 });

// This code is contributed by shivanisinghss2110
</script>```
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 <iostream>
#include <bits/stdc++.h>
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<Integer, Integer> mp
= new HashMap<Integer, Integer>();

// 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<Integer, Integer> 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 <iostream>

# 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

```<script>

// Javascript program to count number
// of occurrences of each
// element in the array

// It prints number of
// occurrences of each
// element in the array.
function findFrequency(arr, n)
{
let mp = new Map();

// Traverse the array
for(let i = 0; i < n; i++)
{

// Update the frequency
if (!mp.has(arr[i]))
mp.set(arr[i],0);

mp.set(arr[i], mp.get(arr[i]) + 1);
}

// Traverse the hashmap
for(let [key, value] of mp.entries())
{
document.write("Element " + key +
" occurs " + value +
" times<br>");
}
}

// Driver code
let arr = [ 1, 1, 1, 2, 3, 3, 5,
5, 8, 8, 8, 9, 9, 10 ];
let n = arr.length;

findFrequency(arr, n);

// This code is contributed by patel2127

</script>```
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 <bits/stdc++.h>
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

```<script>
// Javascript 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
function 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
let mid = Math.floor((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.
function 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.
let freq = new Array(arr[n - 1] + 1);

for(let i = 0; i < arr[n - 1] + 1; i++)
{
freq[i] = 0;
}

// Fill the vector with frequency
findFrequencyUtil(arr, 0, n - 1, freq);

// Print the frequencies
for (let i = 0; i <= arr[n - 1]; i++)
if (freq[i] != 0)
document.write("Element " + i + " occurs " + freq[i] + " times<br>");
}

// Driver Code
let arr = [1, 1, 1, 2, 3, 3, 5,
5, 8, 8, 8, 9, 9, 10 ];
let n = arr.length;
findFrequency(arr, n);

// This code is contributed by rag2127.
</script>```
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 <iostream>
#include <bits/stdc++.h>
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;
}

## 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);
}
}

## 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

```<script>
// Javascript program to count number of occurrences of
// each element in the array

// It prints number of
// occurrences of each element in the array.
function findFrequency(input, n)
{
for (let i = 0; i < n; i++)
input[i]--;

for (let i = 0; i < n; i++)
input[input[i] % n] += n;

console.log(input)
for (let i = 0; i < n; i++) {
if (Math.floor(input[i] / n))
document.write("Element " + (i + 1) +
" occurs " + Math.floor(input[i] / n) + " times <br>");

// Change the element back to original value
input[i] = input[i] % n + 1;
}
}

// Driver function
let arr = [1, 1, 1, 2, 3, 3, 5, 5, 8, 8, 8, 9, 9, 10];
let n = arr.length;

findFrequency(arr, n);

// This code is contributed by Saurabh Jaiswal
</script>```
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 <stdio.h>

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 <bits/stdc++.h>

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 << freq[i] << " ";
}
cout << endl;
return 0;
}```

## 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();```

## C#

```using System;

class Program {
static 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++) {
Console.WriteLine("{0} occurring {1} times.", i+1, freq[i]);
}
return freq;
}

static void 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++) {
Console.Write(freq[i] + " ");
}
}
}
```
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