Smallest Difference Triplet from Three arrays

Three arrays of same size are given. Find a triplet such that maximum – minimum in that triplet is minimum of all the triplets. A triplet should be selected in a way such that it should have one number from each of the three given arrays. 

If there are 2 or more smallest difference triplets, then the one with the smallest sum of its elements should be displayed.

Examples :

Input : arr1[] = {5, 2, 8}
    arr2[] = {10, 7, 12}
    arr3[] = {9, 14, 6}
Output : 7, 6, 5

Input : arr1[] = {15, 12, 18, 9}
    arr2[] = {10, 17, 13, 8}
    arr3[] = {14, 16, 11, 5}
Output : 11, 10, 9

Note:The elements of the triplet are displayed in non-decreasing order.

Simple Solution : Consider each an every triplet and find the required smallest difference triplet out of them. Complexity of O(n³).

Efficient Solution:

1. Sort the 3 arrays in non-decreasing order.
2. Start three pointers from left most elements of three arrays.
3. Now find min and max and calculate max-min from these three elements.
4. Now increment pointer of minimum element’s array.
5. Repeat steps 2, 3, 4, for the new set of pointers until any one pointer reaches to its end.

Implementatipon:

C++

// C++ implementation of smallest difference triplet
#include <bits/stdc++.h>
using namespace std;

// function to find maximum number
int maximum(int a, int b, int c)
{
   return max(max(a, b), c);
}

// function to find minimum number
int minimum(int a, int b, int c)
{
   return min(min(a, b), c);
}

// Finds and prints the smallest Difference Triplet
void smallestDifferenceTriplet(int arr1[], int arr2[],
                                    int arr3[], int n)
{
    // sorting all the three arrays
    sort(arr1, arr1+n);
    sort(arr2, arr2+n);
    sort(arr3, arr3+n);

    // To store resultant three numbers
    int res_min, res_max, res_mid;

    // pointers to arr1, arr2, arr3
    // respectively
    int i = 0, j = 0, k = 0;

    // Loop until one array reaches to its end
    // Find the smallest difference.
    int diff = INT_MAX;
    while (i < n && j < n && k < n)
    {
        int sum = arr1[i] + arr2[j] + arr3[k];

        // maximum number
        int max = maximum(arr1[i], arr2[j], arr3[k]);

        // Find minimum and increment its index.
        int min = minimum(arr1[i], arr2[j], arr3[k]);
        if (min == arr1[i])
            i++;
        else if (min == arr2[j])
            j++;
        else
            k++;

        // comparing new difference with the
        // previous one and updating accordingly
        if (diff > (max-min))
        {
            diff = max - min;
            res_max = max;
            res_mid = sum - (max + min);
            res_min = min;
        }
    }

    // Print result
    cout << res_max << ", " << res_mid << ", " << res_min;
}

// Driver program to test above
int main()
{
    int arr1[] = {5, 2, 8};
    int arr2[] = {10, 7, 12};
    int arr3[] = {9, 14, 6};
    int n = sizeof(arr1) / sizeof(arr1[0]);
    smallestDifferenceTriplet(arr1, arr2, arr3, n);
    return 0;
}

Java

// Java implementation of smallest difference
// triplet
import java.util.Arrays;

class GFG {

    // function to find maximum number
    static int maximum(int a, int b, int c)
    {
        return Math.max(Math.max(a, b), c);
    }

    // function to find minimum number
    static int minimum(int a, int b, int c)
    {
        return Math.min(Math.min(a, b), c);
    }

    // Finds and prints the smallest Difference
    // Triplet
    static void smallestDifferenceTriplet(int arr1[],
                       int arr2[], int arr3[], int n)
    {

        // sorting all the three arrays
        Arrays.sort(arr1);
        Arrays.sort(arr2);
        Arrays.sort(arr3);

        // To store resultant three numbers
        int res_min=0, res_max=0, res_mid=0;

        // pointers to arr1, arr2, arr3
        // respectively
        int i = 0, j = 0, k = 0;

        // Loop until one array reaches to its end
        // Find the smallest difference.
        int diff = 2147483647;

        while (i < n && j < n && k < n)
        {
            int sum = arr1[i] + arr2[j] + arr3[k];

            // maximum number
            int max = maximum(arr1[i], arr2[j], arr3[k]);

            // Find minimum and increment its index.
            int min = minimum(arr1[i], arr2[j], arr3[k]);
            if (min == arr1[i])
                i++;
            else if (min == arr2[j])
                j++;
            else
                k++;

            // comparing new difference with the
            // previous one and updating accordingly
            if (diff > (max - min))
            {
                diff = max - min;
                res_max = max;
                res_mid = sum - (max + min);
                res_min = min;
            }
        }

        // Print result
        System.out.print(res_max + ", " + res_mid
                                 + ", " + res_min);
    }

    //driver code
    public static void main (String[] args)
    {

        int arr1[] = {5, 2, 8};
        int arr2[] = {10, 7, 12};
        int arr3[] = {9, 14, 6};

        int n = arr1.length;

        smallestDifferenceTriplet(arr1, arr2, arr3, n);
    }
}

// This code is contributed by Anant Agarwal.

Python3

# Python3 implementation of smallest
# difference triplet

# Function to find maximum number
def maximum(a, b, c):
    return max(max(a, b), c)

# Function to find minimum number
def minimum(a, b, c):
    return min(min(a, b), c)

# Finds and prints the smallest
# Difference Triplet
def smallestDifferenceTriplet(arr1, arr2, arr3, n):

    # sorting all the three arrays
    arr1.sort()
    arr2.sort()
    arr3.sort()

    # To store resultant three numbers
    res_min = 0; res_max = 0; res_mid = 0

    # pointers to arr1, arr2,
    # arr3 respectively
    i = 0; j = 0; k = 0

    # Loop until one array reaches to its end
    # Find the smallest difference.
    diff = 2147483647
    while (i < n and j < n and k < n):

        sum = arr1[i] + arr2[j] + arr3[k]

        # maximum number
        max = maximum(arr1[i], arr2[j], arr3[k])

        # Find minimum and increment its index.
        min = minimum(arr1[i], arr2[j], arr3[k])
        if (min == arr1[i]):
            i += 1
        else if (min == arr2[j]):
            j += 1
        else:
            k += 1

        # Comparing new difference with the
        # previous one and updating accordingly
        if (diff > (max - min)):

            diff = max - min
            res_max = max
            res_mid = sum - (max + min)
            res_min = min

    # Print result
    print(res_max, ",", res_mid, ",", res_min)

# Driver code
arr1 = [5, 2, 8]
arr2 = [10, 7, 12]
arr3 = [9, 14, 6]
n = len(arr1)
smallestDifferenceTriplet(arr1, arr2, arr3, n)

# This code is contributed by Anant Agarwal.

C#

// C# implementation of smallest
// difference triplet
using System;

class GFG
{

    // function to find
    // maximum number
    static int maximum(int a, int b, int c)
    {
        return Math.Max(Math.Max(a, b), c);
    }

    // function to find
    // minimum number
    static int minimum(int a, int b, int c)
    {
        return Math.Min(Math.Min(a, b), c);
    }

    // Finds and prints the
    // smallest Difference Triplet
    static void smallestDifferenceTriplet(int []arr1,
                                          int []arr2,
                                          int []arr3,
                                          int n)
    {

        // sorting all the
        // three arrays
        Array.Sort(arr1);
        Array.Sort(arr2);
        Array.Sort(arr3);

        // To store resultant
        // three numbers
        int res_min = 0, res_max = 0, res_mid = 0;

        // pointers to arr1, arr2,
        // arr3 respectively
        int i = 0, j = 0, k = 0;

        // Loop until one array
        // reaches to its end
        // Find the smallest difference.
        int diff = 2147483647;

        while (i < n && j < n && k < n)
        {
            int sum = arr1[i] +
                      arr2[j] + arr3[k];

            // maximum number
            int max = maximum(arr1[i],
                              arr2[j], arr3[k]);

            // Find minimum and
            // increment its index.
            int min = minimum(arr1[i],
                              arr2[j], arr3[k]);
            if (min == arr1[i])
                i++;
            else if (min == arr2[j])
                j++;
            else
                k++;

            // comparing new difference
            // with the previous one and
            // updating accordingly
            if (diff > (max - min))
            {
                diff = max - min;
                res_max = max;
                res_mid = sum - (max + min);
                res_min = min;
            }
        }

        // Print result
        Console.WriteLine(res_max + ", " +
                          res_mid + ", " +
                          res_min);
    }

    // Driver code
    static public void Main ()
    {
        int []arr1 = {5, 2, 8};
        int []arr2 = {10, 7, 12};
        int []arr3 = {9, 14, 6};

        int n = arr1.Length;

        smallestDifferenceTriplet(arr1, arr2,
                                  arr3, n);
    }
}

// This code is contributed by ajit.

PHP

<?php
// PHP implementation of
// smallest difference triplet

// function to find
// maximum number
function maximum($a, $b, $c)
{
    return max(max($a, $b), $c);
}

// function to find
// minimum number
function minimum($a, $b, $c)
{
    return min(min($a, $b), $c);
}

// Finds and prints the
// smallest Difference Triplet
function smallestDifferenceTriplet($arr1, $arr2,
                                   $arr3, $n)
{
    // sorting all the
    // three arrays
    sort($arr1);
    sort($arr2);
    sort($arr3);

    // To store resultant
    // three numbers
    $res_min; $res_max; $res_mid;

    // pointers to arr1, arr2,
    // arr3 respectively
    $i = 0; $j = 0; $k = 0;

    // Loop until one array reaches
    // to its end
    // Find the smallest difference.
    $diff = PHP_INT_MAX;
    while ($i < $n && $j < $n && $k < $n)
    {
        $sum = $arr1[$i] +
               $arr2[$j] +
               $arr3[$k];

        // maximum number
        $max = maximum($arr1[$i],
                       $arr2[$j],
                       $arr3[$k]);

        // Find minimum and
        // increment its index.
        $min = minimum($arr1[$i],
                       $arr2[$j],
                       $arr3[$k]);
        if ($min == $arr1[$i])
            $i++;
        else if ($min == $arr2[$j])
            $j++;
        else
            $k++;

        // comparing new difference
        // with the previous one
        // and updating accordingly
        if ($diff > ($max - $min))
        {
            $diff = $max - $min;
            $res_max = $max;
            $res_mid = $sum - ($max + $min);
            $res_min = $min;
        }
    }

    // Print result
    echo $res_max , ", " ,
         $res_mid , ", " ,
         $res_min;
}

// Driver Code
$arr1 = array(5, 2, 8);
$arr2 = array(10, 7, 12);
$arr3 = array(9, 14, 6);

$n = sizeof($arr1);
smallestDifferenceTriplet($arr1, $arr2,
                          $arr3, $n);

// This code is contributed by ajit
?>

Javascript

<script>
    // Javascript implementation of smallest difference triplet

    // function to find
    // maximum number
    function maximum(a, b, c)
    {
        return Math.max(Math.max(a, b), c);
    }

    // function to find
    // minimum number
    function minimum(a, b, c)
    {
        return Math.min(Math.min(a, b), c);
    }

    // Finds and prints the
    // smallest Difference Triplet
    function smallestDifferenceTriplet(arr1, arr2, arr3, n)
    {

        // sorting all the
        // three arrays
        arr1.sort(function(a, b){return a - b});
        arr2.sort(function(a, b){return a - b});
        arr3.sort(function(a, b){return a - b});

        // To store resultant
        // three numbers
        let res_min = 0, res_max = 0, res_mid = 0;

        // pointers to arr1, arr2,
        // arr3 respectively
        let i = 0, j = 0, k = 0;

        // Loop until one array
        // reaches to its end
        // Find the smallest difference.
        let diff = 2147483647;

        while (i < n && j < n && k < n)
        {
            let sum = arr1[i] + arr2[j] + arr3[k];

            // maximum number
            let max = maximum(arr1[i], arr2[j], arr3[k]);

            // Find minimum and
            // increment its index.
            let min = minimum(arr1[i], arr2[j], arr3[k]);
            if (min == arr1[i])
                i++;
            else if (min == arr2[j])
                j++;
            else
                k++;

            // comparing new difference
            // with the previous one and
            // updating accordingly
            if (diff > (max - min))
            {
                diff = max - min;
                res_max = max;
                res_mid = sum - (max + min);
                res_min = min;
            }
        }

        // Print result
        document.write(res_max + ", " + res_mid + ", " + res_min);
    }

    let arr1 = [5, 2, 8];
    let arr2 = [10, 7, 12];
    let arr3 = [9, 14, 6];

    let n = arr1.length;

    smallestDifferenceTriplet(arr1, arr2, arr3, n);

</script>

Output

7, 6, 5

Time Complexity : O(n log n)
Auxiliary Space: O(1),  since no extra space has been taken.