3Sum

3Sum - Problem

Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0.

Notice that the solution set must not contain duplicate triplets.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Two valid triplets that sum to zero: nums[0]+nums[4]+nums[3] = (-1)+(-1)+2 = 0 and nums[0]+nums[1]+nums[2] = (-1)+0+1 = 0

Example 2 — No Solution

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

› Output: []

💡 Note: The only possible triplet is [0,1,1] but 0+1+1 = 2 ≠ 0, so no valid triplets exist

Example 3 — All Zeros

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

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

💡 Note: The only triplet [0,0,0] sums to 0, which is valid

Constraints

3 ≤ nums.length ≤ 3000
-10⁵ ≤ nums[i] ≤ 10⁵

Visualization

Tap to expand

Asked in

f Facebook 89 a Amazon 67 M Microsoft 45 G Google 38

The key insight is to sort the array first to handle duplicates efficiently and enable the two-pointer technique. Best approach uses two pointers after sorting for optimal O(n²) time complexity. Time: O(n²), Space: O(1).

Common Approaches

✓ Brute Force

⏱️ Time: O(n³) Space: O(k)

Generate every possible combination of three different indices and check if their values sum to zero. Use a set to avoid duplicate triplets.

Sort + Hash Set

⏱️ Time: O(n²) Space: O(n)

Sort the array to handle duplicates easier. For each pair (i,j), use hash set to find the third element that makes sum zero.

Two Pointers (Optimal)

⏱️ Time: O(n²) Space: O(1)

Sort the array first. For each element, use two pointers (left and right) to find pairs that sum to the negative of current element. Skip duplicates efficiently.

Brute Force — Algorithm Steps

Use three nested loops to check all triplet combinations
For each triplet, check if sum equals zero
Use set to store unique triplets

Visualization

Tap to expand

Step-by-Step Walkthrough

Setup

Use three pointers i, j, k to check all combinations

Check Sum

For each triplet, verify if sum equals zero

Store Result

Add unique triplets to result set

Code -

solution.c — C

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

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

int** solution(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[3] = {nums[i], nums[j], nums[k]};
                    qsort(triplet, 3, sizeof(int), compare);
                    
                    // Check for duplicates
                    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] = malloc(3 * sizeof(int));
                        result[*returnSize][0] = triplet[0];
                        result[*returnSize][1] = triplet[1];
                        result[*returnSize][2] = triplet[2];
                        (*returnColumnSizes)[*returnSize] = 3;
                        (*returnSize)++;
                    }
                }
            }
        }
    }
    
    return result;
}

void parseArray(const char* str, int* arr, int* size) {
    *size = 0;
    const char* p = str;
    while (*p && *p != '[') p++;
    if (*p == '[') p++;
    while (*p && *p != ']') {
        while (*p == ' ' || *p == ',') p++;
        if (*p == ']' || *p == '\0') break;
        arr[(*size)++] = (int)strtol(p, (char**)&p, 10);
    }
}

int main() {
    char input[1000];
    fgets(input, sizeof(input), stdin);
    
    // Parse array manually
    int nums[1000];
    int numsSize = 0;
    char *token = strtok(input + 1, ",]");
    while (token != NULL) {
        nums[numsSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(nums, numsSize, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[%d,%d,%d]", result[i][0], result[i][1], result[i][2]);
        if (i < returnSize - 1) printf(",");
        free(result[i]);
    }
    printf("]\n");
    
    free(result);
    free(returnColumnSizes);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops iterate through all combinations

⚠ Quadratic Growth

Space Complexity

O(k)

Set stores k unique triplets found

✓ Linear Space

534.6K Views

High Frequency

~25 min Avg. Time

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

Constraints

Visualization

Related Problems

Common Approaches

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler