Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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

  • Difficulty Level : Easy
  • Last Updated : 03 Jun, 2021

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:
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++




// 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 occurrence 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;
}

Java




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

Python3




# 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 occurrence 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

C#




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

Javascript




<script>
 
// JavaScript implementation of the approach
 
    // Function to return the count of
    // all distinct valid elements
   function countOccurence(n, arr, k)
    {
        let cnt, ans = 0;
   
        // To avoid duplicates
        let hash = new Map();
   
        // Traverse the complete array
        for (let 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.set(arr[i], true);
   
                // Count occurrence of arr[i]
                // in range [i + 1, n - 1]
                for (let 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
     
         let arr = [1, 2, 1, 3];
        let n = arr.length;
        let k = 1;
        document.write(countOccurence(n, arr, k));
                     
</script>
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++




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

Java




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

Python3




# 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

C#




// 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 ans = 0;
 
        // To avoid duplicates
        Dictionary<int,
                   bool> hash = new Dictionary<int,
                                               bool>();
 
        // To store the count of arr[i]
        // in range [i + 1, n - 1]
        Dictionary<int,    
                   int> occurence = new Dictionary<int,
                                                   int>();
         
        for (int i = n - 1; i >= 0; i--)
        {
             
            // To avoid duplicates
            if (hash.ContainsKey(arr[i]) &&
                hash[arr[i]] == true)
                continue;
             
            // If occurrence in range i+1 to n becomes
            // equal to K then increment ans by 1
            if (occurence.ContainsKey(arr[i]) &&
                occurence[arr[i]] >= k)
            {
                ans++;
                hash.Add(arr[i], true);
            }
 
            // Otherwise increase occurrence of arr[i] by 1
            else
            {
                if (!occurence.ContainsKey(arr[i]))
                    occurence.Add(arr[i], 1);
                else
                {
                    int temp = occurence[arr[i]];
                    occurence.Add(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;
        Console.WriteLine(countOccurence(n, arr, k));
    }
}
 
// This code is contributed by 29AjayKumar

Javascript




<script>
 
// Javascript implementation of the approach
 
// Function to return the count of
// all distinct valid elements
function countOccurence(n, arr, k)
{
    let ans = 0;
 
    // To avoid duplicates
    let hash = new Map();
 
    // To store the count of arr[i]
    // in range [i + 1, n - 1]
    let occurence = new Map();
 
    for(let 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.set(arr[i], true);
        }
 
        // Otherwise increase occurrence of arr[i] by 1
        else
        {
            if (occurence.get(arr[i]) == null)
                occurence.set(arr[i], 1);
            else
            {
                let temp = occurence.get(arr[i]);
                occurence.set(arr[i], ++temp);
            }
        }
    }
    return ans;
}
 
// Driver Code
let arr = [ 1, 2, 1, 3 ];
let n = arr.length;
let k = 1;
 
document.write(countOccurence(n, arr, k));
 
// This code is contributed by unknown2108
 
</script>
Output: 
1

 

Time Complexity: O(n)
 


My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!