Given an array of integers, remove all the elements which appear strictly less than k times.
Examples:
Input : arr[] = {1, 2, 2, 3, 2, 3, 4} k = 2 Output : 2 2 3 2 3 Explanation : {1, 4} appears less than 2 times.
Approach :
- Take a hash map, which will store the frequency of all the elements in the array.
- Now, traverse once again.
- Remove the elements which appear strictly less than k times.
- Else, print it.
Implementation:
// C++ program to remove the elements which // appear strictly less 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
// more than or equal to k times.
if (mp[arr[i]] >= k) {
cout << arr[i] << " " ;
}
}
} int main()
{ 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 program to remove the elements which // appear strictly less than k times from the array. import java.util.HashMap;
class geeks
{ public static void removeElements( int [] arr,
int n, int k)
{
// Hash map which will store the
// frequency of the elements of the array.
HashMap<Integer, Integer> mp = new HashMap<>();
for ( int i = 0 ; i < n; ++i)
{
// Incrementing the frequency
// of the element by 1.
if (!mp.containsKey(arr[i]))
mp.put(arr[i], 1 );
else
{
int x = mp.get(arr[i]);
mp.put(arr[i], ++x);
}
}
for ( int i = 0 ; i < n; ++i)
{
// Print the element which appear
// more than or equal to k times.
if (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 // sanjeev2552 |
# Python3 program to remove the elements which # appear strictly less 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 = dict ()
for i in range (n):
# Incrementing the frequency
# of the element by 1.
mp[arr[i]] = mp.get(arr[i], 0 ) + 1
for i in range (n):
# Print the element which appear
# more than or equal to k times.
if (arr[i] in mp and mp[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 Mohit Kumar |
// C# program to remove the elements which // appear strictly less than k times from the array. using System;
using System.Collections.Generic;
class geeks
{ public 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.Add(arr[i], 1);
else
{
int x = mp[arr[i]];
mp[arr[i]] = mp[arr[i]] + ++x;
}
}
for ( int i = 0; i < n; ++i)
{
// Print the element which appear
// more than or equal to k times.
if (mp[arr[i]] >= k)
Console.Write(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 |
<script> // JavaScript program to remove the elements which // appear strictly less 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.
if (!mp.has(arr[i]))
mp.set(arr[i], 1);
else
{
let x = mp.get(arr[i]);
mp.set(arr[i], ++x);
}
}
for (let i = 0; i < n; ++i)
{
// Print the element which appear
// more than or equal to k times.
if (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> |
2 2 3 2 3
Time Complexity: O(N)
Auxiliary Space: O(n)
Method #2:Using Built-in Python functions:
- Count the frequencies of every element using Counter() function
- Traverse the array.
- Remove the elements which appear strictly less than k times.
- Else, print it.
Implementation:
// C++ program to remove elements which appear more than k // times in an array #include <iostream> #include <unordered_map> using namespace std;
void removeElements( int arr[], int n, int k)
{ // Creating an unordered_map to store the frequencies
unordered_map< int , int > freq;
for ( int i = 0; i < n; i++) {
if (freq.count(arr[i])) {
freq[arr[i]]++;
}
else {
freq[arr[i]] = 1;
}
}
// Printing the elements which appear more than or equal
// to k times
for ( int i = 0; i < n; i++) {
if (freq[arr[i]] >= k) {
cout << arr[i] << " " ;
}
}
} int main()
{ 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;
} |
import java.util.*;
public class Main {
public static void removeElements( int [] arr, int n, int k) {
// Creating a HashMap to store the frequencies
HashMap<Integer, Integer> freq = new HashMap<>();
for ( int i = 0 ; i < n; i++) {
if (freq.containsKey(arr[i])) {
freq.put(arr[i], freq.get(arr[i]) + 1 );
}
else {
freq.put(arr[i], 1 );
}
}
// Printing the elements which appear more than or equal to k times
for ( int i = 0 ; i < n; i++) {
if (freq.get(arr[i]) >= k) {
System.out.print(arr[i] + " " );
}
}
}
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);
}
} |
# 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# Equivalent using System;
using System.Collections.Generic;
public class Program
{ public static void removeElements( int [] arr, int n, int k)
{
// Creating a Dictionary to store the frequencies
Dictionary< int , int > freq = new Dictionary< int , int >();
for ( int i = 0; i < n; i++)
{
if (freq.ContainsKey(arr[i]))
{
freq[arr[i]] = freq[arr[i]] + 1;
}
else
{
freq.Add(arr[i], 1);
}
}
// Printing the elements which appear more than or equal to k times
for ( int i = 0; i < n; i++)
{
if (freq[arr[i]] >= k)
{
Console.Write(arr[i] + " " );
}
}
}
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);
}
} |
// JavaScript program to remove the elements which // appear strictly less than k times from the array. let x= "" ;
function removeElements(arr, n, k) {
// Calculating frequencies using
// the reduce() function
const freq = arr.reduce((count, val) => {
count[val] = (count[val] || 0) + 1;
return count;
}, {});
for (let i = 0; i < n; i++) {
// Print the element which appears
// more than or equal to k times.
if (freq[arr[i]] >= k) {
x = x+ arr[i] + " " ;
}
}
console.log(x);
} // Driver Code const arr = [1, 2, 2, 3, 2, 3, 4]; const n = arr.length; const k = 2; removeElements(arr, n, k); |
2 2 3 2 3
Time Complexity: O(n)
Auxiliary Space: O(n)
Method #3:( Space optimization): First we will sort the array and then check if the frequency of array element is greater than or equal to k with the use of binary search function ( Upper_bound ) . Frequency of array element is ‘last_index-first_index+1’ . If the frequency is greater than one , then print it .
Below is the implementation of the above approach:
// C++ implementation of the above approach #include <bits/stdc++.h> using namespace std;
// Function to remove element that occurs // lees than k times in the array void removeElements( int arr[], int n, int k)
{ sort(arr, arr + n); // sort array for binary search
for ( int i = 0; i < n; i++) {
// index of first and last occ of arr[i]
int first_index
= lower_bound(arr, arr + n, arr[i]) - arr;
int last_index
= upper_bound(arr, arr + n, arr[i]) - arr - 1;
int fre = last_index - first_index
+ 1; // finding frequency
if (fre >= k) { // printing element if it is greater
// than 1
cout << arr[i] << " " ;
}
}
} // Drive code int main()
{ int arr[] = { 1, 2, 2, 3, 2, 3, 4 };
int n = sizeof (arr) / sizeof (arr[0]);
int k = 2;
// Function call
removeElements(arr, n, k);
return 0;
} // This Code is contributed by nikhilsainiofficial546 |
// javascript implementation of the above approach function lower_bound(a, x){
let l = 0;
let h = arr.length - 1;
while (l <= h){
let m = Math.floor((l + h)/2);
if (a[m] < x){
l = m + 1;
}
else if (a[m] >= x){
h = m - 1;
}
}
return l;
} function upper_bound(a, x){
let l = 0;
let h = arr.length - 1;
while (l <= h){
let m = Math.floor((l + h)/2);
if (a[m] <= x){
l = m + 1;
}
else if (a[m] > x){
h = m - 1;
}
}
return l;
} //Function to remove element that occurs // lees than k times in the array function removeElements(arr, n, k)
{ arr.sort();
for (let i = 0 ; i < n ;i++)
{
//index of first and last occ of arr[i]
let first_index = lower_bound(arr, arr[i]);
let last_index = upper_bound(arr, arr[i])- 1;
let fre = last_index-first_index+1; //finding frequency
if (fre >= k)
{
// printing element if it is greater than 1\
process.stdout.write(arr[i] + " " );
}
}
} // Drive code let arr = [1, 2, 2, 3, 2, 3, 4]; let n = arr.length; let k = 2; // Function call removeElements(arr, n, k); // The code is contributed by Nidhi goel.
|
# Function to remove element that occurs # less than k times in the array def removeElements(arr, n, k):
arr.sort() # sort array for binary search
for i in range (n):
# index of first and last occ of arr[i]
first_index = bisect.bisect_left(arr, arr[i])
last_index = bisect.bisect_right(arr, arr[i]) - 1
fre = last_index - first_index + 1 # finding frequency
if fre > = k:
# printing element if it is greater than 1
print (arr[i], end = " " )
# Driver code if __name__ = = "__main__" :
import bisect
arr = [ 1 , 2 , 2 , 3 , 2 , 3 , 4 ]
n = len (arr)
k = 2
# Function call
removeElements(arr, n, k)
|
import java.util.*;
class Main {
// Function to remove element that occurs
// lees than k times in the array
static void removeElements( int arr[], int n, int k)
{
Arrays.sort(arr); // sort array for binary search
ArrayList<Integer> arr1 = new ArrayList<Integer>( 5 );
// using add() to initialize values
for ( int i = 0 ; i < n; i++) {
arr1.add(arr[i]);
}
for ( int i = 0 ; i < n; i++) {
// index of first and last occ of arr[i]
int first_index = arr1.indexOf(arr[i]);
int last_index = arr1.lastIndexOf(arr[i]);
while (last_index < n
&& arr[last_index] == arr[i])
last_index++;
last_index--;
int fre = last_index - first_index
+ 1 ; // finding frequency
if (fre >= k) { // printing element if it is
// greater than 1
System.out.print(arr[i] + " " );
}
}
}
// Drive code
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 2 , 3 , 2 , 3 , 4 };
int n = arr.length;
int k = 2 ;
// Function call
removeElements(arr, n, k);
}
} // This code is contributed by Pratik Gagare (pratikg03) |
using System;
using System.Collections.Generic;
using System.Linq;
class MainClass {
// Function to remove element that occurs
// less than k times in the array
static void RemoveElements( int [] arr, int n, int k)
{
Array.Sort(arr); // sort array for binary search
List< int > arr1 = new List< int >(5);
// using Add() to initialize values
for ( int i = 0; i < n; i++) {
arr1.Add(arr[i]);
}
for ( int i = 0; i < n; i++) {
// index of first and last occ of arr[i]
int first_index = arr1.IndexOf(arr[i]);
int last_index = arr1.LastIndexOf(arr[i]);
while (last_index < n && arr[last_index] == arr[i])
last_index++;
last_index--;
int fre = last_index - first_index + 1; // finding frequency
if (fre >= k) { // printing element if it is greater than 1
Console.Write(arr[i] + " " );
}
}
}
// Drive code
public static void Main ( string [] args)
{
int [] arr = { 1, 2, 2, 3, 2, 3, 4 };
int n = arr.Length;
int k = 2;
// Function call
RemoveElements(arr, n, k);
}
} |
2 2 2 3 3
Time Complexity: O(n*log2n)
Auxiliary Space: O(1)