# Two elements whose sum is closest to zero

Question: An Array of integers is given, both +ve and -ve. You need to find the two elements such that their sum is closest to zero.
For the below array, program should print -80 and 85.

METHOD 1 (Simple)
For each element, find the sum of it with every other element in the array and compare sums. Finally, return the minimum sum.

Implementation:

## C++

 `// C++ code to find Two elements``// whose sum is closest to zero``# include ``# include /* for abs() */``# include ` `using` `namespace` `std;``void` `minAbsSumPair(``int` `arr[], ``int` `arr_size)``{``    ``int` `inv_count = 0;``    ``int` `l, r, min_sum, sum, min_l, min_r;``    ` `    ``/* Array should have at least``       ``two elements*/``    ``if``(arr_size < 2)``    ``{``        ``cout << ``"Invalid Input"``;``        ``return``;``    ``}``    ` `    ``/* Initialization of values */``    ``min_l = 0;``    ``min_r = 1;``    ``min_sum = arr[0] + arr[1];``    ` `    ``for``(l = 0; l < arr_size - 1; l++)``    ``{``        ``for``(r = l + 1; r < arr_size; r++)``        ``{``        ``sum = arr[l] + arr[r];``        ``if``(``abs``(min_sum) > ``abs``(sum))``          ``{``              ``min_sum = sum;``              ``min_l = l;``              ``min_r = r;``          ``}``        ``}``    ``}``    ``cout << ``"The two elements whose sum is minimum are "``         ``<< arr[min_l] << ``" and "` `<< arr[min_r];``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = {1, 60, -10, 70, -80, 85};``    ``minAbsSumPair(arr, 6);``    ``return` `0;``}` `// This code is contributed``// by Akanksha Rai(Abby_akku)`

## C

 `// C code to find Two elements``// whose sum is closest to zero``# include ``# include /* for abs() */``# include ``void` `minAbsSumPair(``int` `arr[], ``int` `arr_size)``{``  ``int` `inv_count = 0;``  ``int` `l, r, min_sum, sum, min_l, min_r;` `  ``/* Array should have at least two elements*/``  ``if``(arr_size < 2)``  ``{``    ``printf``(``"Invalid Input"``);``    ``return``;``  ``}` `  ``/* Initialization of values */``  ``min_l = 0;``  ``min_r = 1;``  ``min_sum = arr[0] + arr[1];` `  ``for``(l = 0; l < arr_size - 1; l++)``  ``{``    ``for``(r = l+1; r < arr_size; r++)``    ``{``      ``sum = arr[l] + arr[r];``      ``if``(``abs``(min_sum) > ``abs``(sum))``      ``{``        ``min_sum = sum;``        ``min_l = l;``        ``min_r = r;``      ``}``    ``}``  ``}` `  ``printf``(``" The two elements whose sum is minimum are %d and %d"``,``          ``arr[min_l], arr[min_r]);``}` `/* Driver program to test above function */``int` `main()``{``  ``int` `arr[] = {1, 60, -10, 70, -80, 85};``  ``minAbsSumPair(arr, 6);``  ``getchar``();``  ``return` `0;``}`

## Java

 `// Java code to find Two elements``// whose sum is closest to zero``import` `java.util.*;``import` `java.lang.*;``class` `Main``{``    ``static` `void` `minAbsSumPair(``int` `arr[], ``int` `arr_size)``    ``{``      ``int` `inv_count = ``0``;``      ``int` `l, r, min_sum, sum, min_l, min_r;``     ` `      ``/* Array should have at least two elements*/``      ``if``(arr_size < ``2``)``      ``{``        ``System.out.println(``"Invalid Input"``);``        ``return``;``      ``}``     ` `      ``/* Initialization of values */``      ``min_l = ``0``;``      ``min_r = ``1``;``      ``min_sum = arr[``0``] + arr[``1``];``     ` `      ``for``(l = ``0``; l < arr_size - ``1``; l++)``      ``{``        ``for``(r = l+``1``; r < arr_size; r++)``        ``{``          ``sum = arr[l] + arr[r];``          ``if``(Math.abs(min_sum) > Math.abs(sum))``          ``{``            ``min_sum = sum;``            ``min_l = l;``            ``min_r = r;``          ``}``        ``}``      ``}``     ` `      ``System.out.println(``" The two elements whose "``+``                              ``"sum is minimum are "``+``                        ``arr[min_l]+ ``" and "``+arr[min_r]);``    ``}``    ` `    ``// main function``    ``public` `static` `void` `main (String[] args) ``    ``{``        ``int` `arr[] = {``1``, ``60``, -``10``, ``70``, -``80``, ``85``};``        ``minAbsSumPair(arr, ``6``);``    ``}``    ` `}`

## Python3

 `# Python3 code to find Two elements``# whose sum is closest to zero` `def` `minAbsSumPair(arr,arr_size):``    ``inv_count ``=` `0` `    ``# Array should have at least``    ``# two elements``    ``if` `arr_size < ``2``:``        ``print``(``"Invalid Input"``)``        ``return` `    ``# Initialization of values ``    ``min_l ``=` `0``    ``min_r ``=` `1``    ``min_sum ``=` `arr[``0``] ``+` `arr[``1``]``    ``for` `l ``in` `range` `(``0``, arr_size ``-` `1``):``        ``for` `r ``in` `range` `(l ``+` `1``, arr_size):``            ``sum` `=` `arr[l] ``+` `arr[r]                 ``            ``if` `abs``(min_sum) > ``abs``(``sum``):         ``                ``min_sum ``=` `sum``                ``min_l ``=` `l``                ``min_r ``=` `r` `    ``print``(``"The two elements whose sum is minimum are"``, ``            ``arr[min_l], ``"and "``, arr[min_r])` `# Driver program to test above function ``arr ``=` `[``1``, ``60``, ``-``10``, ``70``, ``-``80``, ``85``]` `minAbsSumPair(arr, ``6``);` `# This code is contributed by Smitha Dinesh Semwal`

## C#

 `// C# code to find Two elements``// whose sum is closest to zero``using` `System;` `class` `GFG``{``static` `void` `minAbsSumPair(``int` `[]arr,``                        ``int` `arr_size)``    ``{``    ` `    ``int` `l, r, min_sum, sum, min_l, min_r;``    ` `    ``/* Array should have at least two elements*/``    ``if` `(arr_size < 2)``    ``{``        ``Console.Write(``"Invalid Input"``);``        ``return``;``    ``}``    ` `    ``/* Initialization of values */``    ``min_l = 0;``    ``min_r = 1;``    ``min_sum = arr[0] + arr[1];``    ` `    ``for` `(l = 0; l < arr_size - 1; l++)``    ``{``        ``for` `(r = l+1; r < arr_size; r++)``        ``{``            ``sum = arr[l] + arr[r];``            ``if` `(Math.Abs(min_sum) > Math.Abs(sum))``            ``{``                ``min_sum = sum;``                ``min_l = l;``                ``min_r = r;``            ``}``        ``}``    ``}``    ` `    ``Console.Write(``" The two elements whose "``+``                        ``"sum is minimum are "``+``                    ``arr[min_l]+ ``" and "``+arr[min_r]);``    ``}``    ` `    ``// main function``    ``public` `static` `void` `Main () ``    ``{``        ``int` `[]arr = {1, 60, -10, 70, -80, 85};``    ` `        ``minAbsSumPair(arr, 6);``    ``}``    ` `}` `// This code is contributed by Sam007`

## PHP

 ` ``abs``(``\$sum``))``        ``{``            ``\$min_sum` `= ``\$sum``;``            ``\$min_l` `= ``\$l``;``            ``\$min_r` `= ``\$r``;``        ``}``        ``}``    ``}``    ` `    ``echo` `"The two elements whose sum is minimum are "``            ``.``\$arr``[``\$min_l``].``" and "``. ``\$arr``[``\$min_r``];``            ` `}` `// Driver Code``\$arr` `= ``array``(1, 60, -10, 70, -80, 85);``minAbsSumPair(``\$arr``, 6);` `// This code is contributed by Sam007``?>`

## Javascript

 ``

Output:

`The two elements whose sum is minimum are -80 and 85`

Time complexity: O(n2)

Auxiliary Space: O(1)

METHOD 2 (Use Sorting):

Algorithm :

1. Sort all the elements of the input array.
2. Use two index variables l and r to traverse from left and right ends respectively. Initialize l as 0 and r as n-1.
3. sum = a[l] + a[r]
4. If sum is -ve, then l++
5. If sum is +ve, then r–
6. Keep track of abs min sum.
7. Repeat steps 3, 4, 5 and 6 while l < r

Implementation:

## C++

 `#include ``using` `namespace` `std;` `void` `quickSort(``int` `*, ``int``, ``int``); ` `/* Function to print pair of elements``   ``having minimum sum */``void` `minAbsSumPair(``int` `arr[], ``int` `n) ``{         ``    ``// Variables to keep track ``    ``// of current sum and minimum sum ``    ``int` `sum, min_sum = INT_MAX; ``    ` `    ``// left and right index variables ``    ``int` `l = 0, r = n-1; ``    ` `    ``// variable to keep track of ``    ``// the left and right pair for min_sum ``    ``int` `min_l = l, min_r = n-1; ``    ` `    ``/* Array should have at least two elements*/``    ``if``(n < 2) ``    ``{ ``        ``cout << ``"Invalid Input"``; ``        ``return``; ``    ``} ``    ` `    ``/* Sort the elements */``    ``quickSort(arr, l, r); ``    ` `    ``while``(l < r) ``    ``{ ``        ``sum = arr[l] + arr[r]; ``    ` `        ``/*If abs(sum) is less ``          ``then update the result items*/``        ``if``(``abs``(sum) < ``abs``(min_sum)) ``        ``{ ``            ``min_sum = sum; ``            ``min_l = l; ``            ``min_r = r; ``        ``} ``        ``if``(sum < 0) ``            ``l++; ``        ``else``            ``r--; ``    ``} ``    ` `    ``cout << ``"The two elements whose sum is minimum are "``         ``<< arr[min_l] << ``" and "` `<< arr[min_r]; ``} ` `// Driver Code``int` `main() ``{ ``    ``int` `arr[] = {1, 60, -10, 70, -80, 85}; ``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]); ``    ``minAbsSumPair(arr, n); ``    ``return` `0; ``} ``/* FOLLOWING FUNCTIONS ARE ONLY FOR ``   ``SORTING PURPOSE */``void` `exchange(``int` `*a, ``int` `*b) ``{ ``    ``int` `temp; ``    ``temp = *a; ``    ``*a = *b; ``    ``*b = temp; ``} ` `int` `partition(``int` `arr[], ``int` `si, ``int` `ei) ``{ ``    ``int` `x = arr[ei]; ``    ``int` `i = (si - 1); ``    ``int` `j; ``    ` `    ``for` `(j = si; j <= ei - 1; j++) ``    ``{ ``        ``if``(arr[j] <= x) ``        ``{ ``            ``i++; ``            ``exchange(&arr[i], &arr[j]); ``        ``} ``    ``} ``    ``exchange (&arr[i + 1], &arr[ei]); ``    ``return` `(i + 1); ``} ` `/* Implementation of Quick Sort ``arr[] --> Array to be sorted ``si --> Starting index ``ei --> Ending index ``*/``void` `quickSort(``int` `arr[], ``int` `si, ``int` `ei) ``{ ``    ``int` `pi; ``/* Partitioning index */``    ``if``(si < ei) ``    ``{ ``        ``pi = partition(arr, si, ei); ``        ``quickSort(arr, si, pi - 1); ``        ``quickSort(arr, pi + 1, ei); ``    ``} ``} ` `// This code is contributed by rathbhupendra`

## C

 `# include ``# include ``# include ` `void` `quickSort(``int` `*, ``int``, ``int``);` `/* Function to print pair of elements having minimum sum */``void` `minAbsSumPair(``int` `arr[], ``int` `n)``{``  ``// Variables to keep track of current sum and minimum sum``  ``int` `sum, min_sum = INT_MAX;` `  ``// left and right index variables``  ``int` `l = 0, r = n-1;` `  ``// variable to keep track of the left and right pair for min_sum``  ``int` `min_l = l, min_r = n-1;` `  ``/* Array should have at least two elements*/``  ``if``(n < 2)``  ``{``    ``printf``(``"Invalid Input"``);``    ``return``;``  ``}` `  ``/* Sort the elements */``  ``quickSort(arr, l, r);` `  ``while``(l < r)``  ``{``    ``sum = arr[l] + arr[r];` `    ``/*If abs(sum) is less then update the result items*/``    ``if``(``abs``(sum) < ``abs``(min_sum))``    ``{``      ``min_sum = sum;``      ``min_l = l;``      ``min_r = r;``    ``}``    ``if``(sum < 0)``      ``l++;``    ``else``      ``r--;``  ``}` `  ``printf``(``" The two elements whose sum is minimum are %d and %d"``,``          ``arr[min_l], arr[min_r]);``}` `/* Driver program to test above function */``int` `main()``{``  ``int` `arr[] = {1, 60, -10, 70, -80, 85};``  ``int` `n = ``sizeof``(arr)/``sizeof``(arr[0]);``  ``minAbsSumPair(arr, n);``  ``getchar``();``  ``return` `0;``}` `/* FOLLOWING FUNCTIONS ARE ONLY FOR SORTING``    ``PURPOSE */``void` `exchange(``int` `*a, ``int` `*b)``{``  ``int` `temp;``  ``temp = *a;``  ``*a   = *b;``  ``*b   = temp;``}` `int` `partition(``int` `arr[], ``int` `si, ``int` `ei)``{``  ``int` `x = arr[ei];``  ``int` `i = (si - 1);``  ``int` `j;` `  ``for` `(j = si; j <= ei - 1; j++)``  ``{``    ``if``(arr[j] <= x)``    ``{``      ``i++;``      ``exchange(&arr[i], &arr[j]);``    ``}``  ``}` `  ``exchange (&arr[i + 1], &arr[ei]);``  ``return` `(i + 1);``}` `/* Implementation of Quick Sort``arr[] --> Array to be sorted``si  --> Starting index``ei  --> Ending index``*/``void` `quickSort(``int` `arr[], ``int` `si, ``int` `ei)``{``  ``int` `pi;    ``/* Partitioning index */``  ``if``(si < ei)``  ``{``    ``pi = partition(arr, si, ei);``    ``quickSort(arr, si, pi - 1);``    ``quickSort(arr, pi + 1, ei);``  ``}``}`

## Java

 `import` `java.util.*;``import` `java.lang.*;``class` `Main``{``    ``static` `void` `minAbsSumPair(``int` `arr[], ``int` `n)``    ``{``      ``// Variables to keep track of current sum and minimum sum``      ``int` `sum, min_sum = ``999999``;``     ` `      ``// left and right index variables``      ``int` `l = ``0``, r = n-``1``;``     ` `      ``// variable to keep track of the left and right pair for min_sum``      ``int` `min_l = l, min_r = n-``1``;``     ` `      ``/* Array should have at least two elements*/``      ``if``(n < ``2``)``      ``{``        ``System.out.println(``"Invalid Input"``);``        ``return``;``      ``}``     ` `      ``/* Sort the elements */``      ``sort(arr, l, r);``     ` `      ``while``(l < r)``      ``{``        ``sum = arr[l] + arr[r];``     ` `        ``/*If abs(sum) is less then update the result items*/``        ``if``(Math.abs(sum) < Math.abs(min_sum))``        ``{``          ``min_sum = sum;``          ``min_l = l;``          ``min_r = r;``        ``}``        ``if``(sum < ``0``)``          ``l++;``        ``else``          ``r--;``      ``}``     ` `      ` `      ``System.out.println(``" The two elements whose "``+``                              ``"sum is minimum are "``+``                        ``arr[min_l]+ ``" and "``+arr[min_r]);``    ``}``     ` `    ``// main function``    ``public` `static` `void` `main (String[] args) ``    ``{``        ``int` `arr[] = {``1``, ``60``, -``10``, ``70``, -``80``, ``85``};``        ``int` `n = arr.length;``        ``minAbsSumPair(arr, n);``    ``}``    ` `    ``/* Functions for QuickSort */``    ` `    ``/* This function takes last element as pivot,``       ``places the pivot element at its correct``       ``position in sorted array, and places all``       ``smaller (smaller than pivot) to left of``       ``pivot and all greater elements to right``       ``of pivot */``    ``static` `int` `partition(``int` `arr[], ``int` `low, ``int` `high)``    ``{``        ``int` `pivot = arr[high]; ``        ``int` `i = (low-``1``); ``// index of smaller element``        ``for` `(``int` `j=low; j Array to be sorted,``      ``low  --> Starting index,``      ``high  --> Ending index */``    ``static` `void` `sort(``int` `arr[], ``int` `low, ``int` `high)``    ``{``        ``if` `(low < high)``        ``{``            ``/* pi is partitioning index, arr[pi] is ``              ``now at right place */``            ``int` `pi = partition(arr, low, high);` `            ``// Recursively sort elements before``            ``// partition and after partition``            ``sort(arr, low, pi-``1``);``            ``sort(arr, pi+``1``, high);``        ``}``    ``}``}`

## Python3

 `# Function to print pair of elements``# having minimum sum */` `# FOLLOWING FUNCTIONS ARE ONLY FOR``# SORTING PURPOSE */``def` `partition(arr, si, ei):``    ``x ``=` `arr[ei]``    ``i ``=` `(si ``-` `1``)` `    ``for` `j ``in` `range``(si,ei):``        ``if``(arr[j] <``=` `x):``            ``i ``+``=` `1``            ``arr[i], arr[j] ``=` `arr[j], arr[i]``    ``arr[i ``+` `1``], arr[ei] ``=` `arr[ei], arr[i ``+` `1``]``    ``return` `(i ``+` `1``) ` `# Implementation of Quick Sort``# arr[] --> Array to be sorted``# si --> Starting index``# ei --> Ending index``def` `quickSort(arr, si, ei):``    ``pi ``=` `0` `# Partitioning index */``    ``if``(si < ei):``        ``pi ``=` `partition(arr, si, ei)``        ``quickSort(arr, si, pi ``-` `1``)``        ``quickSort(arr, pi ``+` `1``, ei)` `def` `minAbsSumPair(arr, n):` `    ``# Variables to keep track``    ``# of current sum and minimum sum``    ``sum``, min_sum ``=` `0``, ``10``*``*``9` `    ``# left and right index variables``    ``l ``=` `0``    ``r ``=` `n ``-` `1` `    ``# variable to keep track of``    ``# the left and right pair for min_sum``    ``min_l ``=` `l``    ``min_r ``=` `n ``-` `1` `    ``# Array should have at least two elements*/``    ``if``(n < ``2``):``        ``print``(``"Invalid Input"``, end ``=` `"")``        ``return` `    ``# Sort the elements */``    ``quickSort(arr, l, r)` `    ``while``(l < r):``        ``sum` `=` `arr[l] ``+` `arr[r]` `        ``# If abs(sum) is less``        ``# then update the result items``        ``if``(``abs``(``sum``) < ``abs``(min_sum)):``            ``min_sum ``=` `sum``            ``min_l ``=` `l``            ``min_r ``=` `r``        ``if``(``sum` `< ``0``):``            ``l ``+``=` `1``        ``else``:``            ``r ``-``=` `1` `    ``print``(``"The two elements whose sum is minimum are"``, ``                        ``arr[min_l], ``"and"``, arr[min_r])` `# Driver Code``arr ``=` `[``1``, ``60``, ``-``10``, ``70``, ``-``80``, ``85``] ``n ``=` `len``(arr)``minAbsSumPair(arr, n)` `# This code is contributed by mohit kumar 29`

## C#

 `using` `System;` `class` `GFG``{``    ``static` `void` `minAbsSumPair(``int` `[]arr ,``int` `n)``    ``{``        ``// Variables to keep track ``        ``// of current sum and minimum sum``        ``int` `sum, min_sum = 999999;``        ` `        ``// left and right index variables``        ``int` `l = 0, r = n-1;``        ` `        ``// variable to keep track of the left``        ``// and right pair for min_sum``        ``int` `min_l = l, min_r = n-1;``        ` `        ``/* Array should have at least two elements*/``        ``if` `(n < 2)``        ``{``            ``Console.Write(``"Invalid Input"``);``            ``return``;``        ``}``        ` `        ``/* Sort the elements */``        ``sort(arr, l, r);``        ` `        ``while``(l < r)``        ``{``            ``sum = arr[l] + arr[r];``        ` `            ``/*If abs(sum) is less then update the result items*/``            ``if` `(Math.Abs(sum) < Math.Abs(min_sum))``            ``{``                ``min_sum = sum;``                ``min_l = l;``                ``min_r = r;``            ``}``            ``if` `(sum < 0)``                ``l++;``            ``else``                ``r--;``        ``}``        ` `        ``Console.Write(``" The two elements whose "` `+ ``                                ``"sum is minimum are "` `+``                            ``arr[min_l]+ ``" and "` `+ arr[min_r]);``    ``}``    ` `    ``// driver code``    ``public` `static` `void` `Main () ``    ``{``        ``int` `[]arr = {1, 60, -10, 70, -80, 85};``        ``int` `n = arr.Length;``        ` `        ``minAbsSumPair(arr, n);``    ``}``    ` `    ``/* Functions for QuickSort */``    ` `    ``/* This function takes last element as pivot,``    ``places the pivot element at its correct``    ``position in sorted array, and places all``    ``smaller (smaller than pivot) to left of``    ``pivot and all greater elements to right``    ``of pivot */``    ``static` `int` `partition(``int` `[]arr, ``int` `low, ``int` `high)``    ``{``        ``int` `pivot = arr[high]; ``        ``int` `i = (low-1); ``// index of smaller element``        ` `        ``for` `(``int` `j = low; j < high; j++)``        ``{``            ``// If current element is smaller than or``            ``// equal to pivot``            ``if` `(arr[j] <= pivot)``            ``{``                ``i++;` `                ``// swap arr[i] and arr[j]``                ``int` `temp = arr[i];``                ``arr[i] = arr[j];``                ``arr[j] = temp;``            ``}``        ``}` `        ``// swap arr[i+1] and arr[high] (or pivot)``        ``int` `temp1 = arr[i+1];``        ``arr[i+1] = arr[high];``        ``arr[high] = temp1;` `        ``return` `i+1;``    ``}`  `    ``/* The main function that implements QuickSort()``    ``arr[] --> Array to be sorted,``    ``low --> Starting index,``    ``high --> Ending index */``    ``static` `void` `sort(``int` `[]arr, ``int` `low, ``int` `high)``    ``{``        ``if` `(low < high)``        ``{``            ``/* pi is partitioning index, arr[pi] is ``            ``now at right place */``            ``int` `pi = partition(arr, low, high);` `            ``// Recursively sort elements before``            ``// partition and after partition``            ``sort(arr, low, pi-1);``            ``sort(arr, pi+1, high);``        ``}``    ``}``}` `// This code is contributed by Sam007`

## Javascript

 ``

Output:

`The two elements whose sum is minimum are -80 and 85`

Time Complexity: complexity to sort + complexity of finding the optimum pair = O(nlogn) + O(n) = O(nlogn)

Auxiliary Space: O(1)

STL implementation of Method-2:

Algorithm
1) Sort all the elements of the input array using their absolute values.
2) Check absolute sum of arr[i-1] and arr[i] if their absolute sum is less than min update min with their absolute value.
3) Use two variables to store the index of the elements.

Implementation:

## C++

 `// C++ implementation using STL``#include ``using` `namespace` `std;` `// Modified to sort by absolute values``bool` `compare(``int` `x, ``int` `y)``{``    ``return` `abs``(x) < ``abs``(y);``}` `void` `findMinSum(``int` `arr[], ``int` `n)``{``    ``sort(arr, arr + n, compare);``    ``int` `min = INT_MAX, x, y;``    ``for` `(``int` `i = 1; i < n; i++) {` `        ``// Absolute value shows how close it is to zero``        ``if` `(``abs``(arr[i - 1] + arr[i]) <= min) {` `            ``// if found an even close value``            ``// update min and store the index``            ``min = ``abs``(arr[i - 1] + arr[i]);``            ``x = i - 1;``            ``y = i;``        ``}``    ``}``    ``cout << ``"The two elements whose sum is minimum are "``         ``<< arr[x] << ``" and "` `<< arr[y];``}` `// Driver code``int` `main()``{` `    ``int` `arr[] = { 1, 60, -10, 70, -80, 85 };``    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``findMinSum(arr, n);``    ``return` `0;``    ``// This code is contributed by ceeyesharish``}`

## Java

 `// Java implementation using STL``import` `java.io.*;` `class` `GFG{``    ` `static` `void` `findMinSum(``int``[] arr, ``int` `n)``{``    ``for``(``int` `i = ``1``; i < n; i++)``    ``{``        ``if` `(!(Math.abs(arr[i - ``1``]) <``              ``Math.abs(arr[i])))``        ``{``            ``int` `temp = arr[i - ``1``];``            ``arr[i - ``1``] = arr[i];``            ``arr[i] = temp;``        ``}``    ``}``    ``int` `min = Integer.MAX_VALUE;``    ``int` `x = ``0``, y = ``0``;``    ` `    ``for``(``int` `i = ``1``; i < n; i++)``    ``{``        ` `        ``// Absolute value shows how close ``        ``// it is to zero``        ``if` `(Math.abs(arr[i - ``1``] + arr[i]) <= min)``        ``{``            ` `            ``// If found an even close value``            ``// update min and store the index``            ``min = Math.abs(arr[i - ``1``] + arr[i]);``            ``x = i - ``1``;``            ``y = i;``        ``}``    ``}``    ``System.out.println(``"The two elements whose "` `+``                       ``"sum is minimum are "` `+ ``                       ``arr[x] + ``" and "` `+ arr[y]);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int``[] arr = { ``1``, ``60``, -``10``, ``70``, -``80``, ``85` `};``    ``int` `n = arr.length;``    ` `    ``findMinSum(arr, n);``}``}` `// This code is contributed by rag2127`

## Python3

 `# Python3 implementation using STL``import` `sys` `def` `findMinSum(arr, n):``    ` `    ``for` `i ``in` `range``(``1``, n):``        ` `        ``# Modified to sort by absolute values``        ``if` `(``not` `abs``(arr[i ``-` `1``]) < ``abs``(arr[i])):``            ``arr[i ``-` `1``], arr[i] ``=` `arr[i], arr[i ``-` `1``]` `    ``Min` `=` `sys.maxsize``    ``x ``=` `0``    ``y ``=` `0``  ` `    ``for` `i ``in` `range``(``1``, n):``        ` `        ``# Absolute value shows how ``        ``# close it is to zero ``        ``if` `(``abs``(arr[i ``-` `1``] ``+` `arr[i]) <``=` `Min``):``            ` `            ``# If found an even close value ``            ``# update min and store the index``            ``Min` `=` `abs``(arr[i ``-` `1``] ``+` `arr[i])``            ``x ``=` `i ``-` `1``            ``y ``=` `i` `    ``print``(``"The two elements whose sum is minimum are"``,``          ``arr[x], ``"and"``, arr[y])` `# Driver code ``arr ``=` `[ ``1``, ``60``, ``-``10``, ``70``, ``-``80``, ``85` `]``n ``=` `len``(arr)` `findMinSum(arr, n)` `# This code is contributed by avanitrachhadiya2155`

## C#

 `// C# implementation using STL``using` `System;``class` `GFG{``    ` `static` `void` `findMinSum(``int``[] arr, ``int` `n)``{``    ``for``(``int` `i = 1; i < n; i++)``    ``{``        ``if` `(!(Math.Abs(arr[i - 1]) <``              ``Math.Abs(arr[i])))``        ``{``            ``int` `temp = arr[i - 1];``            ``arr[i - 1] = arr[i];``            ``arr[i] = temp;``        ``}``    ``}``    ``int` `min = Int32.MaxValue;``    ``int` `x = 0, y = 0;``     ` `    ``for``(``int` `i = 1; i < n; i++)``    ``{``        ` `        ``// Absolute value shows how close ``        ``// it is to zero``        ``if` `(Math.Abs(arr[i - 1] + arr[i]) <= min)``        ``{``            ` `            ``// If found an even close value``            ``// update min and store the index``            ``min = Math.Abs(arr[i - 1] + arr[i]);``            ``x = i - 1;``            ``y = i;``        ``}``    ``}``    ``Console.WriteLine(``"The two elements whose "` `+``                      ``"sum is minimum are "` `+ ``                      ``arr[x] + ``" and "` `+ arr[y]);``}` `// Driver Code``static` `void` `Main() ``{``    ``int``[] arr = { 1, 60, -10, 70, -80, 85 };``    ``int` `n = arr.Length;``     ` `    ``findMinSum(arr, n);``}``}` `// This code is contributed by divyesh072019`

## Javascript

 ``

Output:

`The two elements whose sum is minimum are -80 and 85`

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

Previous
Next