LeetCode #11: Container With Most Water (refactor)

Author: DimkaGorhover

src/main/java/org/gd/leetcode/p0011/Solution.java

@@ -1,10 +1,12 @@
 package org.gd.leetcode.p0011;
 
-import org.gd.leetcode.common.Repeat;
 import org.gd.leetcode.common.LeetCode;
+import org.gd.leetcode.common.Repeat;
 
 /**
- * https://leetcode.com/problems/container-with-most-water/
+ * <a href="https://leetcode.com/problems/container-with-most-water/">LeetCode #11: Container With Most Water</a>
+ *
+ * @see org.gd.leetcode.p0042.Solution
  */
 @Repeat
 @LeetCode(
@@ -15,22 +17,31 @@
                 LeetCode.Tags.ARRAY,
                 LeetCode.Tags.TWO_POINTERS
         })
+@SuppressWarnings("JavadocReference")
 class Solution {
 
-    private static int max(int i1, int i2, int i3) { return Math.max(i1, Math.max(i2, i3)); }
+    public int maxArea(int[] heights) {
+        if (heights == null || heights.length < 2) {
+            return 0;
+        }
 
-    public int maxArea(int[] height) {
-        switch (height.length) {
-            case 0:
-            case 1: return 0;
-            case 2: return Math.min(height[0], height[1]);
-            case 3: return max(height[0], height[1], height[2]);
+        if (heights.length == 2) {
+            return Math.max(0, Math.min(heights[0], heights[1]));
         }
-        int i = 0, j = height.length - 1, max = Integer.MIN_VALUE, h;
-        while (i < j) {
-            max = Math.max(max, (j - i) * (h = Math.min(height[i], height[j])));
-            while (height[i] <= h && i < j) i++;
-            while (height[j] <= h && i < j) j--;
+
+        int leftIndex = 0;
+        int rightIndex = heights.length - 1;
+        int max = 0;
+        while (leftIndex < rightIndex) {
+            int height = Math.min(heights[leftIndex], heights[rightIndex]);
+            int width = rightIndex - leftIndex;
+            max = Math.max(max, width * height);
+            while (heights[leftIndex] <= height && leftIndex < rightIndex) {
+                leftIndex++;
+            }
+            while (heights[rightIndex] <= height && leftIndex < rightIndex) {
+                rightIndex--;
+            }
         }
         return max;
     }

src/test/java/org/gd/leetcode/p0011/SolutionTest.java

@@ -0,0 +1,41 @@
+package org.gd.leetcode.p0011;
+
+import lombok.NonNull;
+import lombok.SneakyThrows;
+import lombok.val;
+import org.junit.jupiter.api.DisplayName;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+/**
+ * Test for {@link org.gd.leetcode.p0011.Solution}.
+ *
+ * @author Horkhover Dmytro
+ * @see Solution
+ * @since 2022-09-09
+ */
+@DisplayName("LeetCode #11: Container With Most Water")
+class SolutionTest {
+
+    @NonNull
+    private static Stream<Arguments> args() {
+        return Stream.of(
+                Arguments.of(new int[]{1, 8, 6, 2, 5, 4, 8, 3, 7}, 49),
+                Arguments.of(new int[]{1, 1}, 1)
+        );
+    }
+
+    @ParameterizedTest
+    @MethodSource("args")
+    @DisplayName("Test for maxArea")
+    @SneakyThrows
+    void test_maxArea(int[] heights, int expected) {
+        val solution = new Solution();
+        assertThat(solution.maxArea(heights)).isEqualTo(expected);
+    }
+}