The Quest Begins (The "Why")

I still remember the first time I opened LeetCode feeling like a wide‑eyed Padawan staring at a holocron. I’d pick a problem, stare at the solution for ten minutes, copy it, move on, and then feel completely lost when a slightly different prompt showed up. It was like trying to wield a lightsaber without ever feeling the Force—lots of motion, zero impact. I knew I was grinding, but I wasn’t getting stronger. The frustration built up until I realized I was treating each problem as a isolated boss fight instead of learning the underlying patterns that connect them. That’s when I decided to change my approach and look for a single, repeatable technique that would actually stick.

The Revelation (The Insight)

The breakthrough came when I started treating every solved problem like a mini‑lesson I had to teach someone else. I call it the Teach‑Back Method: after you get a working solution, you pause, explain the algorithm out loud as if you’re teaching a five‑year‑old, and then write one plain‑English sentence that captures the core idea or pattern. That’s it. No fancy notebooks, no endless flashcards—just a verbal recap and a crisp summary.

Why does this work? Because teaching forces you to reorganize your knowledge from “I memorized steps” to “I understand why those steps exist.” When you articulate the logic in simple terms, your brain spots the invariant, the data structure trick, or the loop invariant that makes the solution tick. Once you have that sentence, you’ve got a mental hook you can reuse on future problems. It’s like leveling up your character in an RPG—each teach‑back gives you a new skill point that applies to many quests ahead.

Wielding the Power (Code & Examples)

Before: The Copy‑Paste Trap

Let’s look at a classic easy problem: Two Sum.

# Struggle version – just copying a solution I found online
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]

I’d run this, see it passed, and move on. The next day, a variant asked for “return the indices of three numbers that sum to target.” I stared blankly because I had never internalized the why behind the nested loops—I just knew “brute force works for two.”

After: Applying Teach‑Back

After solving the problem, I explained it out loud:

“We need to find two numbers that add up to a target. As we walk through the list, we can remember what number we’d need to complete the pair. If we’ve already seen that needed number, we’ve found the answer.”

That forced me to think about a lookup table. The “one‑sentence summary” I wrote down was:

“Use a hash map to store each number’s index and check for its complement while iterating.”

Now the solution looks like this:

# Victory version – pattern extracted via teach‑back
def twoSum(nums, target):
    seen = {}                     # value -> index
    for i, num in enumerate(nums):
        complement = target - num
        if complement in seen:    # we’ve already seen the partner
            return [seen[complement], i]
        seen[num] = i             # store current number for future checks

The teach‑back turned a vague memory of “nested loops” into a concrete, reusable pattern: hash map for complement lookup. When I later faced the “3Sum” variant, I immediately thought, “Can I fix one number and reduce it to a two‑sum problem?”—and the same hash‑map idea guided me to a far faster solution.

Another Example: Maximum Subarray (Kadane’s Algorithm)

Before: I’d try every possible subarray, O(n²), and feel proud when it passed the small test cases.

After: I taught myself the idea:

“At each position, the best subarray ending here is either the current element alone, or the current element plus the best subarray ending at the previous position.”

One‑sentence summary:

“Keep running sum; reset to zero when it drops below zero, tracking the maximum seen.”

Code:

# Before – brute force (inefficient)
def maxSubArray(nums):
    best = float('-inf')
    for i in range(len(nums)):
        for j in range(i, len(nums)):
            best = max(best, sum(nums[i:j+1]))
    return best

# After – Kadane’s, derived from teach‑back
def maxSubArray(nums):
    max_ending_here = max_so_far = nums[0]
    for x in nums[1:]:
        max_ending_here = max(x, max_ending_here + x)
        max_so_far = max(max_so_far, max_ending_here)
    return max_ending_here

The teach‑back didn’t just give me a faster algorithm; it gave me a mental model I could apply to any “running total” problem—stock profit, longest positive streak, you name it.

Why This New Power Matters

When you internalize the why behind a solution, you stop treating LeetCode as a memorization marathon and start seeing it as a pattern‑recognition gym. Each teach‑back session deposits a reusable concept in your mental toolbox. Over weeks, you’ll notice that medium‑hard problems begin to feel like variations of themes you’ve already mastered, not alien monsters. Your confidence spikes because you’re not hoping you remembered the right trick; you know the trick because you explained it yourself.

And the best part? The technique scales. Spend five minutes after each problem to teach‑back and write that one‑sentence summary. Do that for 20 problems a week, and you’ll have built a personal cheat sheet of patterns—far more valuable than any pre‑made list of “top 100 interview questions.”

Your Turn: Start the Quest

Pick any problem you’ve solved today (or solve a new one right now). Close the editor, stare at the ceiling, and explain the solution out loud as if your rubber duck is a curious five‑year‑old. Then write one sentence that captures the essence. Post that sentence in a comment or a tweet—share your newly earned pattern with the world.

What’s the first sentence you’ll write? I can’t wait to see what patterns you unlock. Happy coding, and may the Force be with your teach‑backs! 🚀