Skip to content
Related Articles

Related Articles

Given a sorted array and a number x, find the pair in array whose sum is closest to x
  • Difficulty Level : Easy
  • Last Updated : 06 May, 2021

Given a sorted array and a number x, find a pair in array whose sum is closest to x.
Examples:

Input: arr[] = {10, 22, 28, 29, 30, 40}, x = 54
Output: 22 and 30

Input: arr[] = {1, 3, 4, 7, 10}, x = 15
Output: 4 and 10

A simple solution is to consider every pair and keep track of closest pair (absolute difference between pair sum and x is minimum). Finally, print the closest pair. Time complexity of this solution is O(n2)

An efficient solution can find the pair in O(n) time. The idea is similar to method 1 of this post. The following is a detailed algorithm. 

1) Initialize a variable diff as infinite (Diff is used to store the 
   difference between pair and x).  We need to find the minimum diff.
2) Initialize two index variables l and r in the given sorted array.
       (a) Initialize first to the leftmost index:  l = 0
       (b) Initialize second  the rightmost index:  r = n-1
3) Loop while l < r.
       (a) If  abs(arr[l] + arr[r] - sum) < diff  then 
           update diff and result 
       (b) If(arr[l] + arr[r] <  sum )  then l++
       (c) Else r--

Following is the implementation of the above algorithm.

C++




// Simple C++ program to find the pair with sum closest to a given no.
#include <bits/stdc++.h>
using namespace std;
 
// Prints the pair with sum closest to x
void printClosest(int arr[], int n, int x)
{
    int res_l, res_r;  // To store indexes of result pair
 
    // Initialize left and right indexes and difference between
    // pair sum and x
    int l = 0, r = n-1, diff = INT_MAX;
 
    // While there are elements between l and r
    while (r > l)
    {
       // Check if this pair is closer than the closest pair so far
       if (abs(arr[l] + arr[r] - x) < diff)
       {
           res_l = l;
           res_r = r;
           diff = abs(arr[l] + arr[r] - x);
       }
 
       // If this pair has more sum, move to smaller values.
       if (arr[l] + arr[r] > x)
           r--;
       else // Move to larger values
           l++;
    }
 
    cout <<" The closest pair is " << arr[res_l] << " and " << arr[res_r];
}
 
// Driver program to test above functions
int main()
{
    int arr[] =  {10, 22, 28, 29, 30, 40}, x = 54;
    int n = sizeof(arr)/sizeof(arr[0]);
    printClosest(arr, n, x);
    return 0;
}
Java



// Java program to find pair with sum closest to x
import java.io.*;
import java.util.*;
import java.lang.Math;
 
class CloseSum {
     
    // Prints the pair with sum cloest to x
    static void printClosest(int arr[], int n, int x)
    {
        int res_l=0, res_r=0;  // To store indexes of result pair
  
        // Initialize left and right indexes and difference between
        // pair sum and x
        int l = 0, r = n-1, diff = Integer.MAX_VALUE;
  
        // While there are elements between l and r
        while (r > l)
        {
            // Check if this pair is closer than the closest pair so far
            if (Math.abs(arr[l] + arr[r] - x) < diff)
            {
               res_l = l;
               res_r = r;
               diff = Math.abs(arr[l] + arr[r] - x);
            }
  
            // If this pair has more sum, move to smaller values.
            if (arr[l] + arr[r] > x)
               r--;
            else // Move to larger values
               l++;
        }
  
    System.out.println(" The closest pair is "+arr[res_l]+" and "+ arr[res_r]);
}
     
     
    // Driver program to test above function
    public static void main(String[] args)
    {
        int arr[] =  {10, 22, 28, 29, 30, 40}, x = 54;
        int n = arr.length;
        printClosest(arr, n, x);       
    }
}
/*This code is contributed by Devesh Agrawal*/
Python3



# Python3 program to find the pair
# with sum
# closest to a given no.
 
# A sufficiently large value greater
# than any
# element in the input array
MAX_VAL = 1000000000
 
 
#Prints the pair with sum closest to x
 
def printClosest(arr, n, x):
     
    # To store indexes of result pair
    res_l, res_r = 0, 0
     
    #Initialize left and right indexes
    # and difference between
    # pair sum and x
    l, r, diff = 0, n-1, MAX_VAL
     
    # While there are elements between l and r
    while r > l:
        # Check if this pair is closer than the
        # closest pair so far
        if abs(arr[l] + arr[r] - x) < diff:
            res_l = l
            res_r = r
            diff = abs(arr[l] + arr[r] - x)
     
        if arr[l] + arr[r] > x:
        # If this pair has more sum, move to
        # smaller values.
            r -= 1
        else:
        # Move to larger values
            l += 1
         
    print('The closest pair is {} and {}'
         .format(arr[res_l], arr[res_r]))
 
 
# Driver code to test above
if __name__ == "__main__":
    arr = [10, 22, 28, 29, 30, 40]
    n = len(arr)
    x=54
    printClosest(arr, n, x)
 
# This code is contributed by Tuhin Patra
C#



// C# program to find pair with sum closest to x
using System;
 
class GFG {
     
    // Prints the pair with sum cloest to x
    static void printClosest(int []arr, int n, int x)
    {
         
        // To store indexes of result pair
        int res_l = 0, res_r = 0;
 
        // Initialize left and right indexes and
        // difference between pair sum and x
        int l = 0, r = n-1, diff = int.MaxValue;
 
        // While there are elements between l and r
        while (r > l)
        {
             
            // Check if this pair is closer than the
            // closest pair so far
            if (Math.Abs(arr[l] + arr[r] - x) < diff)
            {
                res_l = l;
                res_r = r;
                diff = Math.Abs(arr[l] + arr[r] - x);
            }
 
            // If this pair has more sum, move to
            // smaller values.
            if (arr[l] + arr[r] > x)
            r--;
            else // Move to larger values
            l++;
        }
     
        Console.Write(" The closest pair is " +
                 arr[res_l] + " and " + arr[res_r]);
    }
     
    // Driver program to test above function
    public static void Main()
    {
        int []arr = {10, 22, 28, 29, 30, 40};
        int x = 54;
        int n = arr.Length;
         
        printClosest(arr, n, x);    
    }
}
 
// This code is contributed by nitin mittal.
PHP



<?php
// Simple PHP program to find the
// pair with sum closest to a
// given no.
 
// Prints the pair with
// sum closest to x
function printClosest($arr, $n, $x)
{
     
    // To store indexes
    // of result pair
    $res_l;
    $res_r;
 
    // Initialize left and right
    // indexes and difference between
    // pair sum and x
    $l = 0;
    $r = $n - 1;
    $diff = PHP_INT_MAX;
 
    // While there are elements
    // between l and r
    while ($r > $l)
    {
         
        // Check if this pair is closer
        // than the closest pair so far
        if (abs($arr[$l] + $arr[$r] - $x) <
                                      $diff)
        {
            $res_l = $l;
            $res_r = $r;
            $diff = abs($arr[$l] + $arr[$r] - $x);
        }
     
        // If this pair has more sum,
        // move to smaller values.
        if ($arr[$l] + $arr[$r] > $x)
            $r--;
             
        // Move to larger values
        else
            $l++;
    }
 
    echo " The closest pair is "
         , $arr[$res_l] ," and "
         , $arr[$res_r];
}
 
    // Driver Code
    $arr = array(10, 22, 28, 29, 30, 40);
    $x = 54;
    $n = count($arr);
    printClosest($arr, $n, $x);
     
// This code is contributed by anuj_67.
?>
Javascript



<script>
 
// JavaScript program to find pair
// with sum closest to x
 
     
    // Prints the pair with sum cloest to x
    function printClosest(arr,n,x)
    {
    // To store indexes of result pair
        let res_l=0, res_r=0;
 
        // Initialize left and right indexes
        // and difference between
        // pair sum and x
        let l = 0, r = n-1, diff = Number.MAX_VALUE;
 
        // While there are elements
        // between l and r
        while (r > l)
        {
            // Check if this pair is closer
            // than the closest pair so far
            if (Math.abs(arr[l] +
                arr[r] - x) < diff)
            {
            res_l = l;
            res_r = r;
            diff = Math.abs(arr[l] + arr[r] - x);
            }
 
            // If this pair has more sum,
            // move to smaller values.
            if (arr[l] + arr[r] > x)
            r--;
            else // Move to larger values
            l++;
        }
 
    document.write(
    " The closest pair is "+arr[res_l]+" and "+ arr[res_r]
    );
}
     
     
    // Driver program to test above function
     
        let arr = [10, 22, 28, 29, 30, 40], x = 54;
        let n = arr.length;
        printClosest(arr, n, x);       
     
 
 
// This code is contributed by sravan kumar
 
</script>
Output: 


 The closest pair is 22 and 30
 
This article is contributed by Harsh. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above
 
My Personal Notes
arrow_drop_up
Previous
Find the closest pair from two sorted arrays
Next

Count pairs with given sum
Recommended Articles
Page :
Given an absolute sorted array and a number K, find the pair whose sum is K
14, Feb 20
Find the closest pair from two sorted arrays
11, Nov 14
Find a triplet in an array whose sum is closest to a given number
03, Jul 19
Find three closest elements from given three sorted arrays
09, Oct 15
Given a sorted and rotated array, find if there is a pair with a given sum
30, Mar 15
Closest pair in an Array such that one number is multiple of the other
15, Jul 20
Check if two sorted arrays can be merged to form a sorted array with no adjacent pair from the same array
16, Nov 20
Subarray whose sum is closest to K
19, Aug 18
Subarray whose absolute sum is closest to K
04, Sep 18
Two elements whose sum is closest to zero
10, Jan 10
Closest product pair in an array
04, Jun 18
Number of indices pair such that element pair sum from first Array is greater than second Array
25, Mar 20
Find the Sub-array with sum closest to 0
03, Jul 17
Count number of common elements between a sorted array and a reverse sorted array
12, May 21
Pair with given product | Set 1 (Find if any pair exists)
03, Jun 16
Find closest number in array
23, Nov 17
Count pairs from two sorted arrays whose sum is equal to a given value x
23, Jun 17
Count quadruples from four sorted arrays whose sum is equal to a given value x
04, Jul 17
Find k closest elements to a given value
12, Jun 14
Find the Kth pair in ordered list of all possible sorted pairs of the Array
30, Apr 20
Queries to check if any pair exists in an array having values at most equal to the given pair
04, Dec 20
Pair formation such that maximum pair sum is minimized
30, May 18
Count pairs in a sorted array whose sum is less than x
31, Mar 17
Check if a sorted array can be divided in pairs whose sum is k
02, Nov 15
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
GeeksforGeeks
Vote for difficulty
Current difficulty :
Easy





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox