LeetCode 154: Find Minimum in Rotated Sorted Array II

Author: DimkaGorhover

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

@@ -6,8 +6,10 @@
  * https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/
  *
  * @author Horkhover Dmytro
+ * @see org.gd.leetcode.p0154.Solution
  * @since 2020-07-26
  */
+@SuppressWarnings({"JavadocReference", "DuplicatedCode"})
 @LeetCode(
         name = "Find Minimum in Rotated Sorted Array",
         difficulty = LeetCode.Level.MEDIUM,

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

@@ -0,0 +1,71 @@
+package org.gd.leetcode.p0154;
+
+import org.gd.leetcode.common.LeetCode;
+
+/**
+ * https://leetcode.com/problems/find-minimum-in-rotated-sorted-array-ii/
+ *
+ * @author Horkhover Dmytro
+ * @see org.gd.leetcode.p0153.Solution
+ * @since 2020-07-26
+ */
+@SuppressWarnings({"JavadocReference", "DuplicatedCode"})
+@LeetCode(
+        name = "Find Minimum in Rotated Sorted Array II",
+        difficulty = LeetCode.Level.HARD,
+        state = LeetCode.State.DONE,
+        tags = {
+                LeetCode.Tags.ARRAY,
+                LeetCode.Tags.BINARY_SEARCH
+        }
+)
+class Solution {
+
+    private int[] nums;
+
+    private static int mid(int left, int right) {
+        return (left + right + 1) >> 1;
+    }
+
+    private int findMin(int leftIndex, int rightIndex) {
+
+        while (true) {
+
+            if (leftIndex == rightIndex || nums[leftIndex] < nums[rightIndex])
+                return nums[leftIndex];
+
+            if (rightIndex - leftIndex == 1)
+                return Math.min(nums[leftIndex], nums[rightIndex]);
+
+            final int midIndex = mid(leftIndex, rightIndex);
+
+            if (nums[midIndex] == nums[leftIndex]) {
+                int leftMin = findMin(leftIndex, midIndex);
+                int rightMin = findMin(midIndex, rightIndex);
+                return Math.min(leftMin, rightMin);
+            }
+
+            if (nums[midIndex] < nums[leftIndex]) {
+                rightIndex = midIndex;
+            } else {
+                leftIndex = midIndex;
+            }
+        }
+    }
+
+    public int findMin(int[] nums) {
+        if (nums == null) throw new NullPointerException();
+        if (nums.length == 0) throw new IllegalArgumentException();
+
+        switch (nums.length) {
+            case 1: return nums[0];
+            case 2: return Math.min(nums[0], nums[1]);
+            case 3: return Math.min(nums[0], Math.min(nums[2], nums[1]));
+            case 4: return Math.min(Math.min(nums[0], nums[1]), Math.min(nums[2], nums[3]));
+        }
+
+        this.nums = nums;
+
+        return findMin(0, nums.length - 1);
+    }
+}

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

@@ -6,6 +6,7 @@
 import org.junit.jupiter.params.provider.MethodSource;
 
 import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
 import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assertions.*;
@@ -16,6 +17,7 @@
  * @author Horkhover Dmytro
  * @since 2020-07-26
  */
+@Timeout(value = 100, unit = TimeUnit.MILLISECONDS)
 @DisplayName("LeetCode #153: Find Minimum in Rotated Sorted Array")
 class SolutionTest {
 
@@ -28,6 +30,9 @@ private static Stream<Arguments> args() {
                 Arguments.of(new int[]{2, 2, 2, 2, 2, 3, 1, 2, 2}, 1),
                 Arguments.of(new int[]{2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 1, 2, 2}, 1),
                 Arguments.of(new int[]{2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 0, 1, 2, 2}, 0),
+                Arguments.of(
+                        IntStream.concat(IntStream.rangeClosed(1010, 5_000), IntStream.rangeClosed(14, 1_000)).toArray(),
+                        14),
                 Arguments.of(new int[]{1}, 1),
                 Arguments.of(new int[]{1, 0}, 0),
                 Arguments.of(new int[]{1, 0, -1}, -1),
@@ -39,7 +44,6 @@ private static Stream<Arguments> args() {
     @ParameterizedTest
     @MethodSource("args")
     @DisplayName("FindMin")
-    @Timeout(value = 100, unit = TimeUnit.MILLISECONDS)
     void test_FindMin(int[] nums, int expected) {
         assertEquals(expected, new Solution().findMin(nums));
     }

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

@@ -0,0 +1,50 @@
+package org.gd.leetcode.p0154;
+
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.concurrent.TimeUnit;
+import java.util.stream.IntStream;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+/**
+ * Test for {@link Solution}
+ *
+ * @author Horkhover Dmytro
+ * @since 2020-07-26
+ */
+@Timeout(value = 100, unit = TimeUnit.MILLISECONDS)
+@DisplayName("LeetCode #154: Find Minimum in Rotated Sorted Array II")
+class SolutionTest {
+
+    private static Stream<Arguments> args() {
+        return Stream.of(
+                Arguments.of(new int[]{1, 2, 3, 4, 5}, 1),
+                Arguments.of(new int[]{1, 2, 3, 4, 5, 6}, 1),
+                Arguments.of(new int[]{1, 2, 3, 4, 5, 6, 7}, 1),
+                Arguments.of(new int[]{1, 2, 3, 4, 5, 6, 7, 8}, 1),
+                Arguments.of(new int[]{2, 2, 2, 2, 2, 3, 1, 2, 2}, 1),
+                Arguments.of(new int[]{2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 1, 2, 2}, 1),
+                Arguments.of(new int[]{2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 4, 0, 1, 2, 2}, 0),
+                Arguments.of(
+                        IntStream.concat(IntStream.rangeClosed(1010, 5_000), IntStream.rangeClosed(14, 1_000)).toArray(),
+                        14),
+                Arguments.of(new int[]{1}, 1),
+                Arguments.of(new int[]{1, 0}, 0),
+                Arguments.of(new int[]{1, 0, -1}, -1),
+                Arguments.of(new int[]{3, 4, 5, 1, 2}, 1),
+                Arguments.of(new int[]{2, 2, 2, 2, 2, 1, 2, 2}, 1),
+                Arguments.of(new int[]{4, 5, 6, 7, 0, 1, 2}, 0));
+    }
+
+    @ParameterizedTest
+    @MethodSource("args")
+    @DisplayName("FindMin")
+    void test_FindMin(int[] nums, int expected) {
+        assertEquals(expected, new Solution().findMin(nums));
+    }
+}