Staring at a coding problem and not knowing where to start? You're not alone. The difference between struggling for hours and solving problems efficiently comes down to one thing: having a systematic approach.

This tutorial will teach you a proven framework that works for any data structures and algorithms problem.

Goal: Learn a step-by-step method to approach and solve any problem confidently.

Key Insight: Most people fail not because they lack knowledge, but because they lack a systematic approach. A good framework makes even hard problems manageable.

The 7-Step Problem-Solving Framework

Follow these steps for every problem:

Step 1: Understand the Problem

Step 2: Explore Examples

Step 3: Break It Down

Step 4: Solve a Simpler Version

Step 5: Implement the Solution

Step 6: Test and Debug

Step 7: Optimize

Let's explore each step in detail.

Step 1: Understand the Problem

Time to spend: 2-3 minutes
Goal: Fully understand what you're being asked to do

Questions to Ask:

›
What are the inputs?
- ›What type? (array, string, number, graph, etc.)
- ›What size? (constraints)
- ›What values? (range, negatives allowed?, duplicates?)
›
What are the outputs?
- ›Return value type
- ›Format (single value, array, boolean, etc.)
›
What are the constraints?
- ›Time limit
- ›Space limit
- ›Edge cases
›
Can I restate the problem in my own words?
- ›If you can't explain it simply, you don't understand it

Example Problem:

Problem: "Find the maximum sum of any contiguous subarray"

Understanding Phase:

›Input: Array of integers (can be negative)
›Output: Single integer (the maximum sum)
›Constraints: Array length 1 to 10^5
›Restate: Find a slice of the array where the sum of elements is highest

Questions to clarify:

›Can array have all negative numbers? (Yes)
›Is empty array possible? (No, at least 1 element)
›What if array has one element? (Return that element)

Step 2: Explore Examples

Time to spend: 3-5 minutes
Goal: Understand the problem through concrete cases

Types of Examples to Consider:

›Simple example - Small, easy to trace
›Complex example - Larger, tests your understanding
›Edge cases - Boundary conditions
›Invalid inputs - What if inputs don't meet constraints?

Example Problem: Maximum Subarray Sum

Input: [2, -1, 3, -2, 5]

Examples to trace:

Example 1 - Simple:

Input: [2, -1, 3]
Possible subarrays:
  [2] → sum = 2
  [-1] → sum = -1
  [3] → sum = 3
  [2, -1] → sum = 1
  [-1, 3] → sum = 2
  [2, -1, 3] → sum = 4
Maximum: 4

Example 2 - All negative:

Input: [-5, -2, -8, -1]
Maximum single element: -1
Output: -1

Example 3 - Single element:

Input: [5]
Output: 5

Example 4 - Complex:

Input: [2, -1, 3, -2, 5]
Best subarray: [2, -1, 3, -2, 5] → sum = 7
Output: 7

Step 3: Break It Down

Time to spend: 2-3 minutes
Goal: Write pseudocode or outline

Breaking Down the Problem:

›Write the function signature
›Outline the main steps in comments
›Identify data structures needed
›Note any helper functions

Example: Maximum Subarray Sum

Python

def max_subarray_sum(arr):
    # Step 1: Handle edge case - single element
    
    # Step 2: Initialize variables
    #   - max_sum: track best sum found
    #   - current_sum: track current subarray sum
    
    # Step 3: Iterate through array
    #   - Add element to current_sum
    #   - Update max_sum if needed
    #   - Reset current_sum if it goes negative
    
    # Step 4: Return max_sum
    
    pass

Benefits:

›Catches logical errors before coding
›Gives you a roadmap to follow
›Makes interviews smoother (show your thinking)

Step 4: Solve a Simpler Version

Time to spend: 5-10 minutes
Goal: Solve the problem ignoring some constraints

Simplification Strategies:

›Use brute force - Don't worry about efficiency yet
›Reduce input size - Solve for array of 3 elements
›Remove constraints - Assume all positive numbers
›Use extra space - Don't worry about O(1) space yet

Example: Maximum Subarray Sum (Brute Force)

Python

def max_subarray_sum_brute(arr):
    n = len(arr)
    max_sum = float('-inf')
    
    # Try all possible subarrays
    for i in range(n):
        for j in range(i, n):
            # Calculate sum of subarray arr[i:j+1]
            current_sum = sum(arr[i:j+1])
            max_sum = max(max_sum, current_sum)
    
    return max_sum

# Time: O(n³) - Very slow!
# Space: O(1)
# But it works correctly!

Why brute force first?

›Validates your understanding
›Provides a baseline solution
›Helps you identify what to optimize

Step 5: Implement the Solution

Time to spend: 10-15 minutes
Goal: Write clean, working code

Implementation Tips:

›Start with the simpler solution from Step 4
›Use clear variable names (not x, y, z)
›Add comments for complex logic
›Handle edge cases as you go
›Think about optimization as you write

Example: Optimized Solution (Kadane's Algorithm)

Python

def max_subarray_sum(arr):
    # Edge case: empty array (shouldn't happen per constraints)
    if not arr:
        return 0
    
    # Initialize with first element
    max_sum = arr[0]
    current_sum = arr[0]
    
    # Iterate from second element
    for i in range(1, len(arr)):
        # Either extend current subarray or start new one
        current_sum = max(arr[i], current_sum + arr[i])
        
        # Update maximum if needed
        max_sum = max(max_sum, current_sum)
    
    return max_sum

# Time: O(n) - Much better!
# Space: O(1)

# Test
print(max_subarray_sum([2, -1, 3, -2, 5]))  # Output: 7
print(max_subarray_sum([-5, -2, -8, -1]))   # Output: -1

Key Insight: By keeping track of current_sum, we avoid recalculating sums. If current_sum becomes negative, we start fresh (because adding a negative makes things worse).

Step 6: Test and Debug

Time to spend: 5-10 minutes
Goal: Verify correctness with various inputs

Test Cases to Run:

›Example cases from Step 2
›
Edge cases:
- ›Empty input
- ›Single element
- ›All same values
- ›Minimum/maximum values
›Your custom cases

Debugging Strategy:

If you get wrong output:

›Print intermediate values
›Trace through manually with a small example
›Check loop boundaries (off-by-one errors)
›Verify edge case handling

Example: Testing Maximum Subarray

Python

def test_max_subarray():
    # Test 1: Regular case
    assert max_subarray_sum([2, -1, 3, -2, 5]) == 7
    
    # Test 2: All negative
    assert max_subarray_sum([-5, -2, -8, -1]) == -1
    
    # Test 3: Single element
    assert max_subarray_sum([5]) == 5
    
    # Test 4: All positive
    assert max_subarray_sum([1, 2, 3, 4]) == 10
    
    # Test 5: Alternating signs
    assert max_subarray_sum([1, -3, 2, -1, 3]) == 4
    
    print("All tests passed!")

test_max_subarray()

Step 7: Optimize

Time to spend: Variable (if needed)
Goal: Make your solution more efficient

Optimization Checklist:

Time Complexity:

›Can I eliminate redundant calculations?
›Can I use a better data structure? (hash map, heap, etc.)
›Can I use a different algorithm? (divide and conquer, dynamic programming)

Space Complexity:

›Can I reuse the input array?
›Can I use constant space instead of extra arrays?
›Can I avoid recursion to save stack space?

Code Quality:

›Can I make variable names clearer?
›Can I extract repeated logic into functions?
›Can I simplify complex conditionals?

Optimization Example: From O(n³) to O(n)

We already optimized maximum subarray from brute force O(n³) to Kadane's algorithm O(n). Here's the progression:

Version 1: O(n³) - Triple nested loop
Version 2: O(n²) - Calculate sums incrementally
Version 3: O(n) - Kadane's algorithm (keep running sum)

Complete Example: Two Sum Problem

Let's apply the entire framework to a classic problem.

Problem Statement

Given: An array of integers and a target sum
Find: Indices of two numbers that add up to target
Constraint: Each input has exactly one solution, can't use same element twice

Step 1: Understand

›Input: Array of integers, target integer
›Output: Array of two indices
›Restate: Find positions i and j where arr[i] + arr[j] = target

Step 2: Examples

Input: [2, 7, 11, 15], target = 9
Output: [0, 1] (because 2 + 7 = 9)

Input: [3, 2, 4], target = 6
Output: [1, 2] (because 2 + 4 = 6)

Input: [3, 3], target = 6
Output: [0, 1]

Step 3: Break It Down

Python

def two_sum(nums, target):
    # Approach: Use hash map to store complements
    
    # Step 1: Create hash map to store value → index
    
    # Step 2: Iterate through array
    #   - Calculate complement (target - current)
    #   - Check if complement exists in hash map
    #   - If yes: return [complement_index, current_index]
    #   - If no: add current to hash map
    
    # Step 3: Return result
    pass

Step 4: Brute Force Solution

Python

def two_sum_brute(nums, target):
    n = len(nums)
    
    # Try all pairs
    for i in range(n):
        for j in range(i + 1, n):
            if nums[i] + nums[j] == target:
                return [i, j]
    
    return []

# Time: O(n²)
# Space: O(1)

Step 5: Optimized Solution

Python

def two_sum(nums, target):
    # Hash map: value → index
    seen = {}
    
    for i, num in enumerate(nums):
        complement = target - num
        
        # Check if complement exists
        if complement in seen:
            return [seen[complement], i]
        
        # Store current number
        seen[num] = i
    
    return []

# Time: O(n)
# Space: O(n)

# Test
print(two_sum([2, 7, 11, 15], 9))  # [0, 1]
print(two_sum([3, 2, 4], 6))       # [1, 2]

Step 6: Test

All tests pass! The hash map solution correctly handles all cases.

Step 7: Optimize

Already optimized from O(n²) to O(n) using a hash map. Can't do better than O(n) since we must look at each element at least once.

Common Problem Patterns

Recognizing patterns helps you choose the right approach faster.

Pattern 1: Two Pointers

When to use: Sorted array, finding pairs, palindromes

Example: Find if array has two numbers that sum to target (sorted array)

Python

def two_sum_sorted(arr, target):
    left = 0
    right = len(arr) - 1
    
    while left < right:
        current_sum = arr[left] + arr[right]
        
        if current_sum == target:
            return [left, right]
        elif current_sum < target:
            left += 1
        else:
            right -= 1
    
    return []

# Time: O(n), Space: O(1)

Pattern 2: Sliding Window

When to use: Contiguous subarrays, substrings, fixed/variable window size

Example: Maximum sum of k consecutive elements

Python

def max_sum_k_elements(arr, k):
    # Initial window
    window_sum = sum(arr[:k])
    max_sum = window_sum
    
    # Slide window
    for i in range(k, len(arr)):
        window_sum = window_sum - arr[i - k] + arr[i]
        max_sum = max(max_sum, window_sum)
    
    return max_sum

# Time: O(n), Space: O(1)

Pattern 3: Fast and Slow Pointers

When to use: Linked lists, cycle detection, finding middle

Example: Detect cycle in linked list (concept)

Fast pointer moves 2 steps, slow moves 1 step
If they meet, there's a cycle

Pattern 4: Hash Map/Set

When to use: Looking up values, counting occurrences, finding duplicates

Example: Find first duplicate

Python

def first_duplicate(arr):
    seen = set()
    
    for num in arr:
        if num in seen:
            return num
        seen.add(num)
    
    return -1

# Time: O(n), Space: O(n)

Pattern 5: Divide and Conquer

When to use: Can split problem into independent subproblems

Examples: Merge sort, binary search, quick sort

Problem-Solving Tips

Tip 1: Don't Rush to Code

Spend time understanding and planning. 5 minutes of planning saves 30 minutes of debugging.

Tip 2: Start Simple

Brute force is better than no solution. You can optimize later.

Tip 3: Talk Through Your Thinking

In interviews, explain your approach. Interviewers want to see your thought process.

Tip 4: Draw Diagrams

Visualize the problem. Draw arrays, trees, graphs, or state transitions.

Tip 5: Look for Patterns

Similar problems often have similar solutions. Build a mental library of patterns.

Tip 6: Test As You Go

Don't wait until the end to test. Verify each part works as you build it.

Tip 7: Ask Questions

Clarify ambiguities before coding. It's better to ask than to solve the wrong problem.

When You're Stuck

Strategy 1: Solve a Smaller Version

Can't handle array of size n? Try n = 3 first.

Strategy 2: Work Backwards

Start from the desired output and work back to the input.

Strategy 3: Look for Similar Problems

Have you solved something similar? Can you adapt that approach?

Strategy 4: Try a Different Data Structure

Hash map not working? Try a heap, queue, or stack.

Strategy 5: Take a Break

Step away for 5 minutes. Fresh perspective helps.

Key Takeaways

The 7-Step Framework:

›Understand the problem
›Explore examples
›Break it down
›Solve simpler version
›Implement solution
›Test and debug
›Optimize

Core Principles:

›Plan before you code
›Start with brute force
›Test early and often
›Recognize common patterns
›Communicate your thinking

Success Formula: Understanding + Strategy + Practice = Problem-Solving Mastery

What's Next?

Now that you have a problem-solving framework:

›Array Problems - Practice the framework on array problems
›String Problems - Apply to string manipulation
›Two Pointers Pattern - Master common patterns

Practice Problem

Apply the 7-step framework to this problem:

Problem: Given a sorted array, remove duplicates in-place such that each element appears only once. Return the new length.

Example:

Input: [1, 1, 2, 2, 3, 4, 4]
Output: 4 (array becomes [1, 2, 3, 4, _, _, _])

Your turn: Work through steps 1-7!

Hint: Two pointers pattern works well here.

Congratulations! You now have a systematic approach to solve any problem. Practice this framework on every problem you encounter!

←

PreviousAnalyze Code Complexity

NextHow to Identify Patterns

→