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

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



## 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 freq = new Dictionary();       // 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 #include   void printElements(int arr[], int M, int size) {     // Counting frequency of every element using Map   std::map 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 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 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 dict = new Dictionary();     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 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 #include   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)

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!