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

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of max water container calculation

What is the output of the following Go code that calculates the maximum water container area?

DSA Go

package main
import "fmt"
func maxArea(height []int) int {
    left, right := 0, len(height)-1
    maxArea := 0
    for left < right {
        width := right - left
        var h int
        if height[left] < height[right] {
            h = height[left]
            left++
        } else {
            h = height[right]
            right--
        }
        area := width * h
        if area > maxArea {
            maxArea = area
        }
    }
    return maxArea
}
func main() {
    heights := []int{1,8,6,2,5,4,8,3,7}
    fmt.Println(maxArea(heights))
}

A 48

B 56

C 49

D 36

💡 Hint

Consider the two-pointer approach moving inward and calculating area at each step.

The maximum area is found between the lines at index 1 (height 8) and index 8 (height 7), width 7, area 7*7=49.

🧠 Conceptual

intermediate

Understanding the two-pointer technique in Container With Most Water

Why does the two-pointer technique work efficiently for the Container With Most Water problem?

A Because it checks all pairs of lines in O(n^2) time.

B Because moving both pointers inward simultaneously always increases the area.

C Because the maximum area is always between the first and last lines.

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

💡 Hint

Think about how the height limits the area and which pointer to move.

The pointer with smaller height limits the area, so moving it inward may find a taller line and possibly a larger area.

❓ Predict Output

advanced

Output of modified container water calculation with equal heights

What is the output of this Go code snippet that calculates max water container area with equal heights?

DSA Go

package main
import "fmt"
func maxArea(height []int) int {
    left, right := 0, len(height)-1
    maxArea := 0
    for left < right {
        width := right - left
        var h int
        if height[left] <= height[right] {
            h = height[left]
            left++
        } else {
            h = height[right]
            right--
        }
        area := width * h
        if area > maxArea {
            maxArea = area
        }
    }
    return maxArea
}
func main() {
    heights := []int{5,5,5,5,5}
    fmt.Println(maxArea(heights))
}

A 20

B 25

C 16

D 10

💡 Hint

All heights are equal, so area depends on width.

The maximum area is height 5 times width 4 (between index 0 and 4), so 20.

🔧 Debug

advanced

Identify the error in this Container With Most Water implementation

What error does this Go code produce when run?

DSA Go

package main
import "fmt"
func maxArea(height []int) int {
    left, right := 0, len(height)-1
    maxArea := 0
    for left <= right {
        width := right - left
        var h int
        if height[left] < height[right] {
            h = height[left]
            left++
        } else {
            h = height[right]
            right--
        }
        area := width * h
        if area > maxArea {
            maxArea = area
        }
    }
    return maxArea
}
func main() {
    heights := []int{1,2,3,4,5}
    fmt.Println(maxArea(heights))
}

A Index out of range panic

B Infinite loop

C Correct output 6

D Compilation error

💡 Hint

Check the loop condition and pointer movement.

The loop condition allows left == right, but pointers move only when left < right, causing infinite loop when left == right.

🚀 Application

expert

Maximum water container with additional constraint

Given an array of heights, find the maximum water container area where the container width must be an even number. Which option correctly implements this constraint in Go?

A

for left < right {
    width := right - left
    if width%2 == 0 {
        var h int
        if height[left] < height[right] {
            h = height[left]
            left++
        } else {
            h = height[right]
            right--
        }
        area := width * h
        if area > maxArea {
            maxArea = area
        }
    } else {
        if height[left] < height[right] {
            left++
        } else {
            right--
        }
    }
}

B

for left < right {
    width := right - left
    if width%2 != 0 {
        if height[left] < height[right] {
            left++
        } else {
            right--
        }
        continue
    }
    var h int
    if height[left] < height[right] {
        h = height[left]
        left++
    } else {
        h = height[right]
        right--
    }
    area := width * h
    if area > maxArea {
        maxArea = area
    }
}

C

for left < right {
    width := right - left
    var h int
    if height[left] < height[right] {
        h = height[left]
        left++
    } else {
        h = height[right]
        right--
    }
    if width%2 == 0 {
        area := width * h
        if area > maxArea {
            maxArea = area
        }
    }
}

D

for left < right {
    width := right - left
    var h int
    if width%2 == 0 {
        if height[left] < height[right] {
            h = height[left]
            left++
        } else {
            h = height[right]
            right--
        }
        area := width * h
        if area > maxArea {
            maxArea = area
        }
    } else {
        left++
        right--
    }
}

💡 Hint

Calculate area only when width is even, but always move pointers to avoid infinite loops.

Option A calculates area only if width is even but moves pointers every iteration, ensuring progress and correct max area calculation.

Practice

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

easy

A. The sum of all heights

B. The minimum height in the array

C. The maximum area of water that can be contained between two lines

D. The number of lines taller than a given height

Solution

1. Step 1: Understand the problem statement

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

2. Step 2: Identify what to calculate

   We calculate the area between two lines as the width between them times the smaller height.

3. Final Answer:

   The maximum area of water that can be contained between two lines -> Option C

4. Quick Check:

   Container with most water = maximum area [OK]

Hint: Focus on max area between two heights, not sum or count [OK]

Common Mistakes:

• Confusing max area with sum of heights
• Ignoring the smaller height when calculating area
• Thinking about counting lines instead of area

2. Which of the following Go code snippets correctly declares a slice of heights for the Container With Most Water problem?

easy

A. heights := []int{1, 8, 6, 2, 5, 4, 8, 3, 7}

B. heights := [1, 8, 6, 2, 5, 4, 8, 3, 7]

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

D. heights := {1, 8, 6, 2, 5, 4, 8, 3, 7}

Solution

1. Step 1: Recall Go slice declaration syntax

   In Go, slices are declared using []type{values}, for example []int{1,2,3}.

2. Step 2: Check each option

   heights := []int{1, 8, 6, 2, 5, 4, 8, 3, 7} uses []int{...} which is correct. Options A, B, C use invalid syntax for slices.

3. Final Answer:

   heights := []int{1, 8, 6, 2, 5, 4, 8, 3, 7} -> Option A

4. Quick Check:

   Slice declaration uses []type{values} [OK]

Hint: Use []int{...} to declare slices in Go [OK]

Common Mistakes:

• Using parentheses or braces instead of [] for slices
• Confusing arrays and slices syntax
• Missing type declaration in slice

3. What is the output of the following Go code snippet that implements the Container With Most Water logic?

package main
import "fmt"
func maxArea(height []int) int {
    left, right := 0, len(height)-1
    maxArea := 0
    for left < right {
        width := right - left
        var h int
        if height[left] < height[right] {
            h = height[left]
            left++
        } else {
            h = height[right]
            right--
        }
        area := width * h
        if area > maxArea {
            maxArea = area
        }
    }
    return maxArea
}
func main() {
    heights := []int{1,8,6,2,5,4,8,3,7}
    fmt.Println(maxArea(heights))
}

medium

A. 49

B. 56

C. 48

D. 64

Solution

1. Step 1: Understand the two-pointer approach

   Start with left=0 and right=8, calculate area and move the pointer with smaller height inward.

2. Step 2: Trace the iterations

   Initial area: min(1,7)*8=8 Move left to 1 Next area: min(8,7)*7=49 Move right to 7 Next area: min(8,3)*6=18 Move right to 6 Next area: min(8,8)*5=40 Move right to 5 Next area: min(8,4)*4=16 Move right to 4 Next area: min(8,5)*3=15 Move right to 3 Next area: min(8,2)*2=4 Move right to 2 Next area: min(8,6)*1=1 Move left to 2 Max area found is 49.

3. Final Answer:

   49 -> Option A

4. Quick Check:

   Max area calculated by two-pointer = 49 [OK]

Hint: Use two pointers moving inward, track max area [OK]

Common Mistakes:

• Calculating area with max height instead of min
• Not moving the pointer with smaller height
• Confusing width calculation

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

func maxArea(height []int) int {
    left, right := 0, len(height)-1
    maxArea := 0
    for left <= right {
        width := right - left
        var h int
        if height[left] < height[right] {
            h = height[left]
            left++
        } else {
            h = height[right]
            right--
        }
        area := width * h
        if area > maxArea {
            maxArea = area
        }
    }
    return maxArea
}

medium

A. Use maxArea = area without checking if area > maxArea

B. Initialize maxArea to -1 instead of 0

C. Increment both left and right pointers inside the loop

D. Change loop condition to 'left < right' instead of 'left <= right'

Solution

1. Step 1: Analyze the loop condition

   The loop runs while left <= right, which allows left and right to be equal, causing width to be zero or negative.

2. Step 2: Fix the loop condition

   Changing to left < right ensures width is always positive and valid for area calculation.

3. Final Answer:

   Change loop condition to 'left < right' instead of 'left <= right' -> Option D

4. Quick Check:

   Loop must run while left < right [OK]

Hint: Use strict less than for pointers to avoid zero width [OK]

Common Mistakes:

• Using <= instead of < causing invalid area
• Updating both pointers at once
• Not checking if area is greater before updating maxArea

5. Given the heights slice []int{4, 3, 2, 1, 4}, what is the maximum water container area? Use the two-pointer approach and explain why the maximum area is found at those positions.

hard

A. 12

B. 16

C. 8

D. 6

Solution

1. Step 1: Initialize pointers and calculate areas

   Start with left=0 (height=4), right=4 (height=4), width=4, area=4*4=16.

2. Step 2: Move pointers and check other areas

   Since heights[left] == heights[right], move right pointer left: Now left=0, right=3 (height=1), width=3, area=min(4,1)*3=3 Move right to 2 (height=2), area= min(4,2)*2=4 Move right to 1 (height=3), area= min(4,3)*1=3 Max area remains 16.

3. Final Answer:

   16 -> Option B

4. Quick Check:

   Max area between positions 0 and 4 = 16 [OK]

Hint: Max area often at widest distance with min height [OK]

Common Mistakes:

• Not considering both ends first
• Moving wrong pointer when heights are equal
• Calculating area incorrectly with wrong width