Remove elements that appear strictly less than k times

Difficulty Level : Basic
Last Updated : 28 May, 2021

Given an array of integers, remove all the elements which appear strictly less than k times.
Examples:

Input : arr[] = {1, 2, 2, 3, 2, 3, 4}
        k = 2
Output : 2 2 3 2 3
Explanation : {1, 4} appears less than 2 times.

Approach :

Take a hash map, which will store the frequency of all the elements in the array.
Now, traverse once again.
Remove the elements which appear strictly less than k times.
Else, print it.

C++

// C++ program to remove the elements which
// appear strictly less than k times from the array.
#include "iostream"
#include "unordered_map"
using namespace std;
 
void removeElements(int arr[], int n, int k)
{
    // Hash map which will store the
    // frequency of the elements of the array.
    unordered_map<int, int> mp;
 
    for (int i = 0; i < n; ++i) {
        // Incrementing the frequency
        // of the element by 1.
        mp[arr[i]]++;
    }
 
    for (int i = 0; i < n; ++i) {
 
        // Print the element which appear
        // more than or equal to k times.
        if (mp[arr[i]] >= k) {
            cout << arr[i] << " ";
        }
    }
}
 
int main()
{
    int arr[] = { 1, 2, 2, 3, 2, 3, 4 };
    int n = sizeof(arr) / sizeof(arr[0]);
    int k = 2;
    removeElements(arr, n, k);
    return 0;
}

Java

// Java program to remove the elements which
// appear strictly less than k times from the array.
import java.util.HashMap;
 
class geeks
{
 
    public static void removeElements(int[] arr,
                                        int n, int k)
    {
         
        // Hash map which will store the
        // frequency of the elements of the array.
        HashMap<Integer, Integer> mp = new HashMap<>();
 
        for (int i = 0; i < n; ++i)
        {
 
            // Incrementing the frequency
            // of the element by 1.
            if (!mp.containsKey(arr[i]))
                mp.put(arr[i], 1);
            else
            {
                int x = mp.get(arr[i]);
                mp.put(arr[i], ++x);
            }
        }
 
        for (int i = 0; i < n; ++i)
        {
             
            // Print the element which appear
            // more than or equal to k times.
            if (mp.get(arr[i]) >= k)
                System.out.print(arr[i] + " ");
        }
    }
 
    // Driver code
    public static void main(String[] args)
    {
        int[] arr = { 1, 2, 2, 3, 2, 3, 4 };
        int n = arr.length;
        int k = 2;
        removeElements(arr, n, k);
    }
}
 
// This code is contributed by
// sanjeev2552

Python3

# Python3 program to remove the elements which
# appear strictly less than k times from the array.
def removeElements(arr, n, k):
     
    # Hash map which will store the
    # frequency of the elements of the array.
    mp = dict()
 
    for i in range(n):
         
        # Incrementing the frequency
        # of the element by 1.
        mp[arr[i]] = mp.get(arr[i], 0) + 1
 
    for i in range(n):
 
        # Print the element which appear
        # more than or equal to k times.
        if (arr[i] in mp and mp[arr[i]] >= k):
            print(arr[i], end = " ")
 
# Driver Code
arr = [1, 2, 2, 3, 2, 3, 4]
n = len(arr)
k = 2
removeElements(arr, n, k)
 
# This code is contributed by Mohit Kumar

C#

// C# program to remove the elements which
// appear strictly less than k times from the array.
using System;
using System.Collections.Generic;
  
class geeks
{
  
    public static void removeElements(int[] arr,
                                        int n, int k)
    {
          
        // Hash map which will store the
        // frequency of the elements of the array.
        Dictionary<int, int> mp = new Dictionary<int, int>();
  
        for (int i = 0; i < n; ++i)
        {
  
            // Incrementing the frequency
            // of the element by 1.
            if (!mp.ContainsKey(arr[i]))
                mp.Add(arr[i], 1);
            else
            {
                int x = mp[arr[i]];
                mp[arr[i]] = mp[arr[i]] + ++x;
            }
        }
  
        for (int i = 0; i < n; ++i)
        {
              
            // Print the element which appear
            // more than or equal to k times.
            if (mp[arr[i]] >= k)
                Console.Write(arr[i] + " ");
        }
    }
  
    // Driver code
    public static void Main(String[] args)
    {
        int[] arr = { 1, 2, 2, 3, 2, 3, 4 };
        int n = arr.Length;
        int k = 2;
        removeElements(arr, n, k);
    }
}
 
// This code is contributed by Rajput-Ji

Javascript

<script>
 
// JavaScript program to remove the elements which
// appear strictly less than k times from the array.
 
function removeElements(arr,n,k)
{
    // Hash map which will store the
        // frequency of the elements of the array.
        let mp = new Map();
  
        for (let i = 0; i < n; ++i)
        {
  
            // Incrementing the frequency
            // of the element by 1.
            if (!mp.has(arr[i]))
                mp.set(arr[i], 1);
            else
            {
                let x = mp.get(arr[i]);
                mp.set(arr[i], ++x);
            }
        }
  
        for (let i = 0; i < n; ++i)
        {
              
            // Print the element which appear
            // more than or equal to k times.
            if (mp.get(arr[i]) >= k)
                document.write(arr[i] + " ");
        }
}
 
// Driver code
 
let arr=[ 1, 2, 2, 3, 2, 3, 4 ];
let n = arr.length;
let k = 2;
removeElements(arr, n, k);
 
 
// This code is contributed by unknown2108
 
</script>

Output:

2 2 3 2 3

Time Complexity: O(N)

Method #2:Using Built-in Python functions:

Count the frequencies of every element using Counter() function
Traverse the array.
Remove the elements which appear strictly less than k times.
Else, print it.

Below is the implementation of the above approach:

Python3

# Python3 program to remove the elements which
# appear strictly less than k times from the array.
from collections import Counter
 
def removeElements(arr, n, k):
 
    # Calculating frequencies using
    # Counter function
    freq = Counter(arr)
    for i in range(n):
 
        # Print the element which appear
        # more than or equal to k times.
        if (freq[arr[i]] >= k):
            print(arr[i], end=" ")
 
 
# Driver Code
arr = [1, 2, 2, 3, 2, 3, 4]
n = len(arr)
k = 2
removeElements(arr, n, k)
 
# This code is contributed by vikkycirus

Output:

2 2 3 2 3

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 DSA Live Classes

My Personal Notes