Count of times the current integer has already occurred during Array traversal

Given an array arr[], the task is to find the number of times the current integer has already occurred during array traversal. 

Examples:

Input: arr[] = {2, 3, 3, 200, 175, 2, 200, 2, 175, 3}
Output: 0 0 1 0 0 1 1 2 1 2
Explanation: Before the 0th index, 2 is encountered 0 times. Before the 2nd index, 3 is encountered once at index 1. Similarly, before the 7th index, 2 is occurred twice and so on.

Input: arr[] = {200, 200, 55, 200, 55, 2, 3, 2}
Output:  0 1 0 2 1 0 0 1

Naive Approach:

The naive approach to solve the problem is to run two nested loops: one to traverse each element of the array and another to traverse from 0 to the i-1 element to check how many times ith element has occurred already. 

Algorithm:

     1. Create a function that takes an array and its length as input.

     2. Traverse the array from 0 to n-1:
             a. Initialize a variable count to 0.
             b. Traverse the array from 0 to i-1:
                    i. If the current element matches a previous element, increment count.
             c. Print the count for the current element.

Below is the implementation of the approach:

C++

// C++ code for the approach

#include<bits/stdc++.h>
using namespace std;

// function to find the number of times
// an integer has already occurred
void countOccurences(int arr[], int n) {
    for(int i=0; i<n; i++) {
          // initialize count to 0
        int count = 0;
        for(int j=0; j<i; j++) {
              // if current element matches a previous element
            if(arr[i] == arr[j]) {
                  // increment count
                count++;
            }
        }

          // print count for current element
        cout << count << " ";
    }
}

// Driver's code
int main() {
    int arr[] = { 2, 3, 3, 200, 175,
            2, 200, 2, 175, 3 };
    int n = sizeof(arr)/sizeof(arr[0]);

      // Function call
    countOccurences(arr, n);
    return 0;
}

Output

0 0 1 0 0 1 1 2 1 2 

Time Complexity: O(N*N) as two nested loops are executing. Here, N is size of input array.

Space Complexity: O(1) as no extra space has been used.

Approach: The task can be solved by keeping track of frequencies of distinct elements till the current element using a HashMap. Follow the below steps to solve the problem:

• Create a hashmap say ‘occ‘, to store the frequencies of the distinct elements till the current element
• For the current element, check whether it already exists inside the hashmap or not.
• If it exists, store the frequency corresponding to it, else store 0.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the number of
// times current integer has already
// occurred during array traversal.
void getOccurrences(vector<int>& arr)
{
    // Store the size of array
    int n = arr.size();

    // Hashmap to keep track of
    // the frequencies
    unordered_map<int, int> occ;

    for (int i = 0; i < n; ++i) {

        // If element is already
        // present inside hashmap
        if (occ.find(arr[i]) != occ.end()) {
            cout << occ[arr[i]] << " ";
        }
        else {
            cout << 0 << " ";
        }

        // Increment the frequency
        occ[arr[i]]++;
    }
}

// Driver Code
int main()
{
    vector<int> arr
        = { 2, 3, 3, 200, 175,
            2, 200, 2, 175, 3 };
    getOccurrences(arr);

    return 0;
}

Java

// Java program for the above approach
import java.util.*;

class GFG {

  // Function to find the number of
  // times current integer has already
  // occurred during array traversal.
  static void getOccurrences(int[] arr)
  {

    // Store the size of array
    int n = arr.length;

    // Hashmap to keep track of
    // the frequencies
    HashMap<Integer, Integer> occ
      = new HashMap<Integer, Integer>();

    for (int i = 0; i < n; ++i) {

      // If element is already
      // present inside hashmap
      if (occ.containsKey(arr[i])) {
        System.out.print(occ.get(arr[i]) + " ");

        // Increment the frequency
        occ.put(arr[i], occ.get(arr[i]) + 1);
      }
      else {
        System.out.print(0 + " ");

        // Increment the frequency
        occ.put(arr[i], 1);
      }
    }
  }

  // Driver Code
  public static void main(String[] args)
  {
    int[] arr
      = { 2, 3, 3, 200, 175, 2, 200, 2, 175, 3 };
    getOccurrences(arr);
  }
}

// This code is contributed by ukasp.

Python3

# python3 program for the above approach

# Function to find the number of
# times current integer has already
# occurred during array traversal.
def getOccurrences(arr):

    # Store the size of array
    n = len(arr)

    # Hashmap to keep track of
    # the frequencies
    occ = {}

    for i in range(0, n):

        # If element is already
        # present inside hashmap
        if (arr[i] in occ):
            print(occ[arr[i]], end=" ")

        else:
            print(0, end=" ")

        # Increment the frequency
        occ[arr[i]] = occ[arr[i]] + 1 if arr[i] in occ else 1

# Driver Code
if __name__ == "__main__":

    arr = [2, 3, 3, 200, 175,
           2, 200, 2, 175, 3]
    getOccurrences(arr)

# This code is contributed by rakeshsahni

C#

// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG
{

  // Function to find the number of
  // times current integer has already
  // occurred during array traversal.
  static void getOccurrences(int []arr)
  {

    // Store the size of array
    int n = arr.Length;

    // Hashmap to keep track of
    // the frequencies
    Dictionary<int, int> occ =
      new Dictionary<int, int>();;

    for (int i = 0; i < n; ++i) {

      // If element is already
      // present inside hashmap
      if (occ.ContainsKey(arr[i])) {
        Console.Write(occ[arr[i]] + " ");

        // Increment the frequency
        occ[arr[i]] = occ[arr[i]] + 1;
      }
      else {
        Console.Write(0 + " ");

        // Increment the frequency
        occ.Add(arr[i], 1);
      }
    }
  }

  // Driver Code
  public static void Main()
  {
    int []arr
      = { 2, 3, 3, 200, 175,
         2, 200, 2, 175, 3 };
    getOccurrences(arr);

  }
}

// This code is contributed by Samim Hossain Mondal.

Javascript

<script>
       // JavaScript code for the above approach

       // Function to find the number of
       // times current integer has already
       // occurred during array traversal.
       function getOccurrences(arr) {
           // Store the size of array
           let n = arr.length;

           // Hashmap to keep track of
           // the frequencies
           let occ = new Map();

           for (let i = 0; i < n; ++i) {

               // If element is already
               // present inside hashmap
               if (occ.has(arr[i])) {
                   document.write(occ.get(arr[i]) + " ");
               }
               else {
                   document.write(0 + " ");
               }

               // Increment the frequency
               if (occ.has(arr[i]))
                   occ.set(arr[i], occ.get(arr[i]) + 1);
               else
                   occ.set(arr[i], 1);
           }
       }

       // Driver Code
       let arr
           = [2, 3, 3, 200, 175,
               2, 200, 2, 175, 3];
       getOccurrences(arr);

 // This code is contributed by Potta Lokesh
   </script>

Output

0 0 1 0 0 1 1 2 1 2 

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