How to Explain 3Sum in a Coding Interview (Step-by-Step)

3Sum is where two-pointer technique graduates from beginner to intermediate. The core algorithm is only a few lines — but the duplicate-skipping logic is what trips up most candidates. Get that right and the rest of the explanation writes itself.

In this post, you’ll learn exactly how to walk an interviewer through LeetCode 15: why you sort first, how the fix-one + two-pointer reduction works, where duplicates sneak in, and how to handle all three skip points cleanly.

Problem Statement

Examples

Constraints

• 3 <= nums.length <= 3000
• -105 <= nums[i] <= 105

What Is the Problem?

“I need to find every unique set of three numbers in the array that sums to zero. The tricky part isn’t the sum — it’s the word ‘unique’. The input may contain duplicates, and I can’t return the same triplet twice even if it can be formed from different indices.”

Calling out the uniqueness constraint upfront shows the interviewer you’ve identified the hardest part of the problem before writing a single line of code.

Step 1: Compare Approaches Before Jumping to Code

“Both the HashSet and two-pointer approaches are O(n²), but sorting makes deduplication effortless — once the array is sorted, duplicate values are adjacent, so skipping them is a simple while-loop. That’s why sort + two pointers is the clean interview answer.”

The Key Insight — Reduce to 2Sum

“Sorting unlocks two things: it lets me use two pointers for the inner loop, and it puts duplicates side-by-side so I can skip them with a simple comparison. Both properties are essential.”

Step 2: Explain the Algorithm in Plain English

Step-by-Step Visual — nums = [-4, -1, -1, 0, 1, 2]

After sorting. Let’s trace the first iteration where i = 1 (nums[i] = -1), target = 1.

The Duplicate-Skip Logic — The Part Everyone Trips Over

There are three places where duplicates must be skipped. Miss any one and the output contains duplicate triplets.

“The key is that skipping happens after recording the triplet — not before. And the i > 0 guard on the outer skip is critical: without it, we’d skip index 0 when comparing to a non-existent nums[-1].”

Step 3: Talk Through the Code

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()                # Sort once — enables two pointers + easy deduplication
        result = []

        for i in range(len(nums) - 2):
            # Early exit: smallest remaining value is positive → no triplet can sum to 0
            if nums[i] > 0:
                break

            # Skip duplicate values for the fixed pointer
            if i > 0 and nums[i] == nums[i - 1]:
                continue

            left, right = i + 1, len(nums) - 1

            while left < right:
                total = nums[i] + nums[left] + nums[right]

                if total < 0:
                    left += 1          # Sum too small — move left pointer right
                elif total > 0:
                    right -= 1         # Sum too large — move right pointer left
                else:
                    result.append([nums[i], nums[left], nums[right]])

                    # Skip duplicate values for left and right after a match
                    while left < right and nums[left] == nums[left + 1]:
                        left += 1
                    while left < right and nums[right] == nums[right - 1]:
                        right -= 1

                    left  += 1         # Move both inward to look for the next triplet
                    right -= 1

        return result

Draw attention to the early-break optimisation — once nums[i] > 0, the sorted array guarantees nums[left] and nums[right] are also positive, so the sum can never be zero. This doesn't change worst-case complexity but significantly improves real-world performance.

Step 4: Highlight Edge Cases

Step 5: State Time and Space Complexity

"Sorting costs O(n log n) but the nested loop is O(n²), so sorting doesn't affect the overall time complexity. For space, if we exclude the output list (standard convention), it's O(log n) for the sort. If we include the output, it's O(n) in the worst case — for example, an array of all zeros of length n would produce O(n) triplets."

Interview Checklist for 3Sum

• Restate — "find all unique triplets that sum to zero; no duplicate triplets in the output"
• Call out the uniqueness constraint immediately — it's the hardest part
• Mention brute force O(n³) → explain why it's rejected
• Explain why sorting enables the two-pointer approach and trivial deduplication
• State the reduction: fix nums[i], reduce to Two Sum II in the subarray
• Explain all three duplicate-skip points: outer i, inner left, inner right
• Mention the i > 0 guard on the outer skip
• Mention the early-break when nums[i] > 0
• Call out edge cases: all zeros, no valid triplet, minimum length input
• State O(n²) time and O(n) space (or O(log n) excluding output)

Related Problems to Practice

If you can solve 3Sum cleanly, try these next: