Find three closest elements from given three sorted arrays

// 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.util.Arrays;

public class GFG {

    public static void findClosest(int[] A, int[] B,
                                   int[] C, int p, int q,
                                   int r)
    {
        // Three variable to store answer
        int a = 0, b = 0, c = 0;

        // To Store minimum of
        // max(abs(A[i]-B[j]),abs(B[j]-C[k]),
        // abs(C[k]-A[i]))
        int ans = Integer.MAX_VALUE;

        // Run three nested loop
        for (int i = 0; i < p; i++) {
            for (int j = 0; j < q; j++) {
                for (int k = 0; k < r; k++) {
                    int curr
                        = Math.max(Math.abs(A[i] - B[j]),
                                   Math.abs(B[j] - C[k]));
                    int temp = Math.max(
                        curr, Math.abs(C[k] - A[i]));

                    // If that is minimum than previous then
                    // update answer
                    if (temp < ans) {
                        ans = temp;
                        a = A[i];
                        b = B[j];
                        c = C[k];
                    }
                }
            }
        }
        // Printing final answer
        System.out.println(a + " " + b + " " + c);
    }
    // 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);
    }
}

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

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