Related Articles

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

## Javascript

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

## Javascript

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