Equilibrium Index

3 Sum - Triplet Sum in Array

Last Updated : 02 Jan, 2025

Try it on GfG Practice

Given an array arr[] of size n and an integer sum, the task is to check if there is a triplet in the array which sums up to the given target sum.

Examples:

Input: arr[] = [1, 4, 45, 6, 10, 8], target = 13
Output: true
Explanation: The triplet [1, 4, 8] sums up to 13
Input: arr[] = [1, 2, 4, 3, 6, 7], target = 10
Output: true
Explanation: The triplets [1, 3, 6] and [1, 2, 7] both sum to 10.
Input: arr[] = [40, 20, 10, 3, 6, 7], sum = 24
Output: false
Explanation: No triplet in the array sums to 24.

Table of Content

[Naive Approach] Generating All Triplets - O(n^3) Time and O(1) Space
[Better Approach] - Hash Set - O(n^2) Time and O(n) Space
[Expected Approach] - Sorting and Two Pointer - O(n^2) Time and O(1) Space

[Naive Approach] Generating All Triplets - O(n^3) Time and O(1) Space

A simple method is to generate all possible triplets and compare the sum of every triplet with the given target. If the sum is equal to target, return true. Otherwise, return false.

C++

// C++ Program to check for triplet sum by generating
// all triplets

#include <iostream>
#include <vector>
using namespace std;

bool hasTripletSum(vector<int>& arr, int target) {
    int n = arr.size();
    
    // Fix the first element as arr[i] 
    for (int i = 0; i < n - 2; i++) {
      
        // Fix the second element as arr[j] 
        for (int j = i + 1; j < n - 1; j++) {
            
            // Now look for the third number 
            for (int k = j + 1; k < n; k++) { 
                if (arr[i] + arr[j] + arr[k] == target)
                    return true; 
            } 
        } 
    } 

    // If we reach here, then no triplet was found 
    return false; 
} 

int main() { 
    vector<int> arr = { 1, 4, 45, 6, 10, 8 }; 
    int target = 13; 
    if(hasTripletSum(arr, target))
        cout << "true";
    else
        cout << "false";
    return 0; 
}

C

// C Program to check for triplet sum by generating
// all triplets

#include <stdio.h>
#include <stdbool.h>

bool hasTripletSum(int arr[], int n, int target) {
    
    // Fix the first element as arr[i] 
    for (int i = 0; i < n - 2; i++) {
      
        // Fix the second element as arr[j] 
        for (int j = i + 1; j < n - 1; j++) {
            
            // Now look for the third number 
            for (int k = j + 1; k < n; k++) { 
                if (arr[i] + arr[j] + arr[k] == target)
                    return true;  
            } 
        } 
    } 

    // If we reach here, then no triplet was found 
    return false; 
} 

int main() { 
    int arr[] = { 1, 4, 45, 6, 10, 8 }; 
    int target = 13; 
    int n = sizeof(arr) / sizeof(arr[0]);
    
    if (hasTripletSum(arr, n, target))
        printf("true");
    else
        printf("false");
    return 0; 
}

Java

// Java Program to check for triplet sum by generating
// all triplets

import java.util.*;
class GfG {
  
    // Function to check if there exists a triplet with the given sum
    static boolean hasTripletSum(int[] arr, int target) {
        int n = arr.length;
        
        // Fix the first element as arr[i]
        for (int i = 0; i < n - 2; i++) {
            
            // Fix the second element as arr[j]
            for (int j = i + 1; j < n - 1; j++) {
                
                // Now look for the third number
                for (int k = j + 1; k < n; k++) {
                    if (arr[i] + arr[j] + arr[k] == target)
                        return true; // If a triplet is found
                }
            }
        }

        // If we reach here, then no triplet was found
        return false;
    }

    public static void main(String[] args) {
        int[] arr = { 1, 4, 45, 6, 10, 8 };
        int target = 13;
        
        if (hasTripletSum(arr, target))
            System.out.println("true");
        else
            System.out.println("false");
    }
}

Python

# Python Program to check for triplet sum by generating
# all triplets

def hasTripletSum(arr, target):
    n = len(arr)
    
    # Fix the first element as arr[i]
    for i in range(n - 2):
        
        # Fix the second element as arr[j]
        for j in range(i + 1, n - 1):
            
            # Now look for the third number
            for k in range(j + 1, n):
                if arr[i] + arr[j] + arr[k] == target:
                    return True
    
    # If we reach here, then no triplet was found
    return False

if __name__ == "__main__":
    arr = [1, 4, 45, 6, 10, 8]
    target = 13
    if hasTripletSum(arr, target):
        print("true")
    else:
        print("false")

C#

// C# Program to check for triplet sum by generating
// all triplets

using System;

class GfG {
    static bool hasTripletSum(int[] arr, int target) {
        int n = arr.Length;

        // Fix the first element as arr[i]
        for (int i = 0; i < n - 2; i++) {
            
            // Fix the second element as arr[j]
            for (int j = i + 1; j < n - 1; j++) {
                
                // Now look for the third number
                for (int k = j + 1; k < n; k++) {
                    if (arr[i] + arr[j] + arr[k] == target)
                        return true;
                }
            }
        }

        // If we reach here, then no triplet was found
        return false;
    }

    static void Main() {
        int[] arr = { 1, 4, 45, 6, 10, 8 };
        int target = 13;
        if (hasTripletSum(arr, target))
            Console.WriteLine("true");
        else
            Console.WriteLine("false");
    }
}

JavaScript

// JavaScript Program to check for triplet sum by generating
// all triplets

function hasTripletSum(arr, target) {
    let n = arr.length;
    
    // Fix the first element as arr[i]
    for (let i = 0; i < n - 2; i++) {
        
        // Fix the second element as arr[j]
        for (let j = i + 1; j < n - 1; j++) {
            
            // Now look for the third number
            for (let k = j + 1; k < n; k++) {
                if (arr[i] + arr[j] + arr[k] === target)
                    return true;
            }
        }
    }

    // If we reach here, then no triplet was found
    return false;
}

// Driver code
let arr = [1, 4, 45, 6, 10, 8];
let target = 13;
if (hasTripletSum(arr, target))
    console.log("true");
else
    console.log("false");

Output

true

[Better Approach] - Hash Set - O(n^2) Time and O(n) Space

The idea is to traverse every element arr[i] in a loop. For every arr[i], use the hashing based solution of 2 Sum Problem to check if there is a pair with sum equal to given sum - arr[i] . Below is the Step-by-step approach:

Iterate through the array, fixing the first element (arr[i]) for the triplet.
For each arr[i], use a Hash Set to store potential second elements and run another loop inside it for j from i+1 to n-1.
Inside a nested loop, check if given sum - arr[i] - arr[j] is present in the hash set. If yes, then print the triplet.
If no triplet is found in the entire array, the function returns false.

C++

// C++ Program to check for triplet sum using Hash Set

#include <iostream>
#include <vector>
#include <unordered_set>
using namespace std;

bool hasTripletSum(vector<int>& arr, int target) {
    int n = arr.size();
    
    // Fix the first element as arr[i] 
    for (int i = 0; i < n - 2; i++) {
      
        // Hash set to store potential second elements
        unordered_set<int> st;
      
        // Fix the third element as arr[j]
        for(int j = i + 1; j < n; j++) {
            int second = target - arr[i] - arr[j];
          
            // Search for second element in hash set
        	if(st.find(second) != st.end()) {
            	return true;
            }
          
            // Add arr[j] as a potential second element
            st.insert(arr[j]);
        }
    } 

    // If we reach here, then no triplet was found 
    return false; 
} 

int main() { 
    vector<int> arr = { 1, 4, 45, 6, 10, 8 }; 
    int target = 13; 
    if(hasTripletSum(arr, target))
        cout << "true";
    else
        cout << "false";
    return 0; 
}

Java

// Java Program to check for triplet sum using Hash Set

import java.util.HashSet;
import java.util.Set;

class GfG {
    static boolean hasTripletSum(int[] arr, int target) {
        int n = arr.length;
        
        // Fix the first element as arr[i]
        for (int i = 0; i < n - 2; i++) {
            
            // Hash set to store potential second elements
            Set<Integer> st = new HashSet<>();
            
            // Fix the third element as arr[j]
            for (int j = i + 1; j < n; j++) {
                int second = target - arr[i] - arr[j];
                
                // Search for second element in hash set
                if (st.contains(second)) {
                    return true;
                }
                
                // Add arr[j] as a potential second element
                st.add(arr[j]);
            }
        }

        // If we reach here, then no triplet was found
        return false;
    }

    public static void main(String[] args) {
        int[] arr = { 1, 4, 45, 6, 10, 8 };
        int target = 13;
        if (hasTripletSum(arr, target))
            System.out.println("true");
        else
            System.out.println("false");
    }
}

Python

# Python Program to check for triplet sum using Hash Set

def hasTripletSum(arr, target):
    n = len(arr)
    
    # Fix the first element as arr[i]
    for i in range(n - 2):
        
        # Hash set to store potential second elements
        st = set()
        
        # Fix the third element as arr[j]
        for j in range(i + 1, n):
            second = target - arr[i] - arr[j]
            
            # Search for second element in hash set
            if second in st:
                return True
            
            # Add arr[j] as a potential second element
            st.add(arr[j])
    
    # If we reach here, then no triplet was found
    return False

if __name__ == "__main__":
    arr = [1, 4, 45, 6, 10, 8]
    target = 13
    if hasTripletSum(arr, target):
        print("true")
    else:
        print("false")

C#

// C# Program to check for triplet sum using Hash Set

using System;
using System.Collections.Generic;

class GfG {
    static bool hasTripletSum(int[] arr, int target) {
        int n = arr.Length;
        
        // Fix the first element as arr[i]
        for (int i = 0; i < n - 2; i++) {
            
            // Hash set to store potential second elements
            HashSet<int> st = new HashSet<int>();
            
            // Fix the third element as arr[j]
            for (int j = i + 1; j < n; j++) {
                int second = target - arr[i] - arr[j];
                
                // Search for second element in hash set
                if (st.Contains(second))
                    return true;
                
                // Add arr[j] as a potential second element
                st.Add(arr[j]);
            }
        }

        // If we reach here, then no triplet was found
        return false;
    }

    static void Main(string[] args) {
        int[] arr = { 1, 4, 45, 6, 10, 8 };
        int target = 13;
        if (hasTripletSum(arr, target))
            Console.WriteLine("true");
        else
            Console.WriteLine("false");
    }
}

JavaScript

// JavaScript Program to check for triplet sum using Hash Set

function hasTripletSum(arr, target) {
    let n = arr.length;
    
    // Fix the first element as arr[i]
    for (let i = 0; i < n - 2; i++) {
        
        // Hash set to store potential second elements
        let st = new Set();
        
        // Fix the third element as arr[j]
        for (let j = i + 1; j < n; j++) {
            let second = target - arr[i] - arr[j];
            
            // Search for second element in hash set
            if (st.has(second)) {
                return true;
            }
            
            // Add arr[j] as a potential second element
            st.add(arr[j]);
        }
    }

    // If we reach here, then no triplet was found
    return false;
}

// Driver code
let arr = [1, 4, 45, 6, 10, 8];
let target = 13;
if (hasTripletSum(arr, target))
    console.log("true");
else
    console.log("false");

Output

true

[Expected Approach] - Sorting and Two Pointer - O(n^2) Time and O(1) Space

We first sort the array. After sorting, we traverse every element arr[i] in a loop. For every arr[i], use the Two Pointer Technique based solution of 2 Sum Problem to check if there is a pair with sum equal to given sum - arr[i].

C++

// C++ Program to check for triplet sum using Sorting
// and Two Pointer Technique

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

bool hasTripletSum(vector<int>& arr, int target) {
    int n = arr.size();
    sort(arr.begin(), arr.end());
    
    // Fix the first element as arr[i] 
    for (int i = 0; i < n - 2; i++) {
      
        // Initialize left and right pointers with 
        // start and end of remaining subarray
        int l = i + 1, r = n - 1;
      
        int requiredSum = target - arr[i];
        while(l < r) {
            if(arr[l] + arr[r] == requiredSum)
                return true;
            if(arr[l] + arr[r] < requiredSum)
                l++;
            else if(arr[l] + arr[r] > requiredSum)
                r--;
        }
    } 

    // If we reach here, then no triplet was found 
    return false; 
} 

int main() { 
    vector<int> arr = { 1, 4, 45, 6, 10, 8 }; 
    int target = 13; 
    if(hasTripletSum(arr, target))
        cout << "true";
    else
        cout << "false";
    return 0; 
}

C

// C Program to check for triplet sum using Sorting
// and Two Pointer Technique

#include <stdio.h>

// Function to compare integers for sorting (used by qsort)
int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int hasTripletSum(int arr[], int n, int target) {
    qsort(arr, n, sizeof(int), compare);
    
    // Fix the first element as arr[i]
    for (int i = 0; i < n - 2; i++) {
        
        // Initialize left and right pointers with 
        // start and end of remaining subarray
        int l = i + 1, r = n - 1;
        
        int requiredSum = target - arr[i];
        while (l < r) {
            if (arr[l] + arr[r] == requiredSum)
                return 1;
            if (arr[l] + arr[r] < requiredSum)
                l++;
            else if (arr[l] + arr[r] > requiredSum)
                r--;
        }
    }

    // If we reach here, then no triplet was found
    return 0; 
}

int main() {
    int arr[] = { 1, 4, 45, 6, 10, 8 };
    int target = 13;
    int n = sizeof(arr) / sizeof(arr[0]);
    
    if (hasTripletSum(arr, n, target))
        printf("true");
    else
        printf("false");
    return 0;
}

Java

// Java Program to check for triplet sum using Sorting
// and Two Pointer Technique

import java.util.Arrays;

class GfG {
    static boolean hasTripletSum(int[] arr, int target) {
        int n = arr.length;
        Arrays.sort(arr);
        
        // Fix the first element as arr[i]
        for (int i = 0; i < n - 2; i++) {
            
            // Initialize left and right pointers with 
            // start and end of remaining subarray
            int l = i + 1, r = n - 1;
            
            int requiredSum = target - arr[i];
            while (l < r) {
                if (arr[l] + arr[r] == requiredSum)
                    return true;
                if (arr[l] + arr[r] < requiredSum)
                    l++;
                else if (arr[l] + arr[r] > requiredSum)
                    r--;
            }
        }

        // If we reach here, then no triplet was found
        return false;
    }

    public static void main(String[] args) {
        int[] arr = { 1, 4, 45, 6, 10, 8 };
        int target = 13;
        if (hasTripletSum(arr, target))
            System.out.println("true");
        else
            System.out.println("false");
    }
}

Python

# Python Program to check for triplet sum using Sorting
# and Two Pointer Technique

def hasTripletSum(arr, target):
    n = len(arr)
    arr.sort()
    
    # Fix the first element as arr[i]
    for i in range(n - 2):
        
        # Initialize left and right pointers with 
        # start and end of remaining subarray
        l = i + 1
        r = n - 1
        
        requiredSum = target - arr[i]
        while l < r:
            if arr[l] + arr[r] == requiredSum:
                return True
            if arr[l] + arr[r] < requiredSum:
                l += 1
            else:
                r -= 1
    
    # If we reach here, then no triplet was found
    return False

if __name__ == "__main__":
    arr = [1, 4, 45, 6, 10, 8]
    target = 13
    if hasTripletSum(arr, target):
        print("true")
    else:
        print("false")

C#

// C# Program to check for triplet sum using Sorting
// and Two Pointer Technique

using System;
class GfG {
    static bool hasTripletSum(int[] arr, int target) {
        int n = arr.Length;
        Array.Sort(arr);
        
        // Fix the first element as arr[i]
        for (int i = 0; i < n - 2; i++) {
            
            // Initialize left and right pointers with 
            // start and end of remaining subarray
            int l = i + 1, r = n - 1;
            
            int requiredSum = target - arr[i];
            while (l < r) {
                if (arr[l] + arr[r] == requiredSum)
                    return true;
                if (arr[l] + arr[r] < requiredSum)
                    l++;
                else if (arr[l] + arr[r] > requiredSum)
                    r--;
            }
        }

        // If we reach here, then no triplet was found
        return false;
    }

    static void Main(string[] args) {
        int[] arr = { 1, 4, 45, 6, 10, 8 };
        int target = 13;
        if (hasTripletSum(arr, target))
            Console.WriteLine("true");
        else
            Console.WriteLine("false");
    }
}

JavaScript

// JavaScript Program to check for triplet sum using Sorting
// and Two Pointer Technique

function hasTripletSum(arr, target) {
    let n = arr.length;
    arr.sort((a, b) => a - b);
    
    // Fix the first element as arr[i]
    for (let i = 0; i < n - 2; i++) {
        
        // Initialize left and right pointers with 
        // start and end of remaining subarray
        let l = i + 1, r = n - 1;
        
        let requiredSum = target - arr[i];
        while (l < r) {
            if (arr[l] + arr[r] == requiredSum)
                return true;
            if (arr[l] + arr[r] < requiredSum)
                l++;
            else if (arr[l] + arr[r] > requiredSum)
                r--;
        }
    }

    // If we reach here, then no triplet was found
    return false;
}

// Driver code
let arr = [1, 4, 45, 6, 10, 8];
let target = 13;
if (hasTripletSum(arr, target))
    console.log("true");
else
    console.log("false");

Output

true

Related Problems

Please refer 3Sum - Complete Tutorial for all list of problems on triplets in an array.

Equilibrium Index

K

kartik

Improve

Article Tags :

Practice Tags :

Similar Reads

Array Data Structure

Complete Guide to ArraysLearn more about Array in DSA Self Paced CoursePractice Problems on ArraysTop Quizzes on Arrays What is Array?An array is a collection of items stored at contiguous memory locations. The idea is to store multiple items of the same type together. This makes it easier to calcul

Array is a linear data structure where all elements are arranged sequentially. It is a collection of elements of same data type stored at contiguous memory locations. For simplicity, we can think of an array as a flight of stairs where on each step is placed a value (let's say one of your friends).

Getting Started with Array Data Structure

Array is a collection of items of the same variable type that are stored at contiguous memory locations. It is one of the most popular and simple data structures used in programming. Basic terminologies of ArrayArray Index: In an array, elements are identified by their indexes. Array index starts fr

Applications, Advantages and Disadvantages of Array

Array is a linear data structure that is a collection of data elements of same types. Arrays are stored in contiguous memory locations. It is a static data structure with a fixed size. Applications of Array Data Structure:Arrays mainly have advantages like random access and cache friendliness over o

Subarrays, Subsequences, and Subsets in Array

What is a Subarray?AÂ subarrayÂ is a contiguous part of array, i.e., Subarray is an array that is inside another array. In general, for an array of size n, there areÂ n*(n+1)/2Â non-empty subarrays. For example, Consider the array [1, 2, 3, 4], There are 10 non-empty sub-arrays. The subarrays are: (1),

Top 50 Array Coding Problems for Interviews

Array is one of the most widely used data structure and is frequently asked in coding interviews to the problem solving skills. The following list of 50 array coding problems covers a range of difficulty levels, from easy to hard, to help candidates prepare for interviews.Easy ProblemsSecond Largest