# 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

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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 ` `#include ` `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 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 `

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 ` `#include ` `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 hash = ``new` `HashMap<>(); ` ` `  `        ``// To store the count of arr[i] ` `        ``// in range [i + 1, n - 1] ` `        ``HashMap 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 `

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.