Container With Most Water

                                            
class Solution {
public:
    int maxArea(vector<int>& height) {
        int maxArea = 0;
        int left = 0;
        int right = height.size() - 1;
        
        while (left < right) {
            int minHeight = min(height[left], height[right]);
            maxArea = max(maxArea, minHeight * (right - left));
            
            if (height[left] < height[right]) {
                left++;
            } else {
                right--;
            }
        }
        
        return maxArea;
    }
};

                                            
class Solution {
    public int maxArea(int[] height) {
        int maxArea = 0;
        int left = 0;
        int right = height.length - 1;
        
        while (left < right) {
            int h = Math.min(height[left], height[right]);
            maxArea = Math.max(maxArea, h * (right - left));
            
            if (height[left] < height[right]) {
                left++;
            } else {
                right--;
            }
        }
        
        return maxArea;
    }
}

                                            
class Solution(object):
    def maxArea(self, height):
        """
        :type height: List[int]
        :rtype: int
        """
        max_area = 0
        left = 0
        right = len(height) - 1
        
        while left < right:
            h = min(height[left], height[right])
            max_area = max(max_area, h * (right - left))
            
            if height[left] < height[right]:
                left += 1
            else:
                right -= 1
        
        return max_area

                                            
int maxArea(int* height, int heightSize) {
    int max = 0;
    int left = 0;
    int right = heightSize - 1;
    
    while (left < right) {
        int current = (right - left) * fmin(height[left], height[right]);
        max = fmax(max, current);
        
        if (height[left] < height[right]) {
            left++;
        } else {
            right--;
        }
    }
    
    return max;
}

                                            
public class Solution {
    public int MaxArea(int[] height) {
        int maxArea = 0;
        int left = 0;
        int right = height.Length - 1;

        while (left < right) {
            int currentArea = Math.Min(height[left], height[right]) * (right - left);
            maxArea = Math.Max(maxArea, currentArea);

            if (height[left] < height[right]) {
                left++;
            } else {
                right--;
            }
        }

        return maxArea;
    }
}

                                            
/**
 * @param {number[]} height
 * @return {number}
 */
var maxArea = function(height) {
    let maxWater = 0;
    let left = 0;
    let right = height.length - 1;
    
    while (left < right) {
        const h = Math.min(height[left], height[right]);
        const w = right - left;
        maxWater = Math.max(maxWater, h * w);
        
        if (height[left] < height[right]) {
            left++;
        } else {
            right--;
        }
    }
    
    return maxWater;
};

                                            
function maxArea(height: number[]): number {
    let max = 0;
    let left = 0;
    let right = height.length - 1;

    while (left < right) {
        const currentArea = Math.min(height[left], height[right]) * (right - left);
        max = Math.max(max, currentArea);

        if (height[left] < height[right]) {
            left++;
        } else {
            right--;
        }
    }

    return max;
};

                                            
class Solution {
    /**
     * @param Integer[] $height
     * @return Integer
     */
    function maxArea($height) {
        $maxArea = 0;
        $left = 0;
        $right = count($height) - 1;
        
        while ($left < $right) {
            $area = min($height[$left], $height[$right]) * ($right - $left);
            $maxArea = max($maxArea, $area);
            
            if ($height[$left] < $height[$right]) {
                $left++;
            } else {
                $right--;
            }
        }
        
        return $maxArea;
    }
}

                                            
class Solution {
    func maxArea(_ height: [Int]) -> Int {
        var maxArea = 0
        var left = 0
        var right = height.count - 1
        
        while left < right {
            let currentArea = min(height[left], height[right]) * (right - left)
            maxArea = max(maxArea, currentArea)
            
            if height[left] < height[right] {
                left += 1
            } else {
                right -= 1
            }
        }
        
        return maxArea
    }
}

                                            
class Solution {
    fun maxArea(height: IntArray): Int {
        var left = 0
        var right = height.size - 1
        var maxArea = 0
        
        while (left < right) {
            val currentArea = (right - left) * minOf(height[left], height[right])
            maxArea = maxOf(maxArea, currentArea)
            
            if (height[left] < height[right]) {
                left++
            } else {
                right--
            }
        }
        
        return maxArea
    }
}

                                            
class Solution {
  int maxArea(List<int> height) {
    int maxArea = 0;
    int left = 0;
    int right = height.length - 1;

    while (left < right) {
      int currentArea = (right - left) * (height[left] < height[right] ? height[left] : height[right]);
      maxArea = currentArea > maxArea ? currentArea : maxArea;

      if (height[left] < height[right]) {
        left++;
      } else {
        right--;
      }
    }

    return maxArea;
  }
}

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

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func min(a, b int) int {
    if a < b {
        return a
    }
    return b
}

                                            
# @param {Integer[]} height
# @return {Integer}
def max_area(height)
    max_area = 0
    left = 0
    right = height.length - 1
    
    while left < right
        current_area = [height[left], height[right]].min * (right - left)
        max_area = [max_area, current_area].max
        
        if height[left] < height[right]
            left += 1
        else
            right -= 1
        end
    end
    
    return max_area
end

                                            
object Solution {
    def maxArea(height: Array[Int]): Int = {
        var maxArea = 0
        var left = 0
        var right = height.length - 1
        
        while (left < right) {
            val currentArea = (right - left) * Math.min(height(left), height(right))
            maxArea = Math.max(maxArea, currentArea)
            
            if (height(left) < height(right)) {
                left += 1
            } else {
                right -= 1
            }
        }
        
        maxArea
    }
}

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

To solve this coding challenge, the goal is to identify two vertical lines from the given array that, along with the x-axis, can contain the most water. The problem is essentially about finding the maximum area that can be enclosed by the lines, where the area is defined by the minimum of the two lines multiplied by the distance between them.

# Explanation

The approach to solving this problem efficiently involves using a two-pointer technique. Here’s a step-by-step breakdown of the thought process and the methodology:

Initialize Two Pointers : Start by placing one pointer at the beginning (left) and the other at the end (right) of the array.
Calculate the Area : For the container formed by the lines at these two pointers, calculate the area. The area is determined by the shorter of the two lines (since water cannot go above the shorter line) multiplied by the distance between the two lines.
Update Maximum Area : Keep track of the maximum area observed so far.
Move Pointers : To attempt to find a larger area, move the pointer that is at the shorter line. This is because moving the longer line inward would only decrease the width of the container while not necessarily increasing the height, which could potentially result in a smaller or equal area.
Repeat : Continue the process until the two pointers meet.

Below is the pseudocode with comments for clearer understanding:

Detailed Steps in Pseudocode

Initialize Variables :

Set
left

pointer to 0 (start of the array)
Set
right

pointer to
n-1

(end of the array)
Initialize
max_area

to 0 to keep track of the maximum water area

While Loop :

Run the loop until
left

is less than
right

Calculate the height of the water using the shorter of the two lines
Calculate the width between the lines (right - left)
Compute the current area as height * width
Update
max_area

if the current area is larger than the previous maximum
Move the pointer at the shorter line inward towards the center of the array

Return :

Once the loop ends, return the
max_area

which holds the maximum water that can be contained

Pseudocode with Comments

                                            
// Initialize variables
left = 0                                   // Pointer at the beginning
right = len(height) - 1                    // Pointer at the end
max_area = 0                               // Max area initialized to 0

// Iterate while the left pointer is less than the right pointer
while left < right:

// Calculate the height using the shorter of the two lines
current_height = min(height[left], height[right])

// Calculate the width between the two lines
current_width = right - left

// Calculate the current area
current_area = current_height * current_width

// Update max_area if the current area is larger
if current_area > max_area:
max_area = current_area

// Move the pointer at the shorter line inward
if height[left] < height[right]:
left = left + 1
else:
right = right - 1

// Return the maximum area found
return max_area

# Explanation

Initialize Variables : We start by setting pointers
left

at index 0 and
right

at the last index of the array. The variable
max_area

is used to track the maximum area found during the loop.
Loop Until Pointers Meet : The loop runs until
left

meets
right

. In each iteration of the loop, we:

Determine the height of the water: Since water cannot exceed the shorter of the two lines, the height is the minimum of the heights at the two pointers.
Compute the width between the pointers as the difference between
right

and
left

.
Calculate the area and update
max_area

if this new area is greater.

Move Pointer : Depending on which line is shorter, we move the corresponding pointer inward to potentially find a larger area. This ensures that we always consider the possibility of a taller line that could increase the water contained.
Return Result : After the loop completes, the
max_area

will contain the maximum water that can be held between any two lines in the array.

This approach is efficient with a time complexity of O(n) and solves the problem optimally by making a single pass through the array while adjusting the pointers intelligently.