Problem bank

Compare characters from both ends, skipping non-alphanumerics.

One pointer reads, another marks where the next non-zero goes.

The biggest square is always at one of the two ends.

Sum too big? Only one pointer can fix that.

Fix one number, then it's Two Sum II on the rest.

The shorter wall limits the area — which one is worth moving?

Three regions, three pointers, one pass.

Water at a spot depends on the smaller of the tallest walls on each side.

Fixed width: add the new element, drop the old one.

When a repeat enters, pull the left edge past it.

All positives — once the sum is big enough, shrink.

Longest window with at most two distinct values.

Window is valid while length minus its most common char ≤ k.

Fixed window of len(s1); compare letter counts.

Expand until every needed char is covered, then shrink greedily.

Keep only indices that could still become the max.

Left sum vs total minus left minus current.

Precompute once, answer each query by subtraction.

Which earlier running total would make this one work?

Treat 0 as -1; you're now looking for sum 0.

Same remainder twice, at least two apart.

Count prefix remainders, not prefix sums.

Map each number to 1 if odd, 0 if even — familiar now?

Fix a pair of rows, collapse columns, reuse the 1-D trick.

Compare to the middle, discard half.

First index whose value is ≥ target.

Good…good, bad…bad — find the first bad.

Two lower-bound searches: for target and target + 1.

One side of mid is always sorted.

Search over speeds; can she finish in time?

Guess a capacity, simulate the days.

Binary search the cut position in the smaller array.

Precompute next-greater for nums2 once.

Who's still waiting for a warmer day?

Collapse smaller previous prices into the current one.

Walk the array twice.

A bigger digit before a smaller one should go.

For each element: how far left and right is it the minimum?

A bar's rectangle ends at the first shorter bar on each side.

Each row is the base of a histogram.

Build ranges while the next number continues the run.

After sorting, who can the next interval possibly overlap?

Three phases: before, overlapping, after.

Keep the one that ends first.

Shoot at the earliest end point.

Two pointers; advance whoever finishes first.

Passengers on at start, off at end — track the peak.

Keep intervals sorted; a new number can join neighbours.

Smallest cookie that satisfies the least greedy child.

Collect every upward step.

Track how far you could get.

Think of reachable ranges as BFS levels.

If you run dry at i, every start before i fails too.

A part can't end before the last occurrence of any letter in it.

The smallest card must start a group.

Two passes: left neighbours, then right neighbours.

Will a faster runner ever catch a slower one?

Half speed lands halfway.

The digit-square process is a hidden linked list.

Find the middle, then compare halves.

After meeting, restart one pointer from head.

Give one pointer an n-step head start.

Middle, reverse second half, weave.

Indices as nodes, values as next pointers.

Three references are all you need.

Anchor the node just before the segment.

It's reversal with k = 2.

Close it into a ring, then cut at the right spot.

Reverse the second half and walk both halves together.

Count k ahead before you flip anything.

Keep only k seats on stage.

Always grab the two heaviest.

You don't need the whole array sorted.

Count first, then keep the best k counts.

Keep the k smallest distances — which heap evicts the farthest?

Always run the most frequent available task.

The next output node is the smallest of k heads.

Two heaps facing each other.

The first leaf you meet floor by floor wins.

Sum and count per level.

Freeze the queue length at the start of each floor.

Who's last on each floor?

Same BFS, flip direction each level.

Neighbours on the same floor are adjacent in the queue.

Number positions like a heap: 2i and 2i+1.

Level order with explicit null markers.

Ask both children, take the bigger, add one.

Swap, then let recursion handle the rest.

Return height, but record left + right.

Compute height and balance in the same pass.

Every node lives inside a range set by its ancestors.

If both sides report a hit, you're the answer.

Carry the remaining target down; undo on the way back.

Return the best single arm; record the best bend.

Spread from one cell to same-coloured neighbours.

Each new paint bucket is one island.

Count cells while you flood.

All rotten oranges spread at the same time.

What's safe is connected to the border.

Let water flow uphill from each ocean.

Map old node → new node as you traverse.

Words are nodes; one-letter changes are edges; shortest path.

Can every course's blockers eventually clear?

Record the order in which blockers clear.

Ingredients are prerequisites of recipes.

Reverse the edges and peel off nodes with no outgoing paths.

Propagate prerequisite sets in topological order.

Peel leaves layer by layer toward the centre.

Earliest finish = own time + latest-finishing prerequisite.

Two levels of topological sort: groups, then items.

Same leader means same group.

Start with n groups; each real merge removes one.

Which edge joins two already-joined nodes?

Spare cables vs components minus one.

Union all '==' first, then check every '!='.

Emails are nodes; an account unions its emails.

Answer = stones minus number of groups.

Add cells by height until corners connect.

Extend the path going down, trim it coming back.

Each element: in or out.

Any unused element can go in the next slot.

You may pick the same number again — where does the next call start?

Sort, then skip equal siblings.

One digit per level of the tree.

Mark a cell while it's on the path, unmark on the way back.

One queen per row; track used columns and diagonals.

How could you have arrived at the last step?

Cheapest way to stand on step i.

Rob this one plus two back, or skip it.

Break the circle two different ways.

Last char alone, or last two together?

Which coin did you use last?

A prefix is breakable if it ends with a word after a breakable prefix.

Best chain ending at i, built from any smaller earlier end.

Each cell is the sum of the two above it.

You arrived from the top or from the left.

Cheapest arrival from top or left.

Match? Go diagonal. No match? Drop a char from one side.

Compare the two ends of each range.

Insert, delete, replace — three neighbours.

On a match, you may use this char or skip it.

A star means zero copies or one more copy.