Two Sum - Practice Coding Problems

Two Sum - Problem

The Two Sum problem is a fundamental coding challenge that appears in countless technical interviews! 🎯

Imagine you're shopping with a specific budget. You have a list of item prices and need to find exactly two items that together cost your target amount. That's essentially what this problem asks you to do with numbers!

The Challenge:
Given an array of integers nums and an integer target, find the indices of two numbers that add up to the target value.

Key Rules:
• Each input has exactly one solution - no more, no less
• You cannot use the same array element twice
• Return the indices in any order

Example: If nums = [2,7,11,15] and target = 9, then nums[0] + nums[1] = 2 + 7 = 9, so return [0,1].

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,7,11,15], target = 9

› Output: [0,1]

💡 Note: Because nums[0] + nums[1] = 2 + 7 = 9, we return [0, 1]. This is the most straightforward case where the first two elements sum to the target.

example_2.py — Target at End

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

› Output: [1,2]

💡 Note: nums[1] + nums[2] = 2 + 4 = 6. Note that we cannot use nums[0] + nums[0] = 3 + 3 = 6 because we cannot use the same element twice.

example_3.py — Minimum Input

$ Input: nums = [3,3], target = 6

› Output: [0,1]

💡 Note: The only solution is to use both elements: nums[0] + nums[1] = 3 + 3 = 6. This demonstrates the minimum possible input size.

Visualization

Tap to expand

Understanding the Visualization

The Brute Force Way

Talk to each person and ask every other person if their numbers sum to the target. Very thorough but exhausting!

The Smart Way - Hash Table

As you meet each person, write their number and location in your notebook. For each new person, quickly check if you need their 'complement' number.

The Moment of Truth

When you meet someone whose complement you've already seen, you've found your pair! Return both locations.

Mission Complete

You've efficiently found the two indices that sum to your target in just one pass through the party!

Key Takeaway

🎯 Key Insight: Instead of checking every possible pair (O(n²)), use a hash table to remember what you've seen and instantly find what you need (O(n))!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the array. Each hash map operation (lookup and insert) takes O(1) average time, so total is O(n)

✓ Linear Growth

Space Complexity

O(n)

Hash map stores at most n key-value pairs in worst case (when solution is the last pair checked)

⚡ Linearithmic Space

Constraints

2 ≤ nums.length ≤ 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
-10⁹ ≤ target ≤ 10⁹
Only one valid answer exists

Asked in

G Google 152 a Amazon 98 f Meta 87 ⊞ Microsoft 73

The optimal solution uses a one-pass hash table approach. As we iterate through the array, we check if the complement (target - current number) exists in our hash map. If found, we return the indices immediately. If not, we add the current number and its index to the hash map. This achieves O(n) time complexity and O(n) space complexity, making it the most efficient solution for technical interviews.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(1)	Check every possible pair of numbers using nested loops
One-Pass Hash Table (Optimal)	O(n)	O(n)	Build hash map and search simultaneously in one pass
Sorting + Binary Search	O(n log n)	O(n)	Sort array, then binary search for complement of each element
Two Pointers (Sorted Array)	O(n log n)	O(n)	Sort array and use two pointers from both ends
Two-Pass Hash Table	O(n)	O(n)	Build hash map first, then search for complements

Brute Force (Nested Loops) — Algorithm Steps

Loop through each element with index i
For each element i, loop through elements after it (j = i+1 to end)
Check if nums[i] + nums[j] equals target
If found, return [i, j]

Visualization

Tap to expand

Step-by-Step Walkthrough

Start with first element

Begin with nums[0] and check against all following elements

Check all pairs with first element

Compare nums[0] with nums[1], nums[2], nums[3], etc.

Move to second element

Move to nums[1] and check against remaining elements

Continue until pair found

Keep checking pairs until we find one that sums to target

Code -

solution.c — C

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

int* twoSum(int* nums, int numsSize, int target, int* returnSize) {
    *returnSize = 2;
    int* result = (int*)malloc(2 * sizeof(int));
    
    for (int i = 0; i < numsSize; i++) {
        for (int j = i + 1; j < numsSize; j++) {
            if (nums[i] + nums[j] == target) {
                result[0] = i;
                result[1] = j;
                return result;
            }
        }
    }
    return result; // Should never reach here
}

int main() {
    int nums[] = {2, 7, 11, 15};
    int target = 9;
    int returnSize;
    int* result = twoSum(nums, 4, target, &returnSize);
    printf("[%d,%d]\n", result[0], result[1]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We have nested loops: outer loop runs n times, inner loop runs up to n times, giving us n × n = n² operations

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no additional data structures that scale with input size

✓ Linear Space

Constraints

2 ≤ nums.length ≤ 10⁴
-10⁹ ≤ nums[i] ≤ 10⁹
-10⁹ ≤ target ≤ 10⁹
Only one valid answer exists

142.4K Views

Very High Frequency

~15 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler