A Framework for Any DSA Question

The plain-language idea

Think about how a good cook handles a recipe they've never made. They don't panic — they read it, gather ingredients, taste as they go, and adjust. They have a process that works no matter the dish.

Most people walk into a DSA interview hoping they've seen the exact question before. That's fragile — you can't memorize every problem. What works instead is a small process you run every time, seen before or not. Here it is, in six steps:

1. Restate the problem in your own words. Say out loud what the input is, what the output should be, and what counts as success.
2. Work a small example by hand. Pick tiny numbers. Trace the answer step by step, on paper or out loud.
3. Get a brute-force solution working first, even if it's slow. A correct slow answer beats an incorrect fast one, and gives you something to compare against later.
4. Look for ways to speed it up. Where is the brute force wasting work? Is there a data structure that would skip that waste?
5. Code it. Now, and only now, write the real solution — the one you already understand in your head.
6. Test it against your example. Trace your code through step 2's example. Does it match?

This is, honestly, the single most valuable thing in this track. Patterns like two pointers or hash maps are tools. This framework is what tells you when to reach for which one, on a problem you've never met before.

See it in a real thing: applying the six steps

// Problem: "Given an array of numbers, find the largest gap between
// any two numbers that appear in increasing order (left one smaller)."

// Step 1: restate it. "Find two numbers, left one smaller than right
// one, where (right - left) is as big as possible."

// Step 2: small example by hand. [3, 8, 1, 9]
// Pairs where left < right: (3,8)=5, (3,9)=6, (1,9)=8. Biggest gap: 8.

// Step 3: brute force. Check every pair. Slow, but obviously correct.
function largestGapBruteForce(nums) {
  let best = 0;
  for (let i = 0; i < nums.length; i++) {
    for (let j = i + 1; j < nums.length; j++) {
      if (nums[i] < nums[j]) {
        best = Math.max(best, nums[j] - nums[i]); // keep the biggest gap seen
      }
    }
  }
  return best;
}

// Step 6 (testing step 3 early): largestGapBruteForce([3, 8, 1, 9]) -> 8. Matches!

What people usually miss

Watch out

• Skipping straight to "the clever solution." Without a brute force to compare against, you have nothing to check your fast idea against — and interviewers notice when you can't explain why it works.
• Doing the small example in your head instead of on paper. Writing it down catches mistakes your head glosses over. It's free insurance.
• Treating step 4 as optional. Speeding up the brute force is where the real interview signal lives, more than the code you type.

The genealogy: what this sets up

Every pattern earlier in this track — two pointers, sliding window, hash maps for instant lookup — is a specific answer to step 4: "how do I speed up the brute force?" This framework gets you there on a problem none of those lessons covered directly.