Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like 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 

My Personal Notes
arrow_drop_up
Next

Delete an element from array (Using two traversals and one traversal)
Recommended Articles
Page :
Remove characters that appear more than k times
07, Nov 18
Given an array of size n and a number k, find all elements that appear more than n/k times
31, May 13
Count possible N-digit numbers such that each digit does not appear more than given number of times consecutively
13, Jan 21
Remove elements that appear strictly less than k times
10, Nov 18
Length of longest subarray in which elements greater than K are more than elements not greater than K
14, Aug 19
Array elements that appear more than once
05, Aug 18
Element which occurs consecutively in a given subarray more than or equal to K times
19, Jul 18
Find all array elements occurring more than ⌊N/3⌋ times
28, Sep 20
Print all array elements appearing more than N / K times
11, Dec 20
Count words that appear exactly two times in an array of words
13, Jul 17
Remove minimum elements from the array such that 2*min becomes more than max
18, Jul 19
Largest sub-string where all the characters appear at least K times
07, Jun 19
Largest substring where all characters appear at least K times | Set 2
23, Jun 20
Longest substring where all the characters appear at least K times | Set 3
10, Feb 21
Find Occurrence of Number More Than N/2 Times in a Sorted Array in Java
16, Nov 20
Remove minimum elements from either side such that 2*min becomes more than max
03, May 14
Remove minimum elements from either side such that 2*min becomes more than max | Set 2
13, Mar 19
Replace every character of string by character whose ASCII value is K times more than it
01, Aug 18
Maximum sum possible for a sub-sequence such that no two elements appear at a distance < K in the array
26, Mar 19
Count array elements whose all distinct digits appear in K
18, Jan 21
Remove characters from string that appears strictly less than K times
07, Nov 18
Find the element before which all the elements are smaller than it, and after which all are greater
24, Oct 15
Longest subarray not having more than K distinct elements
08, Nov 17
Check if all occurrences of a character appear together
24, Apr 18
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
imdhruvgupta
@imdhruvgupta
Vote for difficulty
Current difficulty :
Basic





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!