# Remove elements from the array which appear more than k times

Last Updated : 18 Jan, 2024

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 = 2Output : 1 3 3 4Input : arr[] = {2, 5, 5, 7}        k = 1Output : 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 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

 ``

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 ` `#include ` `#include `   `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 arr, ``int` `k)` `    ``{` `        ``// Calculating frequencies using HashMap` `        ``Map 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 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.

Previous
Next