Find the k smallest numbers after deleting given elements
Last Updated :
30 Jan, 2023
Given an array of integers, find the k smallest numbers after deleting given elements. In case of repeating elements delete only one instance in the given array for every instance of element present in the array containing the elements to be deleted.
Assume that there are at least k elements left in the array after making n deletions.
Examples:
Input : array[] = { 5, 12, 33, 4, 56, 12, 20 }, del[] = { 12, 56, 5 }, k = 3
Output : 4 12 20
Explanation : After deletions { 33, 4, 12, 20 } will be left. Print top 3 smallest elements from it.
Approach :
- Insert all the numbers in the hash map which are to be deleted from the array, so that we can check if the element in the array is also present in the Delete-array in O(1) time.
- Traverse through the array. Check if the element is present in the hash map.
- If present, erase it from the hash map.
- Else, insert it into a Min heap.
- After inserting all the elements excluding the ones which are to be deleted, Pop-out k elements from the Min heap.
Implementation:
C++
#include "iostream"
#include "queue"
#include "unordered_map"
#include "vector"
using namespace std;
// Find k minimum element from arr[0..m-1] after deleting
// elements from del[0..n-1]
void findElementsAfterDel(int arr[], int m, int del[],
int n, int k)
{
// Hash Map of the numbers to be deleted
unordered_map<int, int> mp;
for (int i = 0; i < n; ++i) {
// Increment the count of del[i]
mp[del[i]]++;
}
priority_queue<int, vector<int>, greater<int> > heap;
for (int i = 0; i < m; ++i) {
// Search if the element is present
if (mp.find(arr[i]) != mp.end()) {
// Decrement its frequency
mp[arr[i]]--;
// If the frequency becomes 0,
// erase it from the map
if (mp[arr[i]] == 0)
mp.erase(arr[i]);
}
// Else push it in the min heap
else
heap.push(arr[i]);
}
// Print top k elements in the min heap
for (int i = 0; i < k; ++i) {
cout << heap.top() << " ";
// Pop the top element
heap.pop();
}
}
int main()
{
int array[] = { 5, 12, 33, 4, 56, 12, 20 };
int m = sizeof(array) / sizeof(array[0]);
int del[] = { 12, 56, 5 };
int n = sizeof(del) / sizeof(del[0]);
int k = 3;
findElementsAfterDel(array, m, del, n, k);
return 0;
}
// Java program to find the k maximum
// number from the array after n deletions
import java.util.*;
public class GFG
{
// Find k minimum element from arr[0..m-1] after deleting
// elements from del[0..n-1]
static void findElementsAfterDel(int[] arr,
int m, int[] del,
int n, int k)
{
// Hash Map of the numbers to be deleted
HashMap<Integer, Integer> mp = new HashMap<>();
for (int i = 0; i < n; ++i)
{
// Increment the count of del[i]
if(mp.containsKey(del[i]))
{
mp.put(del[i], mp.get(del[i])+1);
}
else{
mp.put(del[i], 1);
}
}
Vector<Integer> heap = new Vector<Integer>();
for (int i = 0; i < m; ++i)
{
// Search if the element is present
if (mp.containsKey(arr[i]))
{
// Decrement its frequency
mp.put(arr[i], mp.get(arr[i]) - 1);
// If the frequency becomes 0,
// erase it from the map
if (mp.get(arr[i]) == 0)
mp.remove(arr[i]);
}
// Else push it in the min heap
else
heap.add(arr[i]);
}
Collections.sort(heap);
// Print top k elements in the min heap
for (int i = 0; i < k; ++i)
{
System.out.print(heap.get(0) + " ");
// Pop the top element
heap.remove(0);
}
}
// Driver code
public static void main(String[] args)
{
int[] array = { 5, 12, 33, 4, 56, 12, 20 };
int m = array.length;
int[] del = { 12, 56, 5 };
int n = del.length;
int k = 3;
findElementsAfterDel(array, m, del, n, k);
}
}
// This code is contributed by divvyeshrabadiya07.
# Python3 program to find the k maximum
# number from the array after n deletions
import math as mt
import heapq
# Find k maximum element from arr[0..m-1]
# after deleting elements from del[0..n-1]
def findElementsAfterDel(arr, m, dell, n, k):
# Hash Map of the numbers to be deleted
mp = dict()
for i in range(n):
# Increment the count of del[i]
if dell[i] in mp.keys():
mp[dell[i]] += 1
else:
mp[dell[i]] = 1
heap = []
for i in range(m):
# Search if the element is present
if (arr[i] in mp.keys()):
# Decrement its frequency
mp[arr[i]] -= 1
# If the frequency becomes 0,
# erase it from the map
if (mp[arr[i]] == 0):
mp.pop(arr[i])
# else push it to heap
else:
heap.append(arr[i])
# creating min heap and heapifying it
heapq.heapify(heap)
# returning nsmallest elements from the min heap.
return heapq.nsmallest(k, heap)
# Driver code
array = [5, 12, 33, 4, 56, 12, 20]
m = len(array)
dell = [12, 56, 5]
n = len(dell)
k = 3
print(*findElementsAfterDel(array, m, dell, n, k))
'''Code is written by RAJAT KUMAR'''
// C# program to find the k maximum
// number from the array after n deletions
using System;
using System.Collections.Generic;
class GFG
{
// Find k minimum element from arr[0..m-1] after deleting
// elements from del[0..n-1]
static void findElementsAfterDel(int[] arr, int m, int[] del,
int n, int k)
{
// Hash Map of the numbers to be deleted
Dictionary<int, int> mp = new Dictionary<int, int>();
for (int i = 0; i < n; ++i)
{
// Increment the count of del[i]
if(mp.ContainsKey(del[i]))
{
mp[del[i]]++;
}
else{
mp[del[i]] = 1;
}
}
List<int> heap = new List<int>();
for (int i = 0; i < m; ++i)
{
// Search if the element is present
if (mp.ContainsKey(arr[i]))
{
// Decrement its frequency
mp[arr[i]]--;
// If the frequency becomes 0,
// erase it from the map
if (mp[arr[i]] == 0)
mp.Remove(arr[i]);
}
// Else push it in the min heap
else
heap.Add(arr[i]);
}
heap.Sort();
// Print top k elements in the min heap
for (int i = 0; i < k; ++i)
{
Console.Write(heap[0] + " ");
// Pop the top element
heap.RemoveAt(0);
}
}
// Driver code
static void Main()
{
int[] array = { 5, 12, 33, 4, 56, 12, 20 };
int m = array.Length;
int[] del = { 12, 56, 5 };
int n = del.Length;
int k = 3;
findElementsAfterDel(array, m, del, n, k);
}
}
// This code is contributed by divyesh072019.
<script>
// JavaScript program to find the k maximum
// number from the array after n deletions
// Find k minimum element from
// arr[0..m-1] after deleting
// elements from del[0..n-1]
function findElementsAfterDel(arr,m,del,n,k)
{
// Hash Map of the numbers to be deleted
let mp = new Map();
for (let i = 0; i < n; ++i)
{
// Increment the count of del[i]
if(mp.has(del[i]))
{
mp.set(del[i], mp.get(del[i])+1);
}
else{
mp.set(del[i], 1);
}
}
let heap = [];
for (let i = 0; i < m; ++i)
{
// Search if the element is present
if (mp.has(arr[i]))
{
// Decrement its frequency
mp.set(arr[i], mp.get(arr[i]) - 1);
// If the frequency becomes 0,
// erase it from the map
if (mp.get(arr[i]) == 0)
mp.delete(arr[i]);
}
// Else push it in the min heap
else
heap.push(arr[i]);
}
heap.sort(function(a,b){return a-b;});
// Print top k elements in the min heap
for (let i = 0; i < k; ++i)
{
document.write(heap[0] + " ");
// Pop the top element
heap.splice(0,1);
}
}
// Driver code
let array=[5, 12, 33, 4, 56, 12, 20 ];
let m = array.length;
let del=[12, 56, 5 ];
let n = del.length;
let k = 3;
findElementsAfterDel(array, m, del, n, k);
// This code is contributed by unknown2108
</script>
Complexity Analysis:
- Time Complexity: O(M*log(M)), since inserting in a priority queue is logarithmic operation and we are doing it M times in worst case where M is the array size.
- Auxiliary Space: O(M + N), where M and N represents the size of the given two arrays.
Similar Reads
Find the k largest numbers after deleting the given elements Given an array of integers, find the k largest number after deleting the given elements. In case of repeating elements, delete one instance for every instance of the element present in the array containing the elements to be deleted. Assume that at least k elements will be left after deleting n elem
7 min read
K-th smallest element after removing given natural numbers | Set 2 Given an array arr[] of size 'n' and a positive integer k. Consider series of natural numbers and remove arr[0], arr[1], arr[2], ..., arr[n-1] from it. Now the task is to find k-th smallest number in the remaining set of natural numbers. If no such number exists print "-1".Examples: Input: arr[] = [
5 min read
K-th smallest element after removing given natural numbers | Set 2 Given an array arr[] of size 'n' and a positive integer k. Consider series of natural numbers and remove arr[0], arr[1], arr[2], ..., arr[n-1] from it. Now the task is to find k-th smallest number in the remaining set of natural numbers. If no such number exists print "-1".Examples: Input: arr[] = [
5 min read
K-th smallest element after removing given natural numbers | Set 2 Given an array arr[] of size 'n' and a positive integer k. Consider series of natural numbers and remove arr[0], arr[1], arr[2], ..., arr[n-1] from it. Now the task is to find k-th smallest number in the remaining set of natural numbers. If no such number exists print "-1".Examples: Input: arr[] = [
5 min read
Find k smallest elements in an array Given an array arr[] and an integer k, the task is to find k smallest elements in the given array. Elements in the output array can be in any order.Examples:Input: arr[] = [1, 23, 12, 9, 30, 2, 50], k = 3Output: [1, 2, 9]Input: arr[] = [11, 5, 12, 9, 44, 17, 2], k = 2Output: [2, 5]Table of Content[A
15 min read
K-th smallest element after removing some integers from natural numbers Given an array arr[] of size 'n' and a positive integer k. Consider series of natural numbers and remove arr[0], arr[1], arr[2], ..., arr[n-1] from it. Now the task is to find k-th smallest number in the remaining set of natural numbers. If no such number exists print "-1".Examples : Input: arr[] =
4 min read