 GFG App
Open App Browser
Continue

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

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