Two Sum Problem Classic Hash Solution in DSA Python - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Two Sum Hash Map Solution

What is the output of the following Python code that solves the Two Sum problem using a hash map?

DSA Python

def two_sum(nums, target):
    lookup = {}
    for i, num in enumerate(nums):
        if target - num in lookup:
            return [lookup[target - num], i]
        lookup[num] = i

result = two_sum([2, 7, 11, 15], 9)
print(result)

A [0, 1]

B [1, 2]

C [2, 3]

D None

💡 Hint

Think about which two numbers add up to the target 9 and their indices.

The function finds two numbers that add up to 9. 2 (index 0) and 7 (index 1) sum to 9, so it returns [0, 1].

🧠 Conceptual

intermediate

Understanding Hash Map Usage in Two Sum

Why does the Two Sum hash map solution use a dictionary to store numbers and their indices?

A To quickly check if the complement (target - current number) exists in the list.

B To count how many times each number appears.

C To store all pairs of numbers that add up to the target.

D To sort the numbers before searching for pairs.

💡 Hint

Think about how to find the other number needed to reach the target efficiently.

The dictionary allows O(1) lookup to check if the complement exists, making the solution efficient.

❓ Predict Output

advanced

Output with No Valid Pair

What will be the output of this Two Sum hash map code when no two numbers add up to the target?

DSA Python

def two_sum(nums, target):
    lookup = {}
    for i, num in enumerate(nums):
        if target - num in lookup:
            return [lookup[target - num], i]
        lookup[num] = i
    return None

result = two_sum([1, 2, 3, 4], 8)
print(result)

A Error

B [0, 3]

C []

D None

💡 Hint

Check if any two numbers sum to 8 in the list.

No two numbers in [1, 2, 3, 4] add up to 8, so the function returns None.

🔧 Debug

advanced

Identify the Error in Two Sum Code

What error does this code produce when run, and why?

DSA Python

def two_sum(nums, target):
    lookup = {}
    for i, num in enumerate(nums):
        if target - num in lookup:
            return [lookup[target - num], i]
        lookup[num] = i

result = two_sum([3, 3], 6)
print(result)

A IndexError because of out of range index

B No error, output is [0, 1]

C TypeError due to wrong data type in lookup

D KeyError because lookup is accessed incorrectly

💡 Hint

Check how the function handles duplicates and if the lookup dictionary is accessed safely.

The code correctly finds indices [0, 1] because 3 + 3 = 6 and both indices are stored properly.

🚀 Application

expert

Number of Unique Pairs Summing to Target

Given the list [1, 2, 3, 4, 3, 2, 1] and target 4, how many unique pairs of indices (i, j) with i < j exist such that nums[i] + nums[j] == target?

A 3

B 4

C 5

D 6

💡 Hint

Consider pairs like (0,2), (1,5), and count unique index pairs carefully.

Pairs are (0,2), (0,4), (1,5), (2,6), (4,6). Total 5 unique pairs.

Practice

1. What is the main idea behind the classic hash solution for the Two Sum Problem?

easy

A. Use a dictionary to store numbers and their indices for quick lookup

B. Sort the array and use two pointers to find the sum

C. Use nested loops to check every pair of numbers

D. Use recursion to find pairs that add up to the target

Solution

1. Step 1: Understand the problem requirement

   The Two Sum problem asks to find two numbers in an array that add up to a target value.

2. Step 2: Explain the hash solution approach

   Using a dictionary (hash map) allows storing each number's index and checking if the complement (target - current number) exists quickly.

3. Final Answer:

   Use a dictionary to store numbers and their indices for quick lookup -> Option A

4. Quick Check:

   Hash map lookup = fast pair finding [OK]

Hint: Use a dictionary to find complements quickly [OK]

Common Mistakes:

• Trying to sort the array which changes indices
• Using nested loops causing slow performance
• Not storing indices, only values

2. Which of the following is the correct syntax to check if a key exists in a Python dictionary named seen?

easy

A. if key exists in seen:

B. if key in seen:

C. if seen.has_key(key):

D. if key inside seen:

Solution

1. Step 1: Recall Python dictionary membership syntax

   In Python, to check if a key exists in a dictionary, use the syntax if key in dict:.

2. Step 2: Identify correct option

   if key in seen: uses the correct syntax. if key exists in seen: and D are invalid syntax. if seen.has_key(key): is legacy and removed in Python 3.

3. Final Answer:

   if key in seen: -> Option B

4. Quick Check:

   Python dict key check = if key in dict [OK]

Hint: Use 'in' keyword to check dictionary keys [OK]

Common Mistakes:

• Using outdated has_key() method
• Writing invalid syntax like 'exists in'
• Confusing keys with values

3. What will be the output of the following code?

def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

print(two_sum([2, 7, 11, 15], 9))

medium

A. [0, 1]

B. [1, 2]

C. [2, 3]

D. []

Solution

1. Step 1: Trace the loop and dictionary updates

   Iteration 0: num=2, complement=7, seen={}, complement not in seen, add 2:0.
   Iteration 1: num=7, complement=2, complement 2 in seen at index 0, return [0,1].

2. Step 2: Determine returned indices

   The function returns indices [0,1] where nums[0]+nums[1]=2+7=9.

3. Final Answer:

   [0, 1] -> Option A

4. Quick Check:

   Indices of 2 and 7 = [0, 1] [OK]

Hint: Check complement in dict before adding current number [OK]

Common Mistakes:

• Returning values instead of indices
• Adding current number before checking complement
• Returning empty list incorrectly

4. The following code tries to solve the Two Sum problem but has a bug. What is the bug?

def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        if num in seen:
            return [seen[num], i]
        complement = target - num
        seen[complement] = i
    return []

medium

A. It does not check for complement in dictionary

B. It returns indices in wrong order

C. It stores complement as key instead of the number itself

D. It uses enumerate incorrectly

Solution

1. Step 1: Analyze dictionary key storage

   The code stores complement as key with current index, but it should store the number as key to check complement later.

2. Step 2: Identify impact of wrong key storage

   Because complement is stored as key, the lookup for num in seen fails to find correct pairs, causing wrong or no results.

3. Final Answer:

   It stores complement as key instead of the number itself -> Option C

4. Quick Check:

   Store number as key, not complement [OK]

Hint: Store numbers as keys, check for complement [OK]

Common Mistakes:

• Swapping complement and number keys
• Returning indices before checking complement
• Not using enumerate properly

5. Given the list nums = [3, 3, 4, 5] and target = 6, what will the classic hash solution return?
Consider the code:

def two_sum(nums, target):
    seen = {}
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:
            return [seen[complement], i]
        seen[num] = i
    return []

print(two_sum(nums, target))

hard

A. []

B. [1, 2]

C. [2, 3]

D. [0, 1]

Solution

1. Step 1: Trace the loop with duplicates

   Iteration 0: num=3, complement=3, seen={}, complement not in seen, add 3:0.
   Iteration 1: num=3, complement=3, complement 3 in seen at index 0, return [0,1].

2. Step 2: Understand duplicate handling

   The solution correctly finds the two 3's at indices 0 and 1 that sum to 6.

3. Final Answer:

   [0, 1] -> Option D

4. Quick Check:

   Two 3's indices = [0, 1] [OK]

Hint: Duplicates allowed; first pair found is returned [OK]

Common Mistakes:

• Ignoring duplicates and returning empty list
• Returning wrong indices due to overwriting
• Assuming no pair exists when duplicates present