3Sum - Practice Coding Problems

3Sum - Problem

Given an integer array nums, your task is to find all unique triplets in the array that sum to zero.

A triplet is a set of three numbers [nums[i], nums[j], nums[k]] where:

i, j, and k are all different indices
nums[i] + nums[j] + nums[k] = 0

Important: The solution must not contain duplicate triplets. For example, if you find [-1, 0, 1], you should not also include [0, -1, 1] or [1, -1, 0] as they represent the same triplet.

Example: Given nums = [-1, 0, 1, 2, -1, -4], the unique triplets that sum to zero are [[-1, -1, 2], [-1, 0, 1]].

Input & Output

example_1.py — Basic case with multiple triplets

$ Input: nums = [-1,0,1,2,-1,-4]

› Output: [[-1,-1,2],[-1,0,1]]

💡 Note: The two unique triplets that sum to zero are [-1,-1,2] and [-1,0,1]. Note that the order of triplets and elements within triplets may vary.

example_2.py — No valid triplets

$ Input: nums = [0,1,1]

› Output: []

💡 Note: The only possible triplet is [0,1,1] which sums to 2, not 0. Therefore, no valid triplets exist.

example_3.py — All zeros

$ Input: nums = [0,0,0]

› Output: [[0,0,0]]

💡 Note: The only possible triplet [0,0,0] sums to 0, so it's a valid answer.

Visualization

Tap to expand

Understanding the Visualization

Organize Blocks

First, arrange all blocks in order from lightest to heaviest (sorting)

Fix One Block

Choose one block as the pivot point of your triangle

Balance the Scale

Use two helpers at opposite ends to find blocks that balance the pivot

Avoid Duplicates

Skip identical blocks to avoid counting the same balance multiple times

Key Takeaway

🎯 Key Insight: Sorting first enables the two-pointer technique, which efficiently finds pairs while naturally avoiding duplicates through systematic pointer movement.

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops each running up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables (excluding output space)

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 3000
-10⁵ ≤ nums[i] ≤ 10⁵
The solution set must not contain duplicate triplets

Asked in

G Google 89 a Amazon 76 f Meta 54 ⊞ Microsoft 43

The optimal solution uses the two-pointers technique after sorting the array. For each fixed first element, we use two pointers to find pairs that complete the triplet. This approach achieves O(n²) time complexity and naturally avoids duplicates through careful pointer management.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible combination of three numbers
Two Pointers (Optimal)	O(n²)	O(1)	Sort array first, then use two pointers for each fixed element

Brute Force (Triple Nested Loops) — Algorithm Steps

Use three nested loops to generate all possible triplets
For each triplet, check if the sum equals zero
Use a set or sorting to avoid duplicate triplets
Add valid unique triplets to the result

Visualization

Tap to expand

Step-by-Step Walkthrough

First Loop (i)

Outer loop selects first element

Second Loop (j)

Middle loop selects second element after i

Third Loop (k)

Inner loop selects third element after j

Check Sum

Test if nums[i] + nums[j] + nums[k] = 0

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int** threeSum(int* nums, int numsSize, int* returnSize, int** returnColumnSizes) {
    int** result = malloc(1000 * sizeof(int*));
    *returnColumnSizes = malloc(1000 * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            for (int k = j + 1; k < numsSize; k++) {
                if (nums[i] + nums[j] + nums[k] == 0) {
                    int* triplet = malloc(3 * sizeof(int));
                    triplet[0] = nums[i];
                    triplet[1] = nums[j];
                    triplet[2] = nums[k];
                    qsort(triplet, 3, sizeof(int), compare);
                    
                    // Simple duplicate check (not optimal)
                    int isDuplicate = 0;
                    for (int m = 0; m < *returnSize; m++) {
                        if (result[m][0] == triplet[0] && 
                            result[m][1] == triplet[1] && 
                            result[m][2] == triplet[2]) {
                            isDuplicate = 1;
                            break;
                        }
                    }
                    
                    if (!isDuplicate) {
                        result[*returnSize] = triplet;
                        (*returnColumnSizes)[*returnSize] = 3;
                        (*returnSize)++;
                    } else {
                        free(triplet);
                    }
                }
            }
        }
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops each running up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space for variables (excluding output space)

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 3000
-10⁵ ≤ nums[i] ≤ 10⁵
The solution set must not contain duplicate triplets

891.0K Views

Very High Frequency

~25 min Avg. Time

28.5K 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