3 Sum - Count Triplets With Given Sum In Sorted Array
Last Updated :
10 Feb, 2025
Given a sorted array arr[] and a target value, the task is to find the count of triplets present in the given array having sum equal to the given target.
More specifically, the task is to count triplets (i, j, k) of valid indices, such that arr[i] + arr[j] + arr[k] = target and i < j < k.
Examples:
Input: arr[] = [-3, -1, -1, 0, 1, 2], target = -2
Output: 4
Explanation: Two triplets that add up to -2 are:
arr[0] + arr[3] + arr[4] = (-3) + 0 + (1) = -2
arr[0] + arr[1] + arr[5] = (-3) + (-1) + (2) = -2
arr[0] + arr[2] + arr[5] = (-3) + (-1) + (2) = -2
arr[1] + arr[2] + arr[3] = (-1) + (-1) + (0) = -2
Input: arr[] = [-2, 0, 1, 1, 5], target = 1
Output: 0
Explanation: There is no triplet whose sum is equal to 1.
We have discussed two approaches, that works for both sorted and unsorted arrays, in the post 3 Sum - Count all triplets with given sum. Now in case the given array is already sorted, we can further optimize the space using two pointers technique.
Using Two Pointers Technique
The idea is to fix the first element of the triplet at index i and then using two pointers technique to count the other two elements. For each index i, initialize left pointer to i + 1 and right pointer to n - 1.
For each triplet, calculate the sum as arr[i] + arr[left] + arr[right] and evaluate:
- If sum = target: A valid triplet is found. Additionally, handle duplicates by counting the frequencies of arr[left] and arr[right] and updating the result accordingly. Then move both pointers to the next distinct values.
- If sum < target: Increment the left pointer to explore larger values and increase the sum.
- If sum > target: Decrement the right pointer to explore smaller values and decrease the sum.
C++
// C++ program to count all triplets having sum equal to
// target by exploring all possible triplets
#include <iostream>
#include <vector>
using namespace std;
int countTriplets(vector<int> &arr, int target) {
int n = arr.size();
int res = 0;
// Iterate through each element as the first element of the triplet
for (int i = 0; i < n - 2; i++) {
int left = i + 1, right = n - 1;
// Use two-pointer approach to find triplets
while (left < right) {
// Calculate the sum of the triplet
int sum = arr[i] + arr[left] + arr[right];
// If sum is smaller, move to bigger values
if (sum < target) {
left += 1;
}
// If sum is greater, move to smaller values
else if (sum > target) {
right -= 1;
}
else if (sum == target) {
int ele1 = arr[left], ele2 = arr[right];
int cnt1 = 0, cnt2 = 0;
// Count frequency of the current value at 'left'
while (left <= right && arr[left] == ele1) {
left++;
cnt1++;
}
// Count frequency of the current value at 'right'
while (left <= right && arr[right] == ele2) {
right--;
cnt2++;
}
// If both the elements are same, then count of
// pairs = the number of ways to choose 2
// elements among cnt1 elements
if (ele1 == ele2)
res += (cnt1 * (cnt1 - 1)) / 2;
// If the elements are different, then count of
// pairs = product of the count of both elements
else
res += (cnt1 * cnt2);
}
}
}
return res;
}
int main() {
vector<int> arr = {-3, -1, -1, 0, 1, 2};
int target = -2;
cout << countTriplets(arr, target) << endl;
return 0;
}
// Java program to count all triplets having sum equal to
// target by exploring all possible triplets
import java.util.*;
class GfG {
// Function to count triplets whose sum equals the target
static int countTriplets(int[] arr, int target) {
int n = arr.length;
int res = 0;
// Iterate through each element as the first element
// of the triplet
for (int i = 0; i < n - 2; i++) {
int left = i + 1, right = n - 1;
// Use two-pointer approach to find triplets
while (left < right) {
// Calculate the sum of the triplet
int sum = arr[i] + arr[left] + arr[right];
// If sum is smaller, move to bigger values
if (sum < target) {
left += 1;
}
// If sum is greater, move to smaller values
else if (sum > target) {
right -= 1;
}
// If sum is equal, check for frequency of elements
else if (sum == target) {
int ele1 = arr[left], ele2 = arr[right];
int cnt1 = 0, cnt2 = 0;
// Count frequency of the current value at 'left'
while (left <= right && arr[left] == ele1) {
left++;
cnt1++;
}
// Count frequency of the current value at 'right'
while (left <= right && arr[right] == ele2) {
right--;
cnt2++;
}
// If both the elements are the same, then count
// of pairs = the number of ways to choose 2
// elements among cnt1 elements
if (ele1 == ele2)
res += (cnt1 * (cnt1 - 1)) / 2;
// If the elements are different, then count of
// pairs = product of the count of both elements
else
res += (cnt1 * cnt2);
}
}
}
return res;
}
public static void main(String[] args) {
int[] arr = {-3, -1, -1, 0, 1, 2};
int target = -2;
System.out.println(countTriplets(arr, target));
}
}
# Python program to count all triplets having sum equal to
# target by exploring all possible triplets
def countTriplets(arr, target):
n = len(arr)
res = 0
# Iterate through each element as the first element of the triplet
for i in range(n - 2):
left = i + 1
right = n - 1
# Use two-pointer approach to find triplets
while left < right:
# Calculate the sum of the triplet
sum = arr[i] + arr[left] + arr[right]
# If sum is smaller, move to bigger values
if sum < target:
left += 1
# If sum is greater, move to smaller values
elif sum > target:
right -= 1
# If sum is equal to target
else:
ele1 = arr[left]
ele2 = arr[right]
cnt1 = 0
cnt2 = 0
# Count frequency of the current value at 'left'
while left <= right and arr[left] == ele1:
left += 1
cnt1 += 1
# Count frequency of the current value at 'right'
while left <= right and arr[right] == ele2:
right -= 1
cnt2 += 1
# If both the elements are the same, then count of pairs
# = the number of ways to choose 2 elements among cnt1 elements
if ele1 == ele2:
res += (cnt1 * (cnt1 - 1)) // 2
# If the elements are different, then count of pairs
# = product of the count of both elements
else:
res += (cnt1 * cnt2)
return res
if __name__ == "__main__":
arr = [-3, -1, -1, 0, 1, 2]
target = -2
print(countTriplets(arr, target))
// C# program to count all triplets having sum equal to
// target by exploring all possible triplets
using System;
using System.Collections.Generic;
class GfG {
// Function to count all triplets having sum equal to target
static int countTriplets(int[] arr, int target) {
int n = arr.Length;
int res = 0;
// Iterate through each element as the first element
// of the triplet
for (int i = 0; i < n - 2; i++) {
int left = i + 1, right = n - 1;
// Use two-pointer approach to find triplets
while (left < right) {
// Calculate the sum of the triplet
int sum = arr[i] + arr[left] + arr[right];
// If sum is smaller, move to bigger values
if (sum < target) {
left += 1;
}
// If sum is greater, move to smaller values
else if (sum > target) {
right -= 1;
}
else if (sum == target) {
int ele1 = arr[left], ele2 = arr[right];
int cnt1 = 0, cnt2 = 0;
// Count frequency of the current value at 'left'
while (left <= right && arr[left] == ele1) {
left++;
cnt1++;
}
// Count frequency of the current value at 'right'
while (left <= right && arr[right] == ele2) {
right--;
cnt2++;
}
// If both the elements are same, then count
// of pairs = the number of ways to choose
// 2 elements among cnt1 elements
if (ele1 == ele2)
res += (cnt1 * (cnt1 - 1)) / 2;
// If the elements are different, then
// count of pairs = product of the count
// of both elements
else
res += (cnt1 * cnt2);
}
}
}
return res;
}
static void Main() {
int[] arr = { -3, -1, -1, 0, 1, 2 };
int target = -2;
Console.WriteLine(countTriplets(arr, target));
}
}
// JavaScript program to count all triplets having sum equal to
// target by exploring all possible triplets
// JavaScript program to count all triplets having sum equal to
// target by exploring all possible triplets
function countTriplets(arr, target) {
let n = arr.length;
let res = 0;
// Iterate through each element as the first element of the triplet
for (let i = 0; i < n - 2; i++) {
let left = i + 1, right = n - 1;
// Use two-pointer approach to find triplets
while (left < right) {
// Calculate the sum of the triplet
let sum = arr[i] + arr[left] + arr[right];
// If sum is smaller, move to bigger values
if (sum < target) {
left += 1;
}
// If sum is greater, move to smaller values
else if (sum > target) {
right -= 1;
}
else if (sum === target) {
let ele1 = arr[left], ele2 = arr[right];
let cnt1 = 0, cnt2 = 0;
// Count frequency of the current value at 'left'
while (left <= right && arr[left] === ele1) {
left++;
cnt1++;
}
// Count frequency of the current value at 'right'
while (left <= right && arr[right] === ele2) {
right--;
cnt2++;
}
// If both the elements are same, then count of
// pairs = the number of ways to choose 2
// elements among cnt1 elements
if (ele1 === ele2)
res += (cnt1 * (cnt1 - 1)) / 2;
// If the elements are different, then count of
// pairs = product of the count of both elements
else
res += (cnt1 * cnt2);
}
}
}
return res;
}
// Driver Code
let arr = [-3, -1, -1, 0, 1, 2];
let target = -2;
console.log(countTriplets(arr, target));
Time Complexity: O(n^2). For each index i, we use two pointers that traverse at most n elements combined.
Auxiliary Space: O(1)
Similar Reads
3 Sum - Count all triplets with given sum Given an array arr[] and a target value, the task is to find the count of triplets present in the given array having sum equal to the given target. Examples:Input: arr[] = [0, -1, 2, -3, 1], target = -2Output: 2Explanation: Two triplets that add up to -2 are:arr[0] + arr[3] + arr[4] = 0 + (-3) + (1)
10 min read
Count of triplets in an Array with odd sum Given an array arr[] with N integers, find the number of triplets of i, j and k such that 1<= i < j < k <= N and arr[i] + arr[j] + arr[k] is odd. Example: Input: arr[] = {1, 2, 3, 4, 5}Output: 4Explanation: The given array contains 4 triplets with an odd sum. They are {1, 2, 4}, {1, 3, 5
6 min read
3 Sum – All Distinct Triplets with given Sum in an Array Given an array arr[], and an integer target, find all possible unique triplets in the array whose sum is equal to the given target value. We can return triplets in any order, but all the returned triplets should be internally sorted, i.e., for any triplet [q1, q2, q3], the condition q1 ≤ q2 ≤ q3 sho
15+ min read
3 Sum - Find all Triplets with Given Sum Given an array arr[] and an integer target, the task is to find all possible indices {i, j, k} of triplet {arr[i], arr[j], arr[k]} such that their sum is equal to given target and all indices in a triplet should be distinct (i != j, j != k, k != i). We need to return indices of a triplet in sorted o
12 min read
Count triplets with sum smaller than a given value Given an array of distinct integers and a sum value. Find count of triplets with sum smaller than given sum value. The expected Time Complexity is O(n2).Examples: Input : arr[] = {-2, 0, 1, 3} sum = 2. Output : 2 Explanation : Below are triplets with sum less than 2 (-2, 0, 1) and (-2, 0, 3) Input :
11 min read