11. Container With Most Water

```Solution.c int maxArea(int* height, int heightSize) { int left = 0, right = heightSize - 1; int maxArea = 0; while (left < right) { int width = right - left; int currentHeight = height[left] < height[right] ? height[left] : height[right]; int area = width * currentHeight; maxArea = maxArea > area ? maxArea : area; if (height[left] < height[right]) { left++; } else { right--; } } return maxArea; } ``` ```Solution.cpp class Solution { public: int maxArea(vector<int>& height) { int left = 0; int right = height.size() - 1; int max_water = 0; while (left < right) { max_water = max(min(height[left], height[right]) * (right - left), max_water); if (height[left] <= height[right]) { left++; } else { right--; } } return max_water; } }; ``` ```Solution.cs public class Solution { public int MaxArea(int[] height) { int left = 0, right = height.Length - 1; int maxArea = 0; while (left < right) { int width = right - left; int currentHeight = Math.Min(height[left], height[right]); maxArea = Math.Max(maxArea, width * currentHeight); if (height[left] < height[right]) { left++; } else { right--; } } return maxArea; } } ``` ```Solution.dart class Solution { int maxArea(List<int> height) { int left = 0, right = height.length - 1; int maxArea = 0; while (left < right) { int width = right - left; int currentHeight = height[left] < height[right] ? height[left] : height[right]; maxArea = maxArea > (width * currentHeight) ? maxArea : (width * currentHeight); if (height[left] < height[right]) { left++; } else { right--; } } return maxArea; } } ``` ```Solution.erl -spec max_area(Height :: [integer()]) -> integer(). max_area(Height) -> Tuple = list_to_tuple(Height), max_area(Tuple, 0, tuple_size(Tuple) - 1, 0). max_area(Tuple, Left, Right, MaxWater) when Left < Right -> Width = Right - Left, LeftHeight = element(Left + 1, Tuple), RightHeight = element(Right + 1, Tuple), Area = min(LeftHeight, RightHeight) * Width, NewMaxWater = max(MaxWater, Area), if LeftHeight < RightHeight -> max_area(Tuple, Left + 1, Right, NewMaxWater); true -> max_area(Tuple, Left, Right - 1, NewMaxWater) end; max_area(_Tuple, _Left, _Right, MaxWater) -> MaxWater. ``` ```Solution.ex defmodule Solution do @SPEC max_area(height :: [integer]) :: integer def max_area(height) do height = List.to_tuple(height) do_max_area(height, 0, tuple_size(height) - 1, 0) end defp do_max_area(_, l, r, max) when l >= r, do: max defp do_max_area(height, l, r, max) do height_l = elem(height, l) height_r = elem(height, r) max = max(max, min(height_l, height_r) * (r - l)) if height_l < height_r do do_max_area(height, l + 1, r, max) else do_max_area(height, l, r - 1, max) end end end ``` ```Solution.go func maxArea(height []int) int { left, right := 0, len(height)-1 maxArea := 0 for left < right { width := right - left currentHeight := height[left] if height[right] < currentHeight { currentHeight = height[right] } area := width * currentHeight if area > maxArea { maxArea = area } if height[left] < height[right] { left++ } else { right-- } } return maxArea } ``` ```Solution.java class Solution { public int maxArea(int[] height) { int left = 0, right = height.length - 1; int maxArea = 0; while (left < right) { int width = right - left; int currentHeight = Math.min(height[left], height[right]); maxArea = Math.max(maxArea, width * currentHeight); if (height[left] < height[right]) { left++; } else { right--; } } return maxArea; } } ``` ```Solution.js /** * @param {number[]} height * @return {number} */ var maxArea = function(height) { let left = 0, right = height.length - 1; let maxArea = 0; while (left < right) { const width = right - left; const currentHeight = Math.min(height[left], height[right]); maxArea = Math.max(maxArea, width * currentHeight); if (height[left] < height[right]) { left++; } else { right--; } } return maxArea; }; ``` ```Solution.kt class Solution { fun maxArea(height: IntArray): Int { var left = 0 var right = height.size - 1 var maxArea = 0 while (left < right) { val width = right - left val currentHeight = minOf(height[left], height[right]) maxArea = maxOf(maxArea, width * currentHeight) if (height[left] < height[right]) { left++ } else { right-- } } return maxArea } } ``` ```Solution.php class Solution { /** * @param Integer[] $height * @return Integer */ function maxArea($height) { $left = 0; $right = count($height) - 1; $maxArea = 0; while ($left < $right) { $width = $right - $left; $currentHeight = min($height[$left], $height[$right]); $maxArea = max($maxArea, $width * $currentHeight); if ($height[$left] < $height[$right]) { $left++; } else { $right--; } } return $maxArea; } } ``` ```Solution.py class Solution: def maxArea(self, height: List[int]) -> int: left, right = 0, len(height) - 1 max_area = 0 while left < right: width = right - left current_height = min(height[left], height[right]) max_area = max(max_area, width * current_height) if height[left] < height[right]: left += 1 else: right -= 1 return max_area ``` ```Solution.rb # @param {Integer[]} height # @return {Integer} def max_area(height) return 0 if height.nil? || height.length < 2 left, right = 0, height.length - 1 max_area = 0 while left < right width = right - left current_height = [height[left], height[right]].min max_area = [max_area, width * current_height].max if height[left] < height[right] left += 1 else right -= 1 end end max_area end ``` ```Solution.rkt (define (max-area height) (define ht (list->vector height)) (define (loop left right max-area) (if (>= left right) max-area (let* ([left-height (vector-ref ht left)] [right-height (vector-ref ht right)] [width (- right left)] [area (* (min left-height right-height) width)] [new-max (max max-area area)]) (if (< left-height right-height) (loop (add1 left) right new-max) (loop left (sub1 right) new-max))))) (loop 0 (sub1 (vector-length ht)) 0)) ``` ```Solution.rs impl Solution { pub 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 current_height = height[left].min(height[right]); max_area = max_area.max(width * current_height); if height[left] < height[right] { left += 1; } else { right -= 1; } } max_area } } ``` ```Solution.scala object Solution { def maxArea(height: Array[Int]): Int = { var left = 0 var right = height.length - 1 var maxArea = 0 while (left < right) { val width = right - left val currentHeight = math.min(height(left), height(right)) maxArea = math.max(maxArea, width * currentHeight) if (height(left) < height(right)) { left += 1 } else { right -= 1 } } maxArea } } ``` ```Solution.swift class Solution { func maxArea(_ height: [Int]) -> Int { var left = 0, right = height.count - 1 var maxArea = 0 while left < right { let width = right - left let currentHeight = min(height[left], height[right]) maxArea = max(maxArea, width * currentHeight) if height[left] < height[right] { left += 1 } else { right -= 1 } } return maxArea } } ``` ```Solution.ts function maxArea(height: number[]): number { let left: number = 0, right: number = height.length - 1; let maxArea: number = 0; while (left < right) { const width: number = right - left; const currentHeight: number = Math.min(height[left], height[right]); maxArea = Math.max(maxArea, width * currentHeight); if (height[left] < height[right]) { left++; } else { right--; } } return maxArea; } ```

Author: nendroids

res/ino/477955856.jpg

@@ -0,0 +1,28 @@
+# [**11. Container With Most Water**](https://leetcode.com/problems/container-with-most-water/description/)
+
+You are given an integer array `height` of length `n`. There are `n` vertical lines drawn such that the two endpoints of the `iᵗʰ` line are `(i, 0)` and `(i, height[i])`.<br>
+Find two lines that together with the x-axis form a container, such that the container contains the most water.<br>
+Return the maximum amount of water a container can store.
+
+**Notice** that you may not slant the container.
+
+#### **Example 1:**
+
+<img src="https://raw.githubusercontent.com/leetcoin-releases/leetcode/refs/heads/main/res/ino/477955856.jpg" style="width: 100%; height: 600;"/>
+
+```md
+Input: height = [1,8,6,2,5,4,8,3,7]
+Output: 49
+Explanation: The above vertical lines are represented by array [1,8,6,2,5,4,8,3,7]. In this case, the max area of water (blue section) the container can contain is 49.
+```
+
+#### **Example 2:**
+```md
+Input: height = [1,1]
+Output: 1
+```
+
+#### **Constraints:**
+> - `n == height.length`
+> - `2 <= n <= 10⁵`
+> - `0 <= height[i] <= 10⁴`

sol/solution/0001-0100/0011/README.md

@@ -0,0 +1,16 @@
+int maxArea(int* height, int heightSize) {
+ int left = 0, right = heightSize - 1;
+ int maxArea = 0;
+ while (left < right) {
+ int width = right - left;
+ int currentHeight = height[left] < height[right] ? height[left] : height[right];
+ int area = width * currentHeight;
+ maxArea = maxArea > area ? maxArea : area;
+ if (height[left] < height[right]) {
+ left++;
+ } else {
+ right--;
+ }
+ }
+ return maxArea;
+}

sol/solution/0001-0100/0011/Solution.c

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

sol/solution/0001-0100/0011/Solution.cpp

@@ -0,0 +1,17 @@
+public class Solution {
+ public int MaxArea(int[] height) {
+ int left = 0, right = height.Length - 1;
+ int maxArea = 0;
+ while (left < right) {
+ int width = right - left;
+ int currentHeight = Math.Min(height[left], height[right]);
+ maxArea = Math.Max(maxArea, width * currentHeight);
+ if (height[left] < height[right]) {
+ left++;
+ } else {
+ right--;
+ }
+ }
+ return maxArea;
+ }
+}

sol/solution/0001-0100/0011/Solution.cs

@@ -0,0 +1,17 @@
+class Solution {
+ int maxArea(List<int> height) {
+ int left = 0, right = height.length - 1;
+ int maxArea = 0;
+ while (left < right) {
+ int width = right - left;
+ int currentHeight = height[left] < height[right] ? height[left] : height[right];
+ maxArea = maxArea > (width * currentHeight) ? maxArea : (width * currentHeight);
+ if (height[left] < height[right]) {
+ left++;
+ } else {
+ right--;
+ }
+ }
+ return maxArea;
+ }
+}

sol/solution/0001-0100/0011/Solution.dart

@@ -0,0 +1,18 @@
+-spec max_area(Height :: [integer()]) -> integer().
+max_area(Height) ->
+ Tuple = list_to_tuple(Height),
+ max_area(Tuple, 0, tuple_size(Tuple) - 1, 0).
+max_area(Tuple, Left, Right, MaxWater) when Left < Right ->
+ Width = Right - Left,
+ LeftHeight = element(Left + 1, Tuple),
+ RightHeight = element(Right + 1, Tuple),
+ Area = min(LeftHeight, RightHeight) * Width,
+ NewMaxWater = max(MaxWater, Area),
+ if
+ LeftHeight < RightHeight ->
+ max_area(Tuple, Left + 1, Right, NewMaxWater);
+ true ->
+ max_area(Tuple, Left, Right - 1, NewMaxWater)
+ end;
+max_area(_Tuple, _Left, _Right, MaxWater) ->
+ MaxWater.

sol/solution/0001-0100/0011/Solution.erl

@@ -0,0 +1,18 @@
+defmodule Solution do
+ @spec max_area(height :: [integer]) :: integer
+ def max_area(height) do
+ height = List.to_tuple(height)
+ do_max_area(height, 0, tuple_size(height) - 1, 0)
+ end
+ defp do_max_area(_, l, r, max) when l >= r, do: max
+ defp do_max_area(height, l, r, max) do
+ height_l = elem(height, l)
+ height_r = elem(height, r)
+ max = max(max, min(height_l, height_r) * (r - l))
+ if height_l < height_r do
+ do_max_area(height, l + 1, r, max)
+ else
+ do_max_area(height, l, r - 1, max)
+ end
+ end
+end

sol/solution/0001-0100/0011/Solution.ex

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

sol/solution/0001-0100/0011/Solution.go

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