Skip to content
Related Articles

Related Articles

Improve Article

Remove elements from the array which appear more than k times

  • Difficulty Level : Basic
  • Last Updated : 01 Jun, 2021

Given an array of integers, remove all the occurrences of those elements which appear strictly more than k times in the array.
Examples: 

Input : arr[] = {1, 2, 2, 3, 2, 3, 4}
        k = 2
Output : 1 3 3 4

Input : arr[] = {2, 5, 5, 7}
        k = 1
Output : 2 7

Approach:  

  • Take a hash map, which will store the frequency of all the elements in the array.
  • Now, traverse once again.
  • Print the elements which appear less than or equal to k times.

C++




// C++ program to remove the elements which
// appear more 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
        // less than or equal to k times.
        if (mp[arr[i]] <= k) {
            cout << arr[i] << " ";
        }
    }
}
 
int main(int argc, char const* argv[])
{
    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 more than k times from the array.
import java.util.HashMap;
import java.util.Map;
 
class GFG
{
 
static void RemoveElements(int arr[], int n, int k)
{
    // Hash map which will store the
    // frequency of the elements of the array.
    Map<Integer,Integer> mp = new HashMap<>();
 
    for (int i = 0; i < n; ++i)
    {
        // Incrementing the frequency
        // of the element by 1.
        mp.put(arr[i],mp.get(arr[i]) == null?1:mp.get(arr[i])+1);
 
    }
 
    for (int i = 0; i < n; ++i)
    {
        // Print the element which appear
        // less than or equal to k times.
        if (mp.containsKey(arr[i]) && 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 Rajput-Ji

Python3




# Python 3 program to remove the elements which
# appear more 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 = {i:0 for i in range(len(arr))}
 
    for i in range(n):
         
        # Incrementing the frequency
        # of the element by 1.
        mp[arr[i]] += 1
 
    for i in range(n):
         
        # Print the element which appear
        # less than or equal to k times.
        if (mp[arr[i]] <= k):
            print(arr[i], end = " ")
 
# Driver Code   
if __name__ == '__main__':
    arr = [1, 2, 2, 3, 2, 3, 4]
    n = len(arr)
 
    k = 2
 
    RemoveElements(arr, n, k)
 
# This code is contributed by
# Sahil_Shelangia

C#




// C# program to remove the elements which
// appear more than k times from the array.
using System;
using System.Collections.Generic;
 
class GFG
{
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[arr[i]]++;
        else
            mp[arr[i]] = 1;
    }
 
    for (int i = 0; i < n; ++i)
    {
        // Print the element which appear
        // less than or equal to k times.
        if (mp.ContainsKey(arr[i]) && mp[arr[i]] <= k)
        {
            Console.Write(arr[i] + " ");
        }
    }
}
 
// Driver code
static public void Main()
{
    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 Mohit kumar 29

Javascript




<script>
 
// JavaScript program to remove the elements which
// appear more 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.
        mp.set(arr[i],mp.get(arr[i]) == null?1:mp.get(arr[i])+1);
  
    }
  
    for (let i = 0; i < n; ++i)
    {
        // Print the element which appear
        // less than or equal to k times.
        if (mp.has(arr[i]) && 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: 

1 3 3 4

Time Complexity – O(N)

Method #2:Using Built-in Python functions:

  • Count the frequencies of every element using Counter function
  • Traverse the array.
  • Print the elements which appear less than or equal to k times.

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:

1 3 3 4 

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 experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.




My Personal Notes arrow_drop_up
Recommended Articles
Page :