Skip to content
Related Articles

Related Articles

Improve 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)
 

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :