Codestin Search App

4Sum - Problem

Welcome to the 4Sum Problem - a fascinating challenge that extends the classic Two Sum problem into multiple dimensions!

You're given an array nums containing n integers and a target value. Your mission is to find all unique quadruplets (groups of four numbers) [nums[a], nums[b], nums[c], nums[d]] where:

All four indices a, b, c, d are different
The sum equals the target: nums[a] + nums[b] + nums[c] + nums[d] == target

Example: Given nums = [1,0,-1,0,-2,2] and target = 0, you should return [[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]

The beauty of this problem lies in efficiently avoiding duplicates while exploring all possible combinations. Can you find all the hidden quadruplets? 🎯

Input & Output

example_1.py — 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: The three unique quadruplets that sum to 0 are: -2+(-1)+1+2=0, -2+0+0+2=0, and -1+0+0+1=0.

example_2.py — Empty Result

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

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

💡 Note: The only quadruplet is [2,2,2,2] which sums to 8, matching our target.

example_3.py — No Valid Quadruplets

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

› Output: []

💡 Note: Array has less than 4 elements, so no quadruplets are possible.

Constraints

1 ≤ nums.length ≤ 200
-10⁹ ≤ nums[i] ≤ 10⁹
-10⁹ ≤ target ≤ 10⁹
All quadruplets must be unique (no duplicate quadruplets in result)

Visualization

Tap to expand

Understanding the Visualization

Sort the Cards

Arrange all cards in ascending order to enable systematic searching

Fix Two Anchors

Choose the first two cards as anchor points

Two-Pointer Search

Use two pointers from opposite ends to find the perfect complementary pair

Skip Duplicates

Move past identical cards to ensure unique combinations

Key Takeaway

🎯 Key Insight: Sorting transforms a chaotic O(n⁴) brute force search into an elegant O(n³) two-pointer dance, where duplicates naturally avoid themselves!

Asked in

G Google 45 a Amazon 38 f Meta 32 ⊞ Microsoft 28

The optimal solution uses the two-pointer technique after sorting the array. We fix the first two elements with nested loops, then use two pointers to efficiently find the remaining pair that sums to the target. This reduces complexity from O(n⁴) brute force to O(n³) while naturally handling duplicate avoidance through sorted order.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers (Optimal)	O(n³)	O(1)	Sort array, fix two elements, then use two pointers for the remaining pair
Brute Force (Four Nested Loops)	O(n⁴)	O(k)	Check every possible combination of four elements using nested loops

Two Pointers (Optimal) — Algorithm Steps

Sort the array to enable two-pointer technique and easy duplicate handling
Use two nested loops to fix the first two elements (i, j)
For remaining target, use two pointers (left, right) to find complementary pair
Skip duplicates at all levels to ensure unique quadruplets
Collect all valid quadruplets

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Array

Sort to enable two-pointer technique: [-2,-1,0,0,1,2]

Fix First Two

Fix i=0(-2) and j=1(-1), need remaining sum = target-(-2)-(-1) = 3

Two Pointers

left=2, right=5: nums[2]+nums[5] = 0+2 = 2 < 3, move left++

Found Match

When sum equals target, record quadruplet and move both pointers

Code -

solution.c — C

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

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

int** fourSum(int* nums, int numsSize, int target, int* returnSize, int** returnColumnSizes) {
    qsort(nums, numsSize, sizeof(int), compare);
    
    int** result = malloc(1000 * sizeof(int*));
    *returnColumnSizes = malloc(1000 * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i < numsSize - 3; i++) {
        if (i > 0 && nums[i] == nums[i - 1]) continue;
        
        for (int j = i + 1; j < numsSize - 2; j++) {
            if (j > i + 1 && nums[j] == nums[j - 1]) continue;
            
            int left = j + 1, right = numsSize - 1;
            
            while (left < right) {
                long long sum = (long long)nums[i] + nums[j] + nums[left] + nums[right];
                
                if (sum == target) {
                    result[*returnSize] = malloc(4 * sizeof(int));
                    result[*returnSize][0] = nums[i];
                    result[*returnSize][1] = nums[j];
                    result[*returnSize][2] = nums[left];
                    result[*returnSize][3] = nums[right];
                    (*returnColumnSizes)[*returnSize] = 4;
                    (*returnSize)++;
                    
                    while (left < right && nums[left] == nums[left + 1]) left++;
                    while (left < right && nums[right] == nums[right - 1]) right--;
                    
                    left++;
                    right--;
                } else if (sum < target) {
                    left++;
                } else {
                    right--;
                }
            }
        }
    }
    
    return result;
}

int main() {
    int nums[] = {1, 0, -1, 0, -2, 2};
    int target = 0;
    int returnSize;
    int* returnColumnSizes;
    
    int** result = fourSum(nums, 6, target, &returnSize, &returnColumnSizes);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n log n) for sorting + O(n³) for three loops with two-pointer optimization

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra space (not counting output array)

✓ Linear Space

42.0K Views

High Frequency

~25 min Avg. Time

1.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

Constraints

Visualization

Related Problems

Common Approaches

Two Pointers (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler