How To Understand and Debug the Two Sum Algorithm in Python

1. Introduction: What Is the “Two Sum” Problem?

The “Two Sum” problem is a widely known beginner-level algorithm challenge. You’re given an array of integers `nums` and an integer `target`, and your task is to find two numbers in the array whose sum is equal to `target`. Then, return their indices.

This problem is not just about finding the correct result—it tests your ability to think through efficient algorithms using data structures like hash maps (dictionaries in Python).

2. Defining the Function and Input Data

We start by defining a function:

def twoSum(nums, target):

This function takes two parameters:
– `nums`: the input list of integers
– `target`: the desired sum of two numbers in the list

Example inputs:

nums = [2, 7, 11, 15]
target = 26
print(twoSum(nums, target))

To understand how the function operates, we place breakpoints inside the function and at the main input line, then run it in a Python debugger (e.g., VSCode’s built-in debugger).

3. Stepping Through the Function With a Debugger

Inside `twoSum`, we create an empty dictionary `num_map = {}` to store each number and its corresponding index.

We then loop through the list using `enumerate(nums)` to get both index `i` and number `num`:

for i, num in enumerate(nums):

For every number:
1. Calculate the **complement**: `complement = target – num`
2. Check if the `complement` exists in `num_map`
– If yes: return `[num_map[complement], i]`
– If no: store `num` with its index: `num_map[num] = i`

By watching variables like `num`, `complement`, and `num_map` during debugging, you can see exactly how values change over time.

4. Case Study: Example Walkthrough With Debugger

Using the input `nums = [2, 7, 11, 15]` and `target = 26`, here’s what happens:

– First iteration: `num = 2`, `complement = 24`, `num_map = {}`
– Not found, so `num_map = {2: 0}`
– Second iteration: `num = 7`, `complement = 19`, still not found
– Continue until:
– Fourth iteration: `num = 15`, `complement = 11` is found in `num_map` at index 2
– Return `[2, 3]`

This debugging process makes the function’s behavior transparent and easier to understand.

5. Conclusion: Why Debugging Improves Learning

By stepping through the code with a debugger and using watch expressions, we transform a seemingly abstract algorithm into something tangible and easy to grasp.

The dictionary-based approach is elegant and efficient—**linear time complexity (O(n))**—and with debugging tools, you not only solve the problem but also deeply understand it.

If you’re new to Python or algorithms, this is a great way to build foundational skills in both coding and critical thinking.

6. Source Code.

def twoSum(nums, target):

    # Create a dictionary to store the numbers and their corresponding indices
    num_map = {}
    
    # Iterate through the array
    for i, num in enumerate(nums):
        
        # Calculate the other number needed
        complement = target - num
        
        # If this number is already in the dictionary, return the result
        if complement in num_map:
            
            return [num_map[complement], i]
        
        # Otherwise, store the current number and its index in the dictionary
        num_map[num] = i
    
    # If no solution is found, return an empty list (according to the problem description, this case won't happen)
    return []


nums = [2, 7, 11, 15]

target = 26

print(twoSum(nums, target))

7. Demo Video

You can watch the following demo video by select the subtitle to your preferred subtitle language.