Find a triplet in an array whose sum is closest to a given number

Given an array arr[] of N integers and an integer X, the task is to find three integers in arr[] such that the sum is closest to X.

Examples:

Input: arr[] = {-1, 2, 1, -4}, X = 1
Output: 2
Explanation:
Sums of triplets:
(-1) + 2 + 1 = 2
(-1) + 2 + (-4) = -3
2 + 1 + (-4) = -1
2 is closest to 1.

Input: arr[] = {1, 2, 3, 4, -5}, X = 10
Output: 9
Explanation:
Sums of triplets:
1 + 2 + 3 = 6
2 + 3 + 4 = 9
1 + 3 + 4 = 7
…
9 is closest to 10.

Find a triplet in an array whose sum is closest to a given number by explore all the subsets of size three:

The naive approach is to explore all the subsets of size three and keep a track of the difference between X and the sum of this subset. Then return the subset whose difference between its sum and X is minimum.

Step-by-step approach:

• Create three nested loops with counter i, j and k respectively.
• The first loop will start from start to end, the second loop will run from i+1 to end, the third loop will run from j+1 to end.
• Check if the difference of the sum of the ith, jth and kth element with the given sum is less than the current minimum or not. Update the current minimum
• Print the closest sum.

Below is the implementation of the above approach:

C++14

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function to return the sum of a
// triplet which is closest to x
int solution(vector<int>& arr, int x)
{
    // To store the closest sum
    int closestSum = INT_MAX;

    // Run three nested loops each loop
    // for each element of triplet
    for (int i = 0; i < arr.size() ; i++)
    {
        for(int j =i + 1; j < arr.size(); j++)
        {
            for(int k =j + 1; k < arr.size(); k++)
            {
                //update the closestSum
                if(abs(x - closestSum) > abs(x - (arr[i] + arr[j] + arr[k])))
                    closestSum = (arr[i] + arr[j] + arr[k]);
            }
        }
    }
    // Return the closest sum found
    return closestSum;
}

// Driver code
int main()
{
    vector<int> arr = { -1, 2, 1, -4 };
    int x = 1;
    cout << solution(arr, x);

    return 0;
}

Java

// Java implementation of the above approach
class GFG{

// Function to return the sum of a
// triplet which is closest to x
public static int solution(int arr[], int x)
{

    // To store the closest sum
    int closestSum = Integer.MAX_VALUE;

    // Run three nested loops each loop
    // for each element of triplet
    for(int i = 0; i < arr.length ; i++)
    {
        for(int j = i + 1; j < arr.length; j++)
        {
            for(int k = j + 1; k < arr.length; k++)
            {

                // Update the closestSum
                if (Math.abs(x - closestSum) >
                    Math.abs(x - (arr[i] + arr[j] + arr[k])))
                    closestSum = (arr[i] + arr[j] + arr[k]);
            }
        }
    }

    // Return the closest sum found
    return closestSum;
}

// Driver code
public static void main(String[] args)
{
    int arr[] = { -1, 2, 1, -4 };
    int x = 1;

    System.out.print(solution(arr, x));
}
}

// This code is contributed by divyeshrabadiya07

Python3

# Python3 implementation of the above approach
import sys

# Function to return the sum of a
# triplet which is closest to x
def solution(arr, x):

    # To store the closest sum
    closestSum = sys.maxsize

    # Run three nested loops each loop
    # for each element of triplet
    for i in range (len(arr)) :
        for j in range(i + 1, len(arr)):
            for k in range(j + 1, len( arr)):

                # Update the closestSum
                if(abs(x - closestSum) >
                abs(x - (arr[i] +
                arr[j] + arr[k]))):
                    closestSum = (arr[i] +
                                    arr[j] + arr[k])

    # Return the closest sum found
    return closestSum

# Driver code
if __name__ == "__main__":

    arr = [ -1, 2, 1, -4 ]
    x = 1

    print(solution(arr, x))

# This code is contributed by chitranayal

C#

// C# implementation of the above approach
using System;
using System.Collections;
using System.Collections.Generic;

class GFG{

// Function to return the sum of a
// triplet which is closest to x
static int solution(ArrayList arr, int x)
{

    // To store the closest sum
    int closestSum = int.MaxValue;

    // Run three nested loops each loop
    // for each element of triplet
    for(int i = 0; i < arr.Count; i++)
    {
        for(int j = i + 1; j < arr.Count; j++)
        {
            for(int k = j + 1; k < arr.Count; k++)
            {
                if (Math.Abs(x - closestSum) >
                    Math.Abs(x - ((int)arr[i] +
                   (int)arr[j] + (int)arr[k])))
                {
                    closestSum = ((int)arr[i] +
                                  (int)arr[j] +
                                  (int)arr[k]);
                }
            }
        }
    }

    // Return the closest sum found
    return closestSum;
}

// Driver code
public static void Main(string[] args)
{
    ArrayList arr = new ArrayList(){ -1, 2, 1, -4 };
    int x = 1;
    Console.Write(solution(arr, x));
}
}

// This code is contributed by rutvik_56

Javascript

<script>

// Javascript implementation of the approach

// Function to return the sum of a
// triplet which is closest to x
function solution(arr, x)
{

    // To store the closest sum
    let closestSum = Number.MAX_VALUE;

    // Run three nested loops each loop
    // for each element of triplet
    for(let i = 0; i < arr.length ; i++)
    {
        for(let j =i + 1; j < arr.length; j++)
        {
            for(let k =j + 1; k < arr.length; k++)
            {

                // Update the closestSum
                if (Math.abs(x - closestSum) >
                    Math.abs(x - (arr[i] + arr[j] + arr[k])))
                    closestSum = (arr[i] + arr[j] + arr[k]);
            }
        }
    }

    // Return the closest sum found
    return closestSum;
}

// Driver code
let arr = [ -1, 2, 1, -4 ];
let x = 1;

document.write(solution(arr, x));

// This code is contributed by rishavmahato348

</script>

Output

2

Time complexity: O(N³). Three nested loops are traversing in the array, so time complexity is O(n^3).
Auxiliary Space: O(1). As no extra space is required.

Find a triplet in an array whose sum is closest to a given number using Sorting:

By Sorting the array the efficiency of the algorithm can be improved. This efficient approach uses the two-pointer technique. Traverse the array and fix the first element of the triplet. Now use the Two Pointers algorithm to find the closest number to x – array[i]. Update the closest sum. The two-pointers algorithm takes linear time so it is better than a nested loop.

Step-by-step approach:

• Sort the given array.
• Loop over the array and fix the first element of the possible triplet, arr[i].
• Then fix two pointers, one at I + 1 and the other at n – 1. And look at the sum, 
  • If the sum is smaller than the sum we need to get to, we increase the first pointer.
  • Else, If the sum is bigger, Decrease the end pointer to reduce the sum.
  • Update the closest sum found so far.

Below is the implementation of the above approach:

C++14

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;

// Function to return the sum of a
// triplet which is closest to x
int solution(vector<int>& arr, int x)
{

    // Sort the array
    sort(arr.begin(), arr.end());

    // To store the closest sum
  //not using INT_MAX to avoid overflowing condition
    int closestSum = 1000000000;

    // Fix the smallest number among
    // the three integers
    for (int i = 0; i < arr.size() - 2; i++) {

        // Two pointers initially pointing at
        // the last and the element
        // next to the fixed element
        int ptr1 = i + 1, ptr2 = arr.size() - 1;

        // While there could be more pairs to check
        while (ptr1 < ptr2) {

            // Calculate the sum of the current triplet
            int sum = arr[i] + arr[ptr1] + arr[ptr2];

              // if sum is equal to x, return sum as
              if (sum == x)
              return sum;
            // If the sum is more closer than
            // the current closest sum
            if (abs(x - sum) < abs(x - closestSum)) {
                closestSum = sum;
            }

            // If sum is greater than x then decrement
            // the second pointer to get a smaller sum
            if (sum > x) {
                ptr2--;
            }

            // Else increment the first pointer
            // to get a larger sum
            else {
                ptr1++;
            }
        }
    }

    // Return the closest sum found
    return closestSum;
}

// Driver code
int main()
{
    vector<int> arr = { -1, 2, 1, -4 };
    int x = 1;
    cout << solution(arr, x);

    return 0;
}

Java

// Java implementation of the above approach
import static java.lang.Math.abs;
import java.util.*;

class GFG
{

// Function to return the sum of a
// triplet which is closest to x
static int solution(Vector<Integer> arr, int x)
{

    // Sort the array
    Collections.sort(arr);

    // To store the closest sum
      // Assigning long to avoid overflow condition
      // when array has negative integers
    long closestSum = Integer.MAX_VALUE;

    // Fix the smallest number among
    // the three integers
    for (int i = 0; i < arr.size() - 2; i++)
    {

        // Two pointers initially pointing at
        // the last and the element
        // next to the fixed element
        int ptr1 = i + 1, ptr2 = arr.size() - 1;

        // While there could be more pairs to check
        while (ptr1 < ptr2)
        {

            // Calculate the sum of the current triplet
            int sum = arr.get(i) + arr.get(ptr1) + arr.get(ptr2);

            // If the sum is more closer than
            // the current closest sum
            if (abs(x - sum) < abs(x - closestSum))
            {
                closestSum = sum;
            }

            // If sum is greater than x then decrement
            // the second pointer to get a smaller sum
            if (sum > x)
            {
                ptr2--;
            }

            // Else increment the first pointer
            // to get a larger sum
            else
            {
                ptr1++;
            }
        }
    }

    // Return the closest sum found
    return (int)closestSum;
}

// Driver code
public static void main(String[] args)
{
    Vector arr = new Vector(Arrays.asList( -1, 2, 1, -4 ));
    int x = 1;
    System.out.println(solution(arr, x));
}
}

/* This code is contributed by PrinciRaj1992 */

Python3

# Python3 implementation of the approach

import sys

# Function to return the sum of a
# triplet which is closest to x
def solution(arr, x) :

    # Sort the array
    arr.sort();

    # To store the closest sum
    closestSum = sys.maxsize;

    # Fix the smallest number among
    # the three integers
    for i in range(len(arr)-2) :

        # Two pointers initially pointing at
        # the last and the element
        # next to the fixed element
        ptr1 = i + 1; ptr2 = len(arr) - 1;

        # While there could be more pairs to check
        while (ptr1 < ptr2) :

            # Calculate the sum of the current triplet
            sum = arr[i] + arr[ptr1] + arr[ptr2];

            # If the sum is more closer than
            # the current closest sum
            if (abs(x - sum) < abs(x - closestSum)) :
                closestSum = sum;

            # If sum is greater than x then decrement
            # the second pointer to get a smaller sum
            if (sum > x) :
                ptr2 -= 1;

            # Else increment the first pointer
            # to get a larger sum
            else :
                ptr1 += 1;

    # Return the closest sum found
    return closestSum;


# Driver code
if __name__ == "__main__" :

    arr = [ -1, 2, 1, -4 ];
    x = 1;
    print(solution(arr, x));

# This code is contributed by AnkitRai01

C#

// C# implementation of the above approach
using System;
using System.Collections.Generic;

class GFG
{

// Function to return the sum of a
// triplet which is closest to x
static int solution(List<int> arr, int x)
{

    // Sort the array
    arr.Sort();

    // To store the closest sum
    int closestSum = int.MaxValue;

    // Fix the smallest number among
    // the three integers
    for (int i = 0; i < arr.Count - 2; i++)
    {

        // Two pointers initially pointing at
        // the last and the element
        // next to the fixed element
        int ptr1 = i + 1, ptr2 = arr.Count - 1;

        // While there could be more pairs to check
        while (ptr1 < ptr2)
        {

            // Calculate the sum of the current triplet
            int sum = arr[i] + arr[ptr1] + arr[ptr2];

            // If the sum is more closer than
            // the current closest sum
            if (Math.Abs(x - sum) <
                Math.Abs(x - closestSum))
            {
                closestSum = sum;
            }

            // If sum is greater than x then decrement
            // the second pointer to get a smaller sum
            if (sum > x)
            {
                ptr2--;
            }

            // Else increment the first pointer
            // to get a larger sum
            else
            {
                ptr1++;
            }
        }
    }

    // Return the closest sum found
    return closestSum;
}

// Driver code
public static void Main(String[] args)
{
    int []ar = { -1, 2, 1, -4 };
    List<int> arr = new List<int>(ar);
    int x = 1;
    Console.WriteLine(solution(arr, x));
}
}

// This code is contributed by Princi Singh

Javascript

<script>

// JavaScript implementation of the approach

// Function to return the sum of a
// triplet which is closest to x
function solution(arr, x)
{

    // Sort the array
    arr.sort((a, b) => a - b);

    // To store the closest sum
   // not using INT_MAX to avoid
   // overflowing condition
    let closestSum = 1000000000;

    // Fix the smallest number among
    // the three integers
    for (let i = 0; i < arr.length - 2; i++)
    {

        // Two pointers initially pointing at
        // the last and the element
        // next to the fixed element
        let ptr1 = i + 1, ptr2 = arr.length - 1;

        // While there could be more pairs to check
        while (ptr1 < ptr2) {

            // Calculate the sum of the current triplet
            let sum = arr[i] + arr[ptr1] + arr[ptr2];

            // If the sum is more closer than
            // the current closest sum
            if (Math.abs(1*x - sum) < Math.abs(1*x - closestSum))
            {
                closestSum = sum;
            }

            // If sum is greater than x then decrement
            // the second pointer to get a smaller sum
            if (sum > x) {
                ptr2--;
            }

            // Else increment the first pointer
            // to get a larger sum
            else {
                ptr1++;
            }
        }
    }

    // Return the closest sum found
    return closestSum;
}

// Driver code
    let arr = [ -1, 2, 1, -4 ];
    let x = 1;
    document.write(solution(arr, x));

// This code is contributed by Surbhi Tyagi.

</script>

Output

2

Time complexity: O(N²). There are only two nested loops traversing the array, so time complexity is O(n^2). Two pointer algorithm take O(n) time and the first element can be fixed using another nested traversal.
Auxiliary Space: O(1). As no extra space is required.