# Find the closest pair from two sorted arrays

Last Updated : 20 Oct, 2023

Given two arrays arr1[0…m-1] and arr2[0..n-1], and a number x, the task is to find the pair arr1[i] + arr2[j] such that absolute value of (arr1[i] + arr2[j] – x) is minimum.

Example:

Input: arr1[] = {1, 4, 5, 7};
arr2[] = {10, 20, 30, 40};
x = 32
Output: 1 and 30
Input: arr1[] = {1, 4, 5, 7};
arr2[] = {10, 20, 30, 40};
x = 50
Output: 7 and 40

## Find the closest pair from two sorted arrays using Nested Loop:

A Simple Solution is to run two loops. The outer loop considers every element of first array and inner loop checks for the pair in second array. We keep track of minimum difference between ar1[i] + ar2[j] and x.

## Find the closest pair from two sorted arrays using Two pointer Technique:

Below is the idea to solve this problem in O(n) time using following steps.

1) Merge given two arrays into an auxiliary array of size m+n using merge process of merge sort. While merging keep another boolean array of size m+n to indicate whether the current element in merged array is from ar1[] or ar2[].
2) Consider the merged array and use the linear time algorithm to find the pair with sum closest to x. One extra thing we need to consider only those pairs which have one element from ar1[] and other from ar2[], we use the boolean array for this purpose.

### Can we do it in a single pass and O(1) extra space?

The idea is to start from left side of one array and right side of another array, and use the algorithm same as step 2 of above approach.

Step-by-step approach:

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

Below is the implementation of the above approach:

## C++

 `// C++ program to find the pair from two sorted arrays such` `// that the sum of pair is closest to a given number x` `#include ` `#include ` `#include ` `using` `namespace` `std;`   `// ar1[0..m-1] and ar2[0..n-1] are two given sorted arrays` `// and x is given number. This function prints the pair  from` `// both arrays such that the sum of the pair is closest to x.` `void` `printClosest(``int` `ar1[], ``int` `ar2[], ``int` `m, ``int` `n, ``int` `x)` `{` `    ``// Initialize the diff between pair sum and x.` `    ``int` `diff = INT_MAX;`   `    ``// res_l and res_r are result indexes from ar1[] and ar2[]` `    ``// respectively` `    ``int` `res_l, res_r;`   `    ``// Start from left side of ar1[] and right side of ar2[]` `    ``int` `l = 0, r = n-1;` `    ``while` `(l=0)` `    ``{` `       ``// If this pair is closer to x than the previously` `       ``// found closest, then update res_l, res_r and diff` `       ``if` `(``abs``(ar1[l] + ar2[r] - x) < diff)` `       ``{` `           ``res_l = l;` `           ``res_r = r;` `           ``diff = ``abs``(ar1[l] + ar2[r] - x);` `       ``}`   `       ``// If sum of this pair is more than x, move to smaller` `       ``// side` `       ``if` `(ar1[l] + ar2[r] > x)` `           ``r--;` `       ``else`  `// move to the greater side` `           ``l++;` `    ``}`   `    ``// Print the result` `    ``cout << ``"The closest pair is ["` `<< ar1[res_l] << ``", "` `         ``<< ar2[res_r] << ``"] \n"``;` `}`   `// Driver program to test above functions` `int` `main()` `{` `    ``int` `ar1[] = {1, 4, 5, 7};` `    ``int` `ar2[] = {10, 20, 30, 40};` `    ``int` `m = ``sizeof``(ar1)/``sizeof``(ar1[0]);` `    ``int` `n = ``sizeof``(ar2)/``sizeof``(ar2[0]);` `    ``int` `x = 38;` `    ``printClosest(ar1, ar2, m, n, x);` `    ``return` `0;` `}`

## Java

 `// Java program to find closest pair in an array` `class` `ClosestPair` `{` `    ``// ar1[0..m-1] and ar2[0..n-1] are two given sorted` `    ``// arrays/ and x is given number. This function prints` `    ``// the pair from both arrays such that the sum of the` `    ``// pair is closest to x.` `    ``void` `printClosest(``int` `ar1[], ``int` `ar2[], ``int` `m, ``int` `n, ``int` `x)` `    ``{` `        ``// Initialize the diff between pair sum and x.` `        ``int` `diff = Integer.MAX_VALUE;`   `        ``// res_l and res_r are result indexes from ar1[] and ar2[]` `        ``// respectively` `        ``int` `res_l = ``0``, res_r = ``0``;`   `        ``// Start from left side of ar1[] and right side of ar2[]` `        ``int` `l = ``0``, r = n-``1``;` `        ``while` `(l=``0``)` `        ``{` `           ``// If this pair is closer to x than the previously` `           ``// found closest, then update res_l, res_r and diff` `           ``if` `(Math.abs(ar1[l] + ar2[r] - x) < diff)` `           ``{` `               ``res_l = l;` `               ``res_r = r;` `               ``diff = Math.abs(ar1[l] + ar2[r] - x);` `           ``}`   `           ``// If sum of this pair is more than x, move to smaller` `           ``// side` `           ``if` `(ar1[l] + ar2[r] > x)` `               ``r--;` `           ``else`  `// move to the greater side` `               ``l++;` `        ``}`   `        ``// Print the result` `        ``System.out.print(``"The closest pair is ["` `+ ar1[res_l] +` `                         ``", "` `+ ar2[res_r] + ``"]"``);` `    ``}`   `    ``// Driver program to test above functions` `    ``public` `static` `void` `main(String args[])` `    ``{` `        ``ClosestPair ob = ``new` `ClosestPair();` `        ``int` `ar1[] = {``1``, ``4``, ``5``, ``7``};` `        ``int` `ar2[] = {``10``, ``20``, ``30``, ``40``};` `        ``int` `m = ar1.length;` `        ``int` `n = ar2.length;` `        ``int` `x = ``38``;` `        ``ob.printClosest(ar1, ar2, m, n, x);` `    ``}` `}` `/*This code is contributed by Rajat Mishra */`

## Python3

 `# Python3 program to find the pair from` `# two sorted arrays such that the sum ` `# of pair is closest to a given number x` `import` `sys`   `# ar1[0..m-1] and ar2[0..n-1] are two ` `# given sorted arrays and x is given ` `# number. This function prints the pair ` `# from both arrays such that the sum ` `# of the pair is closest to x.` `def` `printClosest(ar1, ar2, m, n, x):`   `    ``# Initialize the diff between ` `    ``# pair sum and x.` `    ``diff``=``sys.maxsize`   `    ``# res_l and res_r are result ` `    ``# indexes from ar1[] and ar2[]` `    ``# respectively. Start from left` `    ``# side of ar1[] and right side of ar2[]` `    ``l ``=` `0` `    ``r ``=` `n``-``1` `    ``while``(l < m ``and` `r >``=` `0``):` `    `  `    ``# If this pair is closer to x than ` `    ``# the previously found closest,` `    ``# then update res_l, res_r and diff` `        ``if` `abs``(ar1[l] ``+` `ar2[r] ``-` `x) < diff:` `            ``res_l ``=` `l` `            ``res_r ``=` `r` `            ``diff ``=` `abs``(ar1[l] ``+` `ar2[r] ``-` `x)` `    `    `    ``# If sum of this pair is more than x,` `    ``# move to smaller side` `        ``if` `ar1[l] ``+` `ar2[r] > x:` `            ``r``=``r``-``1` `        ``else``: ``# move to the greater side` `            ``l``=``l``+``1` `    `    `    ``# Print the result` `    ``print``(``"The closest pair is ["``,` `         ``ar1[res_l],``","``,ar2[res_r],``"]"``)`   `# Driver program to test above functions` `ar1 ``=` `[``1``, ``4``, ``5``, ``7``]` `ar2 ``=` `[``10``, ``20``, ``30``, ``40``]` `m ``=` `len``(ar1)` `n ``=` `len``(ar2)` `x ``=` `38` `printClosest(ar1, ar2, m, n, x)`   `# This code is contributed by Smitha Dinesh Semwal `

## C#

 `// C# program to find closest pair in` `// an array` `using` `System;`   `class` `GFG {` `    `  `    ``// ar1[0..m-1] and ar2[0..n-1] are two` `    ``// given sorted arrays/ and x is given` `    ``// number. This function prints the ` `    ``// pair from both arrays such that the` `    ``// sum of the pair is closest to x.` `    ``static` `void` `printClosest(``int` `[]ar1,` `            ``int` `[]ar2, ``int` `m, ``int` `n, ``int` `x)` `    ``{` `        `  `        ``// Initialize the diff between pair` `        ``// sum and x.` `        ``int` `diff = ``int``.MaxValue;`   `        ``// res_l and res_r are result ` `        ``// indexes from ar1[] and ar2[]` `        ``// respectively` `        ``int` `res_l = 0, res_r = 0;`   `        ``// Start from left side of ar1[]` `        ``// and right side of ar2[]` `        ``int` `l = 0, r = n-1;` `        ``while` `(l < m && r >= 0)` `        ``{` `            `  `            ``// If this pair is closer to` `            ``// x than the previously` `            ``// found closest, then update` `            ``// res_l, res_r and diff` `            ``if` `(Math.Abs(ar1[l] + ` `                       ``ar2[r] - x) < diff)` `            ``{` `                ``res_l = l;` `                ``res_r = r;` `                ``diff = Math.Abs(ar1[l]` `                            ``+ ar2[r] - x);` `            ``}` `    `  `            ``// If sum of this pair is more` `            ``// than x, move to smaller` `            ``// side` `            ``if` `(ar1[l] + ar2[r] > x)` `                ``r--;` `            ``else` `// move to the greater side` `                ``l++;` `        ``}`   `        ``// Print the result` `        ``Console.Write(``"The closest pair is ["` `                          ``+ ar1[res_l] + ``", "` `                         ``+ ar2[res_r] + ``"]"``);` `    ``}`   `    ``// Driver program to test above functions` `    ``public` `static` `void` `Main()` `    ``{` `        ``int` `[]ar1 = {1, 4, 5, 7};` `        ``int` `[]ar2 = {10, 20, 30, 40};` `        ``int` `m = ar1.Length;` `        ``int` `n = ar2.Length;` `        ``int` `x = 38;` `        `  `        ``printClosest(ar1, ar2, m, n, x);` `    ``}` `}`   `// This code is contributed by nitin mittal.`

## Javascript

 ``

## PHP

 `= 0)` `    ``{` `        `  `        ``// If this pair is closer to ` `        ``// x than the previously` `        ``// found closest, then ` `        ``// update res_l, res_r and` `        ``// diff` `        ``if` `(``abs``(``\$ar1``[``\$l``] + ``\$ar2``[``\$r``] - ` `                       ``\$x``) < ``\$diff``)` `        ``{` `            ``\$res_l` `= ``\$l``;` `            ``\$res_r` `= ``\$r``;` `            ``\$diff` `= ``abs``(``\$ar1``[``\$l``] +` `                    ``\$ar2``[``\$r``] - ``\$x``);` `        ``}` `    `  `        ``// If sum of this pair is ` `        ``// more than x, move to smaller` `        ``// side` `        ``if` `(``\$ar1``[``\$l``] + ``\$ar2``[``\$r``] > ``\$x``)` `            ``\$r``--;` `            `  `        ``// move to the greater side` `        ``else` `            ``\$l``++;` `    ``}`   `    ``// Print the result` `    ``echo` `"The closest pair is ["` `, ``\$ar1``[``\$res_l``] , ``", "` `                               ``, ``\$ar2``[``\$res_r``] , ``"] \n"``;` `}`   `    ``// Driver Code` `    ``\$ar1` `= ``array``(1, 4, 5, 7);` `    ``\$ar2` `= ``array``(10, 20, 30, 40);` `    ``\$m` `= ``count``(``\$ar1``);` `    ``\$n` `= ``count``(``\$ar2``);` `    ``\$x` `= 38;` `    ``printClosest(``\$ar1``, ``\$ar2``, ``\$m``, ``\$n``, ``\$x``);`   `// This code is contributed by anuj_67.` `?>`

Output:

``` The closest pair is [7, 30]

```

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

## Find the closest pair from two sorted arrays using Binary Search:

Since the two input arrays arr1 and arr2 are sorted, the comparison of the sum of the current pair with x essentially performs a binary search on the input array. By moving the left or right index based on the comparison result, the function implicitly divides the input array into two halves at each iteration, and therefore performs a binary search on the input array to find the closest pair.

Below is the implementation of the above approach:

## C++

 `#include ` `#include ` `#include ` `using` `namespace` `std;`   `// Function to perform binary search on array ar2[] for` `// the closest element to x` `int` `binarySearch(``int` `ar2[], ``int` `left, ``int` `right, ``int` `x)` `{` `    ``if` `(left > right)` `        ``return` `left-1;` `    ``int` `mid = (left + right) / 2;` `    ``if` `(ar2[mid] == x)` `        ``return` `mid;` `    ``else` `if` `(ar2[mid] > x)` `        ``return` `binarySearch(ar2, left, mid-1, x);` `    ``else` `        ``return` `binarySearch(ar2, mid+1, right, x);` `}`   `// ar1[0..m-1] and ar2[0..n-1] are two given sorted arrays` `// and x is given number. This function prints the pair from` `// both arrays such that the sum of the pair is closest to x.` `void` `printClosest(``int` `ar1[], ``int` `ar2[], ``int` `m, ``int` `n, ``int` `x)` `{` `    ``// Initialize the diff between pair sum and x.` `    ``int` `diff = INT_MAX;`   `    ``// res_l and res_r are result indexes from ar1[] and ar2[]` `    ``// respectively` `    ``int` `res_l, res_r;`   `    ``// Start from left side of ar1[] and right side of ar2[]` `    ``int` `l = 0, r = n - 1;` `    ``while` `(l < m && r >= 0)` `    ``{` `        ``// If this pair is closer to x than the previously` `        ``// found closest, then update res_l, res_r and diff` `        ``if` `(``abs``(ar1[l] + ar2[r] - x) < diff)` `        ``{` `            ``res_l = l;` `            ``res_r = r;` `            ``diff = ``abs``(ar1[l] + ar2[r] - x);` `        ``}`   `        ``// If sum of this pair is more than x, move to smaller` `        ``// side` `        ``if` `(ar1[l] + ar2[r] > x)` `            ``r--;` `        ``else` `// move to the greater side` `            ``l++;` `    ``}`   `    ``// Print the result` `    ``cout << ``"The closest pair is ["` `<< ar1[res_l] << ``", "` `         ``<< ar2[res_r] << ``"] \n"``;` `}`   `// Driver program to test above functions` `int` `main()` `{` `    ``int` `ar1[] = {1, 4, 5, 7};` `    ``int` `ar2[] = {10, 20, 30, 40};` `    ``int` `m = ``sizeof``(ar1) / ``sizeof``(ar1[0]);` `    ``int` `n = ``sizeof``(ar2) / ``sizeof``(ar2[0]);` `    ``int` `x = 38;`   `    ``// Perform binary search on ar2[] for the element closest` `    ``// to x-ar1[i]` `    ``for` `(``int` `i = 0; i < m; i++)` `    ``{` `        ``int` `index = binarySearch(ar2, 0, n-1, x-ar1[i]);`   `        ``// Check if the element closest to x-ar1[i] is better` `        ``// than the current best` `        ``if` `(index >= 0 && index < n && ``abs``(ar1[i]+ar2[index]-x) < ``abs``(ar1[i]+ar2[index-1]-x))` `        ``{` `            ``printClosest(ar1, ar2, m, n, x);` `            ``return` `0;` `        ``}` `        ``else` `if` `(index > 0 && ``abs``(ar1[i]+ar2[index-1]-x) < ``abs``(ar1[i]+ar2[index]-x))` `        ``{` `            ``index--;` `        ``}` `    ``}` `}`   `      `

## Java

 `import` `java.util.*;`   `public` `class` `ClosestSumPair {` `    `  `    ``// Function to perform binary search on array ar2[] for` `    ``// the closest element to x` `    ``public` `static` `int` `binarySearch(``int` `ar2[], ``int` `left, ``int` `right, ``int` `x) {` `        ``if` `(left > right)` `            ``return` `left-``1``;` `        ``int` `mid = (left + right) / ``2``;` `        ``if` `(ar2[mid] == x)` `            ``return` `mid;` `        ``else` `if` `(ar2[mid] > x)` `            ``return` `binarySearch(ar2, left, mid-``1``, x);` `        ``else` `            ``return` `binarySearch(ar2, mid+``1``, right, x);` `    ``}` `    `  `    ``// ar1[0..m-1] and ar2[0..n-1] are two given sorted arrays` `    ``// and x is given number. This function prints the pair from` `    ``// both arrays such that the sum of the pair is closest to x.` `    ``public` `static` `void` `printClosest(``int` `ar1[], ``int` `ar2[], ``int` `m, ``int` `n, ``int` `x) {` `        ``// Initialize the diff between pair sum and x.` `        ``int` `diff = Integer.MAX_VALUE;` `    `  `        ``// res_l and res_r are result indexes from ar1[] and ar2[]` `        ``// respectively` `        ``int` `res_l = ``0``, res_r = ``0``;` `    `  `        ``// Start from left side of ar1[] and right side of ar2[]` `        ``int` `l = ``0``, r = n - ``1``;` `        ``while` `(l < m && r >= ``0``) {` `            ``// If this pair is closer to x than the previously` `            ``// found closest, then update res_l, res_r and diff` `            ``if` `(Math.abs(ar1[l] + ar2[r] - x) < diff) {` `                ``res_l = l;` `                ``res_r = r;` `                ``diff = Math.abs(ar1[l] + ar2[r] - x);` `            ``}` `    `  `            ``// If sum of this pair is more than x, move to smaller` `            ``// side` `            ``if` `(ar1[l] + ar2[r] > x)` `                ``r--;` `            ``else` `// move to the greater side` `                ``l++;` `        ``}` `    `  `        ``// Print the result` `        ``System.out.println(``"The closest pair is ["` `+ ar1[res_l] + ``", "` `+ ar2[res_r] + ``"]"``);` `    ``}` `    `  `    ``// Driver program to test above functions` `    ``public` `static` `void` `main(String args[]) {` `        ``int` `ar1[] = {``1``, ``4``, ``5``, ``7``};` `        ``int` `ar2[] = {``10``, ``20``, ``30``, ``40``};` `        ``int` `m = ar1.length;` `        ``int` `n = ar2.length;` `        ``int` `x = ``38``;` `    `  `        ``// Perform binary search on ar2[] for the element closest` `        ``// to x-ar1[i]` `        ``for` `(``int` `i = ``0``; i < m; i++) {` `            ``int` `index = binarySearch(ar2, ``0``, n-``1``, x-ar1[i]);` `    `  `            ``// Check if the element closest to x-ar1[i] is better` `            ``// than the current best` `            ``if` `(index >= ``0` `&& index < n && Math.abs(ar1[i]+ar2[index]-x) < Math.abs(ar1[i]+ar2[index-``1``]-x)) {` `                ``printClosest(ar1, ar2, m, n, x);` `                ``return``;` `            ``} ``else` `if` `(index > ``0` `&& Math.abs(ar1[i]+ar2[index-``1``]-x) < Math.abs(ar1[i]+ar2[index]-x)) {` `                ``index--;` `            ``}` `        ``}` `    ``}` `}` `          `

## Python3

 `import` `sys`   `# Function to perform binary search on array ar2[] for` `# the closest element to x` `def` `binarySearch(ar2, left, right, x):` `    ``if` `left > right:` `        ``return` `left``-``1` `    ``mid ``=` `(left ``+` `right) ``/``/` `2` `    ``if` `ar2[mid] ``=``=` `x:` `        ``return` `mid` `    ``elif` `ar2[mid] > x:` `        ``return` `binarySearch(ar2, left, mid``-``1``, x)` `    ``else``:` `        ``return` `binarySearch(ar2, mid``+``1``, right, x)`   `# ar1[0..m-1] and ar2[0..n-1] are two given sorted arrays` `# and x is given number. This function prints the pair from` `# both arrays such that the sum of the pair is closest to x.` `def` `printClosest(ar1, ar2, m, n, x):` `    ``# Initialize the diff between pair sum and x.` `    ``diff ``=` `sys.maxsize`   `    ``# res_l and res_r are result indexes from ar1[] and ar2[]` `    ``# respectively` `    ``res_l, res_r ``=` `0``, ``0`   `    ``# Start from left side of ar1[] and right side of ar2[]` `    ``l, r ``=` `0``, n ``-` `1` `    ``while` `l < m ``and` `r >``=` `0``:` `        ``# If this pair is closer to x than the previously` `        ``# found closest, then update res_l, res_r and diff` `        ``if` `abs``(ar1[l] ``+` `ar2[r] ``-` `x) < diff:` `            ``res_l ``=` `l` `            ``res_r ``=` `r` `            ``diff ``=` `abs``(ar1[l] ``+` `ar2[r] ``-` `x)`   `        ``# If sum of this pair is more than x, move to smaller` `        ``# side` `        ``if` `ar1[l] ``+` `ar2[r] > x:` `            ``r ``-``=` `1` `        ``else``: ``# move to the greater side` `            ``l ``+``=` `1`   `    ``# Print the result` `    ``print``(``"The closest pair is [{}, {}]"``.``format``(ar1[res_l], ar2[res_r]))`   `# Driver program to test above functions` `if` `__name__ ``=``=` `"__main__"``:` `    ``ar1 ``=` `[``1``, ``4``, ``5``, ``7``]` `    ``ar2 ``=` `[``10``, ``20``, ``30``, ``40``]` `    ``m ``=` `len``(ar1)` `    ``n ``=` `len``(ar2)` `    ``x ``=` `38`   `    ``# Perform binary search on ar2[] for the element closest` `    ``# to x-ar1[i]` `    ``for` `i ``in` `range``(m):` `        ``index ``=` `binarySearch(ar2, ``0``, n``-``1``, x``-``ar1[i])`   `        ``# Check if the element closest to x-ar1[i] is better` `        ``# than the current best` `        ``if` `index >``=` `0` `and` `index < n ``and` `abs``(ar1[i]``+``ar2[index]``-``x) < ``abs``(ar1[i]``+``ar2[index``-``1``]``-``x):` `            ``printClosest(ar1, ar2, m, n, x)` `            ``break` `        ``elif` `index > ``0` `and` `abs``(ar1[i]``+``ar2[index``-``1``]``-``x) < ``abs``(ar1[i]``+``ar2[index]``-``x):` `            ``index ``-``=` `1`

## C#

 `using` `System;`   `public` `class` `MainClass ` `{`   `  ``// Function to perform binary search on array ar2[] for` `  ``// the closest element to x` `  ``public` `static` `int` `BinarySearch(``int``[] ar2, ``int` `left,` `                                 ``int` `right, ``int` `x)` `  ``{` `    ``if` `(left > right)` `      ``return` `left - 1;`   `    ``int` `mid = (left + right) / 2;`   `    ``if` `(ar2[mid] == x)` `      ``return` `mid;` `    ``else` `if` `(ar2[mid] > x)` `      ``return` `BinarySearch(ar2, left, mid - 1, x);` `    ``else` `      ``return` `BinarySearch(ar2, mid + 1, right, x);` `  ``}`   `  ``// ar1[0..m-1] and ar2[0..n-1] are two given sorted` `  ``// arrays and x is given number. This function prints` `  ``// the pair from both arrays such that the sum of the` `  ``// pair is closest to x.` `  ``public` `static` `void` `PrintClosest(``int``[] ar1, ``int``[] ar2,` `                                  ``int` `m, ``int` `n, ``int` `x)` `  ``{` `    ``// Initialize the diff between pair sum and x.` `    ``int` `diff = ``int``.MaxValue;`   `    ``// res_l and res_r are result indexes from ar1[] and` `    ``// ar2[] respectively` `    ``int` `res_l = 0, res_r = 0;`   `    ``// Start from left side of ar1[] and right side of` `    ``// ar2[]` `    ``int` `l = 0, r = n - 1;` `    ``while` `(l < m && r >= 0) {` `      ``// If this pair is closer to x than the` `      ``// previously found closest, then update res_l,` `      ``// res_r and diff` `      ``if` `(Math.Abs(ar1[l] + ar2[r] - x) < diff) {` `        ``res_l = l;` `        ``res_r = r;` `        ``diff = Math.Abs(ar1[l] + ar2[r] - x);` `      ``}`   `      ``// If sum of this pair is more than x, move to` `      ``// smaller side` `      ``if` `(ar1[l] + ar2[r] > x)` `        ``r--;` `      ``else` `// move to the greater side` `        ``l++;` `    ``}`   `    ``// Print the result` `    ``Console.WriteLine(``"The closest pair is ["` `                      ``+ ar1[res_l] + ``", "` `+ ar2[res_r]` `                      ``+ ``"]"``);` `  ``}`   `  ``// Driver program to test above functions` `  ``public` `static` `void` `Main()` `  ``{` `    ``int``[] ar1 = { 1, 4, 5, 7 };` `    ``int``[] ar2 = { 10, 20, 30, 40 };` `    ``int` `m = ar1.Length;` `    ``int` `n = ar2.Length;` `    ``int` `x = 38;`   `    ``// Sort the second array` `    ``Array.Sort(ar2);`   `    ``// Perform binary search on ar2[] for the element` `    ``// closest to x-ar1[i]` `    ``for` `(``int` `i = 0; i < m; i++) {` `      ``int` `index` `        ``= BinarySearch(ar2, 0, n - 1, x - ar1[i]);`   `      ``// Check if the element closest to x-ar1[i] is` `      ``// better than the current best` `      ``if` `(index >= 0 && index < n` `          ``&& Math.Abs(ar1[i] + ar2[index] - x)` `          ``< Math.Abs(ar1[i] + ar2[index - 1]` `                     ``- x)) {` `        ``PrintClosest(ar1, ar2, m, n, x);` `        ``return``;` `      ``}` `      ``else` `if` `(index > 0` `               ``&& Math.Abs(ar1[i] + ar2[index - 1]` `                           ``- x)` `               ``< Math.Abs(ar1[i] + ar2[index]` `                          ``- x)) {` `        ``PrintClosest(ar1, ar2, m, n, x);` `        ``return``;` `      ``}` `    ``}` `  ``}` `}`

## Javascript

 `// Function to perform binary search on array arr for` `// the closest element to x` `function` `binarySearch(arr, left, right, x) {` `if` `(left > right) {` `return` `left - 1;` `}` `const mid = Math.floor((left + right) / 2);` `if` `(arr[mid] === x) {` `return` `mid;` `} ``else` `if` `(arr[mid] > x) {` `return` `binarySearch(arr, left, mid - 1, x);` `} ``else` `{` `return` `binarySearch(arr, mid + 1, right, x);` `}` `}` `// arr1 and arr2 are two given sorted arrays` `// and x is a given number. This function prints the pair from` `// both arrays such that the sum of the pair is closest to x.` `function` `printClosest(arr1, arr2, x) {` `const m = arr1.length;` `const n = arr2.length;` `// Initialize the diff between pair sum and x.` `let diff = Infinity;`   `// res_l and res_r are result indexes from arr1 and arr2` `// respectively` `let res_l = 0,` `res_r = 0;`   `// Start from left side of arr1 and right side of arr2` `let l = 0,` `r = n - 1;` `while` `(l < m && r >= 0) {` `// If this pair is closer to x than the previously` `// found closest, then update res_l, res_r and diff` `if` `(Math.abs(arr1[l] + arr2[r] - x) < diff) {` `res_l = l;` `res_r = r;` `diff = Math.abs(arr1[l] + arr2[r] - x);` `}` `// If sum of this pair is more than x, move to smaller` `// side` `if` `(arr1[l] + arr2[r] > x) {` `  ``r -= 1;` `} ``else` `{` `  ``// move to the greater side` `  ``l += 1;` `}`   `// Print the result` `console.log(The closest pair is [\${arr1[res_l]}, \${arr2[res_r]}]);` `}`   `// Driver program to test above functions` `const arr1 = [1, 4, 5, 7];` `const arr2 = [10, 20, 30, 40];` `const x = 38;`   `// Perform binary search on arr2 for the element closest` `// to x-arr1[i]` `for` `(let i = 0; i < arr1.length; i++) {` `const index = binarySearch(arr2, 0, arr2.length - 1, x - arr1[i]);`   `// Check if the element closest to x-arr1[i] is better` `// than the current best` `if` `(` `index >= 0 &&` `index < arr2.length &&` `Math.abs(arr1[i] + arr2[index] - x) <` `Math.abs(arr1[i] + arr2[index - 1] - x)` `) {` `printClosest(arr1, arr2, x);` `break``;` `} ``else` `if` `(` `index > 0 &&` `Math.abs(arr1[i] + arr2[index - 1] - x) <` `Math.abs(arr1[i] + arr2[index] - x)` `) {` `index -= 1;` `}` `}`

OUTPUT:

```The closest pair is [7, 30]

```

Time Complexity : O(mLogN) , As we are Dividing Arrays using Binary search where.
Auxiliary Space : O(1)

Previous
Next