Related Articles
Find the largest after deleting the given elements
• Difficulty Level : Easy
• Last Updated : 03 Sep, 2019

Given an array of integers, find the 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.

Examples:

Input :array[] = { 5, 12, 33, 4, 56, 12, 20 }
del[] = { 12, 33, 56, 5 }
Output : 20
Explanation : We get {12, 20} after deleting given elements. Largest among remaining element is 20

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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.
• Initialize largest number max to be INT_MIN.
• Traverse through the array. Check if the element is present in the hash map.
• If present, erase it from the hash map, else if not present compare it with max variable and change its value if the value of the element is greater than the max value.

## C++

 `// C++ program to find the largest number``// from the array after  n deletions``#include "climits"``#include "iostream"``#include "unordered_map"``using` `namespace` `std;`` ` `// Returns maximum element from arr[0..m-1] after deleting``// elements from del[0..n-1]``int` `findlargestAfterDel(``int` `arr[], ``int` `m, ``int` `del[], ``int` `n)``{``    ``// 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]]++;``    ``}`` ` `    ``// Initializing the largestElement``    ``int` `largestElement = INT_MIN;`` ` `    ``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 compare it largestElement``        ``else``            ``largestElement = max(largestElement, arr[i]);``    ``}`` ` `    ``return` `largestElement;``}`` ` `int` `main()``{``    ``int` `array[] = { 5, 12, 33, 4, 56, 12, 20 };``    ``int` `m = ``sizeof``(array) / ``sizeof``(array);`` ` `    ``int` `del[] = { 12, 33, 56, 5 };``    ``int` `n = ``sizeof``(del) / ``sizeof``(del);`` ` `    ``cout << findlargestAfterDel(array, m, del, n);``    ``return` `0;``}`

## Java

 `// Java program to find the largest number``// from the array after n deletions``import` `java.util.*;`` ` `class` `GFG ``{`` ` `// Returns maximum element from arr[0..m-1] after deleting``// elements from del[0..n-1]``static` `int` `findlargestAfterDel(``int` `arr[], ``int` `m,``                               ``int` `del[], ``int` `n)``{``    ``// Hash Map of the numbers to be deleted``    ``HashMap 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``);``        ``}``    ``}`` ` `    ``// Initializing the largestElement``    ``int` `largestElement = Integer.MIN_VALUE;`` ` `    ``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 compare it largestElement``        ``else``            ``largestElement = Math.max(largestElement, arr[i]);``    ``}``    ``return` `largestElement;``}`` ` `// Driver Code``public` `static` `void` `main(String[] args) ``{``    ``int` `array[] = { ``5``, ``12``, ``33``, ``4``, ``56``, ``12``, ``20` `};``    ``int` `m = array.length;`` ` `    ``int` `del[] = { ``12``, ``33``, ``56``, ``5` `};``    ``int` `n = del.length;`` ` `    ``System.out.println(findlargestAfterDel(array, m, del, n));    ``}``}`` ` `// This code is contributed by Rajput-Ji`

## Python3

 `# Python3 program to find the largest ``# number from the array after n deletions``import` `math as mt`` ` `# Returns maximum element from arr[0..m-1] ``# after deleting elements from del[0..n-1]``def` `findlargestAfterDel(arr, m, dell, n):`` ` `    ``# 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``             ` `    ``# Initializing the largestElement``    ``largestElement ``=` `-``10``*``*``9`` ` `    ``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 compare it largestElement``        ``else``:``            ``largestElement ``=` `max``(largestElement, ``                                         ``arr[i])`` ` `    ``return` `largestElement`` ` `# Driver code``array ``=` `[``5``, ``12``, ``33``, ``4``, ``56``, ``12``, ``20``]``m ``=` `len``(array)`` ` `dell ``=` `[``12``, ``33``, ``56``, ``5``]``n ``=` `len``(dell)`` ` `print``(findlargestAfterDel(array, m, dell, n))`` ` `# This code is contributed ``# by mohit kumar 29`

## C#

 `// C# program to find the largest number``// from the array after n deletions``using` `System;``using` `System.Collections.Generic;`` ` `class` `GFG ``{`` ` `// Returns maximum element from arr[0..m-1] ``// after deleting elements from del[0..n-1]``static` `int` `findlargestAfterDel(``int` `[]arr, ``int` `m,``                               ``int` `[]del, ``int` `n)``{``    ``// 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[arr[i]] = mp[arr[i]] + 1;``        ``}``        ``else``        ``{``            ``mp.Add(del[i], 1);``        ``}``    ``}`` ` `    ``// Initializing the largestElement``    ``int` `largestElement = ``int``.MinValue;`` ` `    ``for` `(``int` `i = 0; i < m; i++) ``    ``{`` ` `        ``// Search if the element is present``        ``if` `(mp.ContainsKey(arr[i])) ``        ``{`` ` `            ``// Decrement its frequency``            ``mp[arr[i]] = mp[arr[i]] - 1;`` ` `            ``// If the frequency becomes 0,``            ``// erase it from the map``            ``if` `(mp[arr[i]] == 0)``                ``mp.Remove(arr[i]);``        ``}`` ` `        ``// Else compare it largestElement``        ``else``            ``largestElement = Math.Max(largestElement, ``                                             ``arr[i]);``    ``}``    ``return` `largestElement;``}`` ` `// Driver Code``public` `static` `void` `Main(String[] args) ``{``    ``int` `[]array = { 5, 12, 33, 4, 56, 12, 20 };``    ``int` `m = array.Length;`` ` `    ``int` `[]del = { 12, 33, 56, 5 };``    ``int` `n = del.Length;`` ` `    ``Console.WriteLine(findlargestAfterDel(array, m, del, n)); ``}``}`` ` `// This code is contributed by Princi Singh`

Output :

`20`

Time Complexity – O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up