Add a solution to the Container With Most Water (Max Area) problem.

Author: eminencegrs

LeetCode/src/LeetCode.Challenges/ContainerWithMostWater/Description.md

@@ -0,0 +1,30 @@
+# Container With Most Water
+
+You are given an integer array `height` of length `n`.  
+There are `n` vertical lines drawn such that the 2 endpoints of the `i-th` line are `(i, 0)` and `(i, height[i])`.  
+
+Find 2 lines that together with the `x-axis` form a container, such that the container contains the most water.  
+Return the maximum amount of water a container can store.  
+Notice that you may not slant the container.  
+
+## My Note:
+
+We just need to find the max area of a rectangle formed by two lines and an x-axis.
+
+## Examples
+
+### Example 1:
+
+![Example](Example.png)
+
+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, see the picture) the container can contain is 49.  
+
+## Constraints:
+
+ - `n == height.length`  
+ - `2 <= n <= 105`  
+ - `0 <= height[i] <= 104`  

LeetCode/src/LeetCode.Challenges/ContainerWithMostWater/Example.png

@@ -0,0 +1,41 @@
+namespace LeetCode.Challenges.ContainerWithMostWater;
+
+// Time Complexity:
+// The loop continues until left is no longer less than right.
+// Since left starts from `0` and right starts from `heights.Length - 1`,
+// and one of them is moved closer to the other in each iteration,
+// the loop will execute at most `n - 1` times where `n` is the length of the `heights` array.
+// The time complexity of the algorithm is O(n).
+// 
+// Space Complexity of the algorithm is O(1).
+public static class Solution
+{
+    public static int GetMaxArea(int[] heights)
+    {
+        var leftPointer = 0;
+        var rightPointer = heights.Length - 1;
+        var maxArea = int.MinValue;
+        while (leftPointer < rightPointer)
+        {
+            var leftEdgeHeight = heights[leftPointer];
+            var rightEdgeHeight = heights[rightPointer];
+            var minEdgeHeight = Math.Min(leftEdgeHeight, rightEdgeHeight);
+            var currentArea = minEdgeHeight * (rightPointer - leftPointer);
+            if (maxArea < currentArea)
+            {
+                maxArea = currentArea;
+            }
+
+            if (leftEdgeHeight < rightEdgeHeight)
+            {
+                leftPointer++;
+            }
+            else
+            {
+                rightPointer--;
+            }
+        }
+
+        return maxArea;
+    }
+}

LeetCode/src/LeetCode.Challenges/ContainerWithMostWater/Solution.cs

@@ -0,0 +1,22 @@
+using LeetCode.Challenges.ContainerWithMostWater;
+using Shouldly;
+using Xunit;
+
+namespace LeetCode.Challenges.UnitTests.ContainerWithMostWater;
+
+public class SolutionTests
+{
+    [Theory]
+    [MemberData(nameof(TestData))]
+    public void GivenHeights_WhenCallGetMaxArea_ThenResultAsExpected(int[] heights, int expectedResult)
+    {
+        var actualResult = Solution.GetMaxArea(heights);
+        actualResult.ShouldBeEquivalentTo(expectedResult);
+    }
+
+    public static IEnumerable<object[]> TestData()
+    {
+        yield return [new[] { 1, 8, 6, 2, 5, 4, 8, 3, 7 }, 49];
+        yield return [new[] { 1, 1 }, 1];
+    }
+}