Python LeetCode Journey: Solving Two Sum as a Beginner

My First LeetCode Challenge: Two Sum Solution

As a Python novice with limited coding experience, I documented my raw attempt at solving LeetCode's Two Sum problem. With only basic Python knowledge from boot.dev courses and animation experience using Manim library, I tackled this "easy" coding interview question. The process revealed surprising challenges - from understanding terms like "indices" to debugging nested loops. After 33 minutes of trial and error, I finally created a working solution. Here's what I learned that every beginner should know.

Understanding the Problem and Initial Approach

The Two Sum problem requires finding two numbers in an array that add up to a target value, then returning their positions. For example, given [2,7,11,15] and target 9, the solution should return [0,1] since 2+7=9.

Key insight I gained: "Indices" simply means positions in the array. My initial confusion highlights why beginners should clarify terminology before coding. I used a double loop approach:

1. Iterate through each number using its index
2. For each number, iterate through remaining numbers
3. Check if pairs sum to target
4. Return indices when found

The video demonstrates how I fixed critical errors:

• Using range(len(nums)) instead of direct iteration to access indices
• Preventing self-comparison by ensuring inner loop starts after current index
• Handling duplicate values like [3,3] with target 6

Debugging Process and Solution Optimization

My initial solution failed test cases due to three key mistakes:

1. Self-comparison: The inner loop compared numbers to themselves
2. Index handling: Incorrect variable naming (num vs nums)
3. Edge case oversight: Duplicate values required careful index management

Corrected solution structure:

def twoSum(nums, target):
    for i in range(len(nums)):
        for j in range(i+1, len(nums)):
            if nums[i] + nums[j] == target:
                return [i, j]

Why this works:

• Outer loop processes each item once
• Inner loop starts at i+1 to avoid repeats
• Immediate return when solution found

Key Learnings for Coding Beginners

1. Problem analysis matters most: Spend 10 minutes understanding requirements before coding
2. Test early: Use provided test cases immediately
3. Master fundamentals: Array indexing and loops are essential for 80% of easy problems
4. Edge cases are crucial: Always test with duplicates, zeros, and negative numbers

Common pitfalls to avoid:

• Forgetting Python's zero-based indexing
• Modifying arrays while iterating
• Using nested loops for large datasets (O(n²) complexity)

Beginner Action Plan for LeetCode

1. Start with array problems: They build core logic skills
2. Practice daily: Solve 1 easy problem consistently
3. Learn complexity analysis: Understand Big O notation basics
4. Use Python Tutor: Visualize code execution step-by-step
5. Join coding communities: Get feedback on solutions

Recommended resources:

• boot.dev (ideal for beginners with interactive Python courses)
• NeetCode.io (excellent video explanations of LeetCode patterns)
• PythonTutor.com (visualize code execution - crucial for debugging)

Conclusion: Embrace the Struggle

Solving my first LeetCode problem taught me that programming isn't about instant brilliance - it's about systematic problem-solving through errors. The 33-minute struggle with Two Sum proved more valuable than any perfect solution. What matters isn't avoiding mistakes, but developing the persistence to debug them.

"When starting your coding journey, which concept feels most intimidating? Share your challenge below - let's solve it together!"