Loading…

mediumArraysLC #11Frequently asked

Container With Most Water

Q: How do you solve Container With Most Water using the Brute Force — Check Every Pair approach?

When to use it: Say it first to anchor the O(n²) baseline and to motivate the greedy two-pointer move. Consider every unordered pair of lines `(i, j)` and compute the rectangle they enclose: width `j - i` times the shorter height `min(height[i], height[j])`. Keep the largest area seen. **Why this is the natural first attempt.** The answer is literally 'the best pair of lines', so enumerating all pairs is the obvious correct baseline. Stating it shows you understand the area formula before optimizing. **Why we don't ship this.** With `n` up to `10⁵`, n²/2 is about 5 billion pairs — far too slow. The inefficiency is that we re-examine pairs that can't possibly beat what we've found. The two-pointer method exploits a property that lets us discard a whole wall at a time instead of one pair at a time. Time complexity: O(n²). Space complexity: O(1).

Q: How do you solve Container With Most Water using the Two Pointers — Move the Shorter Wall (Optimal) approach?

When to use it: The answer they want. Lead with the correctness argument, not just 'use two pointers'. Place `l` at index 0 and `r` at index `n-1` — the widest container possible. Compute its area, update the best, then advance the pointer sitting at the *shorter* wall. Repeat until the pointers meet. **Why starting widest is the right frame.** Width is maximal at the ends and can only shrink as pointers move inward. So every future container is narrower; the only thing that can make a narrower container win is a taller limiting wall. That reframes the search from 'try all pairs' to 'try to find a taller wall before width costs too much.' **Why moving the shorter wall is provably safe — the exchange argument.** Suppose `height[l] < height[r]`. The current area is `(r − l) × height[l]`. Consider keeping `l` fixed and moving `r` to any `r' < r`. The width `r' − l` is strictly smaller, and the height is still at most `height[l]` (the shorter wall, unchanged). So *every* container that keeps the short wall `l` is no better than the one we just measured. We can therefore discard `l` forever and move it inward — we lose nothing, and only by doing so might we find a wall taller than `height[l]`. The symmetric argument holds when the right wall is shorter. **Why this finds the global optimum.** Each pointer move permanently eliminates one wall as a left/right endpoint, but only after we've recorded the best container that wall could ever participate in. Since no discarded option could have beaten what we measured, the maximum we track is the true maximum. **Why O(1) space and one pass.** Two indices and a running maximum — nothing scales with input size, and each element is passed at most once. Time complexity: O(n). Space complexity: O(1).

LCPractice

Two Pointers · 3 of 30 · 9 min

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the iᵗʰ line are (i, 0) and (i, height[i]).

Find two lines that together with the x-axis form a container, such that the container contains the most water. Return the maximum amount of water a container can store.

Notice that you may not slant the container.

In plain English

Pick two of the vertical lines. The water they hold is the rectangle between them: its width is the index distance, its height is the shorter of the two lines (water spills over the lower wall). Maximize that rectangle's area. We choose two lines only — the bars between them are irrelevant here.

Examples

Example 1

Input: height = [1, 8, 6, 2, 5, 4, 8, 3, 7]
Output: 49
Note: Lines at index 1 (height 8) and index 8 (height 7): width 7 × min(8,7)=7 → 49.

Example 2

Input: height = [1, 1]
Output: 1
Note: Width 1 × min(1,1)=1 → 1.

Example 3

Input: height = [4, 3, 2, 1, 4]
Output: 16
Note: The two 4s at the ends: width 4 × min(4,4)=4 → 16.

Constraints

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

Clarifying questions4First question: Is the container's height the taller or shorter wall?Explore questions

Q1.Is the container's height the taller or shorter wall?
The shorter wall — water above it would spill over the lower side, so min(height[l], height[r]) caps it.
Q2.Do the lines between the two chosen ones matter?
No. Unlike trapping rain water, we pick exactly two lines and the bars between them are ignored.
Q3.Can heights be zero?
Yes. A zero-height wall gives zero area for any pair that uses it.
Q4.Do I return the area or the pair of indices?
Just the maximum area (an integer).

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Maximize area = (distance between two lines) × (height of the shorter line). The interview-grade answer is two pointers starting at both ends: compute the area, then move the pointer at the shorter wall inward — moving the taller one can never help. O(n) time, O(1) space, beating the O(n²) all-pairs brute force.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you can prove that moving the shorter wall is always safe and turn an O(n²) pair search into an O(n) two-pointer sweep with a greedy exchange argument.

Where candidates slip

Moving the taller wall (or both), or confusing this with trapping rain water and trying to sum water over every index.

How to stand out

State brute force, then justify the two-pointer move out loud: 'the area is capped by the shorter wall, so keeping it can never beat moving it — therefore discard it.' That correctness argument is the whole point.

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Brute Force — Check Every Pair	`O(n²)`	`O(1)`	Say it first to anchor the O(n²) baseline and to motivate the greedy two-pointer move.	Read
2	Two Pointers — Move the Shorter Wall (Optimal)Optimal	`O(n)`	`O(1)`	The answer they want. Lead with the correctness argument, not just 'use two pointers'.	Read

Interactive decision treeInteractiveChoose the right approachFollow the branches and learn why each constraint changes the solution.First decision previewMax area between two vertical linesCan you argue one pointer is safe to move?NoYes (move shorter wall)Explore the full tree

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Brute Force — Check Every Pair

TimeO(n²)SpaceO(1)

Say it first to anchor the O(n²) baseline and to motivate the greedy two-pointer move.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

The most direct reading: the answer is some pair of lines. How many pairs are there?

2Hint 2Explore hint

Try every pair (i, j) with i < j. The area is (j - i) * min(height[i], height[j]).

3Hint 3Explore hint

Track the maximum across all pairs. It's correct but quadratic — your cue to find structure that lets you skip pairs.

A · Core idea

Consider every unordered pair of lines (i, j) and compute the rectangle they enclose: width j - i times the shorter height min(height[i], height[j]). Keep the largest area seen.

Why this is the natural first attempt. The answer is literally 'the best pair of lines', so enumerating all pairs is the obvious correct baseline. Stating it shows you understand the area formula before optimizing.

Why we don't ship this. With n up to 10⁵, n²/2 is about 5 billion pairs — far too slow. The inefficiency is that we re-examine pairs that can't possibly beat what we've found. The two-pointer method exploits a property that lets us discard a whole wall at a time instead of one pair at a time.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

height = [1, 2, 1]

(0,1)

width 1 × min(1,2)=1

Statebest = 1

Final result2

C · Code with teaching comments

Reference implementation previewpublic int maxArea(int[] height) { int best = 0; int n = height.length; for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) {Explore the full code

solution.javaJava

Brute Force — Check Every Pair — reference

3 teaching notes

1
public int maxArea(int[] height) {
2
    int best = 0;
3
    int n = height.length;
4
    for (int i = 0; i < n; i++) {
5
        // j > i so each pair is considered once and width is positive.
6
        for (int j = i + 1; j < n; j++) {
7
            // Width times the shorter wall — water spills over the lower side.
8
            int area = (j - i) * Math.min(height[i], height[j]);
9
            // Track the maximum over all pairs.
10
            best = Math.max(best, area);
11
        }
12
    }
13
    return best;
14
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.14 lines

D · Why it works and complexityO(n²) timeO(1) spaceOpen the invariant and proofExplore the proof

Brute force treats all pairs as equally worth checking. The key observation it misses: starting from the widest pair and shrinking, the only way a narrower container can beat a wider one is by being taller — so the shorter wall is the thing holding us back, and it's safe to abandon it.

ComplexityO(n²) time, O(1) space — C(n,2) ≈ n²/2 pairs, each evaluated in O(1). No extra storage beyond the running maximum → O(1) space.

E · Edge cases and pitfalls3Using max instead of min for the height — water can't sit higher than the shorter wall.Explore edge cases

Pitfalls

Using max instead of min for the height — water can't sit higher than the shorter wall.
Off-by-one on width (using j - i + 1) — the container width is the index distance j - i.
Shipping O(n²) when n = 10⁵ — it will time out.

03.2

Approach 2 of 2 · Optimal

Two Pointers — Move the Shorter Wall (Optimal)

TimeO(n)SpaceO(1)

The answer they want. Lead with the correctness argument, not just 'use two pointers'.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Start with the widest possible container — one pointer at each end. Any other container is narrower, so to beat this you need more height.

2Hint 2Explore hint

The area is capped by the shorter wall. If you move the taller wall inward, width shrinks and the height is still capped by that same shorter wall — area can't grow.

3Hint 3Explore hint

So always move the pointer at the shorter wall. That's the only move that could expose a taller wall and possibly increase the area.

A · Core idea

Place l at index 0 and r at index n-1 — the widest container possible. Compute its area, update the best, then advance the pointer sitting at the shorter wall. Repeat until the pointers meet.

Why starting widest is the right frame. Width is maximal at the ends and can only shrink as pointers move inward. So every future container is narrower; the only thing that can make a narrower container win is a taller limiting wall. That reframes the search from 'try all pairs' to 'try to find a taller wall before width costs too much.'

Why moving the shorter wall is provably safe — the exchange argument. Suppose height[l] < height[r]. The current area is (r − l) × height[l]. Consider keeping l fixed and moving r to any r' < r. The width r' − l is strictly smaller, and the height is still at most height[l] (the shorter wall, unchanged). So every container that keeps the short wall l is no better than the one we just measured. We can therefore discard l forever and move it inward — we lose nothing, and only by doing so might we find a wall taller than height[l]. The symmetric argument holds when the right wall is shorter.

Why this finds the global optimum. Each pointer move permanently eliminates one wall as a left/right endpoint, but only after we've recorded the best container that wall could ever participate in. Since no discarded option could have beaten what we measured, the maximum we track is the true maximum.

Why O(1) space and one pass. Two indices and a running maximum — nothing scales with input size, and each element is passed at most once.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

height = [1, 8, 6, 2, 5, 4, 8, 3, 7]

Array state

l=0, r=8

area = 8 × min(1,7) = 8; left shorter → l++

l ↓

[0]

[1]

[2]

[3]

[4]

[5]

[6]

[7]

r ↓

[8]

Current pointerResolved stateNot processed

Final result49

C · Code with teaching comments

solution.javaJava

Two Pointers — Move the Shorter Wall (Optimal) — optimal

4 teaching notes

1
public int maxArea(int[] height) {
2
    // Start with the widest container — both extremes.
3
    int l = 0, r = height.length - 1;
4
    int best = 0;
5
    while (l < r) {
6
        // Width × shorter wall — the water this pair holds.
7
        int area = (r - l) * Math.min(height[l], height[r]);
8
        best = Math.max(best, area);
9
        if (height[l] < height[r]) {
10
            l++;
11
        } else {
12
            r--;
13
        }
14
    }
15
    return best;
16
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.16 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

The whole algorithm rests on one exchange argument: the shorter wall caps the area, and any container still using that shorter wall is narrower and therefore no better — so abandon it. Spotting which endpoint is 'safe to discard' is the transferable skill; it turns many O(n²) pair searches into O(n) sweeps.

ComplexityO(n) time, O(1) space — Each step moves one pointer inward and they never move apart, so the pointers meet after at most n steps → O(n) time. Only two indices and a running max are stored → O(1) space.

E · Edge cases and pitfalls6height = [1, 1] — Only one pair: width 1 × min(1,1)=1 → returns 1.Explore edge cases

Edge cases handled

height = [1, 1]Only one pair: width 1 × min(1,1)=1 → returns 1.
height = [0, 2, 0]Any container touching a 0 wall has area 0; the best is width 2 × min(0,0)=0 → 0.
height = [2, 3, 4, 5, 18, 17, 6]The huge inner bars are reachable because moving the shorter wall keeps exploring inward; tracks the true max.

Pitfalls

Moving the taller wall — width shrinks while the cap stays the same, so you can miss the optimum.
Recomputing with max instead of min for height.
Confusing this with Trapping Rain Water and trying to accumulate water over every index.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic int maxArea(int[] height) { int l = 0, r = height.length - 1; int best = 0; while (l < r) { int area = (r - l) * Math.min(height[l], height[r]);Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Moving the wrong (taller) wall

If the right wall is taller and you move it, width shrinks but the height is still capped by the unchanged shorter left wall — you can only lose area and may skip the optimum.

Explore the code comparison

Don't write this

if height[l] < height[r]:
    r -= 1   # moving the taller wall
else:
    l += 1

Write this instead

if height[l] < height[r]:
    l += 1   # discard the shorter wall
else:
    r -= 1

Using max instead of min for the height

Water spills over the lower wall, so the usable height is the shorter of the two lines, not the taller.

Explore the code comparison

Don't write this

int area = (r - l) * Math.max(height[l], height[r]);

Write this instead

int area = (r - l) * Math.min(height[l], height[r]);

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Two pointers from both ends, move the shorter wall

Code pattern to memorize

l, r = 0, n-1
best = 0
while l < r:
    area = (r - l) * min(h[l], h[r])
    best = max(best, area)
    if h[l] < h[r]: l += 1
    else: r -= 1
return best

Rules to remember

1Area is bounded by the shorter of the two walls × the width between them.
2Always move the pointer at the shorter wall — moving the taller one can only shrink or tie the area.
3Start as wide as possible (both ends); width only decreases, so you trade width for a chance at more height.
4On a tie (h[l] == h[r]), moving either is fine — the area can't improve by keeping both.
5This is not the same as trapping rain water — here you pick exactly two lines, not sum trapped water.

Use this pattern when

Maximize/minimize a quantity defined by a pair of endpoints
The metric depends on width and the min/max of two endpoint values
You can argue one pointer is always safe to move (a greedy exchange argument)
Brute force is all-pairs O(n²) and you want O(n)

Choose another pattern when

You must sum a contribution across all positions → that's Trapping Rain Water, not this
The pair must satisfy a sum/target rather than maximize area → Two Sum family
Order of elements can change → sorting problems, not fixed-position lines

Interview takeaway

When a quantity depends on two endpoints and the binding constraint is the smaller one, two pointers with a 'move the limiting side' rule finds the optimum in one pass. The proof that discarding the shorter wall loses nothing is the insight interviewers want to hear.

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Transferable patternTwo pointers with a greedy 'move the limiting endpoint' rule. Reach for it when a value depends on two endpoints and you can prove one side is always safe to discard. Cousin of Trapping Rain Water and 3Sum.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Trapping Rain Water
Sum water trapped above every bar — also two pointers, but track leftMax/rightMax instead of a single pair.
3Sum
Another two-pointer sweep, but on a sorted array hunting for a target sum.
Largest Rectangle in Histogram
Coming soon
Maximize a rectangle area too, but the bars between matter — needs a monotonic stack.

Same pattern

←

3Sum

Continue · Next problem

Trapping Rain Water

mediumArraysLC #11Frequently asked

Container With Most Water

LCPractice

Two Pointers · 3 of 30 · 9 min

You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the iᵗʰ line are (i, 0) and (i, height[i]).

Find two lines that together with the x-axis form a container, such that the container contains the most water. Return the maximum amount of water a container can store.

Notice that you may not slant the container.

In plain English

Examples

Example 1

Input: height = [1, 8, 6, 2, 5, 4, 8, 3, 7]
Output: 49
Note: Lines at index 1 (height 8) and index 8 (height 7): width 7 × min(8,7)=7 → 49.

Example 2

Input: height = [1, 1]
Output: 1
Note: Width 1 × min(1,1)=1 → 1.

Example 3

Input: height = [4, 3, 2, 1, 4]
Output: 16
Note: The two 4s at the ends: width 4 × min(4,4)=4 → 16.

Constraints

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

Clarifying questions4First question: Is the container's height the taller or shorter wall?Explore questions

Q1.Is the container's height the taller or shorter wall?
The shorter wall — water above it would spill over the lower side, so min(height[l], height[r]) caps it.
Q2.Do the lines between the two chosen ones matter?
No. Unlike trapping rain water, we pick exactly two lines and the bars between them are ignored.
Q3.Can heights be zero?
Yes. A zero-height wall gives zero area for any pair that uses it.
Q4.Do I return the area or the pair of indices?
Just the maximum area (an integer).

Quick interview revision

Understand

30-second explanation

Build the interview-ready mental model before comparing implementations.

Interview contextWhat is testedWhere candidates slipHow to stand outExplore interview context

What's being tested

Whether you can prove that moving the shorter wall is always safe and turn an O(n²) pair search into an O(n) two-pointer sweep with a greedy exchange argument.

Where candidates slip

Moving the taller wall (or both), or confusing this with trapping rain water and trying to sum water over every index.

How to stand out

Choose

Compare the available approaches

Use constraints and trade-offs to select the route you can defend in an interview.

Approaches at a glanceCompare before you dive in

#	Approach	Time	Space	When to mention	Jump
1	Brute Force — Check Every Pair	`O(n²)`	`O(1)`	Say it first to anchor the O(n²) baseline and to motivate the greedy two-pointer move.	Read
2	Two Pointers — Move the Shorter Wall (Optimal)Optimal	`O(n)`	`O(1)`	The answer they want. Lead with the correctness argument, not just 'use two pointers'.	Read

Learn & trace

Build each solution step by step

Move from the core idea to a visual trace, implementation, proof, and edge cases.

03.1

Approach 1 of 2

Brute Force — Check Every Pair

TimeO(n²)SpaceO(1)

Say it first to anchor the O(n²) baseline and to motivate the greedy two-pointer move.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

The most direct reading: the answer is some pair of lines. How many pairs are there?

2Hint 2Explore hint

Try every pair (i, j) with i < j. The area is (j - i) * min(height[i], height[j]).

3Hint 3Explore hint

Track the maximum across all pairs. It's correct but quadratic — your cue to find structure that lets you skip pairs.

A · Core idea

Consider every unordered pair of lines (i, j) and compute the rectangle they enclose: width j - i times the shorter height min(height[i], height[j]). Keep the largest area seen.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

height = [1, 2, 1]

(0,1)

width 1 × min(1,2)=1

Statebest = 1

Final result2

C · Code with teaching comments

Reference implementation previewpublic int maxArea(int[] height) { int best = 0; int n = height.length; for (int i = 0; i < n; i++) { for (int j = i + 1; j < n; j++) {Explore the full code

solution.javaJava

Brute Force — Check Every Pair — reference

3 teaching notes

1
public int maxArea(int[] height) {
2
    int best = 0;
3
    int n = height.length;
4
    for (int i = 0; i < n; i++) {
5
        // j > i so each pair is considered once and width is positive.
6
        for (int j = i + 1; j < n; j++) {
7
            // Width times the shorter wall — water spills over the lower side.
8
            int area = (j - i) * Math.min(height[i], height[j]);
9
            // Track the maximum over all pairs.
10
            best = Math.max(best, area);
11
        }
12
    }
13
    return best;
14
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.14 lines

D · Why it works and complexityO(n²) timeO(1) spaceOpen the invariant and proofExplore the proof

ComplexityO(n²) time, O(1) space — C(n,2) ≈ n²/2 pairs, each evaluated in O(1). No extra storage beyond the running maximum → O(1) space.

E · Edge cases and pitfalls3Using max instead of min for the height — water can't sit higher than the shorter wall.Explore edge cases

Pitfalls

Using max instead of min for the height — water can't sit higher than the shorter wall.
Off-by-one on width (using j - i + 1) — the container width is the index distance j - i.
Shipping O(n²) when n = 10⁵ — it will time out.

03.2

Approach 2 of 2 · Optimal

Two Pointers — Move the Shorter Wall (Optimal)

TimeO(n)SpaceO(1)

The answer they want. Lead with the correctness argument, not just 'use two pointers'.

Stuck? Progressive hintsReveal one at a time

1Hint 1Explore hint

Start with the widest possible container — one pointer at each end. Any other container is narrower, so to beat this you need more height.

2Hint 2Explore hint

The area is capped by the shorter wall. If you move the taller wall inward, width shrinks and the height is still capped by that same shorter wall — area can't grow.

3Hint 3Explore hint

So always move the pointer at the shorter wall. That's the only move that could expose a taller wall and possibly increase the area.

A · Core idea

Why O(1) space and one pass. Two indices and a running maximum — nothing scales with input size, and each element is passed at most once.

B · Visual dry run

Interactive dry run

Select a frame to connect the decision with its visual state.

height = [1, 8, 6, 2, 5, 4, 8, 3, 7]

Array state

l=0, r=8

area = 8 × min(1,7) = 8; left shorter → l++

l ↓

[0]

[1]

[2]

[3]

[4]

[5]

[6]

[7]

r ↓

[8]

Current pointerResolved stateNot processed

Final result49

C · Code with teaching comments

solution.javaJava

Two Pointers — Move the Shorter Wall (Optimal) — optimal

4 teaching notes

1
public int maxArea(int[] height) {
2
    // Start with the widest container — both extremes.
3
    int l = 0, r = height.length - 1;
4
    int best = 0;
5
    while (l < r) {
6
        // Width × shorter wall — the water this pair holds.
7
        int area = (r - l) * Math.min(height[l], height[r]);
8
        best = Math.max(best, area);
9
        if (height[l] < height[r]) {
10
            l++;
11
        } else {
12
            r--;
13
        }
14
    }
15
    return best;
16
}

Yellow row = the algorithm's core logic. Amber `//` lines above it = what you'd say out loud.16 lines

D · Why it works and complexityO(n) timeO(1) spaceOpen the invariant and proofExplore the proof

E · Edge cases and pitfalls6height = [1, 1] — Only one pair: width 1 × min(1,1)=1 → returns 1.Explore edge cases

Edge cases handled

height = [1, 1]Only one pair: width 1 × min(1,1)=1 → returns 1.
height = [0, 2, 0]Any container touching a 0 wall has area 0; the best is width 2 × min(0,0)=0 → 0.
height = [2, 3, 4, 5, 18, 17, 6]The huge inner bars are reachable because moving the shorter wall keeps exploring inward; tracks the true max.

Pitfalls

Moving the taller wall — width shrinks while the cap stays the same, so you can miss the optimum.
Recomputing with max instead of min for height.
Confusing this with Trapping Rain Water and trying to accumulate water over every index.

Practice

Try the solution yourself

Edit the optimal implementation, test another input, and observe the result.

Editable code previewpublic int maxArea(int[] height) { int l = 0, r = height.length - 1; int best = 0; while (l < r) { int area = (r - l) * Math.min(height[l], height[r]);Explore the playground

Try it — Java· run a complete program; method snippets need a driver

Avoid mistakes

Recognize the interview traps

Understand why common attempts fail before reviewing the corrected implementation.

Moving the wrong (taller) wall

If the right wall is taller and you move it, width shrinks but the height is still capped by the unchanged shorter left wall — you can only lose area and may skip the optimum.

Explore the code comparison

Don't write this

if height[l] < height[r]:
    r -= 1   # moving the taller wall
else:
    l += 1

Write this instead

if height[l] < height[r]:
    l += 1   # discard the shorter wall
else:
    r -= 1

Using max instead of min for the height

Water spills over the lower wall, so the usable height is the shorter of the two lines, not the taller.

Explore the code comparison

Don't write this

int area = (r - l) * Math.max(height[l], height[r]);

Write this instead

int area = (r - l) * Math.min(height[l], height[r]);

Revise

Carry the pattern into the interview

Quick interview revision

Pattern to remember

Two pointers from both ends, move the shorter wall

Code pattern to memorize

l, r = 0, n-1
best = 0
while l < r:
    area = (r - l) * min(h[l], h[r])
    best = max(best, area)
    if h[l] < h[r]: l += 1
    else: r -= 1
return best

Rules to remember

1Area is bounded by the shorter of the two walls × the width between them.
2Always move the pointer at the shorter wall — moving the taller one can only shrink or tie the area.
3Start as wide as possible (both ends); width only decreases, so you trade width for a chance at more height.
4On a tie (h[l] == h[r]), moving either is fine — the area can't improve by keeping both.
5This is not the same as trapping rain water — here you pick exactly two lines, not sum trapped water.

Use this pattern when

Maximize/minimize a quantity defined by a pair of endpoints
The metric depends on width and the min/max of two endpoint values
You can argue one pointer is always safe to move (a greedy exchange argument)
Brute force is all-pairs O(n²) and you want O(n)

Choose another pattern when

You must sum a contribution across all positions → that's Trapping Rain Water, not this
The pair must satisfy a sum/target rather than maximize area → Two Sum family
Order of elements can change → sorting problems, not fixed-position lines

Interview takeaway

Continue

Transfer the pattern to another problem

Use a direct variation or pattern sibling to prove the idea is reusable.

Practice queueDirect variations and pattern siblings

Direct follow-ups

Trapping Rain Water
Sum water trapped above every bar — also two pointers, but track leftMax/rightMax instead of a single pair.
3Sum
Another two-pointer sweep, but on a sorted array hunting for a target sum.
Largest Rectangle in Histogram
Coming soon
Maximize a rectangle area too, but the bars between matter — needs a monotonic stack.

Same pattern

←

3Sum

Continue · Next problem

Trapping Rain Water