refactor 189

fishercoder1534 · fishercoder1534 · commit f77b9bb46088 · 2018-06-08T07:20:58.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_189.java b/src/main/java/com/fishercoder/solutions/_189.java
@@ -3,83 +3,78 @@
 import java.util.ArrayList;
 import java.util.List;
 
-import static com.fishercoder.solutions._189.Solution2.rotate_naive;
-
 /**
  * 189. Rotate Array
- *
- * Rotate an array of n elements to the right by k steps.
- * For example, with n = 7 and k = 3, the array [1,2,3,4,5,6,7] is rotated to [5,6,7,1,2,3,4].
- * */
-
-public class _189 {
-
-    public static class Solution1 {
-        public void rotate(int[] nums, int k) {
-            int len = nums.length;
-            int[] tmp = new int[len];
-            for (int i = 0; i < len; i++) {
-                tmp[(i + k) % len] = nums[i];
-            }
-            for (int i = 0; i < len; i++) {
-                nums[i] = tmp[i];
-            }
-        }
-    }
 
-    public static class Solution2 {
-        /**
-         * My original idea and got AC'ed.
-         * One thing to notice is that when k > nums.length, we'll continue to rotate_naive the array, it just becomes k -= nums.length
-         */
-        public static void rotate_naive(int[] nums, int k) {
-            if (k == 0 || k == nums.length) {
-                return;
-            }
-            if (k > nums.length) {
-                k -= nums.length;
-            }
-            List<Integer> tmp = new ArrayList();
-            int i = 0;
-            if (nums.length - k >= 0) {
-                i = nums.length - k;
-                for (; i < nums.length; i++) {
-                    tmp.add(nums[i]);
-                }
-            } else {
-                i = nums.length - 1;
-                for (; i >= 0; i--) {
-                    tmp.add(nums[i]);
-                }
+ Given an array, rotate the array to the right by k steps, where k is non-negative.
 
-            }
-            for (i = 0; i < nums.length - k; i++) {
-                tmp.add(nums[i]);
-            }
-            for (i = 0; i < tmp.size(); i++) {
-                nums[i] = tmp.get(i);
-            }
-        }
-    }
+ Example 1:
+ Input: [1,2,3,4,5,6,7] and k = 3
+ Output: [5,6,7,1,2,3,4]
+ Explanation:
+ rotate 1 steps to the right: [7,1,2,3,4,5,6]
+ rotate 2 steps to the right: [6,7,1,2,3,4,5]
+ rotate 3 steps to the right: [5,6,7,1,2,3,4]
 
-    public static void main(String... strings) {
-//        int k = 1;
-//        int[] nums = new int[]{1,2,3};
-//        int[] nums = new int[]{1};
-//        int[] nums = new int[]{1,2};
+ Example 2:
+ Input: [-1,-100,3,99] and k = 2
+ Output: [3,99,-1,-100]
+ Explanation:
+ rotate 1 steps to the right: [99,-1,-100,3]
+ rotate 2 steps to the right: [3,99,-1,-100]
 
-//        int k = 3;
-//        int[] nums = new int[]{1,2};
+ Note:
+ Try to come up as many solutions as you can, there are at least 3 different ways to solve this problem.
+ Could you do it in-place with O(1) extra space?
 
-//        int k = 2;
-//        int[] nums = new int[]{1,2};
+ * */
 
-        int k = 4;
-        int[] nums = new int[]{1, 2, 3};
+public class _189 {
 
-//        int k = 2;
-//        int[] nums = new int[]{-1};
-        rotate_naive(nums, k);
+  public static class Solution1 {
+    public void rotate(int[] nums, int k) {
+      int len = nums.length;
+      int[] tmp = new int[len];
+      for (int i = 0; i < len; i++) {
+        tmp[(i + k) % len] = nums[i];
+      }
+      for (int i = 0; i < len; i++) {
+        nums[i] = tmp[i];
+      }
     }
+  }
 
+  public static class Solution2 {
+    /**
+     * My original idea and got AC'ed.
+     * One thing to notice is that when k > nums.length, we'll continue to rotate_naive the array, it just becomes k -= nums.length
+     */
+    public static void rotate_naive(int[] nums, int k) {
+      if (k == 0 || k == nums.length) {
+        return;
+      }
+      if (k > nums.length) {
+        k -= nums.length;
+      }
+      List<Integer> tmp = new ArrayList();
+      int i = 0;
+      if (nums.length - k >= 0) {
+        i = nums.length - k;
+        for (; i < nums.length; i++) {
+          tmp.add(nums[i]);
+        }
+      } else {
+        i = nums.length - 1;
+        for (; i >= 0; i--) {
+          tmp.add(nums[i]);
+        }
+      }
+      for (i = 0; i < nums.length - k; i++) {
+        tmp.add(nums[i]);
+      }
+      for (i = 0; i < tmp.size(); i++) {
+        nums[i] = tmp.get(i);
+      }
+    }
+  }
 }
diff --git a/src/test/java/com/fishercoder/_189Test.java b/src/test/java/com/fishercoder/_189Test.java
@@ -0,0 +1,24 @@
+package com.fishercoder;
+
+import com.fishercoder.common.utils.CommonUtils;
+import com.fishercoder.solutions._189;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+public class _189Test {
+  private static _189.Solution1 solution1;
+  private static int[] nums;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _189.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    nums = new int[] {1, 2, 3};
+
+    solution1.rotate(nums, 1);
+    CommonUtils.printArray(nums);
+  }
+}
