Container With Most Water in DSA Javascript - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the 'Container With Most Water' problem ask you to find?

It asks to find two lines in an array that, together with the x-axis, form a container that holds the maximum amount of water.

intermediate

Why do we use two pointers in the 'Container With Most Water' problem?

Two pointers start at both ends and move inward to efficiently check all possible containers without checking every pair, reducing time from O(n²) to O(n).

beginner

How do you calculate the area of water between two lines at positions i and j?

Area = (distance between i and j) × (minimum height of the two lines).

intermediate

In the two-pointer approach, which pointer do you move and why?

Move the pointer at the shorter line inward because moving the taller line won't increase the area; the shorter line limits the water height.

beginner

What is the time complexity of the optimal solution for 'Container With Most Water'?

O(n), where n is the number of lines, because each pointer moves at most n times.

What does the 'Container With Most Water' problem primarily involve?

A Finding the longest increasing subsequence

B Sorting an array

C Finding two lines that hold the most water

D Calculating the sum of all elements

The problem is about finding two lines that form a container holding the maximum water.

In the two-pointer method, where do the pointers start?

A Random positions

B Both at the end

C Both at the start

D One at start, one at end

One pointer starts at the beginning and the other at the end of the array.

How is the area between two lines calculated?

A Distance × maximum height

B Distance × minimum height

C Sum of heights

D Difference of heights

Area is distance between lines multiplied by the smaller height.

Which pointer do you move when the left line is shorter?

A Move left pointer

B Do not move any pointer

C Move both pointers

D Move right pointer

Move the pointer at the shorter line inward to try to find a taller line.

What is the time complexity of the two-pointer solution?

A O(n)

B O(n log n)

C O(n²)

D O(log n)

The two-pointer approach runs in linear time, O(n).

Explain the two-pointer approach to solve the 'Container With Most Water' problem.

Think about how moving the shorter line pointer can help find a bigger container.

Describe how to calculate the area between two lines and why the minimum height is used.

Imagine water spilling over the shorter line if you used the taller one.

Practice

1. What does the "Container With Most Water" problem ask you to find given an array of heights?

easy

A. The maximum area formed between two lines representing container walls.

B. The minimum height in the array.

C. The sum of all heights in the array.

D. The difference between the tallest and shortest lines.

Solution

1. Step 1: Understand the problem statement

   The problem asks to find two lines that together with the x-axis form a container that holds the most water.

2. Step 2: Identify what to maximize

   The area between two lines is width (distance between lines) times the height (minimum of the two lines). We want the maximum such area.

3. Final Answer:

   The maximum area formed between two lines representing container walls. -> Option A

4. Quick Check:

   Max area = max water container [OK]

Hint: Look for two lines maximizing min height * distance [OK]

Common Mistakes:

• Thinking it's about sum of heights
• Confusing max height with max area
• Ignoring the distance between lines

2. Which of the following JavaScript code snippets correctly initializes two pointers for the Container With Most Water problem?

easy

A. let left = 1, right = heights.length;

B. let left = -1, right = heights.length + 1;

C. let left = heights.length, right = 0;

D. let left = 0, right = heights.length - 1;

Solution

1. Step 1: Identify correct pointer initialization

   We start with left pointer at index 0 and right pointer at last index (length - 1).

2. Step 2: Check each option

   let left = 0, right = heights.length - 1; correctly sets left = 0 and right = heights.length - 1. Others use invalid indices.

3. Final Answer:

   let left = 0, right = heights.length - 1; -> Option D

4. Quick Check:

   Start pointers at array ends [OK]

Hint: Start pointers at array ends: 0 and length-1 [OK]

Common Mistakes:

• Using invalid indices outside array bounds
• Starting both pointers at same position
• Confusing length with last index

3. What is the output of the following JavaScript code?

function maxArea(height) {
  let left = 0, right = height.length - 1;
  let max = 0;
  while (left < right) {
    const area = Math.min(height[left], height[right]) * (right - left);
    max = Math.max(max, area);
    if (height[left] < height[right]) {
      left++;
    } else {
      right--;
    }
  }
  return max;
}

console.log(maxArea([1,8,6,2,5,4,8,3,7]));

medium

A. 56

B. 49

C. 64

D. 72

Solution

1. Step 1: Trace the two-pointer approach

   Start with left=0 (height=1), right=8 (height=7), area = min(1,7)*8=8. Max=8.

2. Step 2: Move pointers and update max

   Since height[left]

3. Final Answer:

   49 -> Option B

4. Quick Check:

   Max area for input = 49 [OK]

Hint: Move pointer at smaller height inward to find max area [OK]

Common Mistakes:

• Calculating area incorrectly using max height
• Not updating max area properly
• Moving wrong pointer in the loop

4. Identify the bug in this JavaScript function for Container With Most Water:

function maxArea(height) {
  let left = 0, right = height.length - 1;
  let max = 0;
  while (left < right) {
    const area = Math.min(height[left], height[right]) * (right - left);
    max = Math.max(max, area);
    if (height[left] < height[right]) {
      left++;
    } else {
      right++;
    }
  }
  return max;
}

medium

A. The right pointer should decrement (right--) instead of increment (right++).

B. The area calculation should use max instead of min height.

C. The max variable should be initialized to Infinity.

D. The loop condition should be left < right, not left <= right.

Solution

1. Step 1: Check pointer movement logic

   The right pointer is incorrectly incremented (right++), which moves it out of array bounds.

2. Step 2: Correct pointer movement

   When height[left] >= height[right], right pointer should move left (right--) to find a potentially larger area.

3. Final Answer:

   The right pointer should decrement (right--) instead of increment (right++). -> Option A

4. Quick Check:

   Right pointer moves left to reduce width [OK]

Hint: Right pointer moves left (decrement) to find max area [OK]

Common Mistakes:

• Using right++ instead of right--
• Loop condition allowing left == right
• Incorrect area calculation using max height

5. Given an array of heights, how would you modify the Container With Most Water algorithm to also return the indices of the two lines forming the container with the maximum water?

hard

A. Sort the array and return indices of the tallest two lines.

B. Return the first two indices always, as they form the max container.

C. Track indices when updating max area and return them along with max area.

D. Use a nested loop to check all pairs and return the last pair found.

Solution

1. Step 1: Add variables to track indices

   Initialize variables to store left and right indices when max area updates.

2. Step 2: Update indices when max area changes

   Inside the loop, when a new max area is found, save current left and right indices.

3. Step 3: Return max area and indices

   Return an object or array containing max area and the two indices after loop ends.

4. Final Answer:

   Track indices when updating max area and return them along with max area. -> Option C

5. Quick Check:

   Save indices on max update for output [OK]

Hint: Save indices when max area updates during pointer moves [OK]

Common Mistakes:

• Returning fixed indices without checking area
• Sorting array loses original indices
• Using nested loops increases time complexity