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

Recommended Practice

## 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 ` `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

 ``

Output

`2`

Time complexity: O(N3). 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 ` `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 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

 ``

Output

`2`

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.
Auxiliary Space: O(1). As no extra space is required.

Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Previous
Next