How to Solve Any LeetCode Problem: A 5-Step Framework

Step 1: Understand the Problem

Most wrong answers start with a misunderstood problem. Before you think about algorithms, make sure you know exactly what is being asked.

1A — Restate the inputs and outputs

Say it out loud (or write it down): "I receive an array of integers and a target integer. I must return the indices of two numbers that sum to target." If you cannot restate the problem clearly, you do not understand it yet.

1B — Clarify the constraints

Constraints tell you which algorithms are even feasible. They are the single strongest signal for choosing a pattern.

• n ≤ 20 — brute force, backtracking, bitmask DP are all fine
• n ≤ 10⁴ — O(n²) is acceptable; two pointers, sliding window
• n ≤ 10⁵ — O(n log n) or O(n); sorting, binary search, hash map
• n ≤ 10⁷+ — must be O(n) or O(log n); math, prefix sum, binary search

1C — Walk through examples and edge cases

Work through the provided examples by hand. Then invent your own edge cases:

• Empty input (n = 0)
• Single element
• All duplicates
• Already sorted / reverse sorted
• Negative numbers, zeros
• Maximum constraint value

If your approach handles these, it will almost certainly handle everything in between. This step typically takes 2–3 minutes but saves 10+ minutes of debugging.

Step 2: Identify the Pattern

This is the step where most people get stuck, and where this framework saves the most time. Instead of guessing, use two signals: the input data structure and what the problem asks you to do.

Pattern Identification Cheat-Sheet

When you see a certain signal in the problem, try the corresponding pattern:

Not sure which row fits? Use the AlgoArk Decision Tree — it asks you yes/no questions and narrows down to the correct pattern automatically.

What if multiple patterns seem to fit?

This is normal. Many problems combine patterns ( Binary Search + Greedy, BFS + Hash Map). When two patterns seem plausible, pick the one whose time complexity matches the constraint best. For a deeper look at combination patterns, read our Pattern Combinations Guide.

Step 3: Write Pseudocode First

Never jump straight to code. Pseudocode lets you validate your logic without worrying about syntax. It is also what interviewers want to see — they can follow along, give feedback, and spot issues before you spend five minutes coding a wrong approach.

Example: Two Sum

Problem: given an array and a target, return indices of two numbers that add up to target.

# Pattern: Hash Map (complement lookup)

function twoSum(nums, target):
    create empty hash map: complement -> index

    for i from 0 to len(nums) - 1:
        complement = target - nums[i]

        if complement exists in map:
            return [map[complement], i]

        map[nums[i]] = i

    return []  # no solution found

Example: Maximum Subarray (Kadane's)

# Pattern: Kadane's Algorithm

function maxSubarray(nums):
    currentSum = nums[0]
    maxSum     = nums[0]

    for i from 1 to len(nums) - 1:
        # Either extend the current subarray or start fresh
        currentSum = max(nums[i], currentSum + nums[i])
        maxSum     = max(maxSum, currentSum)

    return maxSum

Example: Sliding Window — Longest Substring Without Repeating

# Pattern: Sliding Window

function lengthOfLongestSubstring(s):
    create empty set: charSet
    left = 0
    maxLen = 0

    for right from 0 to len(s) - 1:
        while s[right] in charSet:
            remove s[left] from charSet
            left += 1

        add s[right] to charSet
        maxLen = max(maxLen, right - left + 1)

    return maxLen

Notice how each pseudocode block starts with a comment naming the pattern. This anchors your thinking and communicates intent to the interviewer. After writing pseudocode, trace through your example from Step 1 to verify correctness before moving on.

Step 4: Implement and Test

Now translate your pseudocode to real code. Because the logic is already validated, this step is mostly mechanical.

Implementation checklist

• Use descriptive variable names: left, right, windowSum — not i, j, s
• Handle edge cases first (empty array, single element, null input) with early returns
• Get the brute force working before optimizing — a correct O(n²) beats a buggy O(n)
• Use helper functions if a block of logic is complex

Testing strategy

After writing code, test with at least three cases:

Walk through the code line by line with your happy-path example. Track variables in your head (or on paper). If any variable has an unexpected value, you have found a bug. Fix it before submitting.

Step 5: Optimize

Once your solution is correct, ask yourself: can I do better? Interviewers often follow up with "Can you improve the time or space complexity?"

Common optimization moves

• Hash map for O(1) lookup: replace nested loops with a hash map to turn O(n²) into O(n).
• Sort + two pointers: for pair/triplet problems, sorting unlocks two pointers at O(n log n).
• Binary search on answer: if you can frame the problem as "is X possible?" with a monotonic check function, binary search on the answer space works.
• Sliding window instead of prefix sum: when the window condition is monotonic (all positive values), sliding window avoids a hash map entirely.
• DP space reduction: if your DP only depends on the previous row, reduce from O(n²) space to O(n).
• Heap for streaming top-K: instead of sorting the entire array, maintain a min-heap of size K with Top K.

State your complexity explicitly

Always tell the interviewer: "This runs in O(n) time and O(n) space because we iterate once and store at most n entries in the hash map." Naming the complexity shows mastery and prevents follow-up questions.