Print all array elements occurring at least M times

Given an array arr[] consisting of N integers and a positive integer M, the task is to find the number of array elements that occur at least M times.

Examples:

Input: arr[] = {2, 3, 2, 2, 3, 5, 6, 3}, M = 2
Output: 2 3
Explanation:
In the given array arr[], the element that occurs at least M number of times are {2, 3}.

Input: arr[] = {1, 32, 2, 1, 33, 5, 1, 5}, M = 2
Output: 1 5

Naive Approach: The simplest approach to solve the problem is as follows:

• Traverse the array from left to right
• Check if an element has already appeared in the earlier traversal or not. If appeared check for the next element. Else again traverse the array from ith position to (n – 1)th position.
• If the frequency is >= M. Print the element.

Below is the implementation of the above approach:

C++

// C++ program for the above approach
#include <bits/stdc++.h>
using namespace std;

// Function to find the number of array
// elements with frequency at least M
void printElements(int arr[], int N, int M)
{

    // Traverse the array
    for (int i = 0; i < N; i++) {

        int j;
        for (j = i - 1; j >= 0; j--) {
            if (arr[i] == arr[j])
                break;
        }

        // If the element appeared before
        if (j >= 0)
            continue;

        // Count frequency of the element
        int freq = 0;
        for (j = i; j < N; j++) {
            if (arr[j] == arr[i])
                freq++;
        }

        if (freq >= M)
            cout << arr[i] << " ";
    }
}

// Driver Code
int main()
{
    int arr[] = { 2, 3, 2, 2, 3, 5, 6, 3 };
    int M = 2;
    int N = sizeof(arr) / sizeof(arr[0]);

    printElements(arr, N, M);

    return 0;
}

Java

// Java program for the above approach
import java.io.*;

class GFG{

// Function to find the number of array
// elements with frequency at least M
static void printElements(int[] arr, int N, int M)
{

    // Traverse the array
    for(int i = 0; i < N; i++)
    {
        int j;
        for(j = i - 1; j >= 0; j--)
        {
            if (arr[i] == arr[j])
                break;
        }

        // If the element appeared before
        if (j >= 0)
            continue;

        // Count frequency of the element
        int freq = 0;
        for(j = i; j < N; j++)
        {
            if (arr[j] == arr[i])
                freq++;
        }

        if (freq >= M)
            System.out.print(arr[i] + " ");
    }
}

// Driver Code
public static void main(String[] args)
{
    int[] arr = { 2, 3, 2, 2, 3, 5, 6, 3 };
    int M = 2;
    int N = arr.length;

    printElements(arr, N, M);
}
}

// This code is contributed by subhammahato348

Python3

# Python3 program for the above approach

# Function to find the number of array
# elements with frequency at least M
def printElements(arr, N, M):

    # Traverse the array
    for  i in range(N):
        j = i - 1

        while j >= 0:
            if (arr[i] == arr[j]):
                break

            j -= 1

        # If the element appeared before
        if (j >= 0):
            continue

        # Count frequency of the element
        freq = 0

        for j in range(i, N):
            if (arr[j] == arr[i]):
                freq += 1

        if (freq >= M):
            print(arr[i], end = " ")

# Driver Code
arr = [ 2, 3, 2, 2, 3, 5, 6, 3 ]
M = 2
N = len(arr)

printElements(arr, N, M)

# This code is contributed by rohitsingh07052

Javascript

<script>
// Javascript program for the above approach

// Function to find the number of array
// elements with frequency at least M
function printElements(arr, N, M)
{

    // Traverse the array
    for (let i = 0; i < N; i++) {

        let j;
        for (j = i - 1; j >= 0; j--) {
            if (arr[i] == arr[j])
                break;
        }

        // If the element appeared before
        if (j >= 0)
            continue;

        // Count frequency of the element
        let freq = 0;
        for (j = i; j < N; j++) {
            if (arr[j] == arr[i])
                freq++;
        }

        if (freq >= M)
            document.write(arr[i] + " ");
    }
}

// Driver Code
    let arr = [ 2, 3, 2, 2, 3, 5, 6, 3 ];
    let M = 2;
    let N = arr.length;

    printElements(arr, N, M);

 // This code is contributed by subham348.
</script>

C#

// C# program for the above approach
using System;

class GFG{

// Function to find the number of array
// elements with frequency at least M
static void printElements(int[] arr, int N, int M)
{

    // Traverse the array
    for(int i = 0; i < N; i++)
    {
        int j;
        for(j = i - 1; j >= 0; j--)
        {
            if (arr[i] == arr[j])
                break;
        }

        // If the element appeared before
        if (j >= 0)
            continue;

        // Count frequency of the element
        int freq = 0;
        for(j = i; j < N; j++)
        {
            if (arr[j] == arr[i])
                freq++;
        }

        if (freq >= M)
            Console.Write(arr[i] + " ");
    }
}

// Driver Code
public static void Main()
{
    int[] arr = { 2, 3, 2, 2, 3, 5, 6, 3 };
    int M = 2;
    int N = arr.Length;

    printElements(arr, N, M);
}
}

// This code is contributed by subham348

Output

2 3 

Approach: The given problem can be solved by storing the frequencies of array elements in a HashMap, say M, and print all the elements in the map having frequency at least M.

Below is the implementation of the above approach.

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

// Function to find the number of array
// elements with frequency at least M
void printElements(int arr[], int N, int M)
{
    // Stores the frequency of each
    // array elements
    unordered_map<int, int> freq;

    // Traverse the array
    for (int i = 0; i < N; i++) {

        // Update frequency of
        // current array element
        freq[arr[i]]++;
    }

    // Traverse the map and print array
    // elements occurring at least M times
    for (auto it : freq) {

        if (it.second >= M) {
            cout << it.first << " ";
        }
    }

    return;
}

// Driver Code
int main()
{
    int arr[] = { 2, 3, 2, 2,
                  3, 5, 6, 3 };
    int M = 2;
    int N = sizeof(arr) / sizeof(arr[0]);

    printElements(arr, N, M);

    return 0;
}

Java

// Java program for the above approach
import java.io.*;
import java.lang.*;
import java.util.*;

class GFG
{

  // Function to find the number of array
  // elements with frequency at least M
  static void printElements(int arr[], int N, int M)
  {

    // Stores the frequency of each
    // array elements
    HashMap<Integer, Integer> freq = new HashMap<>();

    // Traverse the array
    for (int i = 0; i < N; i++)
    {

      // Update frequency of
      // current array element
      freq.put(arr[i],
               freq.getOrDefault(arr[i], 0) + 1);
    }

    // Traverse the map and print array
    // elements occurring at least M times
    for (int key : freq.keySet())
    {

      if (freq.get(key) >= M) {
        System.out.print(key + " ");
      }
    }
  }

  // Driver Code
  public static void main(String[] args)
  {

    int arr[] = { 2, 3, 2, 2, 3, 5, 6, 3 };
    int M = 2;
    int N = arr.length;

    printElements(arr, N, M);
  }
}

// This code is contributed by Kingash.

Python3

# Python3 program for the above approach

# Function to find the number of array
# elements with frequency at least M
def printElements(arr, N, M):

    # Stores the frequency of each
    # array elements
    freq = {}

    # Traverse the array
    for i in arr:

        # Update frequency of
        # current array element
        freq[i] = freq.get(i, 0) + 1

    # Traverse the map and print array
    # elements occurring at least M times
    for it in freq:

        if (freq[it] >= M):
            print(it, end = " ")

    return

# Driver Code
if __name__ == '__main__':
    arr = [2, 3, 2, 2, 3, 5, 6, 3]
    M = 2
    N = len(arr)

    printElements(arr, N, M)

    # This code is contributed by mohit kumar 29.

Javascript

<script>
// Javascript program for the above approach


// Function to find the number of array
// elements with frequency at least M
function printElements(arr, N, M) {
    // Stores the frequency of each
    // array elements
    let freq = new Map();

    // Traverse the array
    for (let i = 0; i < N; i++) {

        // Update frequency of
        // current array element
        freq[arr[i]]++;
        if (freq.has(arr[i])) {
            freq.set(arr[i], freq.get(arr[i]) + 1)
        } else {
            freq.set(arr[i], 1)
        }
    }

    // Traverse the map and print array
    // elements occurring at least M times
    for (let it of freq) {

        if (it[1] >= M) {
            document.write(it[0] + " ");
        }
    }

    return;
}

// Driver Code

let arr = [2, 3, 2, 2,
    3, 5, 6, 3];
let M = 2;
let N = arr.length;

printElements(arr, N, M);

// This code is contributed by gfgking.
</script>

C#

// C# program for the above approach
using System;
using System.Collections.Generic;

class GFG{

// Function to find the number of array
// elements with frequency at least M
static void printElements(int []arr, int N, int M)
{

    // Stores the frequency of each
    // array elements
    Dictionary<int,
               int> freq = new Dictionary<int,
                                          int>();

    // Traverse the array
    for(int i = 0; i < N; i++)
    {

        // Update frequency of
        // current array element
        if (freq.ContainsKey(arr[i]))
            freq[arr[i]] += 1;
        else
            freq[arr[i]] = 1;
    }

    // Traverse the map and print array
    // elements occurring at least M times
    foreach(var item in freq)
    {
        if (item.Value >= M)
        {
            Console.Write(item.Key + " ");
        }
    }

    return;
}

// Driver Code
public static void Main()
{
    int []arr = { 2, 3, 2, 2,
                  3, 5, 6, 3 };
    int M = 2;
    int N = arr.Length;

    printElements(arr, N, M);
}
}

// This code is contributed by SURENDRA_GANGWAR

Output

3 2 

Time Complexity: O(N)
Auxiliary Space: O(N)

Method #2:Using Built in functions:

• Count the frequencies of every element using built-in function
• Traverse the frequency array and print all the elements which occur at least m times.

Below is the implementation:

C++

#include <iostream>
#include <map>

void printElements(int arr[], int M, int size)
{

  // Counting frequency of every element using Map
  std::map<int, int> mp;
  for (int i = 0; i < size; i++) {
    if (mp.find(arr[i]) != mp.end()) {
      mp[arr[i]]++;
    }
    else {
      mp[arr[i]] = 1;
    }
  }

  // Traverse the map and print all
  // the elements with occurrence at least M times
  for (auto entry : mp) {
    if (entry.second >= M) {
      std::cout << entry.first << " ";
    }
  }
}

int main() {
  int arr[] = { 2, 3, 2, 2, 3, 5, 6, 3 };
  int M = 2;

  printElements(arr, M, 8);
}

// This code is contributed by akashish__

Java

import java.util.HashMap;
import java.util.Map;

public class Main {
  public static void printElements(int[] arr, int M)
  {

    // Counting frequency of every element using Map
    Map<Integer, Integer> mp = new HashMap<>();
    for (int val : arr) {
      if (mp.containsKey(val)) {
        mp.put(val, mp.get(val) + 1);
      } else {
        mp.put(val, 1);
      }
    }

    // Traverse the map and print all
    // the elements with occurrence at least M times
    for (Map.Entry<Integer, Integer> entry : mp.entrySet()) {
      if (entry.getValue() >= M) {
        System.out.print(entry.getKey() + " ");
      }
    }
  }

  public static void main(String[] args) {
    int[] arr = { 2, 3, 2, 2, 3, 5, 6, 3 };
    int M = 2;

    printElements(arr, M);
  }
}

// This code is contributed by aadityaburujwale.

Python3

# Python3 implementation
from collections import Counter

# Function to find the number of array
# elements with frequency at least M
def printElements(arr, M):

    # Counting frequency of every element using Counter
    mp = Counter(arr)

    # Traverse the map and print all
    # the elements with occurrence atleast m times
    for it in mp:
        if mp[it] >= M:
            print(it, end=" ")


# Driver code
arr = [2, 3, 2, 2, 3, 5, 6, 3]
M = 2

printElements(arr, M)

# This code is contributed by vikkycirus

Javascript

function printElements(arr, M)
{

  // Counting frequency of every element using Map
  const mp = new Map();
  for (const val of arr) {
    if (mp.has(val)) {
      mp.set(val, mp.get(val) + 1);
    } else {
      mp.set(val, 1);
    }
  }

  // Traverse the map and print all
  // the elements with occurrence at least M times
  for (const [key, value] of mp) {
    if (value >= M) {
      console.log(key);
    }
  }
}

// Driver code
const arr = [2, 3, 2, 2, 3, 5, 6, 3];
const M = 2;

printElements(arr, M);

// This code is contributed by aadityaburujwale.

C#

// Include namespace system
using System;
using System.Collections.Generic;

public class Program
{
  public static void PrintElements(int[] arr, int M)
  {

    // Counting frequency of every element using a Dictionary
    Dictionary<int, int> dict = new Dictionary<int, int>();
    foreach (int val in arr)
    {
      if (dict.ContainsKey(val))
      {
        dict[val]++;
      }
      else
      {
        dict[val] = 1;
      }
    }

    // Traverse the dictionary and print all
    // the elements with occurrence at least M times
    foreach (KeyValuePair<int, int> entry in dict)
    {
      if (entry.Value >= M)
      {
        Console.Write(entry.Key + " ");
      }
    }
  }

  public static void Main(string[] args)
  {
    int[] arr = { 2, 3, 2, 2, 3, 5, 6, 3 };
    int M = 2;

    PrintElements(arr, M);
  }
}

// This code is contributed by mallelagowtalm.

Output

2 3 

Time Complexity: O(N)

Auxiliary Space: O(N)

Approach:

One approach to solve this problem is to sort the array in non-decreasing order, and then traverse through the sorted array to count the frequency of each element. After that, we can traverse through the frequency array to find the elements that occur at least M times.

Steps:

1. Sort the array in non-decreasing order.
2. Initialize a variable ‘count’ to keep track of the number of elements that occur at least M times.
3. Initialize two variables, ‘currElement’ and ‘currFrequency’ to keep track of the current element and its frequency while traversing through the sorted array.
4. Traverse through the sorted array and count the frequency of each element. If the current element is different from the previous element, reset the ‘currFrequency’ to 1.
5. Traverse through the frequency array to find the elements that occur at least M times. If the frequency of an element is greater than or equal to M, print the element.

C++

#include <iostream>
#include <algorithm>

using namespace std;

void PrintElements(int arr[], int n, int M);

int main() {
    int arr[] = { 2, 3, 2, 2, 3, 5, 6, 3 };
    int M = 2;
    int n = sizeof(arr) / sizeof(arr[0]);
    PrintElements(arr, n, M);
    return 0;
}

void PrintElements(int arr[], int n, int M) {
    sort(arr, arr + n);
    int count = 0;
    int currElement = arr[0];
    int currFrequency = 1;

    for (int i = 1; i < n; i++) {
        if (arr[i] == currElement) {
            currFrequency++;
        }
        else {
            if (currFrequency >= M) {
                cout << currElement << " ";
                count++;
            }
            currElement = arr[i];
            currFrequency = 1;
        }
    }

    if (currFrequency >= M) {
        cout << currElement << " ";
        count++;
    }

    cout << "\nNumber of elements occurring at least " << M << " times: " << count << endl;
}

Java

import java.util.*;

public class Main {
    public static void printElements(int[] arr, int M) {
        int n = arr.length;
        Arrays.sort(arr);
        int count = 0;
        int currElement = arr[0];
        int currFrequency = 1;

        for (int i = 1; i < n; i++) {
            if (arr[i] == currElement) {
                currFrequency++;
            } else {
                if (currFrequency >= M) {
                    System.out.print(currElement + " ");
                    count++;
                }
                currElement = arr[i];
                currFrequency = 1;
            }
        }

        if (currFrequency >= M) {
            System.out.print(currElement + " ");
            count++;
        }

        System.out.println("\nNumber of elements occurring at least " + M + " times: " + count);
    }

    // example usage
    public static void main(String[] args) {
        int[] arr = {2, 3, 2, 2, 3, 5, 6, 3};
        int M = 2;
        printElements(arr, M);
    }
}

Python3

def printElements(arr, M):
    n = len(arr)
    arr.sort()
    count = 0
    currElement = arr[0]
    currFrequency = 1

    for i in range(1, n):
        if arr[i] == currElement:
            currFrequency += 1
        else:
            if currFrequency >= M:
                print(currElement, end=" ")
                count += 1
            currElement = arr[i]
            currFrequency = 1

    if currFrequency >= M:
        print(currElement, end=" ")
        count += 1

    print("\nNumber of elements occurring at least {} times: {}".format(M, count))

# example usage
arr = [2, 3, 2, 2, 3, 5, 6, 3]
M = 2
printElements(arr, M)

C#

using System;
using System.Linq;

class Program {
    static void Main(string[] args) {
        int[] arr = new int[] { 2, 3, 2, 2, 3, 5, 6, 3 };
        int M = 2;
        PrintElements(arr, M);
    }

    static void PrintElements(int[] arr, int M) {
        int n = arr.Length;
        Array.Sort(arr);
        int count = 0;
        int currElement = arr[0];
        int currFrequency = 1;

        for (int i = 1; i < n; i++) {
            if (arr[i] == currElement) {
                currFrequency++;
            }
            else {
                if (currFrequency >= M) {
                    Console.Write(currElement + " ");
                    count++;
                }
                currElement = arr[i];
                currFrequency = 1;
            }
        }

        if (currFrequency >= M) {
            Console.Write(currElement + " ");
            count++;
        }

        Console.WriteLine($"\nNumber of elements occurring at least {M} times: {count}");
    }
}

Javascript

function printElements(arr, M) {
    let n = arr.length;
    arr.sort((a, b) => a - b);
    let count = 0;
    let currElement = arr[0];
    let currFrequency = 1;
    let result = [];

    for (let i = 1; i < n; i++) {
        if (arr[i] == currElement) {
            currFrequency++;
        } else {
            if (currFrequency >= M) {
                result.push(currElement);
                count++;
            }
            currElement = arr[i];
            currFrequency = 1;
        }
    }

    if (currFrequency >= M) {
        result.push(currElement);
        count++;
    }

    console.log(`Elements occurring at least ${M} times: ${result.join(' ')}`);
    console.log(`Number of elements occurring at least ${M} times: ${count}`);
}

let arr = [2, 3, 2, 2, 3, 5, 6, 3];
let M = 2;
printElements(arr, M);

Output

2 3 
Number of elements occurring at least 2 times: 2

Time complexity: O(nlogn)

Auxiliary space: O(1)