 GFG App
Open App Browser
Continue

# Find three closest elements from given three sorted arrays

Given three sorted arrays A[], B[] and C[], find 3 elements i, j and k from A, B and C respectively such that max(abs(A[i] – B[j]), abs(B[j] – C[k]), abs(C[k] – A[i])) is minimized. Here abs() indicates absolute value.

Example :

Input : A[] = {1, 4, 10}
B[] = {2, 15, 20}
C[] = {10, 12}

Output: 10 15 10
Explanation: 10 from A, 15 from B and 10 from C

Input: A[] = {20, 24, 100}
B[] = {2, 19, 22, 79, 800}
C[] = {10, 12, 23, 24, 119}
Output: 24 22 23
Explanation: 24 from A, 22 from B and 23 from C

We strongly recommend you to minimize your browser and try this yourself first.

A Simple Solution is to run three nested loops to consider all triplets from A, B and C. Compute the value of max(abs(A[i] – B[j]), abs(B[j] – C[k]), abs(C[k] – A[i])) for every triplet and return minimum of all values. Time complexity of this solution is O(n3)

A Better Solution is to use Binary Search.
1) Iterate over all elements of A[],
a) Binary search for element just smaller than or equal to in B[] and C[], and note the difference.
2) Repeat step 1 for B[] and C[].
3) Return overall minimum.
Time complexity of this solution is O(nLogn)

Efficient Solution Let ‘p’ be size of A[], ‘q’ be size of B[] and ‘r’ be size of C[]

```1)   Start with i=0, j=0 and k=0 (Three index variables for A,
B and C respectively)

//  p, q and r are sizes of A[], B[] and C[] respectively.
2)   Do following while i < p and j < q and k < r
a) Find min and maximum of A[i], B[j] and C[k]
b) Compute diff = max(X, Y, Z) - min(A[i], B[j], C[k]).
c) If new result is less than current result, change
it to the new result.
d) Increment the pointer of the array which contains
the minimum.```

Note that we increment the pointer of the array which has the minimum because our goal is to decrease the difference. Increasing the maximum pointer increases the difference. Increase the second maximum pointer can potentially increase the difference.

## C++

 `// C++ program to find 3 elements such that max(abs(A[i]-B[j]), abs(B[j]-` `// C[k]), abs(C[k]-A[i])) is minimized.`   `#include` `using` `namespace` `std;`   `void` `findClosest(``int` `A[], ``int` `B[], ``int` `C[], ``int` `p, ``int` `q, ``int` `r)` `{`   `    ``int` `diff = INT_MAX;  ``// Initialize min diff`   `    ``// Initialize result` `    ``int` `res_i =0, res_j = 0, res_k = 0;`   `    ``// Traverse arrays` `    ``int` `i=0,j=0,k=0;` `    ``while` `(i < p && j < q && k < r)` `    ``{` `        ``// Find minimum and maximum of current three elements` `        ``int` `minimum = min(A[i], min(B[j], C[k]));` `        ``int` `maximum = max(A[i], max(B[j], C[k]));`   `        ``// Update result if current diff is less than the min` `        ``// diff so far` `        ``if` `(maximum-minimum < diff)` `        ``{` `             ``res_i = i, res_j = j, res_k = k;` `             ``diff = maximum - minimum;` `        ``}`   `        ``// We can't get less than 0 as values are absolute` `        ``if` `(diff == 0) ``break``;`   `        ``// Increment index of array with smallest value` `        ``if` `(A[i] == minimum) i++;` `        ``else` `if` `(B[j] == minimum) j++;` `        ``else` `k++;` `    ``}`   `    ``// Print result` `    ``cout << A[res_i] << ``" "` `<< B[res_j] << ``" "` `<< C[res_k];` `}`   `// Driver program` `int` `main()` `{` `    ``int` `A[] = {1, 4, 10};` `    ``int` `B[] = {2, 15, 20};` `    ``int` `C[] = {10, 12};`   `    ``int` `p = ``sizeof` `A / ``sizeof` `A;` `    ``int` `q = ``sizeof` `B / ``sizeof` `B;` `    ``int` `r = ``sizeof` `C / ``sizeof` `C;`   `    ``findClosest(A, B, C, p, q, r);` `    ``return` `0;` `}`

## Java

 `// Java program to find 3 elements such` `// that max(abs(A[i]-B[j]), abs(B[j]-C[k]), ` `// abs(C[k]-A[i])) is minimized.` `import` `java.io.*;`   `class` `GFG {` `    `  `    ``static` `void` `findClosest(``int` `A[], ``int` `B[], ``int` `C[],` `                                  ``int` `p, ``int` `q, ``int` `r)` `    ``{` `        ``int` `diff = Integer.MAX_VALUE; ``// Initialize min diff` `    `  `        ``// Initialize result` `        ``int` `res_i =``0``, res_j = ``0``, res_k = ``0``;` `    `  `        ``// Traverse arrays` `        ``int` `i = ``0``, j = ``0``, k = ``0``;` `        ``while` `(i < p && j < q && k < r)` `        ``{` `            ``// Find minimum and maximum of current three elements` `            ``int` `minimum = Math.min(A[i],` `                          ``Math.min(B[j], C[k]));` `            ``int` `maximum = Math.max(A[i], ` `                          ``Math.max(B[j], C[k]));` `    `  `            ``// Update result if current diff is ` `            ``// less than the min diff so far` `            ``if` `(maximum-minimum < diff)` `            ``{` `                ``res_i = i;` `                ``res_j = j;` `                ``res_k = k;` `                ``diff = maximum - minimum;` `            ``}` `    `  `            ``// We can't get less than 0 ` `            ``// as values are absolute` `            ``if` `(diff == ``0``) ``break``;` `    `  `            ``// Increment index of array` `            ``// with smallest value` `            ``if` `(A[i] == minimum) i++;` `            ``else` `if` `(B[j] == minimum) j++;` `            ``else` `k++;` `        ``}` `    `  `        ``// Print result` `        ``System.out.println(A[res_i] + ``" "` `+` `                           ``B[res_j] + ``" "` `+ C[res_k]);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `main (String[] args)` `    ``{` `        ``int` `A[] = {``1``, ``4``, ``10``};` `        ``int` `B[] = {``2``, ``15``, ``20``};` `        ``int` `C[] = {``10``, ``12``};` `    `  `        ``int` `p = A.length;` `        ``int` `q = B.length;` `        ``int` `r = C.length;` `    `  `        ``// Function calling` `        ``findClosest(A, B, C, p, q, r);` `    ``}` `}`   `// This code is contributed by Ajit.`

## Python3

 `# Python program to find 3 elements such` `# that max(abs(A[i]-B[j]), abs(B[j]- C[k]),` `# abs(C[k]-A[i])) is minimized.` `import` `sys`   `def` `findCloset(A, B, C, p, q, r):`   `    ``# Initialize min diff` `    ``diff ``=` `sys.maxsize`   `    ``res_i ``=` `0` `    ``res_j ``=` `0` `    ``res_k ``=` `0`   `    ``# Traverse Array` `    ``i ``=` `0` `    ``j ``=` `0` `    ``k ``=` `0` `    ``while``(i < p ``and` `j < q ``and` `k < r):`   `        ``# Find minimum and maximum of` `        ``# current three elements` `        ``minimum ``=` `min``(A[i], ``min``(B[j], C[k]))` `        ``maximum ``=` `max``(A[i], ``max``(B[j], C[k]));`   `        ``# Update result if current diff is` `        ``# less than the min diff so far` `        ``if` `maximum``-``minimum < diff:` `            ``res_i ``=` `i` `            ``res_j ``=` `j` `            ``res_k ``=` `k` `            ``diff ``=` `maximum ``-` `minimum;`   `        ``# We can 't get less than 0 as ` `        ``# values are absolute` `        ``if` `diff ``=``=` `0``:` `            ``break`     `        ``# Increment index of array with` `        ``# smallest value` `        ``if` `A[i] ``=``=` `minimum:` `            ``i ``=` `i``+``1` `        ``elif` `B[j] ``=``=` `minimum:` `            ``j ``=` `j``+``1` `        ``else``:` `            ``k ``=` `k``+``1`   `    ``# Print result` `    ``print``(A[res_i], ``" "``, B[res_j], ``" "``, C[res_k])`   `# Driver Program` `A ``=` `[``1``, ``4``, ``10``]` `B ``=` `[``2``, ``15``, ``20``]` `C ``=` `[``10``, ``12``]`   `p ``=` `len``(A)` `q ``=` `len``(B)` `r ``=` `len``(C)`   `findCloset(A,B,C,p,q,r)`   `# This code is contributed by Shrikant13.`

## C#

 `// C# program to find 3 elements ` `// such that max(abs(A[i]-B[j]), ` `// abs(B[j]-C[k]), abs(C[k]-A[i]))` `// is minimized.` `using` `System;`   `class` `GFG ` `{` `    ``static` `void` `findClosest(``int` `[]A, ``int` `[]B, ` `                            ``int` `[]C, ``int` `p,` `                            ``int` `q, ``int` `r)` `    ``{` `        ``// Initialize min diff` `        ``int` `diff = ``int``.MaxValue; ` `    `  `        ``// Initialize result` `        ``int` `res_i = 0, ` `            ``res_j = 0, ` `            ``res_k = 0;` `    `  `        ``// Traverse arrays` `        ``int` `i = 0, j = 0, k = 0;` `        ``while` `(i < p && j < q && k < r)` `        ``{` `            ``// Find minimum and maximum ` `            ``// of current three elements` `            ``int` `minimum = Math.Min(A[i],` `                          ``Math.Min(B[j], C[k]));` `            ``int` `maximum = Math.Max(A[i], ` `                          ``Math.Max(B[j], C[k]));` `    `  `            ``// Update result if current ` `            ``// diff is less than the min` `            ``// diff so far` `            ``if` `(maximum - minimum < diff)` `            ``{` `                ``res_i = i;` `                ``res_j = j;` `                ``res_k = k;` `                ``diff = maximum - minimum;` `            ``}` `    `  `            ``// We can't get less than 0 ` `            ``// as values are absolute` `            ``if` `(diff == 0) ``break``;` `    `  `            ``// Increment index of array` `            ``// with smallest value` `            ``if` `(A[i] == minimum) i++;` `            ``else` `if` `(B[j] == minimum) j++;` `            ``else` `k++;` `        ``}` `    `  `        ``// Print result` `        ``Console.WriteLine(A[res_i] + ``" "` `+` `                          ``B[res_j] + ``" "` `+ ` `                          ``C[res_k]);` `    ``}`   `    ``// Driver code` `    ``public` `static` `void` `Main ()` `    ``{` `        ``int` `[]A = {1, 4, 10};` `        ``int` `[]B = {2, 15, 20};` `        ``int` `[]C = {10, 12};` `    `  `        ``int` `p = A.Length;` `        ``int` `q = B.Length;` `        ``int` `r = C.Length;` `    `  `        ``// Function calling` `        ``findClosest(A, B, C, p, q, r);` `    ``}` `}`   `// This code is contributed ` `// by anuj_67.`

## PHP

 ``

## Javascript

 ``

Output:

`10 15 10`

Time complexity of this solution is O(p + q + r) where p, q and r are sizes of A[], B[] and C[] respectively.
Auxiliary space: O(1) as constant space is required.

Approach 2: Using Binary Search:

Another approach to solve this problem can be to use binary search along with two pointers.

First, sort all the three arrays A, B, and C. Then, we take three pointers, one for each array. For each i, j, k combination, we calculate the maximum difference using the absolute value formula given in the problem. If the current maximum difference is less than the minimum difference found so far, then we update our result.

Next, we move our pointers based on the value of the maximum element among the current i, j, k pointers. We increment the pointer of the array with the smallest maximum element, hoping to find a smaller difference.

The time complexity of this approach will be O(nlogn) due to sorting, where n is the size of the largest array.

Here’s the code for this approach:

## C++

 `#include` `using` `namespace` `std;`   `void` `findClosest(``int` `A[], ``int` `B[], ``int` `C[], ``int` `p, ``int` `q, ``int` `r)` `{`   `    ``sort(A, A+p);` `    ``sort(B, B+q);` `    ``sort(C, C+r);`   `    ``int` `diff = INT_MAX; ``// Initialize min diff`   `    ``// Initialize result` `    ``int` `res_i =0, res_j = 0, res_k = 0;`   `    ``// Traverse arrays` `    ``int` `i=0,j=0,k=0;` `    ``while` `(i < p && j < q && k < r)` `    ``{` `        ``// Find minimum and maximum of current three elements` `        ``int` `minimum = min(A[i], min(B[j], C[k]));` `        ``int` `maximum = max(A[i], max(B[j], C[k]));`   `        ``// Calculate the maximum difference for the current combination` `        ``int` `curDiff = ``abs``(maximum - minimum);`   `        ``// Update result if current diff is less than the min` `        ``// diff so far` `        ``if` `(curDiff < diff)` `        ``{` `            ``res_i = i, res_j = j, res_k = k;` `            ``diff = curDiff;` `        ``}`   `        ``// If the maximum element of A is the smallest among the three,` `        ``// we move the A pointer forward` `        ``if` `(A[i] == minimum && A[i] <= B[j] && A[i] <= C[k]) i++;`   `        ``// If the maximum element of B is the smallest among the three,` `        ``// we move the B pointer forward` `        ``else` `if` `(B[j] == minimum && B[j] <= A[i] && B[j] <= C[k]) j++;`   `        ``// If the maximum element of C is the smallest among the three,` `        ``// we move the C pointer forward` `        ``else` `k++;` `    ``}`   `    ``// Print result` `    ``cout << A[res_i] << ``" "` `<< B[res_j] << ``" "` `<< C[res_k];` `}`   `// Driver program` `int` `main()` `{` `    ``int` `A[] = {1, 4, 10};` `    ``int` `B[] = {2, 15, 20};` `    ``int` `C[] = {10, 12};`   `    ``int` `p = ``sizeof` `A / ``sizeof` `A;` `    ``int` `q = ``sizeof` `B / ``sizeof` `B;` `    ``int` `r = ``sizeof` `C / ``sizeof` `C;`   `    ``findClosest(A, B, C, p, q, r);` `    ``return` `0;` `}`

## Java

 `import` `java.util.*;`   `public` `class` `Main {` `public` `static` `void` `findClosest(``int``[] A, ``int``[] B, ``int``[] C, ``int` `p, ``int` `q, ``int` `r) {` `      ``Arrays.sort(A);` `    ``Arrays.sort(B);` `    ``Arrays.sort(C);`   `    ``int` `diff = Integer.MAX_VALUE; ``// Initialize min diff`   `    ``// Initialize result` `    ``int` `res_i = ``0``, res_j = ``0``, res_k = ``0``;`   `    ``// Traverse arrays` `    ``int` `i = ``0``, j = ``0``, k = ``0``;` `    ``while` `(i < p && j < q && k < r) {` `        ``// Find minimum and maximum of current three elements` `        ``int` `minimum = Math.min(A[i], Math.min(B[j], C[k]));` `        ``int` `maximum = Math.max(A[i], Math.max(B[j], C[k]));`   `        ``// Calculate the maximum difference for the current combination` `        ``int` `curDiff = Math.abs(maximum - minimum);`   `        ``// Update result if current diff is less than the min` `        ``// diff so far` `        ``if` `(curDiff < diff) {` `            ``res_i = i;` `            ``res_j = j;` `            ``res_k = k;` `            ``diff = curDiff;` `        ``}`   `        ``// If the maximum element of A is the smallest among the three,` `        ``// we move the A pointer forward` `        ``if` `(A[i] == minimum && A[i] <= B[j] && A[i] <= C[k])` `            ``i++;`   `        ``// If the maximum element of B is the smallest among the three,` `        ``// we move the B pointer forward` `        ``else` `if` `(B[j] == minimum && B[j] <= A[i] && B[j] <= C[k])` `            ``j++;`   `        ``// If the maximum element of C is the smallest among the three,` `        ``// we move the C pointer forward` `        ``else` `            ``k++;` `    ``}`   `    ``// Print result` `    ``System.out.println(A[res_i] + ``" "` `+ B[res_j] + ``" "` `+ C[res_k]);` `}`   `// Driver program` `public` `static` `void` `main(String[] args) {` `    ``int``[] A = {``1``, ``4``, ``10``};` `    ``int``[] B = {``2``, ``15``, ``20``};` `    ``int``[] C = {``10``, ``12``};`   `    ``int` `p = A.length;` `    ``int` `q = B.length;` `    ``int` `r = C.length;`   `    ``findClosest(A, B, C, p, q, r);` `}` `}`

## Python3

 `import` `sys`   `def` `find_closest(A, B, C):` `    ``p, q, r ``=` `len``(A), ``len``(B), ``len``(C)` `    ``A.sort()` `    ``B.sort()` `    ``C.sort()` `    `  `    ``diff ``=` `sys.maxsize` `    ``res_i, res_j, res_k ``=` `0``, ``0``, ``0` `    `  `    ``i ``=` `j ``=` `k ``=` `0` `    ``while` `i < p ``and` `j < q ``and` `k < r:` `        ``minimum ``=` `min``(A[i], ``min``(B[j], C[k]))` `        ``maximum ``=` `max``(A[i], ``max``(B[j], C[k]))` `        `  `        ``cur_diff ``=` `abs``(maximum ``-` `minimum)` `        ``if` `cur_diff < diff:` `            ``res_i, res_j, res_k ``=` `i, j, k` `            ``diff ``=` `cur_diff` `        `  `        ``if` `A[i] ``=``=` `minimum ``and` `A[i] <``=` `B[j] ``and` `A[i] <``=` `C[k]:` `            ``i ``+``=` `1` `        ``elif` `B[j] ``=``=` `minimum ``and` `B[j] <``=` `A[i] ``and` `B[j] <``=` `C[k]:` `            ``j ``+``=` `1` `        ``else``:` `            ``k ``+``=` `1` `    `  `    ``return` `[A[res_i], B[res_j], C[res_k]]`   `# Driver program` `A ``=` `[``1``, ``4``, ``10``]` `B ``=` `[``2``, ``15``, ``20``]` `C ``=` `[``10``, ``12``]`   `print``(find_closest(A, B, C)) ``# Output: [4, 10, 10]`

## C#

 `using` `System;`   `public` `class` `Program` `{` `    ``public` `static` `int``[] FindClosest(``int``[] A, ``int``[] B, ``int``[] C)` `    ``{` `        ``int` `p = A.Length;` `        ``int` `q = B.Length;` `        ``int` `r = C.Length;`   `        ``Array.Sort(A);` `        ``Array.Sort(B);` `        ``Array.Sort(C);`   `        ``int` `diff = ``int``.MaxValue;` `        ``int` `res_i = 0, res_j = 0, res_k = 0;`   `        ``int` `i = 0, j = 0, k = 0;` `        ``while` `(i < p && j < q && k < r)` `        ``{` `            ``int` `minimum = Math.Min(A[i], Math.Min(B[j], C[k]));` `            ``int` `maximum = Math.Max(A[i], Math.Max(B[j], C[k]));`   `            ``int` `curDiff = Math.Abs(maximum - minimum);`   `            ``if` `(curDiff < diff)` `            ``{` `                ``res_i = i;` `                ``res_j = j;` `                ``res_k = k;` `                ``diff = curDiff;` `            ``}`   `            ``if` `(A[i] == minimum && A[i] <= B[j] && A[i] <= C[k])` `            ``{` `                ``i++;` `            ``}` `            ``else` `if` `(B[j] == minimum && B[j] <= A[i] && B[j] <= C[k])` `            ``{` `                ``j++;` `            ``}` `            ``else` `            ``{` `                ``k++;` `            ``}` `        ``}`   `        ``return` `new` `int``[] { A[res_i], B[res_j], C[res_k] };` `    ``}`   `    ``public` `static` `void` `Main()` `    ``{` `        ``int``[] A = { 1, 4, 10 };` `        ``int``[] B = { 2, 15, 20 };` `        ``int``[] C = { 10, 12 };`   `        ``int``[] result = FindClosest(A, B, C);` `        ``Console.WriteLine(``string``.Join(``" "``, result));` `    ``}` `}`

## Javascript

 `// Function to find the closest elements from three sorted arrays` `function` `find_closest(A, B, C) {` `  ``// Get the length of the three arrays` `  ``let p = A.length,` `    ``q = B.length,` `    ``r = C.length;`   `  ``// Sort the three arrays in non-decreasing order` `  ``A.sort((a, b) => a - b);` `  ``B.sort((a, b) => a - b);` `  ``C.sort((a, b) => a - b);`   `  ``// Initialize variables to store the minimum difference and the indices` `  ``// of the closest elements` `  ``let diff = Number.MAX_SAFE_INTEGER;` `  ``let res_i = 0,` `    ``res_j = 0,` `    ``res_k = 0;`   `  ``// Initialize indices to traverse the three arrays` `  ``let i = 0,` `    ``j = 0,` `    ``k = 0;`   `  ``// Traverse the arrays until we reach the end of any one of them` `  ``while` `(i < p && j < q && k < r) {` `    ``// Get the minimum and maximum elements from the three arrays` `    ``let minimum = Math.min(A[i], Math.min(B[j], C[k]));` `    ``let maximum = Math.max(A[i], Math.max(B[j], C[k]));`   `    ``// Calculate the difference between the maximum and minimum elements` `    ``let cur_diff = Math.abs(maximum - minimum);`   `    ``// Update the variables to store the indices of the closest elements` `    ``// if the current difference is less than the minimum difference` `    ``if` `(cur_diff < diff) {` `      ``res_i = i;` `      ``res_j = j;` `      ``res_k = k;` `      ``diff = cur_diff;` `    ``}`   `    ``// Increment the index of the array with the minimum element` `    ``if` `(A[i] == minimum && A[i] <= B[j] && A[i] <= C[k]) {` `      ``i++;` `    ``} ``else` `if` `(B[j] == minimum && B[j] <= A[i] && B[j] <= C[k]) {` `      ``j++;` `    ``} ``else` `{` `      ``k++;` `    ``}` `  ``}`   `  ``// Return the closest elements from the three arrays` `  ``return` `[A[res_i], B[res_j], C[res_k]];` `}`   `// Driver program` `let A = [1, 4, 10];` `let B = [2, 15, 20];` `let C = [10, 12];`   `// Call the find_closest function with the three arrays and print the result` `console.log(find_closest(A, B, C)); `

OUTPUT:

`10 15 10`

Time complexity :O(NlogN)
Auxiliary space: O(1) as constant space is required.

//Thanks to Gaurav Ahirwar for suggesting the above solutions.