# Last remaining element by removing values closest to half of Array sum

• Last Updated : 01 Sep, 2022

Given an array arr[] of size N, the task is to find the last element remaining after removing all elements closest to sum/2 sequentially where sum is the array sum.

Note: If sum/2 is decimal, then its floor value is considered for the operation and if there is a tie between the closest elements then delete the smaller one.

Examples:

Input:  N = 4, arr[] = {1, 3, 5, 7}
Output: 5
Explanation: Iteration 1: {1, 3, 5, 7}, sum = 16, sum/2 = 8, delete 7
Iteration 2: {1, 3, 5}, sum = 9, sum/2 = 4, delete 3
Iteration 3: {1, 5}, sum = 6, sum/2 = 3, delete 1
At last only element 5 is present.

Input: N = 4, arr[] = {1, 2, 3, 4}
Output: 2
Explanation: Iteration 1: {1, 2, 3, 4}, sum = 10, sum/2 = 5, delete 4
Iteration 2: {1, 2, 3}, sum = 6, sum/2 = 3, delete 3
Iteration 3: {1, 2}, sum = 3, sum/2 = 1, delete 1
At last only element 2 is present.

Approach: To solve the problem follow the below idea:

The problem deals with the efficient searching of the elements within the array or vector and can be achieved by binary search
Use a loop and calculate the sum of the array and delete the element that is closest to sum/2. Execute the loop till there is only one element left.

Follow the given steps to solve the problem:

• Sort the given N integers.
• Traverse and find the sum of all integers.
• While the size is greater than 1, find the index of the closest element to sum/2
• Apply binary search for the purpose and in each iteration update the difference to get the closest element.
• Subtract arr[index] from the sum.
• Erase the element from vector arr at position index.
• Return the only remaining element of the vector.

Below is the implementation for the above approach:

## C++14

 `// C++ program for above approach` `#include ``using` `namespace` `std;` `// Function to find the position in the``// vector whose value is closest to the key,``// using binary search``int` `correctPOS(vector<``int``>& arr, ``int` `n, ``int` `key)``{``    ``int` `low = 0, high = n - 1, mid;` `    ``// Base cases``    ``if` `(key <= arr)``        ``return` `0;``    ``else` `if` `(key >= arr[n - 1])``        ``return` `n - 1;` `    ``// Implementation of binary search``    ``while` `(low <= high) {` `        ``mid = low + (high - low) / 2;` `        ``// If the value of arr[mid] is``        ``// equal to the key, return mid``        ``if` `(arr[mid] == key)``            ``return` `mid;` `        ``// If this is the case``        ``// then ignore right half``        ``else` `if` `(key < arr[mid]) {``            ``high = mid - 1;` `            ``// Condition to check if the key is``            ``// in-between arr[mid] and arr[mid-1]``            ``if` `(mid > 0 && arr[mid - 1] < key) {` `                ``if` `(``abs``(key - arr[mid - 1])``                    ``<= ``abs``(arr[mid] - key))``                    ``return` `mid - 1;``                ``else``                    ``return` `mid;``            ``}``        ``}` `        ``// If this is the case``        ``// then ignore left half``        ``else` `{``            ``low = mid + 1;` `            ``// Condition to check if the key``            ``// is in-between arr[mid] and arr[mid+1]``            ``if` `(mid + 1 < n && arr[mid + 1] > key) {` `                ``if` `(``abs``(key - arr[mid])``                    ``<= ``abs``(arr[mid + 1] - key))``                    ``return` `mid;``                ``else``                    ``return` `mid + 1;``            ``}``        ``}``    ``}` `    ``return` `mid;``}` `// Function to find the last``// remaining element``int` `FindVirus(vector<``int``>& arr)``{``    ``int` `i, index, n = arr.size();``    ``long` `long` `sum = 0;` `    ``// Sort the input vector``    ``sort(arr.begin(), arr.end());` `    ``// Traverse the vector to calculate``    ``// the sum of elements``    ``for` `(i = 0; i < n; i++)``        ``sum += arr[i];` `    ``// Run a while loop, while size of vector``    ``// is greater than one``    ``while` `(arr.size() > 1) {``        ``int` `index = correctPOS(arr, arr.size(),``                               ``sum / 2);``        ``sum -= arr[index];``        ``arr.erase(arr.begin() + index);``    ``}` `    ``// Return the remaining element``    ``return` `arr;``}` `// Driver code``int` `main()``{``    ``vector<``int``> arr = { 1, 3, 5, 7 };` `    ``// Function call``    ``cout << FindVirus(arr);``    ``return` `0;``}`

## Java

 `// Java program for above approach` `import` `java.io.*;``import` `java.util.*;` `class` `GFG {` `    ``// Function to find the position in the vector whose``    ``// value is closest to the key, using binary search``    ``public` `static` `int` `correctPOS(List arr, ``int` `n,``                                 ``int` `key)``    ``{``        ``int` `low = ``0``, high = n - ``1``;``        ``int` `mid = ``0``;``        ``// Base cases``        ``if` `(key <= arr.get(``0``)) {``            ``return` `0``;``        ``}``        ``else` `if` `(key >= arr.get(n - ``1``)) {``            ``return` `n - ``1``;``        ``}``        ``// Implementation of binary search``        ``while` `(low <= high) {``            ``mid = low + (high - low) / ``2``;``            ``// If the value of arr[mid] is equal to the key,``            ``// return mid``            ``if` `(arr.get(mid) == key) {``                ``return` `mid;``            ``}``            ``// If this is the case then ignore right half``            ``else` `if` `(key < arr.get(mid)) {``                ``high = mid - ``1``;``                ``// Condition to check if the key is``                ``// in-between arr[mid] and arr[mid-1]``                ``if` `(mid > ``0` `&& arr.get(mid - ``1``) < key) {``                    ``if` `(Math.abs(key - arr.get(mid - ``1``))``                        ``<= Math.abs(arr.get(mid)) - key) {``                        ``return` `mid - ``1``;``                    ``}``                    ``else` `{``                        ``return` `mid;``                    ``}``                ``}``            ``}``            ``// If this is the case then ignore left half``            ``else` `{``                ``low = mid + ``1``;``                ``// Condition to check if the key is``                ``// in-between arr[mid] and arr[mid+1]``                ``if` `(mid + ``1` `< n && arr.get(mid + ``1``) > key) {``                    ``if` `(Math.abs(key - arr.get(mid))``                        ``<= Math.abs(arr.get(mid + ``1``)``                                    ``- key)) {``                        ``return` `mid;``                    ``}``                    ``else` `{``                        ``return` `mid + ``1``;``                    ``}``                ``}``            ``}``        ``}``        ``return` `mid;``    ``}` `    ``// Function to find the last remaining element.``    ``public` `static` `int` `FindVirus(List arr)``    ``{``        ``int` `i, index, n = arr.size();``        ``int` `sum = ``0``;``        ``// Sort the array``        ``Collections.sort(arr);``        ``// Traverse the array to calculate the sum of``        ``// elements``        ``for` `(i = ``0``; i < n; i++) {``            ``sum += arr.get(i);``        ``}``        ``// Run a while loop, while size of array is greater``        ``// than one``        ``while` `(arr.size() > ``1``) {``            ``index = correctPOS(arr, arr.size(), sum / ``2``);``            ``sum -= arr.get(index);``            ``arr.remove(index);``        ``}``        ``// Return the remaining element``        ``return` `arr.get(``0``);``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``List arr = ``new` `ArrayList();``        ``arr.add(``1``);``        ``arr.add(``3``);``        ``arr.add(``5``);``        ``arr.add(``7``);` `        ``// Function call``        ``System.out.print(FindVirus(arr));``    ``}``}` `// This code is contributed by lokesh (lokeshmvs21).`

## Python3

 `# Python program for above approach` `# Function to find the position in the``# vector whose value is closest to the key,``# using binary search`  `def` `correctPOS(arr, n, key):``    ``low ``=` `0``    ``high ``=` `n ``-` `1``    ``mid ``=` `0` `    ``# Base cases``    ``if` `(key <``=` `arr[``0``]):``        ``return` `0``    ``elif` `(key >``=` `arr[n ``-` `1``]):``        ``return` `n ``-` `1` `    ``# Implementation of binary search``    ``while` `(low <``=` `high):``        ``mid ``=` `low ``+` `(high ``-` `low) ``/``/` `2``        ``# If the value of arr[mid] is``        ``# equal to the key, return mid``        ``if` `(arr[mid] ``=``=` `key):``            ``return` `mid``        ``# If this is the case``        ``# then ignore right half``        ``elif` `(key < arr[mid]):``            ``high ``=` `mid ``-` `1` `        ``# Condition to check if the key is``        ``# in-between arr[mid] and arr[mid-1]``        ``if` `(mid > ``0` `and` `arr[mid ``-` `1``] < key):``            ``if` `(``abs``(key ``-` `arr[mid ``-` `1``]) <``=` `abs``(arr[mid] ``-` `key)):``                ``return` `mid ``-` `1``            ``else``:``                ``return` `mid` `        ``# If this is the case``        ``# then ignore left half``        ``else``:``            ``low ``=` `mid ``+` `1``            ``# Condition to check if the key``            ``# is in-between arr[mid] and arr[mid+1]``            ``if` `(mid ``+` `1` `< n ``and` `arr[mid ``+` `1``] > key):``                ``if` `(``abs``(key ``-` `arr[mid]) <``=` `abs``(arr[mid ``+` `1``] ``-` `key)):``                    ``return` `mid``                ``else``:``                    ``return` `mid ``+` `1` `    ``return` `mid` `# Function to find the last``# remaining element`  `def` `FindVirus(arr):``    ``i ``=` `0``    ``index ``=` `0``    ``n ``=` `len``(arr)``    ``sum` `=` `0` `    ``# Sort the input vector``    ``arr.sort()` `    ``# Traverse the vector to calculate``    ``# the sum of elements``    ``for` `i ``in` `range``(n):``        ``sum` `+``=` `arr[i]` `    ``# Run a while loop, while size of vector``    ``# is greater than one``    ``while` `(``len``(arr) > ``1``):``        ``index ``=` `correctPOS(arr, ``len``(arr), ``sum` `/` `2``)``        ``sum` `-``=` `arr[index]``        ``del` `arr[index]``    ``# Return the remaining element``    ``return` `arr[``0``]`  `# Driver code``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``1``, ``3``, ``5``, ``7``]` `    ``# Function call``    ``print``(FindVirus(arr))` `# This code is contributed by Rohit Pradhan`

## C#

 `// C# program for above approach`  `using` `System;``using` `System.Collections.Generic;` `public` `class` `GFG {` `    ``// Function to find the position in the vector whose``    ``// value is closest to the key, using binary search``    ``public` `static` `int` `correctPOS(List<``int``> arr, ``int` `n,``                                 ``int` `key)``    ``{``        ``int` `low = 0, high = n - 1;``        ``int` `mid = 0;``        ``// Base cases``        ``if` `(key <= arr) {``            ``return` `0;``        ``}``        ``else` `if` `(key >= arr[n - 1]) {``            ``return` `n - 1;``        ``}``        ``// Implementation of binary search``        ``while` `(low <= high) {``            ``mid = low + (high - low) / 2;``            ``// If the value of arr[mid] is equal to the key,``            ``// return mid``            ``if` `(arr[mid] == key) {``                ``return` `mid;``            ``}``            ``// If this is the case then ignore right half``            ``else` `if` `(key < arr[mid]) {``                ``high = mid - 1;``                ``// Condition to check if the key is``                ``// in-between arr[mid] and arr[mid-1]``                ``if` `(mid > 0 && arr[mid - 1] < key) {``                    ``if` `(Math.Abs(key - arr[mid - 1])``                        ``<= Math.Abs(arr[mid]) - key) {``                        ``return` `mid - 1;``                    ``}``                    ``else` `{``                        ``return` `mid;``                    ``}``                ``}``            ``}``            ``// If this is the case then ignore left half``            ``else` `{``                ``low = mid + 1;``                ``// Condition to check if the key is``                ``// in-between arr[mid] and arr[mid+1]``                ``if` `(mid + 1 < n && arr[mid + 1] > key) {``                    ``if` `(Math.Abs(key - arr[mid])``                        ``<= Math.Abs(arr[mid + 1]``                                    ``- key)) {``                        ``return` `mid;``                    ``}``                    ``else` `{``                        ``return` `mid + 1;``                    ``}``                ``}``            ``}``        ``}``        ``return` `mid;``    ``}` `    ``// Function to find the last remaining element.``    ``public` `static` `int` `FindVirus(List<``int``> arr)``    ``{``        ``int` `i, index, n = arr.Count;``        ``int` `sum = 0;``        ``// Sort the array``        ``arr.Sort();``        ``// Traverse the array to calculate the sum of``        ``// elements``        ``for` `(i = 0; i < n; i++) {``            ``sum += arr[i];``        ``}``        ``// Run a while loop, while size of array is greater``        ``// than one``        ``while` `(arr.Count > 1) {``            ``index = correctPOS(arr, arr.Count, sum / 2);``            ``sum -= arr[index];``            ``arr.RemoveAt(index);``        ``}``        ``// Return the remaining element``        ``return` `arr;``    ``}` `    ``public` `static` `void` `Main(String[] args)``    ``{``        ``List<``int``> arr = ``new` `List<``int``>();``        ``arr.Add(1);``        ``arr.Add(3);``        ``arr.Add(5);``        ``arr.Add(7);` `        ``// Function call``        ``Console.Write(FindVirus(arr));``    ``}``}`  `// This code contributed by shikhasingrajput`

## Javascript

 ``

Output

`8`

Time Complexity: O(N2)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up