Timevolt

Posted on Jul 13

Like a Jedi: Mastering LeetCode with the Two‑Pointer Technique

#interview #career #programming #softwareengineering

The Quest Begins (The "Why")

I still remember the first time I opened LeetCode as a total newbie. The problem list looked like a dragon’s hoard—shiny, intimidating, and impossible to carry all at once. I picked “Two Sum II – Input array is sorted” because it sounded easy, then spent 45 minutes writing a double‑loop, checking every pair, and watching my submission time‑out on the biggest test case. I felt like Luke staring at the Death Star, wondering how a tiny proton torpedo could ever make a dent.

The frustration wasn’t about my logic; it was about the approach. I was brute‑forcing when the problem practically whispered a smarter path. That moment—when my code timed out and I realized I was missing a simple pattern—became the spark for my quest: find a single, repeatable technique that turns many “hard‑looking” array problems into smooth, linear‑time victories.

The Revelation (The Insight)

The treasure I uncovered was the two‑pointer technique.

If the array is sorted (or can be sorted), you can place one pointer at the start and another at the end, then move them inward based on a simple comparison.

That’s it. No nested loops, no extra data structures—just two indices marching toward each other. The technique works whenever the decision to move left or right depends on a monotonic property (e.g., sum too small → move left pointer right; sum too big → move right pointer left).

Why does this feel like a lightsaber? Because it slices through O(n²) complexity in a single swing, leaving O(n) time and O(1) space. Once you internalize the pattern, problems like “Container With Most Water”, “3Sum”, “Remove Duplicates from Sorted Array II”, and even “Valid Palindrome” start to feel like routine drills rather than boss fights.

Wielding the Power (Code & Examples)

The Struggle: Brute Force

Here’s how I initially tackled Two Sum II (the sorted version):

function twoSumBrute(numbers, target) {
  for (let i = 0; i < numbers.length; i++) {
    for (let j = i + 1; j < numbers.length; j++) {
      if (numbers[i] + numbers[j] === target) {
        return [i + 1, j + 1]; // 1‑based indices as LeetCode expects
      }
    }
  }
  return [];
}

What’s wrong?

O(n²) time – the inner loop repeats work we already know isn’t needed.
No early exit based on the sorted order; we keep checking pairs that are obviously too big or too small.

The Victory: Two‑Pointer

Now the same problem with the two‑pointer spell:

function twoSumPointer(numbers, target) {
  let left = 0;
  let right = numbers.length - 1;

  while (left < right) {
    const sum = numbers[left] + numbers[right];

    if (sum === target) {
      return [left + 1, right + 1]; // found!
    } else if (sum < target) {
      left++;   // need a bigger sum → move left pointer right
    } else {
      right--;  // sum too big → move right pointer left
    }
  }
  return []; // no solution (shouldn't happen for valid LeetCode input)
}

Why this works:

Because numbers is sorted, increasing left always increases the sum, and decreasing right always decreases it.
Each step discards a portion of the search space that can’t possibly contain the answer, guaranteeing we finish after at most n moves.

Common Traps (The “Don’t Do This” Signs)

Forgetting to sort first – If the input isn’t guaranteed sorted, sorting adds O(n log n) but is still far better than O(n²). Missing this step leads to wrong answers on unsorted tests.
Moving both pointers on the same condition – e.g., if (sum < target) { left++; right--; }. This skips viable pairs and can miss the solution.
Ignoring duplicate values when they matter – For problems like 3Sum, you need to skip over equal values after recording a triplet to avoid duplicate results. A simple while (left < right && nums[left] === nums[left+1]) left++; does the trick.

Another Quick Example: Container With Most Water

Brute force (O(n²)): check every pair of lines.

Two‑pointer (O(n)):

function maxArea(height) {
  let left = 0, right = height.length - 1, max = 0;
  while (left < right) {
    const width = right - left;
    const current = Math.min(height[left], height[right]) * width;
    max = Math.max(max, current);
    if (height[left] < height[right]) {
      left++;
    } else {
      right--;
    }
  }
  return max;
}

Same principle: move the pointer at the shorter line because moving the taller one can’t increase the area.

Why This New Power Matters

Adopting the two‑pointer mindset changed my LeetCode experience from “grind until I’m exhausted” to “recognize the pattern, apply the spell, move on.”

Speed: Most array‑based problems drop from O(n²) to O(n), turning minutes‑long struggles into sub‑second runs.
Confidence: When you see a sorted array, you instantly know the go‑to tool. No more second‑guessing whether to reach for a hash map, a stack, or recursion.
Transferability: The same pattern pops up in interview questions, competitive programming, and even real‑world sliding‑window tasks (think streaming data or buffer management).

In short, you’ve upgraded from a wooden sword to a lightsaber—still the same hand, but now you can cut through the toughest defenses.

Your Next Quest

Pick one of these problems and solve it using only the two‑pointer technique (no extra arrays, no nested loops):

Two Sum II – Input array is sorted (167)
Container With Most Water (11)
3Sum (15)
Remove Duplicates from Sorted Array II (80)

After you’ve cracked it, drop a comment with your solution or aha‑moment. I’m curious—did the technique feel like discovering a hidden shortcut in a video game, or did it feel more like finally understanding the Force? May your pointers always converge on the answer! 🚀

DEV Community