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

05 Dec, 2021
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.
Simple Approach: The naive approach is to explore all the subsets of size 3 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.
Algorithm:
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 minimumPrint the closest sum.
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.
Implementation:
C++14
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; // Function to return the sum of a// triplet which is closest to xint 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 codeint main(){    vector<int> arr = { -1, 2, 1, -4 };    int x = 1;    cout << solution(arr, x);     return 0;}
// Java implementation of the above approachclass GFG{     // Function to return the sum of a// triplet which is closest to xpublic 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 codepublic 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 implementation of the above approachimport sys # Function to return the sum of a# triplet which is closest to xdef 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 codeif __name__ == "__main__":         arr = [ -1, 2, 1, -4 ]    x = 1         print(solution(arr, x)) # This code is contributed by chitranayal
// C# implementation of the above approachusing System;using System.Collections;using System.Collections.Generic; class GFG{ // Function to return the sum of a// triplet which is closest to xstatic 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 codepublic 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
<script> // Javascript implementation of the approach // Function to return the sum of a// triplet which is closest to xfunction 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 codelet arr = [ -1, 2, 1, -4 ];let x = 1; document.write(solution(arr, x)); // This code is contributed by rishavmahato348 </script>
2
Complexity Analysis:
Time complexity: O(N3). Three nested loops are traversing in the array, so time complexity is O(n^3).
Space Complexity: O(1). As no extra space is required.
Efficient approach: 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.
Algorithm: 
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.
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.
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.
Implementation:
C++14
Java
Python3
C#
Javascript
// C++ implementation of the approach#include <bits/stdc++.h>using namespace std; // Function to return the sum of a// triplet which is closest to xint 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 then 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 codeint main(){    vector<int> arr = { -1, 2, 1, -4 };    int x = 1;    cout << solution(arr, x);     return 0;}
// Java implementation of the above approachimport static java.lang.Math.abs;import java.util.*; class GFG{ // Function to return the sum of a// triplet which is closest to xstatic 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 then 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 codepublic 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 implementation of the approach import sys # Function to return the sum of a# triplet which is closest to xdef 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 then 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 codeif __name__ == "__main__" :     arr = [ -1, 2, 1, -4 ];    x = 1;    print(solution(arr, x)); # This code is contributed by AnkitRai01
// C# implementation of the above approachusing System;using System.Collections.Generic; class GFG{ // Function to return the sum of a// triplet which is closest to xstatic 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 then 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 codepublic 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
<script> // JavaScript implementation of the approach // Function to return the sum of a// triplet which is closest to xfunction 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 then 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>
2
Complexity Analysis:
Time complexity: O(N2). 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.
Space Complexity: O(1). As no extra space is required.
princiraj1992
ankthon
princi singh
anvy2
andrew1234
ukasp
rutvik_56
divyeshrabadiya07
manish kumar 77
rishavmahato348
surbhityagi15
vaibhavpatel1904
arorakashish0911
ashutoshsinghgeeksforgeeks
two-pointer-algorithm
Algorithms
Arrays
Mathematical
Sorting
two-pointer-algorithm
Arrays
Mathematical
Sorting
Algorithms
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Comments
Old Comments
DSA Sheet by Love Babbar
Difference between Informed and Uninformed Search in AI
SCAN (Elevator) Disk Scheduling Algorithms
Quadratic Probing in Hashing
K means Clustering - Introduction
Arrays in Java
Arrays in C/C++
Program for array rotation
Stack Data Structure (Introduction and Program)
Largest Sum Contiguous Subarray