# Given Array of size n and a number k, find all elements that appear more than n/k times

Given an array of size n and an integer k, find all elements in the array that appear more than n/k times.

Examples:

Input: arr[] = {3, 1, 2, 2, 1, 2, 3, 3}, k = 4
Output: {2, 3}
Explanation: Here n/k is 8/4 = 2, therefore 2 appears 3 times in the array that is greater than 2 and 3 appears 3 times in the array that is greater than 2

Input: arr[] = {9, 8, 7, 9, 2, 9, 7}, k = 3
Output: {9}
Explanation: Here n/k is 7/3 = 2, therefore 9 appears 3 times in the array that is greater than 2.

## Find all elements that appear more than n/k times using Hashing:

The idea is to pick all elements one by one. For every picked element, count its occurrences by traversing the array, if count becomes more than n/k, then print the element.

Follow the steps below to solve the problem:

• First, make a frequency map of all the elements in the array
• Then traverse the map and check the frequency of every element
• If the frequency is greater than n/k then print the element.

Below is the implementation of the above approach:

## C++

 `// C++ code to find elements whose` `// frequency is more than n/k` `#include ` `using` `namespace` `std;`   `void` `morethanNbyK(``int` `arr[], ``int` `n, ``int` `k)` `{` `    ``int` `x = n / k;`   `    ``// unordered_map initialization` `    ``unordered_map<``int``, ``int``> freq;`   `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``freq[arr[i]]++;` `    ``}`   `    ``// Traversing the map` `    ``for` `(``auto` `i : freq) {`   `        ``// Checking if value of a key-value pair` `        ``// is greater than x (where x=n/k)` `        ``if` `(i.second > x) {`   `            ``// Print the key of whose value` `            ``// is greater than x` `            ``cout << i.first << endl;` `        ``}` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 2, 3, 5, 4, 2, 2, 3, 1, 1, 1 };` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);` `    ``int` `k = 4;`   `    ``morethanNbyK(arr, n, k);`   `    ``return` `0;` `}`   `// This code is contributed by chayandas018`

## Java

 `// Java Code to find elements whose` `// frequency is more than n/k` `import` `java.util.*;`   `public` `class` `Main`   `{` `    ``public` `static` `void` `morethanNdK(``int` `a[], ``int` `n, ``int` `k)` `    ``{` `        ``int` `x = n / k;`   `        ``// Hash map initialization` `        ``HashMap y = ``new` `HashMap<>();`   `        ``// count the frequency of each element.` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``// is element doesn't exist in hash table` `            ``if` `(!y.containsKey(a[i]))` `                ``y.put(a[i], ``1``);`   `            ``// if element does exist in the hash table` `            ``else` `{` `                ``int` `count = y.get(a[i]);` `                ``y.put(a[i], count + ``1``);` `            ``}` `        ``}`   `        ``// iterate over each element in the hash table` `        ``// and check their frequency, if it is more than` `        ``// n/k, print it.` `        ``for` `(Map.Entry m : y.entrySet()) {` `            ``Integer temp = (Integer)m.getValue();` `            ``if` `(temp > x)` `                ``System.out.println(m.getKey());` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `main(String[] args)` `    ``{`   `        ``int` `a[] = ``new` `int``[] { ``1``, ``1``, ``2``, ``2``, ``3``, ``5``, ``4``,` `                              ``2``, ``2``, ``3``, ``1``, ``1``, ``1` `};` `        ``int` `n = ``12``;` `        ``int` `k = ``4``;` `        ``morethanNdK(a, n, k);` `    ``}` `}`

## Python3

 `# Python3 code to find elements whose` `# frequency is more than n/k`     `def` `morethanNbyK(arr, n, k):` `    ``x ``=` `n ``/``/` `k`   `    ``# unordered_map initialization` `    ``freq ``=` `{}`   `    ``for` `i ``in` `range``(n):` `        ``if` `arr[i] ``in` `freq:` `            ``freq[arr[i]] ``+``=` `1` `        ``else``:` `            ``freq[arr[i]] ``=` `1`   `    ``# Traversing the map` `    ``for` `i ``in` `freq:`   `        ``# Checking if value of a key-value pair` `        ``# is greater than x (where x=n/k)` `        ``if` `(freq[i] > x):`   `            ``# Print the key of whose value` `            ``# is greater than x` `            ``print``(i)`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``1``, ``1``, ``2``, ``2``, ``3``, ``5``, ``4``, ``2``, ``2``, ``3``, ``1``, ``1``, ``1``]` `    ``n ``=` `len``(arr)` `    ``k ``=` `4` `    `  `    ``morethanNbyK(arr, n, k)`   `# This code is contributed by mohit kumar 29`

## C#

 `// C# code to find elements whose` `// frequency is more than n/k` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG {`   `    ``public` `static` `void` `morethanNdK(``int``[] a, ``int` `n, ``int` `k)` `    ``{` `        ``int` `x = n / k;`   `        ``// Hash map initialization` `        ``Dictionary<``int``, ``int``> y = ``new` `Dictionary<``int``, ``int``>();`   `        ``// Count the frequency of each element.` `        ``for` `(``int` `i = 0; i < n; i++) {`   `            ``// Is element doesn't exist in hash table` `            ``if` `(!y.ContainsKey(a[i]))` `                ``y.Add(a[i], 1);`   `            ``// If element does exist in the hash table` `            ``else` `{` `                ``int` `count = y[a[i]];` `                ``y[a[i]] = count + 1;` `            ``}` `        ``}`   `        ``// Iterate over each element in the hash table` `        ``// and check their frequency, if it is more than` `        ``// n/k, print it.` `        ``foreach``(KeyValuePair<``int``, ``int``> m ``in` `y)` `        ``{` `            ``int` `temp = (``int``)m.Value;` `            ``if` `(temp > x)` `                ``Console.WriteLine(m.Key);` `        ``}` `    ``}`   `    ``// Driver Code` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int``[] a = ``new` `int``[] { 1, 1, 2, 2, 3, 5, 4,` `                              ``2, 2, 3, 1, 1, 1 };` `        ``int` `n = 12;` `        ``int` `k = 4;`   `        ``morethanNdK(a, n, k);` `    ``}` `}`   `// This code is contributed by Princi Singh`

## Javascript

 ``

Output

```2
1```

Time Complexity: O(N), Traversing the array of size N.
Auxiliary Space: O(N), Space occupied by the hashmap

## Find all elements that appear more than n/k times using Moore’s Voting Algorithm:

The idea is to apply Moore’s Voting algorithm, as there can be at max k – 1 elements present in the array which appears more than n/k times so their will be k – 1 candidates. When we encounter an element which is one of our candidates then increment the count else decrement the count.

Illustration:

Consider k = 4, n = 9
Given array: 3 1 2 2 2 1 4 3 3

i = 0
temp[] has one element {3} with count 1

i = 1
temp[] has two elements {3, 1} with counts 1 and 1 respectively

i = 2
temp[] has three elements, {3, 1, 2} with counts as 1, 1 and 1 respectively.

i = 3
temp[] has three elements, {3, 1, 2} with counts as 1, 1 and 2 respectively.

i = 4
temp[] has three elements, {3, 1, 2} with counts as 1, 1 and 3 respectively.

i = 5
temp[] has three elements, {3, 1, 2 with counts as 1, 2 and 3 respectively.

i = 6
temp[] has two elements, {1, 2} with counts as 1 and 2 respectively.

i = 7
temp[] has three elements, {3, 1, 2} with counts as 1, 1 and 2 respectively.

i = 8
temp[] has three elements, {3, 1, 2} with counts as 2, 1 and 2 respectively.

Follow the steps below to solve the problem:

• Create a temporary array of size (k – 1) to store elements and their counts (The output elements are going to be among these k-1 elements).
• Traverse through the input array and update temp[] (add/remove an element or increase/decrease count) for every traversed element. The array temp[] stores potential (k-1) candidates at every step.
• Iterate through final (k-1) potential candidates (stored in temp[]). or every element, check if it actually has counted of more than n/k.

Below is the implementation of the above approach.

## C++

 `// A C++ program to print elements with count more than n/k` `#include ` `using` `namespace` `std;`   `// A structure to store an element and its current count` `struct` `eleCount {` `    ``int` `e; ``// Element` `    ``int` `c; ``// Count` `};`   `// Prints elements with more` `// than n/k occurrences in arr[]` `// of size n. If there are no` `// such elements, then it prints` `// nothing.` `void` `moreThanNdK(``int` `arr[], ``int` `n, ``int` `k)` `{` `    ``// k must be greater than` `    ``// 1 to get some output` `    ``if` `(k < 2)` `        ``return``;`   `    ``/* Step 1: Create a temporary` `       ``array (contains element` `       ``and count) of size k-1.` `       ``Initialize count of all` `       ``elements as 0 */` `    ``struct` `eleCount temp[k - 1];` `    ``for` `(``int` `i = 0; i < k - 1; i++)` `        ``temp[i].c = 0;`   `    ``/* Step 2: Process all` `      ``elements of input array */` `    ``for` `(``int` `i = 0; i < n; i++) {` `        ``int` `j;`   `        ``/* If arr[i] is already present in` `           ``the element count array,` `           ``then increment its count` `         ``*/` `        ``for` `(j = 0; j < k - 1; j++) {` `            ``if` `(temp[j].e == arr[i]) {` `                ``temp[j].c += 1;` `                ``break``;` `            ``}` `        ``}`   `        ``/* If arr[i] is not present in temp[] */` `        ``if` `(j == k - 1) {` `            ``int` `l;`   `            ``/* If there is position available` `              ``in temp[], then place arr[i] in` `              ``the first available position and` `              ``set count as 1*/` `            ``for` `(l = 0; l < k - 1; l++) {` `                ``if` `(temp[l].c == 0) {` `                    ``temp[l].e = arr[i];` `                    ``temp[l].c = 1;` `                    ``break``;` `                ``}` `            ``}`   `            ``/* If all the position in the` `               ``temp[] are filled, then decrease` `               ``count of every element by 1 */` `            ``if` `(l == k - 1)` `                ``for` `(l = 0; l < k - 1; l++)` `                    ``temp[l].c -= 1;` `        ``}` `    ``}`   `    ``/*Step 3: Check actual counts of` `     ``* potential candidates in temp[]*/` `    ``for` `(``int` `i = 0; i < k - 1; i++) {` `        ``// Calculate actual count of elements` `        ``int` `ac = 0; ``// actual count` `        ``for` `(``int` `j = 0; j < n; j++)` `            ``if` `(arr[j] == temp[i].e)` `                ``ac++;`   `        ``// If actual count is more than n/k,` `        ``// then print it` `        ``if` `(ac > n / k)` `            ``cout << ``"Number:"` `<< temp[i].e` `                 ``<< ``" Count:"` `<< ac << endl;` `    ``}` `}`   `/* Driver code */` `int` `main()` `{`   `    ``int` `arr1[] = { 4, 5, 6, 7, 8, 4, 4 };` `    ``int` `size = ``sizeof``(arr1) / ``sizeof``(arr1[0]);` `    ``int` `k = 3;` `    ``moreThanNdK(arr1, size, k);`   `    ``return` `0;` `}`

## Java

 `// A Java program to print elements with count more than n/k` `import` `java.util.*;`   `class` `GFG {`   `    ``// A structure to store an element and its current count` `    ``static` `class` `eleCount {` `        ``int` `e; ``// Element` `        ``int` `c; ``// Count` `    ``};`   `    ``// Prints elements with more` `    ``// than n/k occurrences in arr[]` `    ``// of size n. If there are no` `    ``// such elements, then it prints` `    ``// nothing.` `    ``static` `void` `moreThanNdK(``int` `arr[], ``int` `n, ``int` `k)` `    ``{` `        ``// k must be greater than` `        ``// 1 to get some output` `        ``if` `(k < ``2``)` `            ``return``;`   `        ``/* Step 1: Create a temporary` `           ``array (contains element` `           ``and count) of size k-1.` `           ``Initialize count of all` `           ``elements as 0 */` `        ``eleCount[] temp = ``new` `eleCount[k - ``1``];` `        ``for` `(``int` `i = ``0``; i < k - ``1``; i++)` `            ``temp[i] = ``new` `eleCount();` `        ``for` `(``int` `i = ``0``; i < k - ``1``; i++) {` `            ``temp[i].c = ``0``;` `        ``}`   `        ``/* Step 2: Process all` `          ``elements of input array */` `        ``for` `(``int` `i = ``0``; i < n; i++) {` `            ``int` `j;`   `            ``/* If arr[i] is already present in` `               ``the element count array,` `               ``then increment its count` `             ``*/` `            ``for` `(j = ``0``; j < k - ``1``; j++) {` `                ``if` `(temp[j].e == arr[i]) {` `                    ``temp[j].c += ``1``;` `                    ``break``;` `                ``}` `            ``}`   `            ``/* If arr[i] is not present in temp[] */` `            ``if` `(j == k - ``1``) {` `                ``int` `l;`   `                ``/* If there is position available` `                  ``in temp[], then place arr[i] in` `                  ``the first available position and` `                  ``set count as 1*/` `                ``for` `(l = ``0``; l < k - ``1``; l++) {` `                    ``if` `(temp[l].c == ``0``) {` `                        ``temp[l].e = arr[i];` `                        ``temp[l].c = ``1``;` `                        ``break``;` `                    ``}` `                ``}`   `                ``/* If all the position in the` `                   ``temp[] are filled, then decrease` `                   ``count of every element by 1 */` `                ``if` `(l == k - ``1``)` `                    ``for` `(l = ``0``; l < k - ``1``; l++)` `                        ``temp[l].c -= ``1``;` `            ``}` `        ``}`   `        ``/*Step 3: Check actual counts of` `         ``* potential candidates in temp[]*/` `        ``for` `(``int` `i = ``0``; i < k - ``1``; i++) {`   `            ``// Calculate actual count of elements` `            ``int` `ac = ``0``; ``// actual count` `            ``for` `(``int` `j = ``0``; j < n; j++)` `                ``if` `(arr[j] == temp[i].e)` `                    ``ac++;`   `            ``// If actual count is more than n/k,` `            ``// then print it` `            ``if` `(ac > n / k)` `                ``System.out.print(``"Number:"` `+ temp[i].e` `                                 ``+ ``" Count:"` `+ ac + ``"\n"``);` `        ``}` `    ``}`   `    ``/* Driver code */` `    ``public` `static` `void` `main(String[] args)` `    ``{` `        ``int` `arr1[] = { ``4``, ``5``, ``6``, ``7``, ``8``, ``4``, ``4` `};` `        ``int` `size = arr1.length;` `        ``int` `k = ``3``;` `        ``moreThanNdK(arr1, size, k);` `    ``}` `}`   `// This code contributed by Princi Singh .`

## Python3

 `# A Python3 program to print elements with` `# count more than n/k`   `# Prints elements with more than n/k` `# occurrences in arrof size n. If` `# there are no such elements, then` `# it prints nothing.`     `def` `moreThanNdK(arr, n, k):`   `    ``# k must be greater than 1` `    ``# to get some output` `    ``if` `(k < ``2``):` `        ``return`   `    ``# Step 1: Create a temporary array` `    ``# (contains element and count) of` `    ``# size k-1. Initialize count of all` `    ``# elements as 0` `    ``temp ``=` `[[``0` `for` `i ``in` `range``(``2``)]` `            ``for` `i ``in` `range``(k)]`   `    ``for` `i ``in` `range``(k ``-` `1``):` `        ``temp[i][``0``] ``=` `0`   `    ``# Step 2: Process all elements` `    ``# of input array` `    ``for` `i ``in` `range``(n):` `        ``j ``=` `0`   `        ``# If arr[i] is already present in` `        ``# the element count array, then` `        ``# increment its count` `        ``while` `j < k ``-` `1``:` `            ``if` `(temp[j][``1``] ``=``=` `arr[i]):` `                ``temp[j][``0``] ``+``=` `1` `                ``break`   `            ``j ``+``=` `1`   `        ``# If arr[i] is not present in temp` `        ``if` `(j ``=``=` `k ``-` `1``):` `            ``l ``=` `0`   `            ``# If there is position available` `            ``# in temp[], then place arr[i]` `            ``# in the first available position` `            ``# and set count as 1*/` `            ``while` `l < k ``-` `1``:` `                ``if` `(temp[l][``0``] ``=``=` `0``):` `                    ``temp[l][``1``] ``=` `arr[i]` `                    ``temp[l][``0``] ``=` `1` `                    ``break`   `                ``l ``+``=` `1`   `            ``# If all the position in the` `            ``# tempare filled, then decrease` `            ``# count of every element by 1` `            ``if` `(l ``=``=` `k ``-` `1``):` `                ``while` `l < k:` `                    ``temp[l][``0``] ``-``=` `1` `                    ``l ``+``=` `1`   `    ``# Step 3: Check actual counts` `    ``# of potential candidates in temp[]` `    ``for` `i ``in` `range``(k ``-` `1``):`   `        ``# Calculate actual count of elements` `        ``ac ``=` `0`  `# Actual count` `        ``for` `j ``in` `range``(n):` `            ``if` `(arr[j] ``=``=` `temp[i][``1``]):` `                ``ac ``+``=` `1`   `        ``# If actual count is more` `        ``# than n/k, then print` `        ``if` `(ac > n ``/``/` `k):` `            ``print``(``"Number:"``,` `                  ``temp[i][``1``],` `                  ``" Count:"``, ac)`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:`   `    ``arr1 ``=` `[``4``, ``5``, ``6``, ``7``, ``8``, ``4``, ``4``]` `    ``size ``=` `len``(arr1)` `    ``k ``=` `3` `    ``moreThanNdK(arr1, size, k)` `# This code is contributed by mohit kumar 29`

## C#

 `// A C# program to print elements` `// with count more than n/k` `using` `System;` `class` `GFG {`   `    ``// A structure to store an element` `    ``// and its current count` `    ``public` `class` `eleCount {` `        ``public` `int` `e; ``// Element` `        ``public` `int` `c; ``// Count` `    ``};`   `    ``// Prints elements with more` `    ``// than n/k occurrences in []arr` `    ``// of size n. If there are no` `    ``// such elements, then it prints` `    ``// nothing.` `    ``static` `void` `moreThanNdK(``int``[] arr, ``int` `n, ``int` `k)` `    ``{`   `        ``// k must be greater than` `        ``// 1 to get some output` `        ``if` `(k < 2)` `            ``return``;`   `        ``/* Step 1: Create a temporary` `           ``array (contains element` `           ``and count) of size k-1.` `           ``Initialize count of all` `           ``elements as 0 */` `        ``eleCount[] temp = ``new` `eleCount[k - 1];` `        ``for` `(``int` `i = 0; i < k - 1; i++)` `            ``temp[i] = ``new` `eleCount();` `        ``for` `(``int` `i = 0; i < k - 1; i++) {` `            ``temp[i].c = 0;` `        ``}`   `        ``/* Step 2: Process all` `          ``elements of input array */` `        ``for` `(``int` `i = 0; i < n; i++) {` `            ``int` `j;`   `            ``/* If arr[i] is already present in` `               ``the element count array,` `               ``then increment its count` `             ``*/` `            ``for` `(j = 0; j < k - 1; j++) {` `                ``if` `(temp[j].e == arr[i]) {` `                    ``temp[j].c += 1;` `                    ``break``;` `                ``}` `            ``}`   `            ``/* If arr[i] is not present in []temp */` `            ``if` `(j == k - 1) {` `                ``int` `l;`   `                ``/* If there is position available` `                  ``in []temp, then place arr[i] in` `                  ``the first available position and` `                  ``set count as 1*/` `                ``for` `(l = 0; l < k - 1; l++) {` `                    ``if` `(temp[l].c == 0) {` `                        ``temp[l].e = arr[i];` `                        ``temp[l].c = 1;` `                        ``break``;` `                    ``}` `                ``}`   `                ``/* If all the position in the` `                   ``[]temp are filled, then decrease` `                   ``count of every element by 1 */` `                ``if` `(l == k - 1)` `                    ``for` `(l = 0; l < k - 1; l++)` `                        ``temp[l].c -= 1;` `            ``}` `        ``}`   `        ``/*Step 3: Check actual counts of` `         ``* potential candidates in []temp*/` `        ``for` `(``int` `i = 0; i < k - 1; i++) {`   `            ``// Calculate actual count of elements` `            ``int` `ac = 0; ``// actual count` `            ``for` `(``int` `j = 0; j < n; j++)` `                ``if` `(arr[j] == temp[i].e)` `                    ``ac++;`   `            ``// If actual count is more than n/k,` `            ``// then print it` `            ``if` `(ac > n / k)` `                ``Console.Write(``"Number:"` `+ temp[i].e` `                              ``+ ``" Count:"` `+ ac + ``"\n"``);` `        ``}` `    ``}`   `    ``/* Driver code */` `    ``public` `static` `void` `Main(String[] args)` `    ``{` `        ``int``[] arr1 = { 4, 5, 6, 7, 8, 4, 4 };` `        ``int` `size = arr1.Length;` `        ``int` `k = 3;` `        ``moreThanNdK(arr1, size, k);` `    ``}` `}`   `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output

`Number:4 Count:3`

Time Complexity: O(N * K), Checking for each element of the array(size N) in the candidate array of size K
Auxiliary Space: O(K), Space required to store the candidates.

## Find all elements that appear more than n/k times using Built-in Python functions:

This approach is same the first approach but here in python there is a counter() that calculates the frequency array.

• Count the frequencies of every element using Counter() function.
• Traverse the frequency array and print all the elements which occur at more than n/k times.

Below is the implementation of the above approach:

## Python3

 `# Python3 implementation` `from` `collections ``import` `Counter`   `# Function to find the number of array` `# elements with frequency more than n/k times` `def` `printElements(arr, n, k):`   `    ``# Calculating n/k` `    ``x ``=` `n``/``/``k`   `    ``# Counting frequency of every ` `    ``# element using Counter` `    ``mp ``=` `Counter(arr)` `    `  `    ``# Traverse the map and print all` `    ``# the elements with occurrence ` `    ``# more than n/k times` `    ``for` `it ``in` `mp:` `        ``if` `mp[it] > x:` `            ``print``(it)`     `# Driver code` `if` `__name__ ``=``=` `'__main__'``:` `    ``arr ``=` `[``1``, ``1``, ``2``, ``2``, ``3``, ``5``, ``4``, ``2``, ``2``, ``3``, ``1``, ``1``, ``1``]` `    ``n ``=` `len``(arr)` `    ``k ``=` `4` `    `  `    ``printElements(arr, n, k)`   `# This code is contributed by vikkycirus`

## Java

 `/*package whatever //do not write package name here */`   `import` `java.io.*;` `import` `java.util.*;`   `class` `GFG {` `   `  `    ``public` `static` `void` `printElements(``int``[] arr, ``int` `n, ``int` `k) {` `        ``// Calculating n/k` `        ``int` `x = n / k;`   `        ``// Counting frequency of every element using a HashMap` `        ``HashMap mp = ``new` `HashMap<>();` `        ``for` `(``int` `i : arr) {` `            ``if` `(mp.containsKey(i)) {` `                ``mp.put(i, mp.get(i) + ``1``);` `            ``} ``else` `{` `                ``mp.put(i, ``1``);` `            ``}` `        ``}` `        `  `        ``// Traverse the map and print all the elements with occurrence more than n/k times` `        ``for` `(``int` `key : mp.keySet()) {` `            ``if` `(mp.get(key) > x) {` `                ``System.out.println(key);` `            ``}` `        ``}` `    ``}`   `    ``public` `static` `void` `main(String[] args) {` `        ``int``[] arr = {``1``, ``1``, ``2``, ``2``, ``3``, ``5``, ``4``, ``2``, ``2``, ``3``, ``1``, ``1``, ``1``};` `        ``int` `n = arr.length;` `        ``int` `k = ``4``;` `        ``printElements(arr, n, k);` `    ``}` `}` `// This code is contributed by Shivam Tiwari`

## C++

 `#include ` `#include ` `using` `namespace` `std;`   `// Function to find the number of array` `// elements with frequency more than n/k times` `void` `printElements(``int` `arr[], ``int` `n, ``int` `k)` `{` `    ``// Calculating n/k` `    ``int` `x = n/k;`   `    ``// Counting frequency of every element` `    ``unordered_map<``int``, ``int``> mp;` `    ``for` `(``int` `i = 0; i < n; i++)` `        ``mp[arr[i]]++;`   `    ``// Traverse the map and print all` `    ``// the elements with occurrence` `    ``// more than n/k times` `    ``for` `(``auto` `it : mp)` `        ``if` `(it.second > x)` `            ``cout << it.first << endl;` `}`   `// Driver code` `int` `main()` `{` `    ``int` `arr[] = { 1, 1, 2, 2, 3, 5, 4, 2, 2, 3, 1, 1, 1 };` `    ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);` `    ``int` `k = 4;`   `    ``printElements(arr, n, k);`   `    ``return` `0;` `}`   `// This code is contributed by Shivam Tiwari`

## Javascript

 `// function to find the number of array` `// elements with frequency more than n/k times` `function` `printElements(arr, n, k){` `    ``// calculating n/k` `    ``let x = parseInt(n/k);`     `    ``// counting the frequency of every ` `    ``// element using counter` `    ``let mp = ``new` `Map();` `    ``for``(let ele of arr){` `        ``if``(ele ``in` `mp){` `            ``mp[ele] += 1;` `        ``}` `        ``else``{` `            ``mp[ele] = 1;` `        ``}` `    ``}`   `    ``// Traverse the map and print all ` `    ``// the elements with occurrence ` `    ``// more than n/k times ` `    ``for``(let it ``in` `mp){` `        ``if``(mp[it] > x){` `            ``console.log(it);` `        ``}` `    ``}` `}`   `// Driver code` `let arr = [ 1, 1, 2, 2, 3, 5, 4, 2, 2, 3, 1, 1, 1 ];` `let n = arr.length;` `let k = 4;` `printElements(arr, n, k);`   `// This code is contributed by Prince Kumar`

## C#

 `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG` `{` `    ``static` `void` `Main()` `    ``{` `        ``int``[] arr = { 1, 1, 2, 2, 3, 5, 4, 2, 2, 3, 1, 1, 1 };` `        ``int` `n = arr.Length;` `        ``int` `k = 4;`   `        ``PrintElements(arr, n, k);` `    ``}`   `    ``static` `void` `PrintElements(``int``[] arr, ``int` `n, ``int` `k)` `    ``{` `        ``// Calculating n/k` `        ``int` `x = n / k;`   `        ``// Counting frequency of every element` `        ``Dictionary<``int``, ``int``> mp = ``new` `Dictionary<``int``, ``int``>();` `        ``for` `(``int` `i = 0; i < n; i++)` `        ``{` `            ``// If the element is already in the dictionary, increment its count by 1` `            ``if` `(mp.ContainsKey(arr[i]))` `            ``{` `                ``mp[arr[i]]++;` `            ``}` `            ``// If the element is not in the dictionary, add it with a count of 1` `            ``else` `            ``{` `                ``mp[arr[i]] = 1;` `            ``}` `        ``}`   `        ``// Traverse the dictionary and print all the elements with occurrence more than n/k times` `        ``foreach` `(KeyValuePair<``int``, ``int``> item ``in` `mp)` `        ``{` `            ``if` `(item.Value > x)` `            ``{` `                ``Console.WriteLine(item.Key);` `            ``}` `        ``}` `    ``}` `}` `// This code is contributed by Shivam Tiwari`

Output

```1
2```

Time Complexity: O(N), Traversing over the array to store the frequency
Auxiliary Space: O(N), Space used to store the frequency

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next