# Triplet Sum in Array (3sum)

Given an array arr[] of size n and an integer X. Find if there’s a triplet in the array which sums up to the given integer X.

Examples:

Input: array = {12, 3, 4, 1, 6, 9}, sum = 24;
Output: 12, 3, 9
Explanation: There is a triplet (12, 3 and 9) present
in the array whose sum is 24.

Input: array = {1, 2, 3, 4, 5}, sum = 9
Output: 5, 3, 1
Explanation: There is a triplet (5, 3 and 1) present
in the array whose sum is 9.

Recommended Practice

## Triplet Sum in Array (3sum) by generating all the triplets:

A simple method is to generate all possible triplets and compare the sum of every triplet with the given value. The following code implements this simple method using three nested loops.

Step-by-step approach:

• Given an array of length n and a sum s
• Create three nested loop first loop runs from start to end (loop counter i), second loop runs from i+1 to end (loop counter j) and third loop runs from j+1 to end (loop counter k)
• The counter of these loops represents the index of 3 elements of the triplets.
• Find the sum of ith, jth and kth element. If the sum is equal to given sum. Print the triplet and break.
• If there is no triplet, then print that no triplet exist.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// returns true if there is triplet with sum equal ``// to 'sum' present in A[]. Also, prints the triplet ``bool` `find3Numbers(``int` `A[], ``int` `arr_size, ``int` `sum) ``{``    ``// Fix the first element as A[i] ``    ``for` `(``int` `i = 0; i < arr_size - 2; i++)``    ``{ ` `        ``// Fix the second element as A[j] ``        ``for` `(``int` `j = i + 1; j < arr_size - 1; j++)``        ``{ ` `            ``// Now look for the third number ``            ``for` `(``int` `k = j + 1; k < arr_size; k++)``            ``{ ``                ``if` `(A[i] + A[j] + A[k] == sum)``                ``{ ``                    ``cout << ``"Triplet is "` `<< A[i] <<``                        ``", "` `<< A[j] << ``", "` `<< A[k]; ``                    ``return` `true``; ``                ``} ``            ``} ``        ``} ``    ``} ` `    ``// If we reach here, then no triplet was found ``    ``return` `false``; ``} ` `/* Driver code */``int` `main() ``{ ``    ``int` `A[] = { 1, 4, 45, 6, 10, 8 }; ``    ``int` `sum = 22; ``    ``int` `arr_size = ``sizeof``(A) / ``sizeof``(A[0]); ``    ``find3Numbers(A, arr_size, sum); ``    ``return` `0; ``} ` `// This is code is contributed by rathbhupendra`

## C

 `#include ` `// returns true if there is triplet with sum equal``// to 'sum' present in A[]. Also, prints the triplet``bool` `find3Numbers(``int` `A[], ``int` `arr_size, ``int` `sum)``{``    ``int` `l, r;` `    ``// Fix the first element as A[i]``    ``for` `(``int` `i = 0; i < arr_size - 2; i++) {` `        ``// Fix the second element as A[j]``        ``for` `(``int` `j = i + 1; j < arr_size - 1; j++) {` `            ``// Now look for the third number``            ``for` `(``int` `k = j + 1; k < arr_size; k++) {``                ``if` `(A[i] + A[j] + A[k] == sum) {``                    ``printf``(``"Triplet is %d, %d, %d"``,``                           ``A[i], A[j], A[k]);``                    ``return` `true``;``                ``}``            ``}``        ``}``    ``}` `    ``// If we reach here, then no triplet was found``    ``return` `false``;``}` `/* Driver program to test above function */``int` `main()``{``    ``int` `A[] = { 1, 4, 45, 6, 10, 8 };``    ``int` `sum = 22;``    ``int` `arr_size = ``sizeof``(A) / ``sizeof``(A[0]);``    ``find3Numbers(A, arr_size, sum);``    ``return` `0;``}`

## Java

 `// Java program to find a triplet``class` `FindTriplet {` `    ``// returns true if there is triplet with sum equal``    ``// to 'sum' present in A[]. Also, prints the triplet``    ``boolean` `find3Numbers(``int` `A[], ``int` `arr_size, ``int` `sum)``    ``{``        ``int` `l, r;` `        ``// Fix the first element as A[i]``        ``for` `(``int` `i = ``0``; i < arr_size - ``2``; i++) {` `            ``// Fix the second element as A[j]``            ``for` `(``int` `j = i + ``1``; j < arr_size - ``1``; j++) {` `                ``// Now look for the third number``                ``for` `(``int` `k = j + ``1``; k < arr_size; k++) {``                    ``if` `(A[i] + A[j] + A[k] == sum) {``                        ``System.out.print(``"Triplet is "` `+ A[i] + ``", "` `+ A[j] + ``", "` `+ A[k]);``                        ``return` `true``;``                    ``}``                ``}``            ``}``        ``}` `        ``// If we reach here, then no triplet was found``        ``return` `false``;``    ``}` `    ``// Driver program to test above functions``    ``public` `static` `void` `main(String[] args)``    ``{``        ``FindTriplet triplet = ``new` `FindTriplet();``        ``int` `A[] = { ``1``, ``4``, ``45``, ``6``, ``10``, ``8` `};``        ``int` `sum = ``22``;``        ``int` `arr_size = A.length;` `        ``triplet.find3Numbers(A, arr_size, sum);``    ``}``}`

## Python3

 `# Python3 program to find a triplet ``# that sum to a given value` `# returns true if there is triplet with``# sum equal to 'sum' present in A[]. ``# Also, prints the triplet``def` `find3Numbers(A, arr_size, ``sum``):` `    ``# Fix the first element as A[i]``    ``for` `i ``in` `range``( ``0``, arr_size``-``2``):` `        ``# Fix the second element as A[j]``        ``for` `j ``in` `range``(i ``+` `1``, arr_size``-``1``): ``            ` `            ``# Now look for the third number``            ``for` `k ``in` `range``(j ``+` `1``, arr_size):``                ``if` `A[i] ``+` `A[j] ``+` `A[k] ``=``=` `sum``:``                    ``print``(``"Triplet is"``, A[i],``                          ``", "``, A[j], ``", "``, A[k])``                    ``return` `True``    ` `    ``# If we reach here, then no ``    ``# triplet was found``    ``return` `False` `# Driver program to test above function ``A ``=` `[``1``, ``4``, ``45``, ``6``, ``10``, ``8``]``sum` `=` `22``arr_size ``=` `len``(A)``find3Numbers(A, arr_size, ``sum``)` `# This code is contributed by Smitha Dinesh Semwal `

## C#

 `// C# program to find a triplet``// that sum to a given value``using` `System;` `class` `GFG {``    ``// returns true if there is``    ``// triplet with sum equal``    ``// to 'sum' present in A[].``    ``// Also, prints the triplet``    ``static` `bool` `find3Numbers(``int``[] A,``                             ``int` `arr_size,``                             ``int` `sum)``    ``{``        ``// Fix the first``        ``// element as A[i]``        ``for` `(``int` `i = 0;``             ``i < arr_size - 2; i++) {` `            ``// Fix the second``            ``// element as A[j]``            ``for` `(``int` `j = i + 1;``                 ``j < arr_size - 1; j++) {` `                ``// Now look for``                ``// the third number``                ``for` `(``int` `k = j + 1;``                     ``k < arr_size; k++) {``                    ``if` `(A[i] + A[j] + A[k] == sum) {``                        ``Console.WriteLine(``"Triplet is "` `+ A[i] + ``", "` `+ A[j] + ``", "` `+ A[k]);``                        ``return` `true``;``                    ``}``                ``}``            ``}``        ``}` `        ``// If we reach here,``        ``// then no triplet was found``        ``return` `false``;``    ``}` `    ``// Driver Code``    ``static` `public` `void` `Main()``    ``{``        ``int``[] A = { 1, 4, 45, 6, 10, 8 };``        ``int` `sum = 22;``        ``int` `arr_size = A.Length;` `        ``find3Numbers(A, arr_size, sum);``    ``}``}` `// This code is contributed by m_kit`

## Javascript

 ``

## PHP

 ``

Output
```Triplet is 4, 10, 8

```

Complexity Analysis:

• Time Complexity: O(n3), There are three nested loops traversing the array, so the time complexity is O(n^3)
• Auxiliary Space: O(1), As no extra space is required.

## Triplet Sum in Array (3sum) using Two pointer technique:

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 if there is a pair whose sum is equal to x â€“ array[i]. Two pointers algorithm take 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 required sum, increment the first pointer.
• Else, If the sum is bigger, Decrease the end pointer to reduce the sum.
• Else, if the sum of elements at two-pointer is equal to given sum then print the triplet and break.

Below is the implementation of the above approach:

## C++

 `// C++ program to find a triplet``#include ``using` `namespace` `std;` `// returns true if there is triplet with sum equal``// to 'sum' present in A[]. Also, prints the triplet``bool` `find3Numbers(``int` `A[], ``int` `arr_size, ``int` `sum)``{``    ``int` `l, r;``    ``/* Sort the elements */``    ``sort(A, A + arr_size);``    ``/* Now fix the first element one by one and find the``       ``other two elements */``    ``for` `(``int` `i = 0; i < arr_size - 2; i++) {` `        ``// To find the other two elements, start two index``        ``// variables from two corners of the array and move``        ``// them toward each other``        ``l = i + 1; ``// index of the first element in the``        ``// remaining elements``        ``r = arr_size - 1; ``// index of the last element``        ``while` `(l < r) {``            ``if` `(A[i] + A[l] + A[r] == sum) {``                ``printf``(``"Triplet is %d, %d, %d"``, A[i], A[l],A[r]);``                ``return` `true``;``            ``}``            ``else` `if` `(A[i] + A[l] + A[r] < sum)``                ``l++;``            ``else` `// A[i] + A[l] + A[r] > sum``                ``r--;``        ``}``    ``}``    ``// If we reach here, then no triplet was found``    ``return` `false``;``}` `/* Driver program to test above function */``int` `main()``{``    ``int` `A[] = { 1, 4, 45, 6, 10, 8 };``    ``int` `sum = 22;``    ``int` `arr_size = ``sizeof``(A) / ``sizeof``(A[0]);``    ``find3Numbers(A, arr_size, sum);``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## C

 `// C program to find a triplet``#include ``#include ``#include ` `int` `cmpfunc(``const` `void``* a, ``const` `void``* b)``{``    ``return` `(*(``int``*)a - *(``int``*)b);``}` `// returns true if there is triplet with sum equal``// to 'sum' present in A[]. Also, prints the triplet``bool` `find3Numbers(``int` `A[], ``int` `arr_size, ``int` `sum)``{``    ``int` `l, r;``  ` `    ``/* Sort the elements */``    ``qsort``(A, arr_size, ``sizeof``(``int``), cmpfunc);``  ` `    ``/* Now fix the first element one by one and find the``       ``other two elements */``    ``for` `(``int` `i = 0; i < arr_size - 2; i++)``    ``{``      ` `        ``// To find the other two elements, start two index``        ``// variables from two corners of the array and move``        ``// them toward each other``        ``l = i + 1; ``// index of the first element in the``        ``// remaining elements``        ``r = arr_size - 1; ``// index of the last element``        ``while` `(l < r) {``            ``if` `(A[i] + A[l] + A[r] == sum) {``                ``printf``(``"Triplet is %d, %d, %d"``, A[i], A[l],``                       ``A[r]);``                ``return` `true``;``            ``}``            ``else` `if` `(A[i] + A[l] + A[r] < sum)``                ``l++;``            ``else` `// A[i] + A[l] + A[r] > sum``                ``r--;``        ``}``    ``}``  ` `    ``// If we reach here, then no triplet was found``    ``return` `false``;``}` `/* Driver program to test above function */``int` `main()``{``    ``int` `A[] = { 1, 4, 45, 6, 10, 8 };``    ``int` `sum = 22;``    ``int` `arr_size = ``sizeof``(A) / ``sizeof``(A[0]);``    ``find3Numbers(A, arr_size, sum);``    ``return` `0;``}` `// This code is contributed by Aditya Kumar (adityakumar129)`

## Java

 `// Java program to find a triplet``class` `FindTriplet {` `    ``// returns true if there is triplet with sum equal``    ``// to 'sum' present in A[]. Also, prints the triplet``    ``boolean` `find3Numbers(``int` `A[], ``int` `arr_size, ``int` `sum)``    ``{``        ``int` `l, r;` `        ``/* Sort the elements */``        ``quickSort(A, ``0``, arr_size - ``1``);` `        ``/* Now fix the first element one by one and find the``           ``other two elements */``        ``for` `(``int` `i = ``0``; i < arr_size - ``2``; i++) {` `            ``// To find the other two elements, start two``            ``// index variables from two corners of the array``            ``// and move them toward each other``            ``l = i + ``1``; ``// index of the first element in the``                       ``// remaining elements``            ``r = arr_size - ``1``; ``// index of the last element``            ``while` `(l < r) {``                ``if` `(A[i] + A[l] + A[r] == sum) {``                    ``System.out.print(``"Triplet is "` `+ A[i] + ``", "` `+ A[l] + ``", "` `+ A[r]);``                    ``return` `true``;``                ``}``                ``else` `if` `(A[i] + A[l] + A[r] < sum)``                    ``l++;` `                ``else` `// A[i] + A[l] + A[r] > sum``                    ``r--;``            ``}``        ``}` `        ``// If we reach here, then no triplet was found``        ``return` `false``;``    ``}` `    ``int` `partition(``int` `A[], ``int` `si, ``int` `ei)``    ``{``        ``int` `x = A[ei];``        ``int` `i = (si - ``1``);``        ``int` `j;` `        ``for` `(j = si; j <= ei - ``1``; j++) {``            ``if` `(A[j] <= x) {``                ``i++;``                ``int` `temp = A[i];``                ``A[i] = A[j];``                ``A[j] = temp;``            ``}``        ``}``        ``int` `temp = A[i + ``1``];``        ``A[i + ``1``] = A[ei];``        ``A[ei] = temp;``        ``return` `(i + ``1``);``    ``}` `    ``/* Implementation of Quick Sort``    ``A[] --> Array to be sorted``    ``si  --> Starting index``    ``ei  --> Ending index``     ``*/``    ``void` `quickSort(``int` `A[], ``int` `si, ``int` `ei)``    ``{``        ``int` `pi;` `        ``/* Partitioning index */``        ``if` `(si < ei) {``            ``pi = partition(A, si, ei);``            ``quickSort(A, si, pi - ``1``);``            ``quickSort(A, pi + ``1``, ei);``        ``}``    ``}` `    ``// Driver program to test above functions``    ``public` `static` `void` `main(String[] args)``    ``{``        ``FindTriplet triplet = ``new` `FindTriplet();``        ``int` `A[] = { ``1``, ``4``, ``45``, ``6``, ``10``, ``8` `};``        ``int` `sum = ``22``;``        ``int` `arr_size = A.length;` `        ``triplet.find3Numbers(A, arr_size, sum);``    ``}``}`

## Python3

 `# Python3 program to find a triplet` `# returns true if there is triplet``# with sum equal to 'sum' present``# in A[]. Also, prints the triplet``def` `find3Numbers(A, arr_size, ``sum``):` `    ``# Sort the elements ``    ``A.sort()` `    ``# Now fix the first element ``    ``# one by one and find the``    ``# other two elements ``    ``for` `i ``in` `range``(``0``, arr_size``-``2``):``    `  `        ``# To find the other two elements,``        ``# start two index variables from``        ``# two corners of the array and``        ``# move them toward each other``        ` `        ``# index of the first element``        ``# in the remaining elements``        ``l ``=` `i ``+` `1``        ` `        ``# index of the last element``        ``r ``=` `arr_size``-``1``        ``while` `(l < r):``        ` `            ``if``( A[i] ``+` `A[l] ``+` `A[r] ``=``=` `sum``):``                ``print``(``"Triplet is"``, A[i], ``                     ``', '``, A[l], ``', '``, A[r]);``                ``return` `True``            ` `            ``elif` `(A[i] ``+` `A[l] ``+` `A[r] < ``sum``):``                ``l ``+``=` `1``            ``else``: ``# A[i] + A[l] + A[r] > sum``                ``r ``-``=` `1` `    ``# If we reach here, then``    ``# no triplet was found``    ``return` `False` `# Driver program to test above function ``A ``=` `[``1``, ``4``, ``45``, ``6``, ``10``, ``8``]``sum` `=` `22``arr_size ``=` `len``(A)` `find3Numbers(A, arr_size, ``sum``)` `# This is contributed by Smitha Dinesh Semwal`

## C#

 `// C# program to find a triplet``using` `System;` `class` `GFG {` `    ``// returns true if there is triplet``    ``// with sum equal to 'sum' present``    ``// in A[]. Also, prints the triplet``    ``bool` `find3Numbers(``int``[] A, ``int` `arr_size,``                      ``int` `sum)``    ``{``        ``int` `l, r;` `        ``/* Sort the elements */``        ``quickSort(A, 0, arr_size - 1);` `        ``/* Now fix the first element ``    ``one by one and find the``    ``other two elements */``        ``for` `(``int` `i = 0; i < arr_size - 2; i++) {` `            ``// To find the other two elements,``            ``// start two index variables from``            ``// two corners of the array and``            ``// move them toward each other``            ``l = i + 1; ``// index of the first element``            ``// in the remaining elements``            ``r = arr_size - 1; ``// index of the last element``            ``while` `(l < r) {``                ``if` `(A[i] + A[l] + A[r] == sum) {``                    ``Console.Write(``"Triplet is "` `+ A[i] + ``", "` `+ A[l] + ``", "` `+ A[r]);``                    ``return` `true``;``                ``}``                ``else` `if` `(A[i] + A[l] + A[r] < sum)``                    ``l++;` `                ``else` `// A[i] + A[l] + A[r] > sum``                    ``r--;``            ``}``        ``}` `        ``// If we reach here, then``        ``// no triplet was found``        ``return` `false``;``    ``}` `    ``int` `partition(``int``[] A, ``int` `si, ``int` `ei)``    ``{``        ``int` `x = A[ei];``        ``int` `i = (si - 1);``        ``int` `j;` `        ``for` `(j = si; j <= ei - 1; j++) {``            ``if` `(A[j] <= x) {``                ``i++;``                ``int` `temp = A[i];``                ``A[i] = A[j];``                ``A[j] = temp;``            ``}``        ``}``        ``int` `temp1 = A[i + 1];``        ``A[i + 1] = A[ei];``        ``A[ei] = temp1;``        ``return` `(i + 1);``    ``}` `    ``/* Implementation of Quick Sort``A[] --> Array to be sorted``si --> Starting index``ei --> Ending index``*/``    ``void` `quickSort(``int``[] A, ``int` `si, ``int` `ei)``    ``{``        ``int` `pi;` `        ``/* Partitioning index */``        ``if` `(si < ei) {``            ``pi = partition(A, si, ei);``            ``quickSort(A, si, pi - 1);``            ``quickSort(A, pi + 1, ei);``        ``}``    ``}` `    ``// Driver Code``    ``static` `void` `Main()``    ``{``        ``GFG triplet = ``new` `GFG();``        ``int``[] A = ``new` `int``[] { 1, 4, 45, 6, 10, 8 };``        ``int` `sum = 22;``        ``int` `arr_size = A.Length;` `        ``triplet.find3Numbers(A, arr_size, sum);``    ``}``}` `// This code is contributed by mits`

## Javascript

 ``

## PHP

 ` sum``                ``\$r``--;``        ``}``    ``}` `    ``// If we reach here, then``    ``// no triplet was found``    ``return` `false;``}` `// Driver Code``\$A` `= ``array` `(1, 4, 45, 6, 10, 8);``\$sum` `= 22;``\$arr_size` `= sizeof(``\$A``);` `find3Numbers(``\$A``, ``\$arr_size``, ``\$sum``);` `// This code is contributed by ajit``?>`

Output
```Triplet is 4, 8, 10

```

Complexity Analysis:

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

## Triplet Sum in Array (3sum) using Hashing:

This approach uses extra space but is simpler than the two-pointers approach. Run two loops outer loop from start to end and inner loop from i+1 to end. Create a hashmap or set to store the elements in between i+1 to n-1. So if the given sum is x, check if there is a number in the set which is equal to x – arr[i] – arr[j]. If yes print the triplet.

Step-by-step approach:

• Iterate through the array, fixing the first element (A[i]) for the triplet.
• For each A[i], use a Hashmap to store potential second elements that complete the desired sum (sum – A[i]).
• Inside a nested loop, check if the difference between the current element (A[j]) and the desired sum (sum – A[i]) is present in the Hashmap. If it is, a triplet is found, then print it.
• If no triplet is found in the entire array, the function returns false.

Below is the implementation of the above approach:

## C++

 `#include ``using` `namespace` `std;` `// Function to find a triplet with a given sum in an array``bool` `find3Numbers(``int` `A[], ``int` `arr_size, ``int` `sum)``{``    ``// Fix the first element as A[i]``    ``for` `(``int` `i = 0; i < arr_size - 2; i++) {` `        ``// Create a set to store potential second elements``        ``// that complement the desired sum``        ``unordered_set<``int``> s;` `        ``// Calculate the current sum needed to reach the``        ``// target sum``        ``int` `curr_sum = sum - A[i];` `        ``// Iterate through the subarray A[i+1..n-1] to find``        ``// a pair with the required sum``        ``for` `(``int` `j = i + 1; j < arr_size; j++) {` `            ``// Calculate the required value for the second``            ``// element``            ``int` `required_value = curr_sum - A[j];` `            ``// Check if the required value is present in the``            ``// set``            ``if` `(s.find(required_value) != s.end()) {` `                ``// Triplet is found; print the triplet``                ``// elements``                ``printf``(``"Triplet is %d, %d, %d"``, A[i], A[j],``                       ``required_value);``                ``return` `true``;``            ``}` `            ``// Add the current element to the set for future``            ``// complement checks``            ``s.insert(A[j]);``        ``}``    ``}` `    ``// If no triplet is found, return false``    ``return` `false``;``}` `/* Driver program to test above function */``int` `main()``{``    ``int` `A[] = { 1, 4, 45, 6, 10, 8 };``    ``int` `sum = 22;``    ``int` `arr_size = ``sizeof``(A) / ``sizeof``(A[0]);` `    ``// Call the find3Numbers function to find and print the``    ``// triplet, if it exists``    ``find3Numbers(A, arr_size, sum);` `    ``return` `0;``}`

## Java

 `import` `java.util.HashSet;` `public` `class` `TripletSumFinder {` `    ``// Function to find a triplet with a given sum in an``    ``// array``    ``public` `static` `boolean``    ``find3Numbers(``int``[] A, ``int` `arr_size, ``int` `sum)``    ``{``        ``// Fix the first element as A[i]``        ``for` `(``int` `i = ``0``; i < arr_size - ``2``; i++) {` `            ``// Create a HashSet to store potential second``            ``// elements that complement the desired sum``            ``HashSet s = ``new` `HashSet<>();` `            ``// Calculate the current sum needed to reach the``            ``// target sum``            ``int` `curr_sum = sum - A[i];` `            ``// Iterate through the subarray A[i+1..n-1] to``            ``// find a pair with the required sum``            ``for` `(``int` `j = i + ``1``; j < arr_size; j++) {` `                ``// Calculate the required value for the``                ``// second element``                ``int` `required_value = curr_sum - A[j];` `                ``// Check if the required value is present in``                ``// the HashSet``                ``if` `(s.contains(required_value)) {` `                    ``// Triplet is found; print the triplet``                    ``// elements``                    ``System.out.println(``"Triplet is "` `+ A[i]``                                       ``+ ``", "` `+ A[j] + ``", "``                                       ``+ required_value);``                    ``return` `true``;``                ``}` `                ``// Add the current element to the HashSet``                ``// for future complement checks``                ``s.add(A[j]);``            ``}``        ``}` `        ``// If no triplet is found, return false``        ``return` `false``;``    ``}` `    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[] A = { ``1``, ``4``, ``45``, ``6``, ``10``, ``8` `};``        ``int` `sum = ``22``;``        ``int` `arr_size = A.length;` `        ``// Call the find3Numbers function to find and print``        ``// the triplet, if it exists``        ``if` `(!find3Numbers(A, arr_size, sum)) {``            ``System.out.println(``                ``"No triplet found with the given sum."``);``        ``}``    ``}``}`

## Python3

 `# Function to find a triplet with a given sum in an array``def` `find3Numbers(arr, ``sum``):` `    ``# Fix the first element as arr[i]``    ``for` `i ``in` `range``(``len``(arr) ``-` `2``):` `        ``# Create a set to store potential second elements that complement the desired sum``        ``s ``=` `set``()` `        ``# Calculate the current sum needed to reach the target sum``        ``curr_sum ``=` `sum` `-` `arr[i]` `        ``# Iterate through the subarray arr[i+1:]``        ``for` `j ``in` `range``(i ``+` `1``, ``len``(arr)):` `            ``# Calculate the required value for the second element``            ``required_value ``=` `curr_sum ``-` `arr[j]` `            ``# Check if the required value is present in the set``            ``if` `required_value ``in` `s:` `                ``# Triplet is found; print the triplet elements``                ``print``(f``"Triplet is {arr[i]}, {arr[j]}, {required_value}"``)``                ``return` `True` `            ``# Add the current element to the set for future complement checks``            ``s.add(arr[j])` `    ``# If no triplet is found, return False``    ``return` `False`  `# Driver program to test above function``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``1``, ``4``, ``45``, ``6``, ``10``, ``8``]``    ``target_sum ``=` `22` `    ``# Call the find3Numbers function to find and print the triplet, if it exists``    ``if` `not` `find3Numbers(arr, target_sum):``        ``print``(``"No triplet found."``)`

## C#

 `using` `System;``using` `System.Collections.Generic;` `class` `Program {``    ``// Function to find a triplet with a given sum in an``    ``// array``    ``static` `bool` `Find3Numbers(``int``[] arr, ``int` `sum)``    ``{``        ``// Fix the first element as arr[i]``        ``for` `(``int` `i = 0; i < arr.Length - 2; i++) {``            ``// Create a HashSet to store potential second``            ``// elements that complement the desired sum``            ``HashSet<``int``> s = ``new` `HashSet<``int``>();` `            ``// Calculate the current sum needed to reach the``            ``// target sum``            ``int` `curr_sum = sum - arr[i];` `            ``// Iterate through the subarray arr[i+1:]``            ``for` `(``int` `j = i + 1; j < arr.Length; j++) {``                ``// Calculate the required value for the``                ``// second element``                ``int` `required_value = curr_sum - arr[j];` `                ``// Check if the required value is present in``                ``// the HashSet``                ``if` `(s.Contains(required_value)) {``                    ``// Triplet is found; print the triplet``                    ``// elements``                    ``Console.WriteLine(``"Triplet is "` `+ arr[i]``                                      ``+ ``", "` `+ arr[j] + ``", "``                                      ``+ required_value);``                    ``return` `true``;``                ``}` `                ``// Add the current element to the HashSet``                ``// for future complement checks``                ``s.Add(arr[j]);``            ``}``        ``}` `        ``// If no triplet is found, return false``        ``return` `false``;``    ``}` `    ``// Driver program to test the Find3Numbers function``    ``static` `void` `Main()``    ``{``        ``int``[] arr = { 1, 4, 45, 6, 10, 8 };``        ``int` `target_sum = 22;` `        ``// Call the Find3Numbers function to find and print``        ``// the triplet, if it exists``        ``if` `(!Find3Numbers(arr, target_sum)) {``            ``Console.WriteLine(``"No triplet found."``);``        ``}``    ``}``}`

## Javascript

 `function` `find3Numbers(A, sum) {``  ``// Fix the first element as A[i]``  ``for` `(let i = 0; i < A.length - 2; i++) {``    ``// Create a Set to store potential second elements that complement the desired sum``    ``const s = ``new` `Set();` `    ``// Calculate the current sum needed to reach the target sum``    ``const currSum = sum - A[i];` `    ``// Iterate through the subarray A[i+1..n-1] to find a pair with the required sum``    ``for` `(let j = i + 1; j < A.length; j++) {``      ``// Calculate the required value for the second element``      ``const requiredValue = currSum - A[j];` `      ``// Check if the required value is present in the Set``      ``if` `(s.has(requiredValue)) {``        ``// Triplet is found; print the triplet elements``        ``console.log(`Triplet is \${A[i]}, \${A[j]}, \${requiredValue}`);``        ``return` `true``;``      ``}` `      ``// Add the current element to the Set for future complement checks``      ``s.add(A[j]);``    ``}``  ``}` `  ``// If no triplet is found, return false``  ``return` `false``;``}` `function` `main() {``  ``const A = [1, 4, 45, 6, 10, 8];``  ``const sum = 22;` `  ``// Call the find3Numbers function to find and print the triplet, if it exists``  ``if` `(!find3Numbers(A, sum)) {``    ``console.log(``"No triplet found with the given sum."``);``  ``}``}` `// Call the main function to start the program``main();`

Output
`Triplet is 4, 8, 10`

Time complexity: O(N^2)
Auxiliary Space: O(N), since n extra space has been taken

You can watch the explanation of the problem on YouTube discussed By Geeks For Geeks Team.

You can also refer this video present on Youtube.
How to print all triplets with given sum?
Refer Find all triplets with zero sum

Previous
Next