 Open in App
Not now

# Two elements whose sum is closest to zero

• Difficulty Level : Easy
• Last Updated : 16 Jun, 2022

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 + arr;` `    `  `    ``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 + arr;`   `  ``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 + arr;` `    `  `    ``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); ` `    ``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);` `  ``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);` `    ``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)

My Personal Notes arrow_drop_up
Related Articles