Open In App

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:

Below is the implementation of the above approach:




#include <bits/stdc++.h>
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




#include <stdio.h>
 
// 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 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 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# 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




<script>
 
// Javascript program to find a triplet
// returns true if there is triplet with sum equal
// to 'sum' present in A[]. Also, prints the triplet
function find3Numbers(A, arr_size, sum)
{
    let l, r;
 
    // Fix the first element as A[i]
    for (let i = 0; i < arr_size - 2; i++)
    {
 
        // Fix the second element as A[j]
        for (let j = i + 1; j < arr_size - 1; j++)
        {
 
            // Now look for the third number
            for (let k = j + 1; k < arr_size; k++)
            {
                if (A[i] + A[j] + A[k] == sum)
                {
                    document.write("Triplet is " + A[i] +
                        ", " + A[j] + ", " + A[k]);
                    return true;
                }
            }
        }
    }
 
    // If we reach here, then no triplet was found
    return false;
}
 
/* Driver code */
  
    let A = [ 1, 4, 45, 6, 10, 8 ];
    let sum = 22;
    let arr_size = A.length;
    find3Numbers(A, arr_size, sum);
     
// This code is contributed by Mayank Tyagi
 
</script>




<?php
// PHP 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
function find3Numbers($A, $arr_size, $sum)
{
    $l; $r;
 
    // Fix the first
    // element as A[i]
    for ($i = 0;
         $i < $arr_size - 2; $i++)
    {
    // Fix the second
    // element as A[j]
    for ($j = $i + 1;
         $j < $arr_size - 1; $j++)
    {
        // Now look for the
        // third number
        for ($k = $j + 1;
             $k < $arr_size; $k++)
        {
            if ($A[$i] + $A[$j] +
                $A[$k] == $sum)
            {
                echo "Triplet is", " ", $A[$i],
                                  ", ", $A[$j],
                                  ", ", $A[$k];
                return true;
            }
        }
    }
    }
 
    // 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, 10, 8



Complexity Analysis: 

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:

Below is the implementation of the above approach:




// C++ program to find a triplet
#include <bits/stdc++.h>
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 program to find a triplet
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
 
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 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 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# 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




<script>
 
// Javascript program to find a triplet
 
// returns true if there is triplet with sum equal
// to 'sum' present in A[]. Also, prints the triplet
function find3Numbers(A, arr_size, sum)
{
    let l, r;
 
    /* Sort the elements */
    A.sort((a,b) => a-b);
 
    /* Now fix the first element one
    by one and find the
    other two elements */
    for (let 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
         
        // index of the first element in the
        l = i + 1;
         
        // remaining elements
         
       // index of the last element
        r = arr_size - 1;
        while (l < r) {
            if (A[i] + A[l] + A[r] == sum)
            {
            document.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;
}
 
/* Driver program to test above function */
 
    let A = [ 1, 4, 45, 6, 10, 8 ];
    let sum = 22;
    let arr_size = A.length;
 
    find3Numbers(A, arr_size, sum);
 
 
// This code is contributed by Mayank Tyagi
 
</script>




<?php
// PHP program to find a triplet
 
// returns true if there is
// triplet with sum equal to
// 'sum' present in A[]. Also,
// prints the triplet
function find3Numbers($A, $arr_size, $sum)
{
    $l; $r;
 
    /* Sort the elements */
    sort($A);
 
    /* Now fix the first element
    one by one and find the
    other two elements */
    for ($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
 
        // index of the last element
        $r = $arr_size - 1;
        while ($l < $r)
        {
            if ($A[$i] + $A[$l] +
                $A[$r] == $sum)
            {
                echo "Triplet is ", $A[$i], " ",
                                    $A[$l], " ",
                                    $A[$r], "\n";
                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 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: 

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:

Below is the implementation of the above approach:




#include <bits/stdc++.h>
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;
}




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<Integer> 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.");
        }
    }
}




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




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.");
        }
    }
}




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


Article Tags :