• n == height.length
• 2 <= n <= 10⁵
• 0 <= height[i] <= 10⁴

We choose two vertical lines and pour water between them. The amount held is width times height, where width is how far apart the lines are and height is the shorter of the two — water spills over the lower wall, so the lower wall sets the level. We want the biggest such amount over all pairs of lines.

Check all pairs (i, j), compute (j - i) * min(height[i], height[j]) for each, keep the largest. That is two nested loops, about N²/2 pairs, so O(N²) — too slow when n reaches 100,000.

best = 0
for i in range(len(height)):
    for j in range(i + 1, len(height)):
        best = max(best, (j - i) * min(height[i], height[j]))
return best

This is the converging walk again, but the decision rule is new — and it is the interesting part. Put left on the first line and right on the last, the widest container there is. Measure its water. Now we must move one of the two pointers inward, which will shrink the width. Which one should we sacrifice?

Here is the key observation. The water is capped by the shorter wall. Say the left wall is the shorter one. Moving the taller (right) wall inward is pointless: the width drops, and the height is still stuck at the short left wall — the water can only stay the same or get worse, never better. So the right wall can't help while the left wall is the bottleneck. The only move with any hope of a bigger container is to abandon the shorter wall and look for a taller one. So: always step the pointer on the shorter wall inward, and track the best area seen.

left, right = 0, len(height) - 1
best = 0
while left < right:
    best = max(best, (right - left) * min(height[left], height[right]))
    if height[left] < height[right]:
        left += 1                      # shorter wall on the left — drop it
    else:
        right -= 1                     # shorter (or tied) wall on the right — drop it
return best

It is worth proving we don't skip the real answer. Suppose the left wall is the shorter one right now. Consider every container that uses this left wall — it pairs with the current right wall, or some wall further left of right. All of those are narrower than the current one (right has moved in), and none can be taller than this same short left wall. So the widest container this short wall will ever appear in is the one we just measured. We have already recorded its best possible contribution; keeping the wall around can only waste steps. Discarding it is safe. Each step permanently drops one wall, so the two pointers meet after about N steps — one linear pass.

Slot it into the template: (a) we read the area from the two ends; (b) we move whichever end holds the shorter wall; (c) we record the running maximum. Notice the enabling property is different from the sorted-sum problems — there is no sorting here. What lets us discard an end is that the objective is bottlenecked by the smaller of the two ends: because the short wall caps the water, we can prove the short wall's best container is the current, widest one. Recognizing that "the answer between two boundaries is limited by the weaker boundary" is the signal to try moving the weaker boundary inward. If the objective did not have that bottleneck shape — if, say, height added instead of capping — this exact discard argument would collapse and you would need a different tool. Same converging skeleton, a problem-specific reason for which end to drop.