---
id: 1
title: Two Sum
difficulty: Easy
tags:
  - array
  - hash-table
status: Solved
date_solved: 2026-05-26
leetcode_url: https://leetcode.com/problems/two-sum/
review_needed: false
---

# 1. Two Sum

> [!info] **Problem Link**: [LeetCode - Two Sum](https://leetcode.com/problems/two-sum/)

## 📝 Problem Description

Given an array of integers `nums` and an integer `target`, return *indices of the two numbers such that they add up to `target`*.

You may assume that each input would have ***exactly* one solution**, and you may not use the *same* element twice.

You can return the answer in any order.

---

### 📥 Example 1
> **Input:** `nums = [2,7,11,15]`, `target = 9`
> **Output:** `[0,1]`
> **Explanation:** Because `nums[0] + nums[1] == 9`, we return `[0, 1]`.

### 📥 Example 2
> **Input:** `nums = [3,2,4]`, `target = 6`
> **Output:** `[1,2]`

### 📥 Example 3
> **Input:** `nums = [3,3]`, `target = 6`
> **Output:** `[0,1]`

---

## 💡 Approaches & Explanations

### Approach 1: Hash Map (One-Pass) — *Optimal*
The optimal approach is to use a hash map to keep track of the numbers we have seen so far and their indices. As we iterate through the array, we check if the complement (`target - nums[i]`) already exists in our hash map.
- If it does, we found the pair and return their indices.
- If it doesn't, we add the current number and its index to the hash map.

#### 📊 Complexity Analysis
- **Time Complexity:** $\mathcal{O}(N)$ where $N$ is the number of elements in the array. We traverse the list containing $N$ elements only once, and lookup in the hash table takes $\mathcal{O}(1)$ time.
- **Space Complexity:** $\mathcal{O}(N)$ since we store at most $N$ elements in the hash map.

---

### Approach 2: Brute Force
Compare every pair of numbers to see if their sum equals the target.
- **Time Complexity:** $\mathcal{O}(N^2)$
- **Space Complexity:** $\mathcal{O}(1)$

---

## 💻 Code Implementations

### Python3
```python
class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        seen = {}  # val -> index
        for i, num in enumerate(nums):
            complement = target - num
            if complement in seen:
                return [seen[complement], i]
            seen[num] = i
        return []
```

---

## 🧠 Key Takeaways & Lessons
- **The Complement Trick:** When looking for a pair that sums to a target, rephrase the search: instead of looking for $A + B = \text{target}$, look for $\text{complement} = \text{target} - A$ that is already stored.
- **Hash Map for $\mathcal{O}(1)$ Lookups:** Trading memory (space complexity) for time complexity is a common pattern in array search problems.