 Open in App
Not now

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

• Difficulty Level : Medium
• Last Updated : 30 Jan, 2023

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

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