Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

Find the k smallest numbers after deleting given elements

  • Difficulty Level : Easy
  • Last Updated : 31 May, 2021

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.

 

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




// 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




# Python3 program to find the k maximum
# number from the array after n deletions
import math as mt
 
# 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 = list()
     
    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
        else:
            heap.append(arr[i])
     
    heap.sort()
 
    return heap[:k]
 
# 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))
 
# This code is contributed
# by mohit kumar 29

C#




// 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.

Javascript




<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>

Output:  

4 12 20

 




My Personal Notes arrow_drop_up
Recommended Articles
Page :