 GFG App
Open App Browser
Continue

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

My Personal Notes arrow_drop_up