Two pointers vs sliding window, and three more pairs people confuse

Short answer. Two pointers walk in from both ends of a sorted array and answer about a pair. A sliding window moves both indexes forward and answers about the contiguous range between them. To stop mixing the two up, log the pattern you reached for after every wrong answer. After twenty problems the log shows your pairs.

Machine learning people call this a confusion matrix.

Rows are the truth. Columns are the prediction. The interesting numbers sit off the diagonal.

Why "wrong" is not enough

A problem site gives you one bit. Solved, or not.

A wrong answer breaks down into four separate ways to miss.

Wrong pattern. Right pattern, forgotten step. Right approach, broken edge case. Plain typo.

Each needs a different response.

Collapsed into one red cross, you cannot pick. So you open another problem.

This collapse is how people grind for months and stay put.

Four pairs that catch nearly everyone

Two pointers and sliding window. Both walk an array with two indices. The window keeps a valid range and answers about that range. Two pointers converge from the ends and usually need the array sorted. Ask what the two indices mean, and the pair separates.

Prefix sums and a sliding window. Windows want a sum that grows when you extend.

One negative number kills that. Prefix sums take over.

The signal is the phrase "may contain negative numbers". It is easy to read past. Reading the statement twice catches it.

Backtracking and dynamic programming. Both explore choices.

Backtracking wants every arrangement. Its cost is the number of answers.

Dynamic programming wants one number. So it throws away everything except the best.

Asking whether to list them or count them resolves most cases.

BFS and Dijkstra. Identical until edges have weights.

Unweighted, breadth-first search is already shortest. Weighted, it silently returns the wrong answer.

Silently wrong is worse than crashing, and it is why Dijkstra exists.

What to log

Three columns is enough.

• What it actually was.
• What you reached for.
• The word in the problem that should have stopped you.

The third column is the fix. A confusion is nearly always a signal you did not weigh.

Which is the same claim as pattern recognition being the trained skill.

By the fourth entry, the same word shows up again.

What to do with a pair

Do not reread both patterns. Write the one sentence that separates them, in your own words.

"A window is valid, a two-pointer walk is sorted." "Backtracking lists, DP counts."

Take two problems, one of each, back to back. For the first pair, the free lessons two pointers from both ends and a window that changes size make that drill.

The contrast makes the sentence stick. Studying them a week apart is how the confusion formed.

Gaps are for one pattern at a time: spaced repetition.

The honest part

Your matrix will be personal. It will look nothing like a list of hard topics.

Mine had heaps and sorting side by side for months. No curriculum pairs those two.

Noticing your own pattern gaps is the point. You are collecting facts about yourself. There are fewer of them than it feels like.

Where this is built in

AlgoPath keeps this matrix for you.

The drill records the pattern you named against the right one. The pairs you confuse come back more often.

The first 33 steps are free.