[N-0] refactor 55

Author: fishercoder1534

src/main/java/com/fishercoder/solutions/_55.java

@@ -1,47 +1,28 @@
 package com.fishercoder.solutions;
 
-/**Given an array of non-negative integers, you are initially positioned at the first index of the array.
-
- Each element in the array represents your maximum jump length at that position.
-
- Determine if you are able to reach the last index.
-
- For example:
- A = [2,3,1,1,4], return true.
-
- A = [3,2,1,0,4], return false.*/
+/**
+ * 55. Jump Game
+ *
+ * Given an array of non-negative integers, you are initially positioned at the first index of the array.
+ * Each element in the array represents your maximum jump length at that position.
+ * Determine if you are able to reach the last index.
+ *
+ * For example:
+ * A = [2,3,1,1,4], return true.
+ * A = [3,2,1,0,4], return false.*/
 public class _55 {
 
-    public static boolean canJump_greedy(int[] nums) {
-        int farthest = nums[0];
-        for (int i = 0; i < nums.length; i++) {
-            if (i <= farthest && nums[i] + i > farthest) {
-                //i <= farthest is to make sure that this current i is within the current range
-                // nums[i]+i > farthest is to make sure that it's necessary to update farthest with current nums[i]+i
-                farthest = nums[i] + i;
-            }
-        }
-        return farthest >= nums.length - 1;
-    }
-
-    //this normal dp ends in TLE for extreme test cases
-    public static boolean canJump_dp(int[] nums) {
-        boolean[] can = new boolean[nums.length];
-        can[0] = true;
-        for (int i = 0; i < nums.length; i++) {
-            int reach = nums[i];
-            if (can[i]) {
-                for (int j = i + 1; j < nums.length && j <= i + reach; j++) {
-                    can[j] = true;
+    public static class Solution1 {
+        public boolean canJump(int[] nums) {
+            int farthest = nums[0];
+            for (int i = 0; i < nums.length; i++) {
+                if (i <= farthest && nums[i] + i > farthest) {
+                    //i <= farthest is to make sure that this current i is within the current range
+                    // nums[i]+i > farthest is to make sure that it's necessary to update farthest with current nums[i]+i
+                    farthest = nums[i] + i;
                 }
             }
+            return farthest >= nums.length - 1;
         }
-        return can[nums.length - 1];
-    }
-
-    public static void main(String... strings) {
-//        int[] nums = new int[]{1,2};
-        int[] nums = new int[]{0, 2, 3};
-        System.out.println(canJump_greedy(nums));
     }
 }

src/test/java/com/fishercoder/_55Test.java

@@ -0,0 +1,30 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._55;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _55Test {
+    private static _55.Solution1 solution1;
+    private static int[] nums;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _55.Solution1();
+    }
+
+    @Test
+    public void test1() {
+        nums = new int[]{0, 2, 3};
+        assertEquals(false, solution1.canJump(nums));
+    }
+
+    @Test
+    public void test2() {
+        nums = new int[]{1, 2};
+        assertEquals(true, solution1.canJump(nums));
+    }
+
+}