Skip to content
Related Articles

Related Articles

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

Improve Article
Save Article
Like Article
  • Difficulty Level : Easy
  • Last Updated : 19 Jan, 2022

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

 

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)

 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!