What happens if you moving the pointer at the taller line instead of the shorter line?

Misses the optimal solution, returns incorrect max area Fix: Always move the pointer pointing to the shorter line inward

What happens if you not handling edge cases like single element or all zero heights?

Code may crash or return wrong result Fix: Add checks or rely on loop conditions to handle these cases gracefully

What happens if you using nested loops for large inputs without optimization?

Code times out or is inefficient Fix: Use two-pointer approach to reduce time complexity to O(n)

Interview Preptwo-pointersmediumAmazonGoogleFacebookBloomberg

Container With Most Water

Choose your preparation mode4 modes available

Try It Solution Trace

🎯

mediumTWO_POINTERAmazonGoogleFacebook

Imagine you have vertical lines on a graph representing walls, and you want to find two walls that can hold the most water between them.

💡 This problem is about finding the maximum area between two lines in an array. Beginners often struggle because the naive approach tries all pairs, which is slow, and the optimal two-pointer technique requires understanding how moving pointers affects the area. Think of it like trying to find the widest container between two walls that can hold the most water.

📋

Problem Statement

Given n non-negative integers a1, a2, ..., an, where each represents a point at coordinate (i, ai). n vertical lines are drawn such that the two endpoints of line i are at (i, ai) and (i, 0). Find two lines, which together with the x-axis forms a container, such that the container contains the most water. Return the maximum amount of water a container can store.

1 ≤ n ≤ 10^50 ≤ ai ≤ 10^4 for each 1 ≤ i ≤ n

💡

Example

Input"[1,8,6,2,5,4,8,3,7]"

Output49

The max area is formed between lines at index 1 (height 8) and index 8 (height 7). Width is 7, height is min(8,7)=7, area=7*7=49.

All heights are zero → max area is 0
Only one line → max area is 0 (no container)
Two lines with same height → area is height * distance
Heights are strictly increasing or decreasing → max area at ends

⚠️

Common Mistakes

Moving the pointer at the taller line instead of the shorter line

Misses the optimal solution, returns incorrect max area

✅ Always move the pointer pointing to the shorter line inward

Calculating area incorrectly by using max height instead of min height

Overestimates area, leading to wrong answers

✅ Use min(height[left], height[right]) to calculate height

Not handling edge cases like single element or all zero heights

Code may crash or return wrong result

✅ Add checks or rely on loop conditions to handle these cases gracefully

Using nested loops for large inputs without optimization

Code times out or is inefficient

✅ Use two-pointer approach to reduce time complexity to O(n)

🧠

Brute Force (Nested Loops)

💡 This approach tries every possible pair of lines to find the maximum area. It is simple and intuitive but inefficient for large inputs. Beginners can understand the problem well by seeing how all pairs are checked.

Intuition

Check all pairs of lines, calculate the area for each, and keep track of the maximum area found.

Algorithm

Initialize max_area to 0.
Use two nested loops to consider every pair of lines (i, j) with i < j.
Calculate the area formed by lines i and j: width = j - i, height = min(height[i], height[j]).
Update max_area if the current area is larger.

💡 The nested loops make it easy to understand but hard to scale; beginners often miss how to calculate area correctly.

</>

Code

def maxArea(height):
    max_area = 0
    n = len(height)
    for i in range(n):
        for j in range(i + 1, n):
            width = j - i
            current_height = min(height[i], height[j])
            area = width * current_height
            if area > max_area:
                max_area = area
    return max_area

# Driver code
if __name__ == '__main__':
    heights = [1,8,6,2,5,4,8,3,7]
    print(maxArea(heights))  # Expected output: 49

Line Notes

max_area = 0Initialize max_area to keep track of the largest area found so far.

for i in range(n)Outer loop picks the first line index.

for j in range(i + 1, n)Inner loop picks the second line index, ensuring pairs are unique and i < j.

area = width * current_heightCalculate the area between lines i and j using width and the smaller height.

public class Solution {
    public static int maxArea(int[] height) {
        int maxArea = 0;
        int n = height.length;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                int width = j - i;
                int currentHeight = Math.min(height[i], height[j]);
                int area = width * currentHeight;
                if (area > maxArea) {
                    maxArea = area;
                }
            }
        }
        return maxArea;
    }

    public static void main(String[] args) {
        int[] heights = {1,8,6,2,5,4,8,3,7};
        System.out.println(maxArea(heights)); // Expected output: 49
    }
}

Line Notes

int maxArea = 0;Initialize maxArea to store the maximum area found.

for (int i = 0; i < n; i++)Outer loop selects the first line index.

for (int j = i + 1; j < n; j++)Inner loop selects the second line index, ensuring unique pairs.

int area = width * currentHeight;Calculate the area between two lines.

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int maxArea(vector<int>& height) {
    int max_area = 0;
    int n = height.size();
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int width = j - i;
            int current_height = min(height[i], height[j]);
            int area = width * current_height;
            if (area > max_area) {
                max_area = area;
            }
        }
    }
    return max_area;
}

int main() {
    vector<int> heights = {1,8,6,2,5,4,8,3,7};
    cout << maxArea(heights) << endl; // Expected output: 49
    return 0;
}

Line Notes

int max_area = 0;Initialize max_area to track the largest area found.

for (int i = 0; i < n; i++)Outer loop picks the first line index.

for (int j = i + 1; j < n; j++)Inner loop picks the second line index, ensuring unique pairs.

int area = width * current_height;Calculate area between lines i and j.

function maxArea(height) {
    let maxArea = 0;
    const n = height.length;
    for (let i = 0; i < n; i++) {
        for (let j = i + 1; j < n; j++) {
            const width = j - i;
            const currentHeight = Math.min(height[i], height[j]);
            const area = width * currentHeight;
            if (area > maxArea) {
                maxArea = area;
            }
        }
    }
    return maxArea;
}

// Test
const heights = [1,8,6,2,5,4,8,3,7];
console.log(maxArea(heights)); // Expected output: 49

Line Notes

let maxArea = 0;Initialize maxArea to keep track of the maximum area found.

for (let i = 0; i < n; i++)Outer loop selects the first line index.

for (let j = i + 1; j < n; j++)Inner loop selects the second line index, ensuring unique pairs.

const area = width * currentHeight;Calculate the area between two lines.

⏱

Complexity

TimeO(n^2)

SpaceO(1)

Two nested loops each run up to n times, resulting in n*(n-1)/2 pairs checked.

💡 For n=20, this means about 190 operations; for n=1000, about 500,000 operations, which is slow.

Interview Verdict: TLE for large inputs

This approach is too slow for large inputs but is useful to understand the problem and correctness.

Approach	Time	Space	Stack Risk	Reconstruct	Use In Interview
1. Brute Force	`O(n^2)`	`O(1)`	No	N/A	Mention only - never code due to inefficiency
2. Two Pointers (Greedy Pointer Move)	`O(n)`	`O(1)`	No	N/A	Code this approach for optimal solution
3. Two Pointers with Early Area Calculation Optimization	`O(n)`	`O(1)`	No	N/A	Optional micro-optimization, mention if time permits

Practice

(1/5)

1. Consider the following code snippet for removing duplicates from a sorted array allowing at most two duplicates. What is the value of write_index after processing the input [1,1,2]?

easy

A. 2

B. 1

C. 3

D. 0

3. Consider the following buggy code for merging two sorted arrays in-place. Which line contains the subtle bug that causes missing elements in the final merged array?

def merge(nums1, m, nums2, n):
    i = m - 1
    j = n - 1
    k = m + n - 1
    while i >= 0 and j >= 0:
        if nums1[i] > nums2[j]:
            nums1[k] = nums1[i]
            i -= 1
        else:
            nums1[k] = nums2[j]
            j -= 1
        k -= 1
    # Missing copying remaining nums2 elements

nums1 = [1,2,3,0,0,0]
m = 3
nums2 = [2,5,6]
n = 3
merge(nums1, m, nums2, n)
print(nums1)

medium

A. Line 12: Missing while loop to copy remaining nums2 elements

B. Line 9: nums1[k] = nums2[j]

C. Line 4: i = m - 1

D. Line 7: if nums1[i] > nums2[j]:

Recommended

Ready to prove it?

Pass the test and this pattern moves unknown strong while earning +1 Grip toward your certificate.

10 questions~5 mineasy hard

Intuition

Algorithm

Intuition

Algorithm

Intuition

Algorithm

How to Present

Time Allocation

What the Interviewer Tests

Common Follow-ups

When to Use

Signature Phrases

NOT This Pattern When

Similar Problems

Practice

Solution

Step 1: Trace write_index and read_index for input [1,1,2]

Step 2: Final write_index value

Final Answer:

Quick Check:

Solution

Step 1: Understand pointer loop condition

Step 2: Identify bug in loop condition

Final Answer:

Quick Check:

Solution

Step 1: Analyze the main merging loop

Step 2: Identify missing step

Final Answer:

Quick Check:

Solution

Step 1: Understand reuse means indices can repeat

Step 2: Adjust pair combination logic

Step 3: Evaluate other options

Final Answer:

Quick Check:

Solution

Step 1: Recognize input is unsorted

Step 2: Choose a correct approach

Final Answer:

Quick Check:

Ready to prove it?