11. Container most water

int maxArea(int *height, int heightSize) {
    int left = 0, right = heightSize - 1, mx = 0;

    while (left < right) {
        int width = right - left;
        int h = height[left] < height[right] ? height[left] : height[right];
        int area = h * width;
        if (area > mx) mx = area;

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

    return mx;
}

#include <vector>
using namespace std;
class Solution {
public:
  int maxArea(vector<int> &height) {
    int mx = 0, left = 0, right = height.size() - 1;

    while (left < right) {
      int width = right - left;
      int h = min(height[left], height[right]);
      mx = max(mx, h * width);
      if (height[left] > height[right]) {
        right--;
      } else {
        left++;
      }
    }

    return mx;
  }
};

package main

func maxArea(height []int) int {
    left, right, mx := 0, len(height)-1, 0

    for left < right {
        width := right - left
        h := height[left]
        if height[right] < h {
            h = height[right]
        }
        if area := h * width; area > mx {
            mx = area
        }

        if height[left] > height[right] {
            right--
        } else {
            left++
        }
    }

    return mx
}

class Solution {
    public int maxArea(int[] height) {
        int left = 0, right = height.length - 1, mx = 0;

        while (left < right) {
            int width = right - left;
            int h = Math.min(height[left], height[right]);
            mx = Math.max(mx, h * width);

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

        return mx;
    }
}

class Solution {
  maxArea(height) {
    let left = 0;
    let right = height.length - 1;
    let mx = 0;

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

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

    return mx;
  }
}

class Solution:
    def maxArea(self, height: list[int]) -> int:
        left, right, mx = 0, len(height) - 1, 0

        while left < right:
            width = right - left
            h = min(height[left], height[right])
            mx = max(mx, h * width)

            if height[left] > height[right]:
                right -= 1
            else:
                left += 1

        return mx

struct Solution;

impl Solution {
    fn max_area(height: Vec<i32>) -> i32 {
        let mut left = 0usize;
        let mut right = height.len() - 1;
        let mut mx = 0;

        while left < right {
            let width = (right - left) as i32;
            let h = height[left].min(height[right]);
            mx = mx.max(h * width);

            if height[left] > height[right] {
                right -= 1;
            } else {
                left += 1;
            }
        }

        mx
    }
}