Two Pointers and Sliding Window

The problem

Some interview techniques scare people more because of the name than the logic.

Two pointers and sliding window belong in that bucket.

A lot of people turn them into a recipe:

• if the prompt looks like a substring, use sliding window
• if the array is sorted, use two pointers

That can help for a while.

It breaks as soon as the prompt changes one small detail.

The real problem is not remembering the label.

It is not having a clear mental model for why moving boundaries solves the problem.

Mental model

These techniques exist to avoid repeated work.

You have a sequence.

Instead of rechecking a bunch of ranges from scratch, you keep adjusting boundaries and reusing what you already know.

The core idea is simple:

• there is an active region of the sequence
• I can expand or shrink that region
• each move changes the state in a predictable way

If you want the short version:

Two pointers and sliding window work when the answer is in moving boundaries, not restarting the analysis every time.

Two pointers is the broader idea.

Sliding window is the more specific case where the active region is usually a contiguous slice defined by two limits.

Breaking it down

When two pointers usually shows up

Two pointers often fits problems like:

• a sorted array
• comparing from both ends
• finding a pair with some property
• deciding which side should move based on the current value

Typical examples:

• target sum in a sorted array
• removing duplicates from a sorted array
• container with most water
• checking a palindrome by comparing the edges

The point is that the pointers carry enough information to make the next decision.

When sliding window usually shows up

Sliding window often fits problems that talk about:

• substring
• subarray
• contiguous range
• the largest or smallest window that satisfies a rule

Classic examples:

• longest substring without repeats
• smallest subarray with sum above a target
• a window with at most k changes

The important part is that the window holds state you can update incrementally:

• sum
• frequency
• number of duplicates
• count of valid characters

The question that unlocks it

When you are unsure, ask:

Can I move one boundary and update the state without recomputing everything?

If the answer is yes, sliding window starts to make sense.

Another useful question is:

Is there a clear rule for which pointer moves next?

If the answer is yes, two pointers may be the right shape.

Not every window is really sliding

Sometimes people force the technique just because the prompt mentions a substring.

But the condition does not stay valid in a cheap, incremental way.

Or the property depends on information that is expensive to maintain.

When that happens, forcing sliding window only gives you awkward code.

That is a good maturity check:

if the state update feels fake, the technique may not be the right one.

Simple example

Take this prompt:

Find the longest substring without repeated characters.

Baseline

Try every possible substring.

For each one, check whether it contains duplicates.

That works.

It is just too expensive.

Sliding window

Keep track of:

• left
• right
• a Set or map of the characters currently in the window

As right expands, add the new character.

If you hit a duplicate, move left until the window becomes valid again.

The important part is this:

you do not recompute the whole substring.

You only adjust the boundaries and update the state.

That is what cuts the cost.

The pattern is not “memorize this answer.”

It is:

• contiguous range
• validity rule
• incremental state update

Common mistakes

• Using two pointers without being able to explain why one pointer moves and the other does not.
• Forcing sliding window onto a problem that is not really about a contiguous range.
• Recomputing the whole window at every step and losing the benefit of the technique.
• Mixing sorted-array logic with window logic and turning both into a mess.
• Treating the technique name as the end goal instead of the underlying structure.

How a senior thinks

People who have seen enough of these problems start looking for invariants.

The reasoning usually sounds like this:

• what do my pointers or my window represent right now?
• when is this state valid?
• what changes when I move one side?
• can I make sure each element enters and leaves only a few times?

That last question matters.

It is often the reason a solution becomes O(n).

Each item is not reprocessed over and over.

It enters the window, maybe leaves, and the analysis moves on.

In real work, the same thinking shows up in streams, parsing, rolling metrics, deduplication over time, and product logic that needs to react as input changes.

So this is not just interview trivia.

What the interviewer wants to see

The interviewer wants to know whether you can:

• recognize a contiguous range or a boundary comparison
• define the state you are maintaining
• explain the rule that moves each pointer
• understand why the technique reduces complexity

If you can say, “I maintain a valid window, expand while I can, and contract when the rule breaks,” that already shows judgment.

The technique is not about two pointers. It is about two justified decisions.

When the right boundary moves at the right time, the problem stops needing brute force.