refactor 650

fishercoder1534 · fishercoder1534 · commit 955b4d9a1a57 · 2019-08-26T07:44:52.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_650.java b/src/main/java/com/fishercoder/solutions/_650.java
@@ -24,18 +24,20 @@
  */
 public class _650 {
 
-    public int minSteps(int n) {
-        int[] dp = new int[n + 1];
-        for (int i = 2; i <= n; i++) {
-            dp[i] = i;//we assign i to dp[i] first, because for a lot of cases, e.g. for most cases when i is odd, its min steps is i itself, if it's not, we can overwrite it later
-            for (int j = i - 1; j > 1; j--) {
-                //traverse backwards, whenever it's divisible by j, we'll update dp[i] because it's guaranteed to be smaller when j is smaller.
-                if (i % j == 0) {
-                    dp[i] = dp[j] + (i / j);
-                    break;
+    public static class Solution1 {
+        public int minSteps(int n) {
+            int[] dp = new int[n + 1];
+            for (int i = 2; i <= n; i++) {
+                dp[i] = i;//we assign i to dp[i] first, because for a lot of cases, e.g. for most cases when i is odd, its min steps is i itself, if it's not, we can overwrite it later
+                for (int j = i - 1; j > 1; j--) {
+                    //traverse backwards, whenever it's divisible by j, we'll update dp[i] because it's guaranteed to be smaller when j is smaller.
+                    if (i % j == 0) {
+                        dp[i] = dp[j] + (i / j);
+                        break;
+                    }
                 }
             }
+            return dp[n];
         }
-        return dp[n];
     }
 }
diff --git a/src/test/java/com/fishercoder/_650Test.java b/src/test/java/com/fishercoder/_650Test.java
@@ -7,35 +7,35 @@
 import static org.junit.Assert.assertEquals;
 
 public class _650Test {
-    private static _650 test;
+    private static _650.Solution1 solution1;
 
     @BeforeClass
     public static void setup() {
-        test = new _650();
+        solution1 = new _650.Solution1();
     }
 
     @Test
     public void test1() {
-        assertEquals(3, test.minSteps(3));
+        assertEquals(3, solution1.minSteps(3));
     }
 
     @Test
     public void test2() {
-        assertEquals(9, test.minSteps(20));
+        assertEquals(9, solution1.minSteps(20));
     }
 
     @Test
     public void test3() {
-        assertEquals(19, test.minSteps(19));
+        assertEquals(19, solution1.minSteps(19));
     }
 
     @Test
     public void test4() {
-        assertEquals(0, test.minSteps(1));
+        assertEquals(0, solution1.minSteps(1));
     }
 
     @Test
     public void test5() {
-        assertEquals(35, test.minSteps(741));
+        assertEquals(35, solution1.minSteps(741));
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -7,35 +7,35 @@`
`7`	`7`	`import static org.junit.Assert.assertEquals;`
`8`	`8`
`9`	`9`	`public class _650Test {`
`10`		`- private static _650 test;`
	`10`	`+ private static _650.Solution1 solution1;`
`11`	`11`
`12`	`12`	`@BeforeClass`
`13`	`13`	`public static void setup() {`
`14`		`- test = new _650();`
	`14`	`+ solution1 = new _650.Solution1();`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`@Test`
`18`	`18`	`public void test1() {`
`19`		`- assertEquals(3, test.minSteps(3));`
	`19`	`+ assertEquals(3, solution1.minSteps(3));`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`@Test`
`23`	`23`	`public void test2() {`
`24`		`- assertEquals(9, test.minSteps(20));`
	`24`	`+ assertEquals(9, solution1.minSteps(20));`
`25`	`25`	`}`
`26`	`26`
`27`	`27`	`@Test`
`28`	`28`	`public void test3() {`
`29`		`- assertEquals(19, test.minSteps(19));`
	`29`	`+ assertEquals(19, solution1.minSteps(19));`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`@Test`
`33`	`33`	`public void test4() {`
`34`		`- assertEquals(0, test.minSteps(1));`
	`34`	`+ assertEquals(0, solution1.minSteps(1));`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`@Test`
`38`	`38`	`public void test5() {`
`39`		`- assertEquals(35, test.minSteps(741));`
	`39`	`+ assertEquals(35, solution1.minSteps(741));`
`40`	`40`	`}`
`41`	`41`	`}`