Two Sum Problem Explained in Python | HashMap Intuition & Optimal Approach

Two Sum Problem – From Confusion to Clear Intuition

The Two Sum problem is one of those classic interview questions that looks simple, but can easily trap you into an inefficient approach if you don’t recognize the pattern early. Initially, I also thought about checking every possible pair, but that quickly leads to a slow solution.

Problem Statement (In Simple Words)

You are given an array of integers and a target value. Your task is to return the indices of the two numbers such that they add up to the target. Each input has exactly one solution, and you cannot use the same element twice.

Brute Force Thought Process

The first idea that naturally comes to mind is: for every number, check all other numbers to see if their sum equals the target. While this works logically, it results in O(n²) time complexity, which is not optimal.

Key Insight That Changes Everything

Instead of asking: “Which two numbers add up to the target?”
I reframed the question as: “For the current number, have I already seen the number needed to complete the target?”

This small shift in thinking is what introduces the HashMap pattern.

Why HashMap Works Here

• We store numbers we have already seen along with their indices
• For each current number, we compute target - current number
• If that value already exists in the map, we have found the answer

This allows us to solve the problem in a single pass.

Optimal Python Solution

Here is the clean and efficient solution using a HashMap:

class Solution:
    def twoSum(self, nums, target):
        t_sum = {}
        for index, i in enumerate(nums):
            if target - i in t_sum:
                return [t_sum[target - i], index]
            t_sum[i] = index

Complete Code on GitHub

You can find the complete implementation of this solution in my GitHub repository here:

🔗 Two Sum – Python Solution (GitHub)

Time & Space Complexity

• Time Complexity: O(n) — single traversal of the array
• Space Complexity: O(n) — extra space for the HashMap

Final Takeaway

The Two Sum problem is not just about solving one question— it teaches an important pattern: using extra space to reduce time complexity.

Once this intuition clicks, many array and HashMap problems become much easier to approach, especially in coding interviews and competitive programming.