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 <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 Code
int main()
{
    int arr[] = { 1, 1, 2, 2, 3, 5, 4, 2, 2, 3, 1, 1, 1 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 4;

    morethanNbyK(arr, n, k);

    return 0;
}

// This code is contributed by chayandas018

Java

// Java Code to find elements whose
// frequency is more than n/k
import java.util.*;

public class Main

{
    public static void morethanNdK(int a[], int n, int k)
    {
        int x = n / k;

        // Hash map initialization
        HashMap<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

# 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

<script>
// Javascript Code to find elements whose
// frequency is 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>

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 <iostream>
using namespace std;

// A structure to store an element and its current count
struct eleCount {
    int e; // Element
    int c; // Count
};

// Prints elements with more
// than n/k occurrences in arr[]
// of size n. If there are no
// such elements, then it prints
// nothing.
void moreThanNdK(int arr[], int n, int k)
{
    // k must be greater than
    // 1 to get some output
    if (k < 2)
        return;

    /* Step 1: Create a temporary
       array (contains element
       and count) of size k-1.
       Initialize count of all
       elements as 0 */
    struct eleCount temp[k - 1];
    for (int i = 0; i < k - 1; i++)
        temp[i].c = 0;

    /* Step 2: Process all
      elements of input array */
    for (int i = 0; i < n; i++) {
        int j;

        /* If arr[i] is already present in
           the element count array,
           then increment its count
         */
        for (j = 0; j < k - 1; j++) {
            if (temp[j].e == arr[i]) {
                temp[j].c += 1;
                break;
            }
        }

        /* If arr[i] is not present in temp[] */
        if (j == k - 1) {
            int l;

            /* If there is position available
              in temp[], then place arr[i] in
              the first available position and
              set count as 1*/
            for (l = 0; l < k - 1; l++) {
                if (temp[l].c == 0) {
                    temp[l].e = arr[i];
                    temp[l].c = 1;
                    break;
                }
            }

            /* If all the position in the
               temp[] are filled, then decrease
               count of every element by 1 */
            if (l == k - 1)
                for (l = 0; l < k - 1; l++)
                    temp[l].c -= 1;
        }
    }

    /*Step 3: Check actual counts of
     * potential candidates in temp[]*/
    for (int i = 0; i < k - 1; i++) {
        // Calculate actual count of elements
        int ac = 0; // actual count
        for (int j = 0; j < n; j++)
            if (arr[j] == temp[i].e)
                ac++;

        // If actual count is more than n/k,
        // then print it
        if (ac > n / k)
            cout << "Number:" << temp[i].e
                 << " Count:" << ac << endl;
    }
}

/* Driver code */
int main()
{

    int arr1[] = { 4, 5, 6, 7, 8, 4, 4 };
    int size = sizeof(arr1) / sizeof(arr1[0]);
    int k = 3;
    moreThanNdK(arr1, size, k);

    return 0;
}

Java

// A Java program to print elements with count more than n/k
import java.util.*;

class GFG {

    // A structure to store an element and its current count
    static class eleCount {
        int e; // Element
        int c; // Count
    };

    // Prints elements with more
    // than n/k occurrences in arr[]
    // of size n. If there are no
    // such elements, then it prints
    // nothing.
    static void moreThanNdK(int arr[], int n, int k)
    {
        // k must be greater than
        // 1 to get some output
        if (k < 2)
            return;

        /* Step 1: Create a temporary
           array (contains element
           and count) of size k-1.
           Initialize count of all
           elements as 0 */
        eleCount[] temp = new eleCount[k - 1];
        for (int i = 0; i < k - 1; i++)
            temp[i] = new eleCount();
        for (int i = 0; i < k - 1; i++) {
            temp[i].c = 0;
        }

        /* Step 2: Process all
          elements of input array */
        for (int i = 0; i < n; i++) {
            int j;

            /* If arr[i] is already present in
               the element count array,
               then increment its count
             */
            for (j = 0; j < k - 1; j++) {
                if (temp[j].e == arr[i]) {
                    temp[j].c += 1;
                    break;
                }
            }

            /* If arr[i] is not present in temp[] */
            if (j == k - 1) {
                int l;

                /* If there is position available
                  in temp[], then place arr[i] in
                  the first available position and
                  set count as 1*/
                for (l = 0; l < k - 1; l++) {
                    if (temp[l].c == 0) {
                        temp[l].e = arr[i];
                        temp[l].c = 1;
                        break;
                    }
                }

                /* If all the position in the
                   temp[] are filled, then decrease
                   count of every element by 1 */
                if (l == k - 1)
                    for (l = 0; l < k - 1; l++)
                        temp[l].c -= 1;
            }
        }

        /*Step 3: Check actual counts of
         * potential candidates in temp[]*/
        for (int i = 0; i < k - 1; i++) {

            // Calculate actual count of elements
            int ac = 0; // actual count
            for (int j = 0; j < n; j++)
                if (arr[j] == temp[i].e)
                    ac++;

            // If actual count is more than n/k,
            // then print it
            if (ac > n / k)
                System.out.print("Number:" + temp[i].e
                                 + " Count:" + ac + "\n");
        }
    }

    /* Driver code */
    public static void main(String[] args)
    {
        int arr1[] = { 4, 5, 6, 7, 8, 4, 4 };
        int size = arr1.length;
        int k = 3;
        moreThanNdK(arr1, size, k);
    }
}

// This code contributed by Princi Singh .

Python3

# A Python3 program to print elements with
# count more than n/k

# Prints elements with more than n/k
# occurrences in arrof size n. If
# there are no such elements, then
# it prints nothing.


def moreThanNdK(arr, n, k):

    # k must be greater than 1
    # to get some output
    if (k < 2):
        return

    # Step 1: Create a temporary array
    # (contains element and count) of
    # size k-1. Initialize count of all
    # elements as 0
    temp = [[0 for i in range(2)]
            for i in range(k)]

    for i in range(k - 1):
        temp[i][0] = 0

    # Step 2: Process all elements
    # of input array
    for i in range(n):
        j = 0

        # If arr[i] is already present in
        # the element count array, then
        # increment its count
        while j < k - 1:
            if (temp[j][1] == arr[i]):
                temp[j][0] += 1
                break

            j += 1

        # If arr[i] is not present in temp
        if (j == k - 1):
            l = 0

            # If there is position available
            # in temp[], then place arr[i]
            # in the first available position
            # and set count as 1*/
            while l < k - 1:
                if (temp[l][0] == 0):
                    temp[l][1] = arr[i]
                    temp[l][0] = 1
                    break

                l += 1

            # If all the position in the
            # tempare filled, then decrease
            # count of every element by 1
            if (l == k - 1):
                while l < k:
                    temp[l][0] -= 1
                    l += 1

    # Step 3: Check actual counts
    # of potential candidates in temp[]
    for i in range(k - 1):

        # Calculate actual count of elements
        ac = 0  # Actual count
        for j in range(n):
            if (arr[j] == temp[i][1]):
                ac += 1

        # If actual count is more
        # than n/k, then print
        if (ac > n // k):
            print("Number:",
                  temp[i][1],
                  " Count:", ac)


# Driver code
if __name__ == '__main__':

    arr1 = [4, 5, 6, 7, 8, 4, 4]
    size = len(arr1)
    k = 3
    moreThanNdK(arr1, size, k)
# This code is contributed by mohit kumar 29

C#

// A C# program to print elements
// with count more than n/k
using System;
class GFG {

    // A structure to store an element
    // and its current count
    public class eleCount {
        public int e; // Element
        public int c; // Count
    };

    // Prints elements with more
    // than n/k occurrences in []arr
    // of size n. If there are no
    // such elements, then it prints
    // nothing.
    static void moreThanNdK(int[] arr, int n, int k)
    {

        // k must be greater than
        // 1 to get some output
        if (k < 2)
            return;

        /* Step 1: Create a temporary
           array (contains element
           and count) of size k-1.
           Initialize count of all
           elements as 0 */
        eleCount[] temp = new eleCount[k - 1];
        for (int i = 0; i < k - 1; i++)
            temp[i] = new eleCount();
        for (int i = 0; i < k - 1; i++) {
            temp[i].c = 0;
        }

        /* Step 2: Process all
          elements of input array */
        for (int i = 0; i < n; i++) {
            int j;

            /* If arr[i] is already present in
               the element count array,
               then increment its count
             */
            for (j = 0; j < k - 1; j++) {
                if (temp[j].e == arr[i]) {
                    temp[j].c += 1;
                    break;
                }
            }

            /* If arr[i] is not present in []temp */
            if (j == k - 1) {
                int l;

                /* If there is position available
                  in []temp, then place arr[i] in
                  the first available position and
                  set count as 1*/
                for (l = 0; l < k - 1; l++) {
                    if (temp[l].c == 0) {
                        temp[l].e = arr[i];
                        temp[l].c = 1;
                        break;
                    }
                }

                /* If all the position in the
                   []temp are filled, then decrease
                   count of every element by 1 */
                if (l == k - 1)
                    for (l = 0; l < k - 1; l++)
                        temp[l].c -= 1;
            }
        }

        /*Step 3: Check actual counts of
         * potential candidates in []temp*/
        for (int i = 0; i < k - 1; i++) {

            // Calculate actual count of elements
            int ac = 0; // actual count
            for (int j = 0; j < n; j++)
                if (arr[j] == temp[i].e)
                    ac++;

            // If actual count is more than n/k,
            // then print it
            if (ac > n / k)
                Console.Write("Number:" + temp[i].e
                              + " Count:" + ac + "\n");
        }
    }

    /* Driver code */
    public static void Main(String[] args)
    {
        int[] arr1 = { 4, 5, 6, 7, 8, 4, 4 };
        int size = arr1.Length;
        int k = 3;
        moreThanNdK(arr1, size, k);
    }
}

// This code is contributed by 29AjayKumar

Javascript

<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 code
document.write("First Test","</br>")
let arr1 = [4, 5, 6, 7, 8, 4, 4]
let size = arr1.length
let k = 3
moreThanNdK(arr1, size, k)

document.write("Second Test","</br>")
let arr2 = [4, 2, 2, 7]
size = arr2.length
k = 3
moreThanNdK(arr2, size, k)

document.write("Third Test","</br>")
let arr3 = [2, 7, 2]
size = arr3.length
k = 2
moreThanNdK(arr3, size, k)

document.write("Fourth Test","</br>")
let arr4 = [2, 3, 3, 2]
size = arr4.length
k = 3
moreThanNdK(arr4, size, k)

// This code is contributed by shinjanpatra

</script>

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<Integer, Integer> 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 <iostream>
#include <unordered_map>
using namespace std;

// Function to find the number of array
// elements with frequency more than n/k times
void printElements(int arr[], int n, int k)
{
    // Calculating n/k
    int x = n/k;

    // Counting frequency of every element
    unordered_map<int, int> mp;
    for (int i = 0; i < n; i++)
        mp[arr[i]]++;

    // Traverse the map and print all
    // the elements with occurrence
    // more than n/k times
    for (auto it : mp)
        if (it.second > x)
            cout << it.first << endl;
}

// Driver code
int main()
{
    int arr[] = { 1, 1, 2, 2, 3, 5, 4, 2, 2, 3, 1, 1, 1 };
    int n = sizeof(arr)/sizeof(arr[0]);
    int k = 4;

    printElements(arr, n, k);

    return 0;
}

// This code is contributed by Shivam Tiwari

Javascript

// function to find the number of array
// elements with frequency more than n/k times
function printElements(arr, n, k){
    // calculating n/k
    let x = parseInt(n/k);


    // counting the frequency of every
    // element using counter
    let mp = new Map();
    for(let ele of arr){
        if(ele in mp){
            mp[ele] += 1;
        }
        else{
            mp[ele] = 1;
        }
    }

    // Traverse the map and print all
    // the elements with occurrence
    // more than n/k times
    for(let it in mp){
        if(mp[it] > x){
            console.log(it);
        }
    }
}

// Driver code
let arr = [ 1, 1, 2, 2, 3, 5, 4, 2, 2, 3, 1, 1, 1 ];
let n = arr.length;
let k = 4;
printElements(arr, n, k);

// This code is contributed by Prince Kumar

C#

using System;
using System.Collections.Generic;

class GFG
{
    static void Main()
    {
        int[] arr = { 1, 1, 2, 2, 3, 5, 4, 2, 2, 3, 1, 1, 1 };
        int n = arr.Length;
        int k = 4;

        PrintElements(arr, n, k);
    }

    static void PrintElements(int[] arr, int n, int k)
    {
        // Calculating n/k
        int x = n / k;

        // Counting frequency of every element
        Dictionary<int, int> mp = new Dictionary<int, int>();
        for (int i = 0; i < n; i++)
        {
            // If the element is already in the dictionary, increment its count by 1
            if (mp.ContainsKey(arr[i]))
            {
                mp[arr[i]]++;
            }
            // If the element is not in the dictionary, add it with a count of 1
            else
            {
                mp[arr[i]] = 1;
            }
        }

        // Traverse the dictionary and print all the elements with occurrence more than n/k times
        foreach (KeyValuePair<int, int> item in mp)
        {
            if (item.Value > x)
            {
                Console.WriteLine(item.Key);
            }
        }
    }
}
// This code is contributed by Shivam Tiwari

Output

1
2

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