Skip to content
Related Articles

Related Articles

Improve Article
Print all array elements occurring at least M times
  • Difficulty Level : Expert
  • Last Updated : 10 Jun, 2021

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

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

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>
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 prarray
    # 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.

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

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>
Output
2 3 

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

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 least m times.

Below is the implementation:

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
Output
2 3 

Time Complexity: O(N)

Auxiliary Space: O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :