Count all elements in the array which appears at least K times after their first occurrence

Given an array arr[] of N integer elements and an integer K. The task is to count all distinct arr[i] such that arr[i] appears at least K times in the index range i + 1 to n – 1.

Examples:

Input: arr[] = {1, 2, 1, 3}, K = 1
Output: 1
arr[0] = 1 is the only element that appears at least once in the index range [1, 3] i.e. arr[2]

Input: arr[] = {1, 2, 3, 2, 1, 3, 1, 2, 1}, K = 2
Output: 2

Naive Approach: Start from i = 0 to n-1, count occurrences of arr[i] in range i+1 to n-1. If the count is greater or equal to K, increment result by 1. Make a hash array to avoid duplicates.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <iostream>
#include <map>
using namespace std;
  
// Function to return the count of
// all distinct valid elements
int countOccurrence(int n, int arr[], int k)
{
    int cnt, ans = 0;
  
    // To avoid duplicates
    map<int, bool> hash;
  
    // Traverse the complete array
    for (int i = 0; i < n; i++) {
        cnt = 0;
  
        // If current element is previously checked
        // don't check it again
        if (hash[arr[i]] == true)
            continue;
  
        // To avoid duplicates
        hash[arr[i]] = true;
  
        // Count occurence of arr[i] in range [i + 1, n - 1]
        for (int j = i + 1; j < n; j++) {
            if (arr[j] == arr[i])
                cnt++;
  
            // If count becomes equal to K
            // break the loop
            if (cnt >= k)
                break;
        }
  
        // If cnt >= K
        // increment ans by 1
        if (cnt >= k)
            ans++;
    }
  
    return ans;
}
  
// Driver code
int main()
{
    int arr[] = { 1, 2, 1, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 1;
    cout << countOccurrence(n, arr, k);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
import java.util.HashMap;
  
class GFG
{
  
    // Function to return the count of
    // all distinct valid elements
    public static int countOccurence(int n, int[] arr, int k) 
    {
        int cnt, ans = 0;
  
        // To avoid duplicates
        HashMap<Integer, Boolean> hash = new HashMap<>();
  
        // Traverse the complete array 
        for (int i = 0; i < n; i++) 
        
            cnt = 0
  
            // If current element is previously checked 
            // don't check it again
            if (hash.get(arr[i]) != null && hash.get(arr[i]) == true)
                continue;
  
                // To avoid duplicates
                hash.put(arr[i], true);
  
                // Count occurence of arr[i] in range [i + 1, n - 1] 
                for (int j = i + 1; j < n; j++)
                
                    if (arr[j] == arr[i]) 
                        cnt++; 
  
                    // If count becomes equal to K 
                    // break the loop 
                    if (cnt >= k) 
                    break
                
  
                // If cnt >= K 
                // increment ans by 1 
                if (cnt >= k) 
                    ans++; 
        
  
        return ans; 
    }
      
    // Driver Code
    public static void main(String[] args) 
    {
        int[] arr = {1, 2, 1, 3};
        int n = arr.length;
        int k = 1;
        System.out.println(countOccurence(n, arr, k));
    }
}
  
// This code is contributed by
// sanjeev2552

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach
  
# Function to return the count of
# all distinct valid elements
def countOccurrence(n, arr, k):
  
    cnt, ans = 0, 0
  
    # To avoid duplicates
    Hash = dict()
  
    # Traverse the complete array
    for i in range(n):
        cnt = 0
  
        # If current element is previously 
        # checked don't check it again
        if (arr[i] in Hash.keys()):
            continue
  
        # To avoid duplicates
        Hash[arr[i]] = 1
  
        # Count occurence of arr[i] in 
        # range [i + 1, n - 1]
        for j in range(i + 1, n):
            if (arr[j] == arr[i]):
                cnt += 1
  
            # If count becomes equal to K
            # break the loop
            if (cnt >= k):
                break
  
        # If cnt >= K
        # increment ans by 1
        if (cnt >= k):
            ans += 1
  
    return ans
  
# Driver code
arr = [1, 2, 1, 3]
n = len(arr)
k = 1
print(countOccurrence(n, arr, k))
  
# This code is contributed 
# by mohit kumar

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
using System.Collections.Generic;
  
class GFG 
  
// Function to return the count of 
// all distinct valid elements 
public static int countOccurence(int n, 
                                 int[] arr, int k) 
    int cnt, ans = 0; 
  
    // To avoid duplicates 
    Dictionary<int
               Boolean> hash = new Dictionary<int
                                              Boolean>();
                                                
    // Traverse the complete array 
    for (int i = 0; i < n; i++) 
    
        cnt = 0; 
  
        // If current element is previously checked 
        // don't check it again 
        if (hash.ContainsKey(arr[i]) &&
            hash[arr[i]] == true
            continue
  
            // To avoid duplicates 
            hash.Add(arr[i], true); 
  
            // Count occurence of arr[i] 
            // in range [i + 1, n - 1] 
            for (int j = i + 1; j < n; j++) 
            
                if (arr[j] == arr[i]) 
                    cnt++; 
  
                // If count becomes equal to K 
                // break the loop 
                if (cnt >= k) 
                break
            
  
            // If cnt >= K 
            // increment ans by 1 
            if (cnt >= k) 
                ans++; 
    
  
    return ans; 
  
// Driver Code 
public static void Main(String[] args) 
    int[] arr = {1, 2, 1, 3}; 
    int n = arr.Length; 
    int k = 1; 
    Console.WriteLine(countOccurence(n, arr, k)); 
  
// This code is contributed by Rajput-Ji

chevron_right


Output:

1

Time Complexity: O(n2)

Efficient Approach: Declare another hash map to store occurrence of all elements and start from n – 1 to 0. If occurrence[arr[i]] ≥ k then increment the count by 1 otherwise increment occurrence of arr[i] by 1.

Below is the implementation of the above approach:

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <iostream>
#include <map>
using namespace std;
  
// Function to return the count of
// all distinct valid elements
int countOccurrence(int n, int arr[], int k)
{
    int cnt, ans = 0;
  
    // To avoid duplicates
    map<int, bool> hash;
  
    // To store the count of arr[i]
    // in range [i + 1, n - 1]
    map<int, int> occurrence;
  
    for (int i = n - 1; i >= 0; i--) {
  
        // To avoid duplicates
        if (hash[arr[i]] == true)
            continue;
  
        // If occurrence in range i+1 to n becomes
        // equal to K then increment ans by 1
        if (occurrence[arr[i]] >= k) {
            ans++;
            hash[arr[i]] = true;
        }
  
        // Otherwise increase occurrence of arr[i] by 1
        else
            occurrence[arr[i]]++;
    }
  
    return ans;
}
  
// Driver code
int main()
{
    int arr[] = { 1, 2, 1, 3 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 1;
    cout << countOccurrence(n, arr, k);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
import java.util.HashMap;
  
class GFG
{
  
    // Function to return the count of
    // all distinct valid elements
    public static int countOccurence(int n, int[] arr, int k)
    {
        int ans = 0;
  
        // To avoid duplicates
        HashMap<Integer, Boolean> hash = new HashMap<>();
  
        // To store the count of arr[i]
        // in range [i + 1, n - 1]
        HashMap<Integer, Integer> occurence = new HashMap<>();
  
        for (int i = n-1; i>=0; i--)
        {
              
            // To avoid duplicates
            if (hash.get(arr[i]) != null && 
                hash.get(arr[i]) == true)
                continue;
              
            // If occurrence in range i+1 to n becomes
            // equal to K then increment ans by 1
            if (occurence.get(arr[i]) != null && 
                occurence.get(arr[i]) >= k)
            {
                ans++;
                hash.put(arr[i], true);
            }
  
            // Otherwise increase occurrence of arr[i] by 1
            else
            {
                if (occurence.get(arr[i]) == null)
                    occurence.put(arr[i], 1);
                else
                {
                    int temp = occurence.get(arr[i]);
                    occurence.put(arr[i], ++temp);
                }
            }
        }
  
        return ans; 
    }
  
    // Driver Code
    public static void main(String[] args) 
    {
        int[] arr = {1, 2, 1, 3};
        int n = arr.length;
        int k = 1;
        System.out.println(countOccurence(n, arr, k));
    }
}
  
// This code is contributed by
// sanjeev2552

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 implementation of the approach 
  
# Function to return the count of 
# all distinct valid elements 
def countOccurrence(n, arr, k) :
  
    ans = 0
  
    # To avoid duplicates 
    hash = dict.fromkeys(arr,0); 
  
    # To store the count of arr[i] 
    # in range [i + 1, n - 1] 
    occurrence = dict.fromkeys(arr, 0); 
  
    for i in range(n - 1, -1, -1) :
  
        # To avoid duplicates 
        if (hash[arr[i]] == True) :
            continue
  
        # If occurrence in range i+1 to n 
        # becomes equal to K then increment
        # ans by 1 
        if (occurrence[arr[i]] >= k) :
            ans += 1
            hash[arr[i]] = True
          
        # Otherwise increase occurrence 
        # of arr[i] by 1 
        else :
            occurrence[arr[i]] += 1
      
    return ans; 
  
# Driver code 
if __name__ == "__main__" :
  
    arr = [ 1, 2, 1, 3 ]; 
    n = len(arr) ;
    k = 1
    print(countOccurrence(n, arr, k)); 
  
# This code is contributed by Ryuga

chevron_right


Output:

1

Time Complexity: O(n)



My Personal Notes arrow_drop_up

Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.





Article Tags :
Practice Tags :


Be the First to upvote.


Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.