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++

filter_none

edit
close

play_arrow

link
brightness_4
code

# include <bits/stdc++.h>
# include <stdlib.h> /* for abs() */
# include <math.h>
  
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)

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

# include <stdio.h>
# include <stdlib.h> /* for abs() */
# include <math.h>
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;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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);
    }
      
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// 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

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to find the Two elements
// whose sum is closest to zero
  
function minAbsSumPair($arr, $arr_size)
{
    $inv_count = 0;
      
    /* Array should have at
    least two elements*/
    if($arr_size < 2)
    {
        echo "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;
        }
        }
    }
      
    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
?>

chevron_right


Output:

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

Time complexity: O(n^2)



METHOD 2 (Use Sorting)
Thanks to baskin for suggesting this approach. We recommend to read this post for background of this approach.

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++

filter_none

edit
close

play_arrow

link
brightness_4
code

#include <bits/stdc++.h>
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

chevron_right


C

filter_none

edit
close

play_arrow

link
brightness_4
code

# include <stdio.h>
# include <math.h>
# include <limits.h>
  
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);
  }
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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<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 temp = arr[i+1];
        arr[i+1] = arr[high];
        arr[high] = temp;
  
        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);
        }
    }
}

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Function to prpair 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right



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)


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++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation using STL
#include <bits/stdc++.h>
using namespace std;
  
// Modified to sort by abolute 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
}

chevron_right



Output:

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


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

Asked by Vineet.

Please write comments if you find any bug in the above program/algorithm or other ways to solve the same problem.



My Personal Notes arrow_drop_up