# Find the largest after deleting the given elements

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

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.

Implementation:

## 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[0]);` `    ``int` `del[] = { 12, 33, 56, 5 };``    ``int` `n = ``sizeof``(del) / ``sizeof``(del[0]);` `    ``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`

## Javascript

 ``

Output
`20`

Complexity Analysis:

• Time Complexity: O(max(m, n)
• Auxiliary Space: O(m + n)

Previous
Next