4Sum

4Sum - Problem

Given an array nums of n integers, return an array of all the unique quadruplets [nums[a], nums[b], nums[c], nums[d]] such that:

• 0 <= a, b, c, d < n
• a, b, c, and d are distinct
• nums[a] + nums[b] + nums[c] + nums[d] == target

You may return the answer in any order.

Input & Output

Example 1 — Basic Case

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

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

💡 Note: Three unique quadruplets sum to 0: [-2,-1,1,2], [-2,0,0,2], and [-1,0,0,1]

Example 2 — No Solution

$ Input: nums = [2,2,2,2,2], target = 8

› Output: [[2,2,2,2]]

💡 Note: Only one unique quadruplet: [2,2,2,2] with sum = 8

Example 3 — Empty Result

$ Input: nums = [1,2,3,4], target = 20

› Output: []

💡 Note: No four numbers can sum to 20, maximum possible is 1+2+3+4=10

Constraints

1 ≤ nums.length ≤ 200
-10⁹ ≤ nums[i] ≤ 10⁹
-10⁹ ≤ target ≤ 10⁹

Visualization

Tap to expand

Asked in

f Facebook 45 G Google 38 a Amazon 32 M Microsoft 28

The 4Sum problem finds all unique quadruplets that sum to target. The key insight is to sort first, then use nested loops with two-pointer technique. Best approach uses Sort + Two Pointers with careful duplicate handling. Time: O(n³), Space: O(1).

Common Approaches

✓ Brute Force - Four Nested Loops

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

Use four nested loops to check every possible quadruplet. For each combination, check if the sum equals target and ensure no duplicates.

Optimized Two Pointers

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

The most efficient approach. Sort the array, use two nested loops for the first two elements, then use two pointers technique for the remaining two elements. Skip duplicates at all levels.

Sort + Three Pointers

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

Sort the array, then for each element, solve the 3Sum problem on the remaining elements. This reduces one dimension of the search space.

Brute Force - Four Nested Loops — Algorithm Steps

Use four nested loops to generate all quadruplets
Check if sum equals target
Use set to avoid duplicate quadruplets

Visualization

Tap to expand

Step-by-Step Walkthrough

Four Loops

Generate all possible quadruplets

Check Sum

Test if sum equals target

Avoid Duplicates

Use set to store unique results

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 target, int* returnSize, int** returnColumnSizes) {
    int** result = malloc(1000 * sizeof(int*));
    *returnColumnSizes = malloc(1000 * sizeof(int));
    *returnSize = 0;
    
    for (int a = 0; a < numsSize; a++) {
        for (int b = a + 1; b < numsSize; b++) {
            for (int c = b + 1; c < numsSize; c++) {
                for (int d = c + 1; d < numsSize; d++) {
                    if ((long long)nums[a] + nums[b] + nums[c] + nums[d] == target) {
                        int* quad = malloc(4 * sizeof(int));
                        quad[0] = nums[a]; quad[1] = nums[b]; quad[2] = nums[c]; quad[3] = nums[d];
                        qsort(quad, 4, sizeof(int), compare);
                        
                        int isDuplicate = 0;
                        for (int i = 0; i < *returnSize; i++) {
                            int match = 1;
                            for (int j = 0; j < 4; j++) {
                                if (result[i][j] != quad[j]) {
                                    match = 0;
                                    break;
                                }
                            }
                            if (match) {
                                isDuplicate = 1;
                                break;
                            }
                        }
                        
                        if (!isDuplicate) {
                            result[*returnSize] = quad;
                            (*returnColumnSizes)[*returnSize] = 4;
                            (*returnSize)++;
                        } else {
                            free(quad);
                        }
                    }
                }
            }
        }
    }
    
    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 line[10000];
    fgets(line, sizeof(line), stdin);
    
    int nums[1000];
    int numsSize = 0;
    char* token = strtok(line, "[],\n");
    while (token != NULL) {
        if (strlen(token) > 0 && token[0] != ' ') {
            nums[numsSize++] = atoi(token);
        }
        token = strtok(NULL, "[],\n");
    }
    
    int target;
    scanf("%d", &target);
    
    int returnSize;
    int* returnColumnSizes;
    int** result = solution(nums, numsSize, target, &returnSize, &returnColumnSizes);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("[");
        for (int j = 0; j < 4; j++) {
            printf("%d", result[i][j]);
            if (j < 3) printf(",");
        }
        printf("]");
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

Four nested loops iterate through all possible combinations

✓ Linear Growth

Space Complexity

O(k)

Space for storing result quadruplets, where k is number of solutions

✓ Linear Space

25.2K Views

Medium Frequency

~15 min Avg. Time

850 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 - Four Nested Loops — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler