Count frequencies of all elements in array in O(1) extra space and O(n) time

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 -> 1
Explanation: 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 -> 4
Explanation: Frequency of elements 1 is 
0, 2 is 0, 3 is 0 and 4 is 4.

Simple Solution 

filter_none

edit
close

play_arrow

link
brightness_4
code

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

edit
close

play_arrow

link
brightness_4
code

// Java program to print frequencies of all array
// elements in O(n) extra space and O(n) time
import java.util.*;
 
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
public static void findCounts(int arr[], int n)
{
     
    // Hashmap
    int hash[] = new int[n];
    Arrays.fill(hash, 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++;
    }
    System.out.println("\nBelow are counts " +
                       "of all elements");
    for(i = 0; i < n; i++)
    {
        System.out.println((i + 1) + " -> " +
                           hash[i]);
    }
}
 
// Driver code
public static void main(String []args)
{
    int arr[] = { 2, 3, 3, 2, 5 };
    findCounts(arr, arr.length);
     
    int arr1[] = {1};
    findCounts(arr1, arr1.length);
     
    int arr3[] = { 4, 4, 4, 4 };
    findCounts(arr3, arr3.length);
     
    int arr2[] = { 1, 3, 5, 7, 9,
                   1, 3, 5, 7, 9, 1 };
    findCounts(arr2, arr2.length);
     
    int arr4[] = { 3, 3, 3, 3, 3,
                   3, 3, 3, 3, 3, 3 };
    findCounts(arr4, arr4.length);
     
    int arr5[] = { 1, 2, 3, 4, 5, 6,
                   7, 8, 9, 10, 11 };
    findCounts(arr5, arr5.length);
     
    int arr6[] = { 11, 10, 9, 8, 7,
                   6, 5, 4, 3, 2, 1 };
    findCounts(arr6, arr6.length);
}
}
 
// This code is contributed by rag2127
chevron_right

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

edit
close

play_arrow

link
brightness_4
code

// C# program to print frequencies of all array
// elements in O(n) 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
  public static void findCounts(int[] arr, int n)
  {
 
    // Hashmap
    int[] hash = new int[n];
 
    // Traverse all array elements
    int i = 0;
    while (i < n)
    {
 
      // Update the frequency of array[i]
      hash[arr[i] - 1]++;
 
      // Increase the index
      i++;
    }
    Console.WriteLine("\nBelow are counts "
                      + "of all elements");
    for (i = 0; i < n; i++)
    {
      Console.WriteLine((i + 1) + " -> " + hash[i]);
    }
  }
 
  // Driver code
  static public void Main()
  {
    int[] arr = new int[] { 2, 3, 3, 2, 5 };
    findCounts(arr, arr.Length);
    int[] arr1 = new int[] { 1 };
    findCounts(arr1, arr1.Length);
    int[] arr3 = new int[] { 4, 4, 4, 4 };
    findCounts(arr3, arr3.Length);
    int[] arr2
      = new int[] { 1, 3, 5, 7, 9, 1, 3, 5, 7, 9, 1 };
    findCounts(arr2, arr2.Length);
    int[] arr4
      = new int[] { 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3 };
    findCounts(arr4, arr4.Length);
    int[] arr5 = new int[] { 1, 2, 3, 4,  5, 6,
                            7, 8, 9, 10, 11 };
    findCounts(arr5, arr5.Length);
    int[] arr6 = new int[] { 11, 10, 9, 8, 7, 6,
                            5,  4,  3, 2, 1 };
    findCounts(arr6, arr6.Length);
  }
}
 
// This code is contributed by Dharanendra L V
chevron_right

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

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. 

filter_none

edit
close

play_arrow

link
brightness_4
code

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

edit
close

play_arrow

link
brightness_4
code

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

edit
close

play_arrow

link
brightness_4
code

# 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

edit
close

play_arrow

link
brightness_4
code

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

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

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

filter_none

edit
close

play_arrow

link
brightness_4
code

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

edit
close

play_arrow

link
brightness_4
code

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

edit
close

play_arrow

link
brightness_4
code

# 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

edit
close

play_arrow

link
brightness_4
code

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

edit
close

play_arrow

link
brightness_4
code

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

Output: 

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

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.




Article Tags :
Practice Tags :