Open In App

Remove elements from the array which appear more than k times

Improve
Improve
Like Article
Like
Save
Share
Report

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), where N is the size of the given integer.

Auxiliary Space – O(N), where N is the size of the given integer.

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:

C++




#include <iostream>
#include <unordered_map>
#include <vector>
 
void removeElements(const std::vector<int>& arr, int k) {
    // Calculating frequencies using unordered_map
    std::unordered_map<int, int> freq;
 
    // Counting the frequency of each element
    for (int i = 0; i < arr.size(); ++i) {
        freq[arr[i]]++;
    }
 
    // Print the elements which appear more than or equal to k times
    for (int i = 0; i < arr.size(); ++i) {
        if (freq[arr[i]] <= k) {
            std::cout << arr[i] << " ";
        }
    }
}
 
int main() {
    std::vector<int> arr = {1, 2, 2, 3, 2, 3, 4};
    int k = 2;
    removeElements(arr, k);
 
    return 0;
}


Java




import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
 
public class Main {
    public static void
    removeElements(ArrayList<Integer> arr, int k)
    {
        // Calculating frequencies using HashMap
        Map<Integer, Integer> freq = new HashMap<>();
 
        // Counting the frequency of each element
        for (int i = 0; i < arr.size(); ++i) {
            freq.put(arr.get(i),
                     freq.getOrDefault(arr.get(i), 0) + 1);
        }
 
        // Print the elements which appear more than or
        // equal to k times
        for (int i = 0; i < arr.size(); ++i) {
            if (freq.get(arr.get(i)) <= k) {
                System.out.print(arr.get(i) + " ");
            }
        }
    }
 
    public static void main(String[] args)
    {
        ArrayList<Integer> arr = new ArrayList<>();
        arr.add(1);
        arr.add(2);
        arr.add(2);
        arr.add(3);
        arr.add(2);
        arr.add(3);
        arr.add(4);
 
        int k = 2;
        removeElements(arr, k);
    }
}


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


C#




using System;
using System.Collections.Generic;
using System.Linq;
 
class Program
{
    static void RemoveElements(List<int> arr, int k)
    {
        // Calculating frequencies using Dictionary
        Dictionary<int, int> freq = new Dictionary<int, int>();
 
        // Counting the frequency of each element
        foreach (int element in arr)
        {
            if (freq.ContainsKey(element))
            {
                freq[element]++;
            }
            else
            {
                freq[element] = 1;
            }
        }
 
        // Print the elements which appear more than or equal to k times
        foreach (int element in arr)
        {
            if (freq[element] <= k)
            {
                Console.Write(element + " ");
            }
        }
    }
 
    static void Main()
    {
        List<int> arr = new List<int> { 1, 2, 2, 3, 2, 3, 4 };
        int k = 2;
        RemoveElements(arr, k);
 
        Console.ReadLine();
    }
}


Javascript




function removeElements(arr, k) {
    // Calculating frequencies using Map
    const freq = new Map();
 
    // Counting the frequency of each element
    for (let i = 0; i < arr.length; ++i) {
        freq.set(arr[i], (freq.get(arr[i]) || 0) + 1);
    }
 
    // Print the elements which appear more than or equal to k times
    for (let i = 0; i < arr.length; ++i) {
        if (freq.get(arr[i]) <= k) {
            console.log(arr[i] + " ");
        }
    }
}
 
// Driver code
const arr = [1, 2, 2, 3, 2, 3, 4];
const k = 2;
removeElements(arr, k);


Output

1 3 3 4 





Time Complexity – O(N), where N is the size of the given integer.
Auxiliary Space – O(N), where N is the size of the given integer.



Last Updated : 18 Jan, 2024
Like Article
Save Article
Previous
Next
Share your thoughts in the comments
Similar Reads