Container With Most Water in DSA Rust - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of Two-Pointer Container Calculation

What is the output of this Rust code that calculates the maximum water container area using two pointers?

DSA Rust

fn max_area(height: Vec<i32>) -> i32 {
    let (mut left, mut right) = (0, height.len() - 1);
    let mut max_area = 0;
    while left < right {
        let width = (right - left) as i32;
        let current_area = width * std::cmp::min(height[left], height[right]);
        if current_area > max_area {
            max_area = current_area;
        }
        if height[left] < height[right] {
            left += 1;
        } else {
            right -= 1;
        }
    }
    max_area
}

fn main() {
    let heights = vec![1,8,6,2,5,4,8,3,7];
    println!("{}", max_area(heights));
}

A 36

B 56

C 49

D 48

💡 Hint

Think about how the two pointers move and how the area is calculated at each step.

The maximum area is found between the lines at positions 1 and 8 (0-based), heights 8 and 7, width 7, min-height 7, area 49. The code correctly computes this using the two-pointer approach.

❓ Predict Output

intermediate

Result of Container Area with Equal Heights

What will be printed by this Rust program that calculates the maximum water container area?

DSA Rust

fn max_area(height: Vec<i32>) -> i32 {
    let (mut left, mut right) = (0, height.len() - 1);
    let mut max_area = 0;
    while left < right {
        let width = (right - left) as i32;
        let current_area = width * std::cmp::min(height[left], height[right]);
        if current_area > max_area {
            max_area = current_area;
        }
        if height[left] < height[right] {
            left += 1;
        } else {
            right -= 1;
        }
    }
    max_area
}

fn main() {
    let heights = vec![5,5,5,5,5];
    println!("{}", max_area(heights));
}

A 20

B 25

C 16

D 10

💡 Hint

All heights are equal, so the area depends on the width between pointers.

With all heights equal to 5, the maximum area is height 5 times width 4 (between indices 0 and 4), which is 20.

🔧 Debug

advanced

Identify the Error in Container Calculation Code

This Rust code is intended to find the maximum water container area but has a bug. What error will it cause when run?

DSA Rust

fn max_area(height: Vec<i32>) -> i32 {
    let (mut left, mut right) = (0, height.len());
    let mut max_area = 0;
    while left < right {
        let width = (right - left) as i32;
        let current_area = width * std::cmp::min(height[left], height[right]);
        if current_area > max_area {
            max_area = current_area;
        }
        if height[left] < height[right] {
            left += 1;
        } else {
            right -= 1;
        }
    }
    max_area
}

fn main() {
    let heights = vec![1,8,6,2,5,4,8,3,7];
    println!("{}", max_area(heights));
}

A Index out of bounds panic

B Infinite loop

C Compilation error due to type mismatch

D Prints 0

💡 Hint

Check how the right pointer is initialized and used as an index.

The right pointer is initialized to height.len(), which is out of bounds for indexing. Accessing height[right] causes a panic at runtime.

🧠 Conceptual

advanced

Why Two-Pointer Approach Works for Container With Most Water

Why does the two-pointer approach correctly find the maximum water container area in linear time?

A Because it sorts the heights first to find the largest area

B Because moving the pointer with smaller height can potentially find a taller line and increase area

C Because it checks all pairs of lines exhaustively

D Because it uses recursion to explore all combinations

💡 Hint

Think about how the area depends on the shorter line and width.

The area is limited by the shorter line. Moving the pointer at the shorter line inward may find a taller line and possibly a larger area. This approach avoids checking all pairs and runs in linear time.

🚀 Application

expert

Maximum Water Container Area for Large Input

Given a vector of 1,000,000 heights where each height is 1, what is the maximum water container area computed by the two-pointer method?

DSA Rust

fn max_area(height: Vec<i32>) -> i32 {
    let (mut left, mut right) = (0, height.len() - 1);
    let mut max_area = 0;
    while left < right {
        let width = (right - left) as i32;
        let current_area = width * std::cmp::min(height[left], height[right]);
        if current_area > max_area {
            max_area = current_area;
        }
        if height[left] < height[right] {
            left += 1;
        } else {
            right -= 1;
        }
    }
    max_area
}

fn main() {
    let heights = vec![1; 1_000_000];
    println!("{}", max_area(heights));
}

A 1000000

B 0

C 1

D 999999

💡 Hint

All heights are equal, so the maximum area is height times the maximum width.

With all heights equal to 1, the maximum area is height 1 times width 999999 (between indices 0 and 999999).

Practice

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

easy

A. The maximum area formed between two vertical lines and the x-axis

B. The minimum height in the array

C. The sum of all heights

D. The longest increasing subsequence of heights

Solution

1. Step 1: Understand the problem statement

   The problem asks to find two lines that together with the x-axis form a container holding the most water, which means maximizing the area between them.

2. Step 2: Identify what to calculate

   The area is calculated by the distance between the two lines multiplied by the smaller height of the two lines.

3. Final Answer:

   The maximum area formed between two vertical lines and the x-axis -> Option A

4. Quick Check:

   Container with most water = max area between lines [OK]

Hint: Look for two lines maximizing width x min height [OK]

Common Mistakes:

• Confusing sum of heights with area
• Choosing tallest lines without considering distance
• Ignoring the smaller height between two lines

2. Which Rust code snippet correctly declares a vector of heights for the Container With Most Water problem?

easy

A. let heights = {1, 8, 6, 2, 5, 4, 8, 3, 7};

B. let heights = vec![1, 8, 6, 2, 5, 4, 8, 3, 7];

C. let heights = (1, 8, 6, 2, 5, 4, 8, 3, 7);

D. let heights = [1, 8, 6, 2, 5, 4, 8, 3, 7];

Solution

1. Step 1: Identify Rust vector syntax

   In Rust, a vector is declared using vec![...] macro to create a growable array.

2. Step 2: Check each option

   let heights = vec![1, 8, 6, 2, 5, 4, 8, 3, 7]; uses vec![...] correctly. let heights = [1, 8, 6, 2, 5, 4, 8, 3, 7]; is an array, not a vector. let heights = (1, 8, 6, 2, 5, 4, 8, 3, 7); is a tuple. let heights = {1, 8, 6, 2, 5, 4, 8, 3, 7}; uses braces which is invalid syntax.

3. Final Answer:

   let heights = vec![1, 8, 6, 2, 5, 4, 8, 3, 7]; -> Option B

4. Quick Check:

   Vector syntax = vec![...] [OK]

Hint: Use vec![...] for vectors in Rust [OK]

Common Mistakes:

• Using array syntax instead of vector
• Using tuple parentheses instead of brackets
• Using braces which is invalid

3. What is the output of this Rust code snippet that finds the max water container area?

fn max_area(height: Vec<i32>) -> i32 {
    let mut left = 0;
    let mut right = height.len() - 1;
    let mut max_area = 0;
    while left < right {
        let width = (right - left) as i32;
        let h = if height[left] < height[right] { height[left] } else { height[right] };
        let area = width * h;
        if area > max_area {
            max_area = area;
        }
        if height[left] < height[right] {
            left += 1;
        } else {
            right -= 1;
        }
    }
    max_area
}

fn main() {
    let heights = vec![1,8,6,2,5,4,8,3,7];
    println!("{}", max_area(heights));
}

medium

A. 48

B. 56

C. 64

D. 49

Solution

1. Step 1: Understand the two-pointer approach

   Start with left at 0 and right at last index, calculate area, move pointer with smaller height inward.

2. Step 2: Trace the code with given heights

   Max area found is between height 8 at index 1 and height 7 at index 8, width = 7, area = 7 * 7 = 49.

3. Final Answer:

   49 -> Option D

4. Quick Check:

   Max area = 49 [OK]

Hint: Use two pointers, move smaller height inward [OK]

Common Mistakes:

• Calculating area with max height instead of min
• Not updating max area correctly
• Moving wrong pointer in the loop

4. Identify the bug in this Rust function for Container With Most Water and select the fix:

fn max_area(height: Vec<i32>) -> i32 {
    let mut left = 0;
    let mut right = height.len();
    let mut max_area = 0;
    while left < right {
        let width = (right - left) as i32;
        let h = if height[left] < height[right] { height[left] } else { height[right] };
        let area = width * h;
        if area > max_area {
            max_area = area;
        }
        if height[left] < height[right] {
            left += 1;
        } else {
            right -= 1;
        }
    }
    max_area
}

medium

A. Change right initialization to height.len() - 1

B. Change while condition to left <= right

C. Use max instead of min height for area calculation

D. Remove the if condition inside the loop

Solution

1. Step 1: Check initialization of right pointer

   Rust vectors are zero-indexed, so last index is length - 1, not length.

2. Step 2: Identify impact of wrong right pointer

   Using length causes out-of-bounds access when accessing height[right], leading to runtime error.

3. Final Answer:

   Change right initialization to height.len() - 1 -> Option A

4. Quick Check:

   Right pointer = last index = len() - 1 [OK]

Hint: Index last element with len() - 1, not len() [OK]

Common Mistakes:

• Using length as index causing panic
• Changing loop condition incorrectly
• Using max height instead of min for area

5. Given a vector of heights, how would you modify the two-pointer approach to also return the indices of the two lines forming the container with the most water?

hard

A. Return the sum of the two heights instead of area

B. Use a nested loop to check all pairs and store indices of max area

C. Keep track of max_area and update a tuple (left_index, right_index) whenever max_area changes

D. Only return the left pointer index as the answer

Solution

1. Step 1: Understand the two-pointer approach

   We move pointers inward and calculate area at each step, updating max area found.

2. Step 2: Track indices when max area updates

   Along with max_area, store the current left and right indices whenever a larger area is found.

3. Final Answer:

   Keep track of max_area and update a tuple (left_index, right_index) whenever max_area changes -> Option C

4. Quick Check:

   Track indices with max area updates [OK]

Hint: Update indices when max area changes [OK]

Common Mistakes:

• Returning sum instead of area
• Using nested loops losing O(n) efficiency
• Returning only one index instead of both