3Sum Closest - Practice Coding Problems

3Sum Closest - Problem

You're a treasure hunter exploring an ancient cave filled with numbered crystals. Your mission? Find the perfect combination of exactly three crystals whose combined power level gets as close as possible to your target magical energy!

Given an array nums of integers representing crystal power levels and a target energy value, find three crystals at different positions whose sum is closest to the target. Return the sum of these three crystals.

Example: With crystals [-1, 2, 1, -4] and target 1, the combination [-1 + 2 + 1 = 2] gets closest to our target of 1.

Note: Each input is guaranteed to have exactly one optimal solution - no ties!

Input & Output

example_1.py — Basic Case

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

› Output: 2

💡 Note: The sum that is closest to the target is 2. (-1 + 2 + 1 = 2). The difference |2 - 1| = 1 is the smallest possible.

example_2.py — All Positive

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

› Output: 2

💡 Note: The closest possible sum is 0 + 1 + 1 = 2. Even though target is -100, we must pick exactly 3 elements, so 2 is the closest we can get.

example_3.py — Exact Match

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

› Output: 0

💡 Note: The only possible sum is 0 + 0 + 0 = 0. The difference |0 - 1| = 1.

Visualization

Tap to expand

Understanding the Visualization

Organize Crystals

First, arrange all crystals by their power level (sorting)

Pick First Crystal

Choose one crystal as your base

Smart Search

Use two treasure hunters from opposite ends to find the best pair

Adjust Strategy

If total power is too low, get stronger crystal. If too high, get weaker one

Key Takeaway

🎯 Key Insight: Sorting enables the two-pointer technique - when sum is too small, we know we need a larger number (move left pointer right), when too large, we need a smaller number (move right pointer left). This eliminates the need to check all combinations!

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops each running up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track the closest sum

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000
-10⁴ ≤ target ≤ 10⁴
Guaranteed to have exactly one solution

Asked in

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

The optimal approach uses sorting + two pointers technique. First sort the array O(n log n), then for each element as the first element of the triplet, use two pointers from both ends to find the closest sum in O(n) time. Total complexity: O(n²) time, O(1) space.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Triple Nested Loops)	O(n³)	O(1)	Check every possible combination of three elements
Two Pointers (Optimal Approach)	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
Calculate the sum of each triplet
Calculate the absolute difference between sum and target
Keep track of the smallest difference and corresponding sum
Return the sum with minimum difference

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with three pointers at positions 0, 1, 2

Calculate

Sum the three elements and find difference from target

Compare

If this difference is smaller, update our best result

Advance

Move to next combination and repeat

Code -

solution.c — C

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

int threeSumClosest(int* nums, int numsSize, int target) {
    int closestSum = INT_MAX;
    int minDiff = INT_MAX;
    
    for (int i = 0; i < numsSize - 2; i++) {
        for (int j = i + 1; j < numsSize - 1; j++) {
            for (int k = j + 1; k < numsSize; k++) {
                int currentSum = nums[i] + nums[j] + nums[k];
                int diff = abs(currentSum - target);
                
                if (diff < minDiff) {
                    minDiff = diff;
                    closestSum = currentSum;
                }
            }
        }
    }
    
    return closestSum;
}

int main() {
    int nums[] = {-1, 2, 1, -4};
    int target = 1;
    printf("%d\n", threeSumClosest(nums, 4, target));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

Three nested loops each running up to n times

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables to track the closest sum

✓ Linear Space

Constraints

3 ≤ nums.length ≤ 1000
-1000 ≤ nums[i] ≤ 1000
-10⁴ ≤ target ≤ 10⁴
Guaranteed to have exactly one solution

89.5K Views

High Frequency

~18 min Avg. Time

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