Given an unsorted array of n integers which can contain integers from 1 to n. Some elements can be repeated multiple times and some other elements can be absent from the array. Count frequency of all elements that are present and print the missing elements.

**Examples:**

Input:arr[] = {2, 3, 3, 2, 5}Output:Below are frequencies of all elements 1 -> 0 2 -> 2 3 -> 2 4 -> 0 5 -> 1Explanation:Frequency of elements 1 is 0, 2 is 2, 3 is 2, 4 is 0 and 5 is 1.Input:arr[] = {4, 4, 4, 4}Output:Below are frequencies of all elements 1 -> 0 2 -> 0 3 -> 0 4 -> 4Explanation:Frequency of elements 1 is 0, 2 is 0, 3 is 0 and 4 is 4.

__Simple Solution__

**Approach:**Create an extra space of size n, as elements of the array is in the range 1 to n. Use the extra space as HashMap. Traverse the array and update the count of the current element. Finally, print the frequencies of the HashMap along with the indices.**Algorithm:**- Create an extra space of size n (
*hm*), use it as a HashMap. - Traverse the array from start to end.
- For every element update
*hm[array[i]-1]*, i.e.*hm[array[i]-1]++* - Run a loop from 0 to n and print
*hm[array[i]-1]*along with the index*i*

- Create an extra space of size n (
**Implementation:**

## C++

`// C++ program to print frequencies of all array` `// elements in O(n) extra space and O(n) time` `#include<bits/stdc++.h>` `using` `namespace` `std;` `// Function to find counts of all elements present in` `// arr[0..n-1]. The array elements must be range from` `// 1 to n` `void` `findCounts(` `int` `*arr, ` `int` `n)` `{` ` ` `//Hashmap` ` ` `int` `hash[n]={0};` ` ` `// Traverse all array elements` ` ` `int` `i = 0;` ` ` `while` `(i<n)` ` ` `{` ` ` `//update the frequency of array[i]` ` ` `hash[arr[i]-1]++;` ` ` ` ` `//increase the index` ` ` `i++;` ` ` `}` ` ` `printf` `(` `"\nBelow are counts of all elements\n"` `);` ` ` `for` `(` `int` `i=0; i<n; i++)` ` ` `printf` `(` `"%d -> %d\n"` `, i+1, hash[i]);` `}` `// Driver program to test above function` `int` `main()` `{` ` ` `int` `arr[] = {2, 3, 3, 2, 5};` ` ` `findCounts(arr, ` `sizeof` `(arr)/ ` `sizeof` `(arr[0]));` ` ` `int` `arr1[] = {1};` ` ` `findCounts(arr1, ` `sizeof` `(arr1)/ ` `sizeof` `(arr1[0]));` ` ` `int` `arr3[] = {4, 4, 4, 4};` ` ` `findCounts(arr3, ` `sizeof` `(arr3)/ ` `sizeof` `(arr3[0]));` ` ` `int` `arr2[] = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9, 1};` ` ` `findCounts(arr2, ` `sizeof` `(arr2)/ ` `sizeof` `(arr2[0]));` ` ` `int` `arr4[] = {3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};` ` ` `findCounts(arr4, ` `sizeof` `(arr4)/ ` `sizeof` `(arr4[0]));` ` ` `int` `arr5[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};` ` ` `findCounts(arr5, ` `sizeof` `(arr5)/ ` `sizeof` `(arr5[0]));` ` ` `int` `arr6[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};` ` ` `findCounts(arr6, ` `sizeof` `(arr6)/ ` `sizeof` `(arr6[0]));` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to print frequencies ` `# of all array elements in O(n) extra` `# space and O(n) time ` `# Function to find counts of all ` `# elements present in arr[0..n-1].` `# The array elements must be range ` `# from 1 to n ` `def` `findCounts(arr, n):` ` ` `# Hashmap ` ` ` `hash` `=` `[` `0` `for` `i ` `in` `range` `(n)]` ` ` `# Traverse all array elements ` ` ` `i ` `=` `0` ` ` `while` `(i < n):` ` ` ` ` `# Update the frequency of array[i] ` ` ` `hash` `[arr[i] ` `-` `1` `] ` `+` `=` `1` ` ` `# Increase the index ` ` ` `i ` `+` `=` `1` ` ` ` ` `print` `(` `"Below are counts of all elements"` `)` ` ` `for` `i ` `in` `range` `(n):` ` ` `print` `(i ` `+` `1` `, ` `"->"` `, ` `hash` `[i], end ` `=` `" "` `)` ` ` `print` `()` `# Driver code` `arr ` `=` `[ ` `2` `, ` `3` `, ` `3` `, ` `2` `, ` `5` `]` `findCounts(arr, ` `len` `(arr))` `arr1 ` `=` `[` `1` `]` `findCounts(arr1, ` `len` `(arr1))` `arr3 ` `=` `[ ` `4` `, ` `4` `, ` `4` `, ` `4` `]` `findCounts(arr3, ` `len` `(arr3))` `arr2 ` `=` `[ ` `1` `, ` `3` `, ` `5` `, ` `7` `, ` `9` `, ` ` ` `1` `, ` `3` `, ` `5` `, ` `7` `, ` `9` `, ` `1` `]` `findCounts(arr2, ` `len` `(arr2))` `arr4 ` `=` `[ ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` ` ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `]` `findCounts(arr4, ` `len` `(arr4))` `arr5 ` `=` `[ ` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `, ` ` ` `6` `, ` `7` `, ` `8` `, ` `9` `, ` `10` `, ` `11` `]` `findCounts(arr5, ` `len` `(arr5))` `arr6 ` `=` `[ ` `11` `, ` `10` `, ` `9` `, ` `8` `, ` `7` `,` ` ` `6` `, ` `5` `, ` `4` `, ` `3` `, ` `2` `, ` `1` `]` `findCounts(arr6, ` `len` `(arr6))` `# This code is contributed by avanitrachhadiya2155` |

*chevron_right*

*filter_none*

**Output:**

Below are counts of all elements 1 -> 0 2 -> 2 3 -> 2 4 -> 0 5 -> 1 Below are counts of all elements 1 -> 1 Below are counts of all elements 1 -> 0 2 -> 0 3 -> 0 4 -> 4 Below are counts of all elements 1 -> 3 2 -> 0 3 -> 2 4 -> 0 5 -> 2 6 -> 0 7 -> 2 8 -> 0 9 -> 2 10 -> 0 11 -> 0 Below are counts of all elements 1 -> 0 2 -> 0 3 -> 11 4 -> 0 5 -> 0 6 -> 0 7 -> 0 8 -> 0 9 -> 0 10 -> 0 11 -> 0 Below are counts of all elements 1 -> 1 2 -> 1 3 -> 1 4 -> 1 5 -> 1 6 -> 1 7 -> 1 8 -> 1 9 -> 1 10 -> 1 11 -> 1 Below are counts of all elements 1 -> 1 2 -> 1 3 -> 1 4 -> 1 5 -> 1 6 -> 1 7 -> 1 8 -> 1 9 -> 1 10 -> 1 11 -> 1

**Complexity Analysis:****Time Complexity:**O(n).

As a single traversal of array takes O(n) time.**Space Complexity:**O(n).

To store all the elements in a HashMap O(n) space is needed.

Below are two Efficient methods to solve this in O(n) time and O(1) extra space. Both methods modify the given array to achieve O(1) extra space.

** Method 2: **By making elements negative.

**Approach:**The idea is to traverse the given array, use elements as an index and store their counts at the index. Consider the basic approach, a Hashmap of size n is needed and the array is also of size n. So the array can be used as a hashmap, all the elements of the array are from 1 to n, i.e. all are positive elements. So the frequency can be stored as negative. This might lead to a problem. Let*i-th*element be a then the count should be stored at*array[a-1]*, but when the frequency will be stored the element will be lost. To deal with this problem, first, replace the ith element by array[a-1] and then put -1 at array[a-1]. So our idea is to replace the element by frequency and store the element in the current index and if the element at array[a-1] is already negative, then it is already replaced by a frequency so decrement*array[a-1]*.

**Algorithm:**- Traverse the array from start to end.
- For each element check if the element is less than or equal to zero or not. If negative or zero skip the element as it is freqeuncy.
- If an element (
*e = array[i] – 1*) is positive, then check if*array[e]*is positive or not. If positive then that means it is the first occurrence of e in the array and replace*array[i]*with*array[e]*, i.e*array[i] = array[e]*and assign*array[e] = -1*. If*array[e]*is negative, then it is not the first occurrence, the update*array[e]*as*array[e]–*and update*array[i]*as*array[i] = 0*. - Again, traverse the array and print i+1 as value and array[i] as frequency.

**Implementation:**

## C++

`// C++ program to print frequencies of all array` `// elements in O(1) extra space and O(n) time` `#include<bits/stdc++.h>` `using` `namespace` `std;` `// Function to find counts of all elements present in` `// arr[0..n-1]. The array elements must be range from` `// 1 to n` `void` `findCounts(` `int` `*arr, ` `int` `n)` `{` ` ` `// Traverse all array elements` ` ` `int` `i = 0;` ` ` `while` `(i<n)` ` ` `{` ` ` `// If this element is already processed,` ` ` `// then nothing to do` ` ` `if` `(arr[i] <= 0)` ` ` `{` ` ` `i++;` ` ` `continue` `;` ` ` `}` ` ` `// Find index corresponding to this element` ` ` `// For example, index for 5 is 4` ` ` `int` `elementIndex = arr[i]-1;` ` ` `// If the elementIndex has an element that is not` ` ` `// processed yet, then first store that element` ` ` `// to arr[i] so that we don't lose anything.` ` ` `if` `(arr[elementIndex] > 0)` ` ` `{` ` ` `arr[i] = arr[elementIndex];` ` ` `// After storing arr[elementIndex], change it` ` ` `// to store initial count of 'arr[i]'` ` ` `arr[elementIndex] = -1;` ` ` `}` ` ` `else` ` ` `{` ` ` `// If this is NOT first occurrence of arr[i],` ` ` `// then decrement its count.` ` ` `arr[elementIndex]--;` ` ` `// And initialize arr[i] as 0 means the element` ` ` `// 'i+1' is not seen so far` ` ` `arr[i] = 0;` ` ` `i++;` ` ` `}` ` ` `}` ` ` `printf` `(` `"\nBelow are counts of all elements\n"` `);` ` ` `for` `(` `int` `i=0; i<n; i++)` ` ` `printf` `(` `"%d -> %d\n"` `, i+1, ` `abs` `(arr[i]));` `}` `// Driver program to test above function` `int` `main()` `{` ` ` `int` `arr[] = {2, 3, 3, 2, 5};` ` ` `findCounts(arr, ` `sizeof` `(arr)/ ` `sizeof` `(arr[0]));` ` ` `int` `arr1[] = {1};` ` ` `findCounts(arr1, ` `sizeof` `(arr1)/ ` `sizeof` `(arr1[0]));` ` ` `int` `arr3[] = {4, 4, 4, 4};` ` ` `findCounts(arr3, ` `sizeof` `(arr3)/ ` `sizeof` `(arr3[0]));` ` ` `int` `arr2[] = {1, 3, 5, 7, 9, 1, 3, 5, 7, 9, 1};` ` ` `findCounts(arr2, ` `sizeof` `(arr2)/ ` `sizeof` `(arr2[0]));` ` ` `int` `arr4[] = {3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3};` ` ` `findCounts(arr4, ` `sizeof` `(arr4)/ ` `sizeof` `(arr4[0]));` ` ` `int` `arr5[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11};` ` ` `findCounts(arr5, ` `sizeof` `(arr5)/ ` `sizeof` `(arr5[0]));` ` ` `int` `arr6[] = {11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};` ` ` `findCounts(arr6, ` `sizeof` `(arr6)/ ` `sizeof` `(arr6[0]));` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

## Java

`// Java program to print frequencies of all array` `// elements in O(1) extra space and O(n) time` `class` `CountFrequencies ` `{` ` ` `// Function to find counts of all elements present in` ` ` `// arr[0..n-1]. The array elements must be range from` ` ` `// 1 to n` ` ` `void` `findCounts(` `int` `arr[], ` `int` `n) ` ` ` `{` ` ` `// Traverse all array elements` ` ` `int` `i = ` `0` `;` ` ` `while` `(i < n) ` ` ` `{` ` ` `// If this element is already processed,` ` ` `// then nothing to do` ` ` `if` `(arr[i] <= ` `0` `) ` ` ` `{` ` ` `i++;` ` ` `continue` `;` ` ` `}` ` ` `// Find index corresponding to this element` ` ` `// For example, index for 5 is 4` ` ` `int` `elementIndex = arr[i] - ` `1` `;` ` ` `// If the elementIndex has an element that is not` ` ` `// processed yet, then first store that element` ` ` `// to arr[i] so that we don't lose anything.` ` ` `if` `(arr[elementIndex] > ` `0` `) ` ` ` `{` ` ` `arr[i] = arr[elementIndex];` ` ` `// After storing arr[elementIndex], change it` ` ` `// to store initial count of 'arr[i]'` ` ` `arr[elementIndex] = -` `1` `;` ` ` `} ` ` ` `else` ` ` `{` ` ` `// If this is NOT first occurrence of arr[i],` ` ` `// then decrement its count.` ` ` `arr[elementIndex]--;` ` ` `// And initialize arr[i] as 0 means the element` ` ` `// 'i+1' is not seen so far` ` ` `arr[i] = ` `0` `;` ` ` `i++;` ` ` `}` ` ` `}` ` ` `System.out.println(` `"Below are counts of all elements"` `);` ` ` `for` `(` `int` `j = ` `0` `; j < n; j++)` ` ` `System.out.println(j+` `1` `+ ` `"->"` `+ Math.abs(arr[j]));` ` ` `}` ` ` `// Driver program to test above functions` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{` ` ` `CountFrequencies count = ` `new` `CountFrequencies();` ` ` `int` `arr[] = {` `2` `, ` `3` `, ` `3` `, ` `2` `, ` `5` `};` ` ` `count.findCounts(arr, arr.length);` ` ` `int` `arr1[] = {` `1` `};` ` ` `count.findCounts(arr1, arr1.length);` ` ` `int` `arr3[] = {` `4` `, ` `4` `, ` `4` `, ` `4` `};` ` ` `count.findCounts(arr3, arr3.length);` ` ` `int` `arr2[] = {` `1` `, ` `3` `, ` `5` `, ` `7` `, ` `9` `, ` `1` `, ` `3` `, ` `5` `, ` `7` `, ` `9` `, ` `1` `};` ` ` `count.findCounts(arr2, arr2.length);` ` ` `int` `arr4[] = {` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `};` ` ` `count.findCounts(arr4, arr4.length);` ` ` `int` `arr5[] = {` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `, ` `6` `, ` `7` `, ` `8` `, ` `9` `, ` `10` `, ` `11` `};` ` ` `count.findCounts(arr5, arr5.length);` ` ` `int` `arr6[] = {` `11` `, ` `10` `, ` `9` `, ` `8` `, ` `7` `, ` `6` `, ` `5` `, ` `4` `, ` `3` `, ` `2` `, ` `1` `};` ` ` `count.findCounts(arr6, arr6.length);` ` ` `}` `}` `// This code has been contributed by Mayank Jaiswal(mayank_24)` |

*chevron_right*

*filter_none*

## Python3

`# Python3 program to print frequencies of all array` `# elements in O(1) extra space and O(n) time` `# Function to find counts of all elements present in` `# arr[0..n-1]. The array elements must be range from` `# 1 to n` `def` `findCounts(arr, n):` ` ` ` ` `# Traverse all array elements` ` ` `i ` `=` `0` ` ` `while` `i<n:` ` ` ` ` `# If this element is already processed,` ` ` `# then nothing to do` ` ` `if` `arr[i] <` `=` `0` `:` ` ` `i ` `+` `=` `1` ` ` `continue` ` ` `# Find index corresponding to this element` ` ` `# For example, index for 5 is 4` ` ` `elementIndex ` `=` `arr[i] ` `-` `1` ` ` `# If the elementIndex has an element that is not` ` ` `# processed yet, then first store that element` ` ` `# to arr[i] so that we don't lose anything.` ` ` `if` `arr[elementIndex] > ` `0` `:` ` ` `arr[i] ` `=` `arr[elementIndex]` ` ` `# After storing arr[elementIndex], change it` ` ` `# to store initial count of 'arr[i]'` ` ` `arr[elementIndex] ` `=` `-` `1` ` ` ` ` `else` `:` ` ` ` ` `# If this is NOT first occurrence of arr[i],` ` ` `# then decrement its count.` ` ` `arr[elementIndex] ` `-` `=` `1` ` ` `# And initialize arr[i] as 0 means the element` ` ` `# 'i+1' is not seen so far` ` ` `arr[i] ` `=` `0` ` ` `i ` `+` `=` `1` ` ` `print` `(` `"Below are counts of all elements"` `)` ` ` `for` `i ` `in` `range` `(` `0` `,n):` ` ` `print` `(` `"%d -> %d"` `%` `(i` `+` `1` `, ` `abs` `(arr[i])))` ` ` `print` `("")` `# Driver program to test above function` `arr ` `=` `[` `2` `, ` `3` `, ` `3` `, ` `2` `, ` `5` `]` `findCounts(arr, ` `len` `(arr))` `arr1 ` `=` `[` `1` `]` `findCounts(arr1, ` `len` `(arr1))` `arr3 ` `=` `[` `4` `, ` `4` `, ` `4` `, ` `4` `]` `findCounts(arr3, ` `len` `(arr3))` `arr2 ` `=` `[` `1` `, ` `3` `, ` `5` `, ` `7` `, ` `9` `, ` `1` `, ` `3` `, ` `5` `, ` `7` `, ` `9` `, ` `1` `]` `findCounts(arr2, ` `len` `(arr2))` `arr4 ` `=` `[` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `, ` `3` `]` `findCounts(arr4, ` `len` `(arr4))` `arr5 ` `=` `[` `1` `, ` `2` `, ` `3` `, ` `4` `, ` `5` `, ` `6` `, ` `7` `, ` `8` `, ` `9` `, ` `10` `, ` `11` `]` `findCounts(arr5, ` `len` `(arr5))` `arr6 ` `=` `[` `11` `, ` `10` `, ` `9` `, ` `8` `, ` `7` `, ` `6` `, ` `5` `, ` `4` `, ` `3` `, ` `2` `, ` `1` `]` `findCounts(arr6, ` `len` `(arr6))` `# This code is contributed` `# by shreyanshi_19` |

*chevron_right*

*filter_none*

## C#

`// C# program to print frequencies of ` `// all array elements in O(1) extra` `// space and O(n) time` `using` `System; ` `class` `GFG ` `{` `// Function to find counts of all ` `// elements present in arr[0..n-1].` `// The array elements must be range ` `// from 1 to n` `void` `findCounts(` `int` `[] arr, ` `int` `n) ` `{` ` ` `// Traverse all array elements` ` ` `int` `i = 0;` ` ` `while` `(i < n) ` ` ` `{` ` ` `// If this element is already ` ` ` `// processed, then nothing to do` ` ` `if` `(arr[i] <= 0) ` ` ` `{` ` ` `i++;` ` ` `continue` `;` ` ` `}` ` ` `// Find index corresponding to ` ` ` `// this element. For example,` ` ` `// index for 5 is 4` ` ` `int` `elementIndex = arr[i] - 1;` ` ` `// If the elementIndex has an element ` ` ` `// that is not processed yet, then ` ` ` `// first store that element to arr[i] ` ` ` `// so that we don't loose anything.` ` ` `if` `(arr[elementIndex] > 0) ` ` ` `{` ` ` `arr[i] = arr[elementIndex];` ` ` `// After storing arr[elementIndex],` ` ` `// change it to store initial count ` ` ` `// of 'arr[i]'` ` ` `arr[elementIndex] = -1;` ` ` `} ` ` ` `else` ` ` `{` ` ` `// If this is NOT first occurrence ` ` ` `// of arr[i], then decrement its count.` ` ` `arr[elementIndex]--;` ` ` `// And initialize arr[i] as 0 means ` ` ` `// the element 'i+1' is not seen so far` ` ` `arr[i] = 0;` ` ` `i++;` ` ` `}` ` ` `}` ` ` `Console.Write(` `"\nBelow are counts of "` `+ ` ` ` `"all elements"` `+ ` `"\n"` `);` ` ` `for` `(` `int` `j = 0; j < n; j++)` ` ` `Console.Write(j + 1 + ` `"->"` `+ ` ` ` `Math.Abs(arr[j]) + ` `"\n"` `);` `}` `// Driver Code` `public` `static` `void` `Main() ` `{` ` ` `GFG count = ` `new` `GFG();` ` ` `int` `[] arr = {2, 3, 3, 2, 5};` ` ` `count.findCounts(arr, arr.Length);` ` ` `int` `[] arr1 = {1};` ` ` `count.findCounts(arr1, arr1.Length);` ` ` `int` `[] arr3 = {4, 4, 4, 4};` ` ` `count.findCounts(arr3, arr3.Length);` ` ` `int` `[] arr2 = {1, 3, 5, 7, 9, 1,` ` ` `3, 5, 7, 9, 1};` ` ` `count.findCounts(arr2, arr2.Length);` ` ` `int` `[] arr4 = {3, 3, 3, 3, 3, ` ` ` `3, 3, 3, 3, 3, 3};` ` ` `count.findCounts(arr4, arr4.Length);` ` ` `int` `[] arr5 = {1, 2, 3, 4, 5, 6, ` ` ` `7, 8, 9, 10, 11};` ` ` `count.findCounts(arr5, arr5.Length);` ` ` `int` `[] arr6 = {11, 10, 9, 8, 7, 6, ` ` ` `5, 4, 3, 2, 1};` ` ` `count.findCounts(arr6, arr6.Length);` `}` `}` `// This code is contributed by ChitraNayal` |

*chevron_right*

*filter_none*

**Output:**

Below are counts of all elements 1 -> 0 2 -> 2 3 -> 2 4 -> 0 5 -> 1 Below are counts of all elements 1 -> 1 Below are counts of all elements 1 -> 0 2 -> 0 3 -> 0 4 -> 4 Below are counts of all elements 1 -> 3 2 -> 0 3 -> 2 4 -> 0 5 -> 2 6 -> 0 7 -> 2 8 -> 0 9 -> 2 10 -> 0 11 -> 0 Below are counts of all elements 1 -> 0 2 -> 0 3 -> 11 4 -> 0 5 -> 0 6 -> 0 7 -> 0 8 -> 0 9 -> 0 10 -> 0 11 -> 0 Below are counts of all elements 1 -> 1 2 -> 1 3 -> 1 4 -> 1 5 -> 1 6 -> 1 7 -> 1 8 -> 1 9 -> 1 10 -> 1 11 -> 1 Below are counts of all elements 1 -> 1 2 -> 1 3 -> 1 4 -> 1 5 -> 1 6 -> 1 7 -> 1 8 -> 1 9 -> 1 10 -> 1 11 -> 1

**Complexity Analysis:****Time Complexity:**O(n).

As a single traversal of the array takes O(n) time.**Space Complexity:**O(1).

Since no extra space is needed.

** Method 3: **By adding ‘n’ to keep track of counts.

**Approach:**All the array elements are from 1 to n. Reduce every element by 1. The array elements now are in range 0 to n-1 so it can be said that for every index i,*floor(array[i]/n) = 0*.

So as previously said that the idea is to traverse the given array, use elements as an index and store their counts at the index. Consider the basic approach, a Hashmap of size n is needed and the array is also of size n. So the array can be used as a hashmap but the difference is that instead of replacing elements add n to the*array[i]th*index.

So after the updadation the*array[i]%n*will give the ith element and*array[i]/n*will give the frequency of i+1.

**Algorithm:**- Traverse the array from start to end and reduce all the elements by 1.
- Again traverse the array from start to end.
- For each element
*array[i]%n*update*array[array[i]%n]*, i.e*array[array[i]%n]++* - Traverse the array from start to end and print
*i + 1*as value and*array[i]/n*as frequency.

**Implementation:**

## C++

`// C++ program to print frequencies of all array` `// elements in O(1) extra space and O(n) time` `#include<bits/stdc++.h>` `using` `namespace` `std;` `// Function to find counts of all elements present in` `// arr[0..n-1]. The array elements must be range from` `// 1 to n` `void` `printfrequency(` `int` `arr[],` `int` `n)` `{` ` ` `// Subtract 1 from every element so that the elements` ` ` `// become in range from 0 to n-1` ` ` `for` `(` `int` `j =0; j<n; j++)` ` ` `arr[j] = arr[j]-1;` ` ` `// Use every element arr[i] as index and add 'n' to` ` ` `// element present at arr[i]%n to keep track of count of` ` ` `// occurrences of arr[i]` ` ` `for` `(` `int` `i=0; i<n; i++)` ` ` `arr[arr[i]%n] = arr[arr[i]%n] + n;` ` ` `// To print counts, simply print the number of times n` ` ` `// was added at index corresponding to every element` ` ` `for` `(` `int` `i =0; i<n; i++)` ` ` `cout << i + 1 << ` `" -> "` `<< arr[i]/n << endl;` `}` `// Driver program to test above function` `int` `main()` `{` ` ` `int` `arr[] = {2, 3, 3, 2, 5};` ` ` `int` `n = ` `sizeof` `(arr)/` `sizeof` `(arr[0]);` ` ` `printfrequency(arr,n);` ` ` `return` `0;` `}` |

*chevron_right*

*filter_none*

## Java

`class` `CountFrequency ` `{` ` ` `// Function to find counts of all elements present in` ` ` `// arr[0..n-1]. The array elements must be range from` ` ` `// 1 to n` ` ` `void` `printfrequency(` `int` `arr[], ` `int` `n) ` ` ` `{` ` ` `// Subtract 1 from every element so that the elements` ` ` `// become in range from 0 to n-1` ` ` `for` `(` `int` `j = ` `0` `; j < n; j++)` ` ` `arr[j] = arr[j] - ` `1` `;` ` ` `// Use every element arr[i] as index and add 'n' to` ` ` `// element present at arr[i]%n to keep track of count of` ` ` `// occurrences of arr[i]` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `arr[arr[i] % n] = arr[arr[i] % n] + n;` ` ` `// To print counts, simply print the number of times n` ` ` `// was added at index corresponding to every element` ` ` `for` `(` `int` `i = ` `0` `; i < n; i++)` ` ` `System.out.println(i + ` `1` `+ ` `"->"` `+ arr[i] / n);` ` ` `}` ` ` `// Driver program to test above functions` ` ` `public` `static` `void` `main(String[] args) ` ` ` `{` ` ` `CountFrequency count = ` `new` `CountFrequency();` ` ` `int` `arr[] = {` `2` `, ` `3` `, ` `3` `, ` `2` `, ` `5` `};` ` ` `int` `n = arr.length;` ` ` `count.printfrequency(arr, n);` ` ` `}` `}` `// This code has been contributed by Mayank Jaiswal` |

*chevron_right*

*filter_none*

## Python3

`# Python 3 program to print frequencies ` `# of all array elements in O(1) extra ` `# space and O(n) time ` `# Function to find counts of all elements ` `# present in arr[0..n-1]. The array ` `# elements must be range from 1 to n ` `def` `printfrequency(arr, n):` ` ` `# Subtract 1 from every element so that ` ` ` `# the elements become in range from 0 to n-1 ` ` ` `for` `j ` `in` `range` `(n):` ` ` `arr[j] ` `=` `arr[j] ` `-` `1` ` ` `# Use every element arr[i] as index ` ` ` `# and add 'n' to element present at ` ` ` `# arr[i]%n to keep track of count of ` ` ` `# occurrences of arr[i] ` ` ` `for` `i ` `in` `range` `(n):` ` ` `arr[arr[i] ` `%` `n] ` `=` `arr[arr[i] ` `%` `n] ` `+` `n` ` ` `# To print counts, simply print the ` ` ` `# number of times n was added at index ` ` ` `# corresponding to every element ` ` ` `for` `i ` `in` `range` `(n):` ` ` `print` `(i ` `+` `1` `, ` `"->"` `, arr[i] ` `/` `/` `n)` `# Driver code` `arr ` `=` `[` `2` `, ` `3` `, ` `3` `, ` `2` `, ` `5` `]` `n ` `=` `len` `(arr)` `printfrequency(arr, n)` `# This code is contributed ` `# by Shrikant13` |

*chevron_right*

*filter_none*

## C#

`using` `System;` `internal` `class` `CountFrequency` `{` ` ` `// Function to find counts of all elements present in ` ` ` `// arr[0..n-1]. The array elements must be range from ` ` ` `// 1 to n ` ` ` `internal` `virtual` `void` `printfrequency(` `int` `[] arr, ` `int` `n)` ` ` `{` ` ` `// Subtract 1 from every element so that the elements ` ` ` `// become in range from 0 to n-1 ` ` ` `for` `(` `int` `j = 0; j < n; j++)` ` ` `{` ` ` `arr[j] = arr[j] - 1;` ` ` `}` ` ` `// Use every element arr[i] as index and add 'n' to ` ` ` `// element present at arr[i]%n to keep track of count of ` ` ` `// occurrences of arr[i] ` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `arr[arr[i] % n] = arr[arr[i] % n] + n;` ` ` `}` ` ` `// To print counts, simply print the number of times n ` ` ` `// was added at index corresponding to every element ` ` ` `for` `(` `int` `i = 0; i < n; i++)` ` ` `{` ` ` `Console.WriteLine(i + 1 + ` `"->"` `+ arr[i] / n);` ` ` `}` ` ` `}` ` ` `// Driver program to test above functions ` ` ` `public` `static` `void` `Main(` `string` `[] args)` ` ` `{` ` ` `CountFrequency count = ` `new` `CountFrequency();` ` ` `int` `[] arr = ` `new` `int` `[] {2, 3, 3, 2, 5};` ` ` `int` `n = arr.Length;` ` ` `count.printfrequency(arr, n);` ` ` `}` `}` `// This code is contributed by Shrikant13` |

*chevron_right*

*filter_none*

## PHP

`<?php` `// PHP program to print ` `// frequencies of all ` `// array elements in O(1)` `// extra space and O(n) time` `// Function to find counts ` `// of all elements present ` `// in arr[0..n-1]. The array` `// elements must be range ` `// from 1 to n` `function` `printfrequency(` `$arr` `,` `$n` `)` `{` ` ` `// Subtract 1 from every` ` ` `// element so that the ` ` ` `// elements become in ` ` ` `// range from 0 to n-1` ` ` `for` `(` `$j` `= 0; ` `$j` `< ` `$n` `; ` `$j` `++)` ` ` `$arr` `[` `$j` `] = ` `$arr` `[` `$j` `] - 1;` ` ` `// Use every element arr[i] ` ` ` `// as index and add 'n' to` ` ` `// element present at arr[i]%n ` ` ` `// to keep track of count of` ` ` `// occurrences of arr[i]` ` ` `for` `(` `$i` `= 0; ` `$i` `< ` `$n` `; ` `$i` `++)` ` ` `$arr` `[` `$arr` `[` `$i` `] % ` `$n` `] =` ` ` `$arr` `[` `$arr` `[` `$i` `] % ` `$n` `] + ` `$n` `;` ` ` `// To print counts, simply ` ` ` `// print the number of times ` ` ` `// n was added at index` ` ` `// corresponding to every element` ` ` `for` `(` `$i` `= 0; ` `$i` `< ` `$n` `; ` `$i` `++)` ` ` `echo` `$i` `+ 1, ` `" -> "` `, ` ` ` `(int)(` `$arr` `[` `$i` `] / ` `$n` `) , ` `"\n"` `;` `}` `// Driver Code` `$arr` `= ` `array` `(2, 3, 3, 2, 5);` `$n` `= sizeof(` `$arr` `);` `printfrequency(` `$arr` `,` `$n` `);` `// This code is contributed by ajit` `?>` |

*chevron_right*

*filter_none*

**Output:**

1 -> 0 2 -> 2 3 -> 2 4 -> 0 5 -> 1

**Complexity Analysis:****Time Complexity:**O(n).

Only two traversals of the array are needed and single traversal of the array takes O(n) time.**Space Complexity:**O(1).

Since, no extra space is needed.

Thanks to Vivek Kumar for suggesting this solution in a comment below.

This article is contributed by Shubham Gupta. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above

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.

## Recommended Posts:

- Duplicates in an array in O(n) time and by using O(1) extra space | Set-3
- Rearrange positive and negative numbers in O(n) time and O(1) extra space
- Find the maximum repeating number in O(n) time and O(1) extra space
- Design a stack that supports getMin() in O(1) time and O(1) extra space
- Find duplicates in O(n) time and O(1) extra space | Set 1
- Move all negative elements to end in order with extra space allowed
- Move all negative numbers to beginning and positive to end with constant extra space
- Count frequencies of all elements in array in Python using collections module
- k smallest elements in same order using O(1) extra space
- Duplicates in an array in O(n) and by using O(1) extra space | Set-2
- Rearrange an array so that arr[i] becomes arr[arr[i]] with O(1) extra space
- Shuffle array {a1, a2, .. an, b1, b2, .. bn} as {a1, b1, a2, b2, a3, b3, ……, an, bn} without using extra space
- Rearrange array in alternating positive & negative items with O(1) extra space | Set 2
- Rearrange an array in maximum minimum form | Set 2 (O(1) extra space)
- Rearrange array in alternating positive & negative items with O(1) extra space | Set 1
- Efficiently merging two sorted arrays with O(1) extra space and O(NlogN + MlogM)
- Check if array elements are consecutive in O(n) time and O(1) space (Handles Both Positive and negative numbers)
- Find the frequencies of all duplicates elements in the array
- Merge two sorted arrays with O(1) extra space
- Shuffle 2n integers in format {a1, b1, a2, b2, a3, b3, ......, an, bn} without using extra space