3Sum With Multiplicity - Practice Coding Problems

3Sum With Multiplicity - Problem

Given an integer array arr and a target sum target, find all unique triplets of indices (i, j, k) where i < j < k and arr[i] + arr[j] + arr[k] == target.

The twist? We need to count all possible combinations, including those with duplicate values. Since the result can be extremely large, return the answer modulo 10⁹ + 7.

Example: For array [1,1,2,2,3,3,4,4,5,5] with target = 8, we need to find all ways to pick three numbers (at different positions) that sum to 8. This includes combinations like (1,2,5), (1,3,4), and (2,2,4), considering all possible index arrangements.

This problem combines the classic 3Sum challenge with combinatorial counting, making it both algorithmically interesting and mathematically rich!

Input & Output

example_1.py — Basic Case

$ Input: arr = [1,1,2,2,3,3,4,4,5,5], target = 8

› Output: 20

💡 Note: Valid triplets include all combinations of indices where values sum to 8: (1,2,5), (1,3,4), (2,2,4), etc. Since we have duplicates, we count all possible ways to choose indices, giving us 20 total combinations.

example_2.py — Small Array

$ Input: arr = [1,1,2,2,2,2], target = 5

› Output: 12

💡 Note: We can form triplets like (1,2,2) in multiple ways. Since we have 2 ones and 4 twos, the number of ways to pick one 1 and two 2s is C(2,1) × C(4,2) = 2 × 6 = 12.

example_3.py — No Valid Triplets

$ Input: arr = [1,1,1], target = 10

› Output: 0

💡 Note: No three elements can sum to 10 since maximum possible sum is 1+1+1=3. This demonstrates the edge case where no valid combinations exist.

Visualization

Tap to expand

Understanding the Visualization

Count Inventory

Count how many of each ice cream flavor you have

Find Valid Combinations

Identify which 3-flavor combinations meet the target price

Calculate Arrangements

For each valid combination, calculate how many ways to pick the scoops

Sum All Possibilities

Add up all possible arrangements across all valid combinations

Key Takeaway

🎯 Key Insight: Use frequency counting + combinatorial math C(n,k) to efficiently calculate arrangements of duplicate elements rather than checking every possible triplet!

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, each potentially running n times in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track indices and count

✓ Linear Space

Constraints

3 ≤ arr.length ≤ 3000
0 ≤ arr[i] ≤ 100
0 ≤ target ≤ 300
Return answer modulo 10⁹ + 7

Asked in

G Google 38 a Amazon 45 f Meta 29 ⊞ Microsoft 33

The optimal approach uses frequency counting with combinatorics to achieve O(n²) time complexity. Key insight: instead of checking all O(n³) triplets, count frequencies of unique values and use mathematical combinations C(n,k) to calculate valid arrangements efficiently while handling duplicates correctly.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check all possible triplets with three nested loops
Two Pointers with Counting	O(n²)	O(n)	Sort array, fix one element, then use two pointers to find pairs

Brute Force (Triple Nested Loops) — Algorithm Steps

Iterate through all possible first indices i
For each i, iterate through all possible second indices j > i
For each pair (i,j), iterate through all possible third indices k > j
Check if arr[i] + arr[j] + arr[k] equals target
If yes, increment counter and apply modulo

Visualization

Tap to expand

Step-by-Step Walkthrough

Fix First Element

Outer loop fixes first index i

Fix Second Element

Middle loop fixes second index j > i

Check Third Element

Inner loop checks third index k > j

Validate Sum

Check if arr[i] + arr[j] + arr[k] = target

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int threeSumMulti(int* arr, int arrSize, int target) {
    const int MOD = 1000000007;
    long long count = 0;
    
    // Check all possible triplets i < j < k
    for (int i = 0; i < arrSize - 2; i++) {
        for (int j = i + 1; j < arrSize - 1; j++) {
            for (int k = j + 1; k < arrSize; k++) {
                if (arr[i] + arr[j] + arr[k] == target) {
                    count = (count + 1) % MOD;
                }
            }
        }
    }
    
    return (int)count;
}

int main() {
    int arr[] = {1, 1, 2, 2, 3, 3, 4, 4, 5, 5};
    int target = 8;
    printf("%d\n", threeSumMulti(arr, 10, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops, each potentially running n times in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track indices and count

✓ Linear Space

Constraints

3 ≤ arr.length ≤ 3000
0 ≤ arr[i] ≤ 100
0 ≤ target ≤ 300
Return answer modulo 10⁹ + 7

73.2K Views

Medium-High Frequency

~22 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Triple Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler