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.