refactor 154

fishercoder1534 · fishercoder1534 · commit 90d0a21b6514 · 2018-05-14T07:28:58.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_154.java b/src/main/java/com/fishercoder/solutions/_154.java
@@ -2,40 +2,51 @@
 
 /**
  * 154. Find Minimum in Rotated Sorted Array II
- *
- * Follow up for "Find Minimum in Rotated Sorted Array":
- What if duplicates are allowed?
 
- Would this affect the run-time complexity? How and why?
  Suppose an array sorted in ascending order is rotated at some pivot unknown to you beforehand.
 
- (i.e., 0 1 2 4 5 6 7 might become 4 5 6 7 0 1 2).
+ (i.e.,  [0,1,2,4,5,6,7] might become  [4,5,6,7,0,1,2]).
 
  Find the minimum element.
 
  The array may contain duplicates.
+
+ Example 1:
+ Input: [1,3,5]
+ Output: 1
+
+ Example 2:
+ Input: [2,2,2,0,1]
+ Output: 0
+
+ Note:
+ This is a follow up problem to Find Minimum in Rotated Sorted Array.
+ Would allow duplicates affect the run-time complexity? How and why?
+
  */
 public class _154 {
+  public static class Solution1 {
     public int findMin(int[] nums) {
-        int left = 0;
-        int right = nums.length - 1;
-        if (nums[left] < nums[right]) {
-            return nums[left];
-        }
-        int min = nums[0];
-        while (left + 1 < right) {
-            int mid = left + (right - left) / 2;
-            min = Math.min(min, nums[mid]);
-            if (nums[mid] > nums[left]) {
-                min = Math.min(nums[left], min);
-                left = mid + 1;
-            } else if (nums[mid] < nums[left]) {
-                right = mid - 1;
-            } else {
-                left++;
-            }
+      int left = 0;
+      int right = nums.length - 1;
+      if (nums[left] < nums[right]) {
+        return nums[left];
+      }
+      int min = nums[0];
+      while (left + 1 < right) {
+        int mid = left + (right - left) / 2;
+        min = Math.min(min, nums[mid]);
+        if (nums[mid] > nums[left]) {
+          min = Math.min(nums[left], min);
+          left = mid + 1;
+        } else if (nums[mid] < nums[left]) {
+          right = mid - 1;
+        } else {
+          left++;
         }
-        min = Math.min(min, Math.min(nums[left], nums[right]));
-        return min;
+      }
+      min = Math.min(min, Math.min(nums[left], nums[right]));
+      return min;
     }
+  }
 }
diff --git a/src/test/java/com/fishercoder/_154Test.java b/src/test/java/com/fishercoder/_154Test.java
@@ -6,21 +6,18 @@
 
 import static org.junit.Assert.assertEquals;
 
-/**
- * Created by fishercoder on 5/25/17.
- */
 public class _154Test {
-    private static _154 test;
-    private static int[] nums;
+  private static _154.Solution1 solution1;
+  private static int[] nums;
 
-    @BeforeClass
-    public static void setup() {
-        test = new _154();
-    }
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _154.Solution1();
+  }
 
-    @Test
-    public void test1() {
-        nums = new int[]{1, 1, 1};
-        assertEquals(1, test.findMin(nums));
-    }
+  @Test
+  public void test1() {
+    nums = new int[] {1, 1, 1};
+    assertEquals(1, solution1.findMin(nums));
+  }
 }
