Container With Most Water in DSA Javascript - Interactive Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to initialize the maximum area variable.

DSA Javascript

let maxArea = [1];

Drag options to blanks, or click blank then click option'

A1

B0

CInfinity

D-1

Attempts:

3 left

💡 Hint

Common Mistakes

Initializing maxArea to 1 or Infinity causes incorrect comparisons later.

We start with maxArea as 0 because initially we have no container formed.

2fill in blank

medium

Complete the code to calculate the width between two pointers.

DSA Javascript

let width = [1] - left;

Drag options to blanks, or click blank then click option'

Aright

Bleft

CmaxArea

Dheight

Attempts:

3 left

💡 Hint

Common Mistakes

Using left - right instead of right - left results in negative width.

Width is the distance between the right and left pointers.

3fill in blank

hard

Fix the error in the condition to update maxArea with the larger area.

DSA Javascript

if (currentArea [1] maxArea) {
  maxArea = currentArea;
}

Drag options to blanks, or click blank then click option'

A<

B==

C>

D<=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '<' or '<=' causes maxArea to never update correctly.

We update maxArea only if currentArea is greater than maxArea.

4fill in blank

hard

Fill both blanks to move the pointers correctly based on height comparison.

DSA Javascript

if (height[left] [1] height[right]) {
  left [2] 1;
} else {
  right -= 1;
}

Drag options to blanks, or click blank then click option'

A<

B>

C+=

D-=

Attempts:

3 left

💡 Hint

Common Mistakes

Using '>' instead of '<' in comparison reverses pointer movement logic.

Using '-=' to move left pointer causes infinite loop.

If left height is less, move left pointer right by 1; else move right pointer left by 1.

5fill in blank

hard

Fill all three blanks to complete the function that returns the maximum water container area.

DSA Javascript

function maxArea(height) {
  let left = 0, right = height.length - 1;
  let maxArea = 0;
  while (left < right) {
    let width = right - left;
    let currentArea = Math.min(height[left], height[right]) [1] width;
    if (currentArea [2] maxArea) {
      maxArea = currentArea;
    }
    if (height[left] [3] height[right]) {
      left += 1;
    } else {
      right -= 1;
    }
  }
  return maxArea;
}

Drag options to blanks, or click blank then click option'

A*

B>

C<

D+

Attempts:

3 left

💡 Hint

Common Mistakes

Using '+' instead of '*' for area calculation.

Using '<' instead of '>' in maxArea update condition.

Using '>' instead of '<' in height comparison.

Multiply min height by width for area; update maxArea if currentArea is greater; move left pointer if left height is less.

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