https://leetcode.com/problems/jump-game/

interview_prep/algorithm/java/src/main/java/hoa/can/code/gg/JumpingDP.java

@@ -0,0 +1,31 @@
+package hoa.can.code.gg;
+
+public class JumpingDP {
+    public static boolean canJump(int[] nums) {
+        return minJumps(nums) != Integer.MAX_VALUE;
+    }
+
+    public static int minJumps(int[] arr) {
+        int n = arr.length;
+        int minCostToIdx[] = new int[n];
+        // result
+        int i, j;
+
+        // if first element is 0,
+        if (n == 0 || arr[0] == 0)
+            return Integer.MAX_VALUE;
+
+        minCostToIdx[0] = 0;
+
+        for (i = 1; i < n; i++) {
+            minCostToIdx[i] = Integer.MAX_VALUE;
+            for (j = 0; j < i; j++) {
+                if (i <= j + arr[j] && minCostToIdx[j] != Integer.MAX_VALUE) {
+                    minCostToIdx[i] = Math.min(minCostToIdx[i], minCostToIdx[j] + 1);
+                    break;
+                }
+            }
+        }
+        return minCostToIdx[n - 1];
+    }
+}

interview_prep/algorithm/java/src/main/java/hoa/can/code/gg/JumpingQuickly.java → interview_prep/algorithm/java/src/main/java/hoa/can/code/gg/JumpingGreedily.java

@@ -1,8 +1,6 @@
 package hoa.can.code.gg;
 
-import java.util.Arrays;
-
-public class JumpingQuickly {
+public class JumpingGreedily {
     final static int NO_WAY = 10000;
 
     public static boolean canJump(int[] nums) {
@@ -24,16 +22,19 @@ public static int minJumps(int[] nums) {
         int steps = 1;
 
         for (int currentBase = 1; currentBase < n; currentBase++) {
-            if(currentMax >= n-1){
-                steps++;
-                return steps;
-            }
             if (currentBase > maxReach) {
                 steps++;
                 maxReach = currentMax;
+                if (currentMax >= n - 1) return steps;
             }
-            if ((currentMax == currentBase) && nums[currentBase] == 0) {
-                return NO_WAY;
+            if (nums[currentBase] == 0) {
+                if ((currentMax == currentBase)) {
+                    return NO_WAY;
+                }
+                if (currentMax >= n - 1) {
+                    steps++;
+                    return steps;
+                }
             }
 
             currentMax = Math.max(currentMax, currentBase + nums[currentBase]);

interview_prep/algorithm/java/src/main/java/hoa/can/code/gg/JumpingLikeASmartAss.java → interview_prep/algorithm/java/src/main/java/hoa/can/code/gg/JumpingRecursive.java

@@ -5,7 +5,7 @@
 /**
  * <a href="https://leetcode.com/problems/jump-game/">Desc</a>
  */
-public class JumpingLikeASmartAss {
+public class JumpingRecursive {
     final static int NO_WAY = 10000;
 
     public static boolean canJump(int[] nums) {

interview_prep/algorithm/java/src/test/java/hoa/can/code/JumpingTest.java

@@ -1,11 +1,14 @@
 package hoa.can.code;
 
-import hoa.can.code.gg.JumpingLikeASmartAss;
-import hoa.can.code.gg.JumpingQuickly;
+import hoa.can.code.gg.JumpingRecursive;
+import hoa.can.code.gg.JumpingDP;
+import hoa.can.code.gg.JumpingGreedily;
 import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.DisplayName;
 import org.junit.jupiter.api.Test;
 
+import java.util.Arrays;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
@@ -14,7 +17,7 @@ public class JumpingTest {
     @Test
     @DisplayName("ok")
     public void yes() {
-        canJump(new int[]{0});
+        //canJump(new int[]{0});// depends
         canJump(new int[]{2, 3, 1, 1, 4});
         canJump(new int[]{1, 3, 5, 8, 9, 2, 6, 7, 6, 8, 9});
         canJump(new int[]{3, 2, 1, 1, 1, 2, 3, 4, 5, 1, 3, 0, 2, 3, 0, 3, 1, 2, 3, 9, 1, 0, 0, 4, 1, 1, 1, 0, 2, 3, 4, 0, 9, 0, 0, 1, 2, 3, 9, 0, 0, 1, 0, 0, 1, 0, 1, 2, 3, 4});
@@ -33,23 +36,24 @@ public void no() {
     @Test
     @DisplayName("yes-WithDetail")
     public void yesWithDetail() {
-        int[] case1 = new int[]{10,8,12,17,1,21,5,17,20,11,5,27,23,8,12,18,16,12,9,8,17,12,23,26,0,5,9,24,10};
-        assertEquals(2, JumpingLikeASmartAss.minJumps(case1), "10 -> 20 -> end");
-        assertEquals(2, JumpingQuickly.minJumps(case1), "10 -> 20 -> end");
-
-
-        int[] case2 = new int[]{2,3,1,1,4};
-        assertEquals(2, JumpingLikeASmartAss.minJumps(case2), "2 -> 3 -> end");
-        assertEquals(2, JumpingQuickly.minJumps(case2), "2 -> 3 -> end");
+        yesWithDetail(new int[]{1, 2}, 1, "1 -> end");
+        yesWithDetail(new int[]{2, 3, 1, 1, 4}, 2, "2 -> 3 -> end");
+        yesWithDetail(new int[]{10, 8, 12, 17, 1, 21, 5, 17, 20, 11, 5, 27, 23, 8, 12, 18, 16, 12, 9, 8, 17, 12, 23, 26, 0, 5, 9, 24, 10}, 2, "10 -> 20 -> end");
+        yesWithDetail(new int[]{5, 9, 3, 2, 1, 0, 2, 3, 3, 1, 0, 0}, 3, "5->9->3->end");
+        yesWithDetail(new int[]{1, 1, 1, 1, 1, 1}, 5, "1 -> 1 ->... end");
+    }
 
 
-        int[] case3 = new int[]{1,1,1,1,1,1};
-        assertEquals(5, JumpingLikeASmartAss.minJumps(case3), "1 -> 1 ->... end");
-        assertEquals(5, JumpingQuickly.minJumps(case3), "1 -> 1 ->... end");
+    @Test
+    public void t(){
+        assertEquals(2, JumpingGreedily.minJumps(new int[]{10, 8, 12, 17, 1, 21, 5, 17, 20, 11, 5, 27, 23, 8, 12, 18, 16, 12, 9, 8, 17, 12, 23, 26, 0, 5, 9, 24, 10}));
+    }
 
-        int[] case4 = new int[]{5,9,3,2,1,0,2,3,3,1,0,0};
-        assertEquals(3, JumpingLikeASmartAss.minJumps(case4), "...3-> end");
-        assertEquals(3, JumpingQuickly.minJumps(case4), "...3 -> end");
+    public void yesWithDetail(int[] steps, int expected, String msg) {
+        String log = String.format("\n%s \n%s", Arrays.toString(steps), msg);
+        assertEquals(expected, JumpingRecursive.minJumps(steps), log);
+        assertEquals(expected, JumpingGreedily.minJumps(steps), log);
+        assertEquals(expected, JumpingDP.minJumps(steps), log);
     }
 
     @Test
@@ -58,27 +62,36 @@ public void yesWithDetail() {
     public void nope() {
         assertEquals(
                 13,
-                JumpingLikeASmartAss.minJumps(new int[]{8,2,4,4,4,9,5,2,5,8,8,0,8,6,9,1,1,6,3,5,1,2,6,6,0,4,8,6,0,3,2,8,7,6,5,1,7,0,3,4,8,3,5,9,0,4,0,1,0,5,9,2,0,7,0,2,1,0,8,2,5,1,2,3,9,7,4,7,0,0,1,8,5,6,7,5,1,9,9,3,5,0,7,5}),
+                JumpingRecursive.minJumps(new int[]{8, 2, 4, 4, 4, 9, 5, 2, 5, 8, 8, 0, 8, 6, 9, 1, 1, 6, 3, 5, 1, 2, 6, 6, 0, 4, 8, 6, 0, 3, 2, 8, 7, 6, 5, 1, 7, 0, 3, 4, 8, 3, 5, 9, 0, 4, 0, 1, 0, 5, 9, 2, 0, 7, 0, 2, 1, 0, 8, 2, 5, 1, 2, 3, 9, 7, 4, 7, 0, 0, 1, 8, 5, 6, 7, 5, 1, 9, 9, 3, 5, 0, 7, 5}),
                 "quick"
         );
     }
+
     @Test
     @DisplayName("yep")
     public void yep() {
         assertEquals(
                 13,
-                JumpingQuickly.minJumps(new int[]{8,2,4,4,4,9,5,2,5,8,8,0,8,6,9,1,1,6,3,5,1,2,6,6,0,4,8,6,0,3,2,8,7,6,5,1,7,0,3,4,8,3,5,9,0,4,0,1,0,5,9,2,0,7,0,2,1,0,8,2,5,1,2,3,9,7,4,7,0,0,1,8,5,6,7,5,1,9,9,3,5,0,7,5}),
+                JumpingGreedily.minJumps(new int[]{8,2,4,4,4,9,5,2,5,8,8,0,8,6,9,1,1,6,3,5,1,2,6,6,0,4,8,6,0,3,2,8,7,6,5,1,7,0,3,4,8,3,5,9,0,4,0,1,0,5,9,2,0,7,0,2,1,0,8,2,5,1,2,3,9,7,4,7,0,0,1,8,5,6,7,5,1,9,9,3,5,0,7,5}),
+                "quick"
+        );
+        assertEquals(
+                13,
+                JumpingDP.minJumps(new int[]{8, 2, 4, 4, 4, 9, 5, 2, 5, 8, 8, 0, 8, 6, 9, 1, 1, 6, 3, 5, 1, 2, 6, 6, 0, 4, 8, 6, 0, 3, 2, 8, 7, 6, 5, 1, 7, 0, 3, 4, 8, 3, 5, 9, 0, 4, 0, 1, 0, 5, 9, 2, 0, 7, 0, 2, 1, 0, 8, 2, 5, 1, 2, 3, 9, 7, 4, 7, 0, 0, 1, 8, 5, 6, 7, 5, 1, 9, 9, 3, 5, 0, 7, 5}),
                 "quick"
         );
     }
 
-    void canJump(int[] steps){
-        assertTrue(JumpingLikeASmartAss.canJump(steps));
-        assertTrue(JumpingQuickly.canJump(steps));
+    void canJump(int[] steps) {
+        String log = String.format("%s Should be REACHABLE", Arrays.toString(steps));
+        assertTrue(JumpingRecursive.canJump(steps), log);
+        assertTrue(JumpingGreedily.canJump(steps), log);
+        assertTrue(JumpingDP.canJump(steps), log);
     }
 
-    void canNotJump(int[] steps){
-        assertFalse(JumpingLikeASmartAss.canJump(steps));
-        assertFalse(JumpingQuickly.canJump(steps));
+    void canNotJump(int[] steps) {
+        assertFalse(JumpingRecursive.canJump(steps));
+        assertFalse(JumpingGreedily.canJump(steps));
+        assertFalse(JumpingDP.canJump(steps));
     }
 }