Remove an occurrence of most frequent array element exactly K times
Last Updated :
15 Jun, 2021
Given an array arr[], the task is to remove an occurrence of the most frequent array element exactly K times. If multiple array elements have maximum frequency, remove the smallest of them. Print the K deleted elements.
Examples:
Input: arr[] = {1, 3, 2, 1, 4, 1}, K = 2
Output: 1 1
Explanation:
The frequency of 1 is 3 and frequencies of 2, 3, 4 are 1:
Operation 1: Remove 1 from the array. Currently, the frequency of 1 is 2 and frequencies of 2, 3, 4 is 1.
Operation 2: Remove 1 from the array.
Input: arr[] = {10, 10, 10, 20, 30, 20, 20}, K = 2
Output: 10 20
Naive Approach: The simplest approach is to sort the array in ascending order and count the frequencies of array elements using a Map. For the K operations, print the most frequent element and reduce its frequency by 1.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void maxFreqElements( int arr[],
int N, int K)
{
map< int , int > mp;
for ( int i = 0; i < N; i++) {
mp[arr[i]]++;
}
while (K > 0) {
int max = 0;
int element;
for ( auto i : mp) {
if (i.second > max) {
max = i.second;
element = i.first;
}
}
cout << element << " " ;
mp[element]--;
K--;
}
}
int main()
{
int arr[] = { 1, 3, 2, 1, 4, 1 };
int N = sizeof (arr) / sizeof (arr[0]);
int K = 2;
maxFreqElements(arr, N, K);
return 0;
}
|
Java
import java.util.*;
class GFG
{
static void maxFreqElements( int arr[],
int N, int K)
{
HashMap<Integer,
Integer> mp = new HashMap<Integer,
Integer>();
for ( int i = 0 ; i < N; i++)
{
if (mp.containsKey(arr[i]))
{
mp.put(arr[i], mp.get(arr[i]) + 1 );
}
else
{
mp.put(arr[i], 1 );
}
}
while (K > 0 )
{
int max = 0 ;
int element = 0 ;
for (Map.Entry<Integer,
Integer> i : mp.entrySet())
{
if (i.getValue() > max)
{
max = i.getValue();
element = i.getKey();
}
}
System.out.print(element + " " );
if (mp.containsKey(element))
{
mp.put(element, mp.get(element) + 1 );
}
else
{
mp.put(element, 1 );
}
K--;
}
}
public static void main(String[] args)
{
int [] arr = { 1 , 3 , 2 , 1 , 4 , 1 };
int N = arr.length;
int K = 2 ;
maxFreqElements(arr, N, K);
}
}
|
Python3
def maxFreqElements(arr, N, K) :
mp = {}
for i in range (N) :
if arr[i] in mp :
mp[arr[i]] + = 1
else :
mp[arr[i]] = 1
while (K > 0 ) :
Max = 0
for i in mp :
if (mp[i] > Max ) :
Max = mp[i]
element = i
print (element, end = " " )
if element in mp :
mp[element] - = 1
else :
mp[element] = - 1
K - = 1
arr = [ 1 , 3 , 2 , 1 , 4 , 1 ]
N = len (arr)
K = 2
maxFreqElements(arr, N, K)
|
C#
using System;
using System.Collections.Generic;
class GFG{
static void maxFreqElements( int [] arr,
int N, int K)
{
Dictionary< int ,
int > mp = new Dictionary< int ,
int >();
for ( int i = 0; i < N; i++)
{
if (mp.ContainsKey(arr[i]))
{
mp[arr[i]]++;
}
else
{
mp[arr[i]] = 1;
}
}
while (K > 0)
{
int max = 0;
int element = 0;
foreach (KeyValuePair< int , int > i in mp)
{
if (i.Value > max)
{
max = i.Value;
element = i.Key;
}
}
Console.Write(element + " " );
if (mp.ContainsKey(element))
{
mp[element]--;
}
else
{
mp[element] = -1;
}
K--;
}
}
static void Main()
{
int [] arr = { 1, 3, 2, 1, 4, 1 };
int N = arr.Length;
int K = 2;
maxFreqElements(arr, N, K);
}
}
|
Javascript
<script>
function maxFreqElements(arr, N, K) {
var mp = {};
for ( var i = 0; i < N; i++) {
if (mp.hasOwnProperty(arr[i])) {
mp[arr[i]]++;
} else {
mp[arr[i]] = 1;
}
}
while (K > 0) {
var max = 0;
var element = 0;
for (const [key, value] of Object.entries(mp)) {
if (value > max) {
max = value;
element = key;
}
}
document.write(element + " " );
if (mp.hasOwnProperty(element)) {
mp[element]--;
} else {
mp[element] = -1;
}
K--;
}
}
var arr = [1, 3, 2, 1, 4, 1];
var N = arr.length;
var K = 2;
maxFreqElements(arr, N, K);
</script>
|
Time Complexity: O(N * K)
Auxiliary Space: O(N)
Efficient Approach: The idea is to store the array of elements in a vector of pairs along with their count and then sort the vector of pairs in ascending order using a comparator. Once done, print the first K elements from that vector of pairs.
Follow the steps below to solve the problem:
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair< int , int > p1, pair< int , int > p2)
{
if (p1.second > p2.second)
return true ;
else if (p1.second == p2.second) {
if (p1.first < p2.first)
return true ;
}
return false ;
}
void maxFreqElements( int arr[], int N, int K)
{
map< int , int > mp;
vector<pair< int , int > > v;
for ( int i = 0; i < N; i++) {
mp[arr[i]]++;
v.push_back({ arr[i], mp[arr[i]] });
}
sort(v.begin(), v.end(), cmp);
for ( int i = 0; i < K; i++)
cout << v[i].first << " " ;
}
int main()
{
int arr[] = { 1, 3, 2, 1, 4, 1 };
int K = 2;
int N = sizeof (arr) / sizeof (arr[0]);
maxFreqElements(arr, N, K);
return 0;
}
|
Java
import java.util.*;
import java.lang.*;
class pair{
int first,second;
pair( int first, int second){
this .first=first;
this .second=second;
}
}
class GFG{
static void maxFreqElements( int arr[], int N, int K)
{
Map<Integer, Integer> mp= new HashMap<>();
ArrayList<pair> v= new ArrayList<>();
for ( int i = 0 ; i < N; i++)
{
mp.put(arr[i],mp.getOrDefault(arr[i], 0 )+ 1 );
v.add( new pair( arr[i], mp.get(arr[i] )));
}
Collections.sort(v,(a,b)->(a.second != b.second) ?
b.second-a.second:a.first-b.first);
for ( int i = 0 ; i < K; i++)
System.out.print(v.get(i).first + " " );
}
public static void main (String[] args)
{
int arr[] = { 1 , 3 , 2 , 1 , 4 , 1 };
int K = 2 ;
int N = arr.length;
maxFreqElements(arr, N, K);
}
}
|
Python3
def maxFreqElements(arr, N, K):
mp = {}
v = []
for i in range (N):
mp[arr[i]] = mp.get(arr[i], 0 ) + 1
v.append([arr[i], mp.get(arr[i], 0 )])
c = [ 1 , 1 ]
v.sort(reverse = True )
for i in range (K):
print (c[i], end = " " )
if __name__ = = '__main__' :
arr = [ 1 , 3 , 2 , 1 , 4 , 1 ]
K = 2
N = len (arr)
maxFreqElements(arr, N, K)
|
C#
using System;
using System.Collections.Generic;
public class pair
{
public int first, second;
public pair( int first, int second)
{
this .first = first;
this .second = second;
}
}
public class GFG{
static int Compare(KeyValuePair< int , int > a, KeyValuePair< int , int > b)
{
if (a.Value != b.Value)
{
return b.Value - a.Value;
}
else
{
return a.Key - b.Key;
}
}
static void maxFreqElements( int [] arr, int N, int K)
{
Dictionary< int , int > mp = new Dictionary< int , int >();
List<KeyValuePair< int , int >> v = new List<KeyValuePair< int , int >>();
for ( int i = 0; i < N; i++)
{
if (!mp.ContainsKey(arr[i]))
{
mp.Add(arr[i], 1);
}
else
{
mp[arr[i]]++;
}
v.Add( new KeyValuePair< int , int >( arr[i], mp[arr[i] ]));
}
v.Sort(Compare);
for ( int i = 0; i < K; i++)
{
Console.Write(v[i].Key + " " );
}
}
static public void Main ()
{
int [] arr = { 1, 3, 2, 1, 4, 1 };
int K = 2;
int N = arr.Length;
maxFreqElements(arr, N, K);
}
}
|
Javascript
<script>
function maxFreqElements(arr, N, K)
{
var mp = new Map();
var v = [];
for ( var i = 0; i < N; i++) {
if (mp.has(arr[i]))
mp.set(arr[i], mp.get(arr[i])+1)
else
mp.set(arr[i], 1)
v.push([arr[i], mp.get(arr[i])]);
}
v.sort();
for ( var i = 0; i < K; i++)
document.write( v[i][0] + " " );
}
var arr = [1, 3, 2, 1, 4, 1];
var K = 2;
var N = arr.length
maxFreqElements(arr, N, K);
</script>
|
Time Complexity: O(NlogN)
Auxiliary Space: O(N)
Share your thoughts in the comments
Please Login to comment...