Given an array of size n and a number k, find all elements that appear more than n/k times - GeeksforGeeks

27 Apr, 2022
Given an array of size n, find all elements in array that appear more than n/k times. For example, if the input arrays is {3, 1, 2, 2, 1, 2, 3, 3} and k is 4, then the output should be [2, 3]. Note that size of array is 8 (or n = 8), so we need to find all e
C++
Java
Python3
C#
Javascript
// C++ code to find elements whose// frequency yis more than n/k#include<bits/stdc++.h>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 Codeint 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 Code to find elements whose// frequency yis more than n/kimport java.util.*; public class Main {    public static void morethanNdK(int a[], int n, int k)    {        int x = n / k;                // Hash map initialization        HashMap<Integer, Integer> 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 code to find elements whose# frequency yis more than n/kdef 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           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# code to find elements whose// frequency yis more than n/kusing 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 Codepublic 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
<script>// Javascript Code to find elements whose// frequency yis more than n/k         function morethanNdK(a,n,k)    {        let x = n / k;        // Hash map initialization        let y=new Map();        // count the frequency of each element.        for (let i = 0; i < n; i++)        {            // is element doesn't exist in hash table            if (!y.has(a[i]))                y.set(a[i], 1);                                    // if element does exist in the hash table            else            {                let count = y.get(a[i]);                y.set(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 (let [key, value] of y.entries())        {            let temp = value;            if (temp > x)                document.write(key+"<br>");        }    }         let a=[1, 1, 2, 2, 3, 5, 4,                              2, 2, 3, 1, 1, 1];    let n = 12;    let k = 4;    morethanNdK(a, n, k);         // This code is contributed by unknown2108</script>
ents that appear more than 2 (or 8/4) times. There are two elements that appear more than two times, 2 and 3. 
A simple method 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. Time Complexity of this method would be O(n2).A better solution is to use sorting. First, sort all elements using a O(nLogn) algorithm. Once the array is sorted, we can find all required elements in a linear scan of array. So overall time complexity of this method is O(nLogn) + O(n) which is O(nLogn).Following is an interesting O(nk) solution: 
We can solve the above problem in O(nk) time using O(k-1) extra space. Note that there can never be more than k-1 elements in output (Why?). There are mainly three steps in this algorithm.
1) 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). Following is structure of temporary array elements. 
struct eleCount {
    int e
C++
Java
Python3
C#
Javascript
// C++ code to find elements whose// frequency yis more than n/k#include<bits/stdc++.h>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 Codeint 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 Code to find elements whose// frequency yis more than n/kimport java.util.*; public class Main {    public static void morethanNdK(int a[], int n, int k)    {        int x = n / k;                // Hash map initialization        HashMap<Integer, Integer> 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 code to find elements whose# frequency yis more than n/kdef 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           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# code to find elements whose// frequency yis more than n/kusing 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 Codepublic 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
<script>// Javascript Code to find elements whose// frequency yis more than n/k         function morethanNdK(a,n,k)    {        let x = n / k;        // Hash map initialization        let y=new Map();        // count the frequency of each element.        for (let i = 0; i < n; i++)        {            // is element doesn't exist in hash table            if (!y.has(a[i]))                y.set(a[i], 1);                                    // if lement does exist in the hash table            else            {                let count = y.get(a[i]);                y.set(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 (let [key, value] of y.entries())        {            let temp = value;            if (temp > x)                document.write(key+"<br>");        }    }         let a=[1, 1, 2, 2, 3, 5, 4,                              2, 2, 3, 1, 1, 1];    let n = 12;    let k = 4;    morethanNdK(a, n, k);         // This code is contributed by unknown2108</script>
ent;
    int count;
}; 
struct eleCount temp[];
This step takes O(k) time. 2) 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. This step takes O(nk) time.
3) Iterate through final (k-1) potential candidates (stored in temp[]). or every element, check if it actually has count more than n/k. This step takes O(nk) time.
The main step is step 2, how to maintain (k-1) potential candidates at every point? The steps used in step 2 are like famous game: Tetris. We treat each number as a piece in Tetris, which falls down in our temporary array temp[]. Our task is to try to keep the same number stacked on the same column (count in temporary array is incremented).
Consider k = 4, n = 9 
Given array: 3 1 2 2 2 1 4 3 3 

i = 0
         3 _ _
temp[] has one element, 3 with count 1

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

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

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

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

i = 5
         - - 2 
         - 1 2 
         3 1 2
temp[] has three elements, 3, 1 and 2 with
counts as 1, 2 and 3 respectively.
Now the question arises, what to do when temp[] is full and we see a new element – we remove the bottom row from stacks of elements, i.e., we decrease count of every element by 1 in temp[]. We ignore the current element.
i = 6
         - - 2 
         - 1 2 
temp[] has two elements, 1 and 2 with
counts as 1 and 2 respectively.

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

i = 8          
         3 - 2
         3 1 2 
temp[] has three elements, 3, 1 and 2 with
counts as 2, 1 and 2 respectively.
Finally, we have at most k-1 numbers in temp[]. The elements in temp are {3, 1, 2}. Note that the counts in temp[] are useless now, the counts were needed only in step 2. Now we need to check whether the actual counts of elements in temp[] are more than n/k (9/4) or not. The elements 3 and 2 have counts more than 9/4. So we print 3 and 2.
Note that the algorithm doesn’t miss any output element. There can be two possibilities, many occurrences are together or spread across the array. If occurrences are together, then count will be high and won’t become 0. If occurrences are spread, then the element would come again in temp[]. Following is the implementation of the above algorithm. 
C++
Java
Python3
C#
Javascript
// A C++ program to print elements with count more than n/k#include <iostream>using namespace std; // A structure to store an element and its current countstruct 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(){    cout << "First Test\n";    int arr1[] = { 4, 5, 6, 7, 8, 4, 4 };    int size = sizeof(arr1) / sizeof(arr1[0]);    int k = 3;    moreThanNdK(arr1, size, k);     cout << "\nSecond Test\n";    int arr2[] = { 4, 2, 2, 7 };    size = sizeof(arr2) / sizeof(arr2[0]);    k = 3;    moreThanNdK(arr2, size, k);     cout << "\nThird Test\n";    int arr3[] = { 2, 7, 2 };    size = sizeof(arr3) / sizeof(arr3[0]);    k = 2;    moreThanNdK(arr3, size, k);     cout << "\nFourth Test\n";    int arr4[] = { 2, 3, 3, 2 };    size = sizeof(arr4) / sizeof(arr4[0]);    k = 3;    moreThanNdK(arr4, size, k);     return 0;}
// A Java program to print elements with count more than n/kimport java.util.*; class GFG{ // A structure to store an element and its current countstatic 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){    System.out.print("First Test\n");    int arr1[] = { 4, 5, 6, 7, 8, 4, 4 };    int size = arr1.length;    int k = 3;    moreThanNdK(arr1, size, k);     System.out.print("\nSecond Test\n");    int arr2[] = { 4, 2, 2, 7 };    size = arr2.length;    k = 3;    moreThanNdK(arr2, size, k);     System.out.print("\nThird Test\n");    int arr3[] = { 2, 7, 2 };    size = arr3.length;    k = 2;    moreThanNdK(arr3, size, k);     System.out.print("\nFourth Test\n");    int arr4[] = { 2, 3, 3, 2 };    size = arr4.length;    k = 3;    moreThanNdK(arr4, size, k); }} // This code contributed by Princi Singh .
# 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 codeif __name__ == '__main__':     print("First Test")    arr1 = [4, 5, 6, 7, 8, 4, 4]    size = len(arr1)    k = 3    moreThanNdK(arr1, size, k)     print("Second Test")    arr2 = [4, 2, 2, 7]    size = len(arr2)    k = 3    moreThanNdK(arr2, size, k)     print("Third Test")    arr3 = [2, 7, 2]    size = len(arr3)    k = 2    moreThanNdK(arr3, size, k)     print("Fourth Test")    arr4 = [2, 3, 3, 2]    size = len(arr4)    k = 3    moreThanNdK(arr4, size, k) # This code is contributed by mohit kumar 29
// A C# program to print elements// with count more than n/kusing System;class GFG{ // A structure to store an element// and its current countpublic 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){    Console.Write("First Test\n");    int []arr1 = { 4, 5, 6, 7, 8, 4, 4 };    int size = arr1.Length;    int k = 3;    moreThanNdK(arr1, size, k);     Console.Write("\nSecond Test\n");    int []arr2 = { 4, 2, 2, 7 };    size = arr2.Length;    k = 3;    moreThanNdK(arr2, size, k);     Console.Write("\nThird Test\n");    int []arr3 = { 2, 7, 2 };    size = arr3.Length;    k = 2;    moreThanNdK(arr3, size, k);     Console.Write("\nFourth Test\n");    int []arr4 = { 2, 3, 3, 2 };    size = arr4.Length;    k = 3;    moreThanNdK(arr4, size, k);}} // This code is contributed by 29AjayKumar
<script> // A JavaScript 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.function 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    let temp = new Array(k-1);     for(let i = 0; i < k - 1; i++){        temp[i] = new Array(2);        temp[i][0] = 0;    }     // Step 2: Process all elements    // of input array    for(let i = 0; i < n; i++){        let 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][1] == arr[i])            {                temp[j][0] += 1;                break;            }        }         // If arr[i] is not present in temp        if (j == k - 1){            let 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][0] == 0)                {                    temp[l][1] = arr[i];                    temp[l][0] = 1;                    break;                }            }             // If all the position in the            // tempare filled, then decrease            // count of every element by 1            if (l == k - 1)                for (l = 0; l < k-1; l++)                    temp[l][0] -= 1;        }    }     // Step 3: Check actual counts    // of potential candidates in temp[]    for(let i = 0; i < k - 1; i++){         // Calculate actual count of elements        let ac = 0 // Actual count        for(let j = 0; j < n; j++){            if (arr[j] == temp[i][1])                ac++;        }         // If actual count is more        // than n/k, then print        if (ac > Math.floor(n/k))            document.write("Number: " + temp[i][1] +            " Count: " + ac,"</br>")         }} // Driver codedocument.write("First Test","</br>")let arr1 = [4, 5, 6, 7, 8, 4, 4]let size = arr1.lengthlet k = 3moreThanNdK(arr1, size, k) document.write("Second Test","</br>")let arr2 = [4, 2, 2, 7]size = arr2.lengthk = 3moreThanNdK(arr2, size, k) document.write("Third Test","</br>")let arr3 = [2, 7, 2]size = arr3.lengthk = 2moreThanNdK(arr3, size, k) document.write("Fourth Test","</br>")let arr4 = [2, 3, 3, 2]size = arr4.lengthk = 3moreThanNdK(arr4, size, k) // This code is contributed by shinjanpatra </script>
First Test
Number:4 Count:3

Second Test
Number:2 Count:2

Third Test
Number:2 Count:2

Fourth Test
Number:2 Count:2
Number:3 Count:2
Time Complexity: O(nk) Auxiliary Space: O(k)Generally asked variations of this problem are, find all elements that appear n/3 times or n/4 times in O(n) time complexity and O(1) extra space.
Another Approach:
Hashing can also be an efficient solution. With a good hash function, we can solve the above problem in O(n) time on average. Extra space required hashing would be higher than O(k). Also, hashing cannot be used to solve the above variations with O(1) extra space.
Below is the implementation of the above idea:
C++
Java
Python3
C#
Javascript
// C++ code to find elements whose// frequency yis more than n/k#include<bits/stdc++.h>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 Codeint 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 Code to find elements whose// frequency yis more than n/kimport java.util.*; public class Main {    public static void morethanNdK(int a[], int n, int k)    {        int x = n / k;                // Hash map initialization        HashMap<Integer, Integer> 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 lement 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 code to find elements whose# frequency yis more than n/kdef 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           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# code to find elements whose// frequency yis more than n/kusing 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 Codepublic 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
<script>// Javascript Code to find elements whose// frequency yis more than n/k         function morethanNdK(a,n,k)    {        let x = n / k;        // Hash map initialization        let y=new Map();        // count the frequency of each element.        for (let i = 0; i < n; i++)        {            // is element doesn't exist in hash table            if (!y.has(a[i]))                y.set(a[i], 1);                                    // if element does exist in the hash table            else            {                let count = y.get(a[i]);                y.set(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 (let [key, value] of y.entries())        {            let temp = value;            if (temp > x)                document.write(key+"<br>");        }    }         let a=[1, 1, 2, 2, 3, 5, 4,                              2, 2, 3, 1, 1, 1];    let n = 12;    let k = 4;    morethanNdK(a, n, k);         // This code is contributed by unknown2108</script>
  
1
2
 
Method #2:Using Built-in Python functions: 
 
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: 
 
C++
Java
Python3
C#
Javascript
// C++ implementation#include <bits/stdc++.h>using namespace std; // Function to find the number of array// elements with frequency more than n/k timesvoid printElements(int arr[], int n, int k){     // Calculating n/k    int x = n / k;     // Counting frequency of every    // element using Counter    map<int, int> mp;    for (int i = 0; i < n; i++)        mp[arr[i]] += 1;     // Traverse the map and print all    // the elements with occurrence    // more than n/k times    for (int it = 0; it < mp.size(); it++) {        if (mp[it] > x)            cout << (it) << endl;    }} // Driver codeint 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);} // This code is contributed by ukasp.
// Java implementationimport java.util.*; class GFG {     // Function to find the number of array    // elements with frequency more than n/k times    static void printElements(int arr[], int n, int k)    {         // Calculating n/k        int x = n / k;         // Counting frequency of every        // element using Counter        TreeMap<Integer, Integer> mp            = new TreeMap<Integer, Integer>();        for (int i = 0; i < n; i++)            mp.put(arr[i],                   mp.getOrDefault(arr[i], 0) + 1);         // Traverse the map and print all        // the elements with occurrence        // more than n/k times        for (Map.Entry m:mp.entrySet()) {            if ((int)m.getValue() > x)              System.out.println(m.getKey());        }    }   // Driver code    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 rajsanghavi9.
# Python3 implementationfrom collections import Counter # Function to find the number of array# elements with frequency more than n/k timesdef 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 codearr = [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
// C# implementationusing System;using System.Collections.Generic; public class GFG {     // Function to find the number of array    // elements with frequency more than n/k times    static void printElements(int[] arr, int n, int k)    {         // Calculating n/k        int x = n / k;         // Counting frequency of every        // element using Counter        Dictionary<int, int> mp            = new Dictionary<int, int>();        for (int i = 0; i < n; i++) {            if (mp.ContainsKey(arr[i]))                mp[arr[i]] = mp[arr[i]] + 1;            else                mp.Add(arr[i], 1);        }         foreach(KeyValuePair<int, int> entry in mp)        {            if (entry.Value > x) {                Console.WriteLine(entry.Key);            }        }        // Traverse the map and print all        // the elements with occurrence        // more than n/k times    }     // Driver code    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 gauravrajput1
<script>// javascript implementation     // Function to find the number of array    // elements with frequency more than n/k times    function printElements(arr , n , k) {         // Calculating n/k        var x = parseInt(n / k);         // Counting frequency of every        // element using Counter        var mp = new Map();        for (var i = 0; i < n; i++) {            if (mp.has(arr[i]))                mp.set(arr[i],mp.get(arr[i])+1);            else                mp.set(arr[i], 1);        }         // Traverse the map and print all        // the elements with occurrence        // more than n/k times                 for (var k of mp) {                  if (parseInt(k[1]) > x)                document.write(k[0]+"<br/>");        }    }     // Driver code        var arr = [ 1, 1, 2, 2, 3, 5, 4, 2, 2, 3, 1, 1, 1 ];        var n = arr.length;        var k = 4;         printElements(arr, n, k); // This code is contributed by gauravrajput1</script>
Output:
1
2
Time Complexity: O(N)Auxiliary Space: O(N)
YouTubeGeeksforGeeks507K subscribersFind all elements that appear more than n/k times in an array | GeeksforGeeksWatch laterShareCopy linkInfoShoppingTap to unmuteIf playback doesn't begin shortly, try restarting your device.You're signed outVideos you watch may be added to the TV's watch history and influence TV recommendations. To avoid this, cancel and sign in to YouTube on your computer.CancelConfirmMore videosMore videosSwitch cameraShareInclude playlistAn error occurred while retrieving sharing information. Please try again later.Watch on0:000:000:00 / 3:02•Live•<div class="player-unavailable"><h1 class="message">An error occurred.</h1><div class="submessage"><a href="https://www.youtube.com/watch?v=3fYcADmz0cM" target="_blank">Try watching this video on www.youtube.com</a>, or enable JavaScript if it is disabled in your browser.</div></div>
?list=PLqM7alHXFySEQDk2MDfbwEdjd2svVJH9p 
ShubhamMaurya3
mohit kumar 29
depanshukumar4444
chayandas018
princi singh
29AjayKumar
divyesh072019
vikkycirus
unknown2108
vedantchawla06
ukasp
rajsanghavi9
anikakapoor
GauravRajput1
avtarkumar719
shinjanpatra
sumitgumber28
Arrays
Searching
Arrays
Searching
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Maximum and minimum of an array using minimum number of comparisons
Top 50 Array Coding Problems for Interviews
Stack Data Structure (Introduction and Program)
Introduction to Arrays
Multidimensional Arrays in Java
Binary Search
Maximum and minimum of an array using minimum number of comparisons
Linear Search
Search an element in a sorted and rotated array
Find the Missing Number