refactor 651

fishercoder1534 · fishercoder1534 · commit 50f9186526db · 2019-08-27T07:12:11.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_651.java b/src/main/java/com/fishercoder/solutions/_651.java
@@ -35,23 +35,26 @@ Now, you can only press the keyboard for N times (with the above four keys), fin
  */
 public class _651 {
 
-    /**Minimum needs to be more than 3 A's in a row, otherwise "Ctrl A, Ctrl C, Ctrl V" will make fewer A's than directly
-     * copying A's with the equal number of steps.
-     * E.g. when n == 5,
-     * if we do 5 this: A, A, Ctrl A, Ctrl C, Ctrl V, => this will result in only AAAA (4 A's)
-     * while if we do A, A, A, A, A, => this will result in AAAAA (5 A's)
-     * So, at a minimum, we need to have 3 A's, then it's worth to do "Ctrl A, Ctrl C, Ctrl V"..
-     * That's why we have j = 3 in the inner for loop below.
-     * */
-    public int maxA(int N) {
-        int[] dp = new int[N + 1];
-        for (int i = 1; i <= N; i++) {
-            dp[i] = i;
-            for (int j = 3; j < i; j++) {
-                dp[i] = Math.max(dp[i], dp[i - j] * (j - 1));
+    public static class Solution1 {
+        /**
+         * Minimum needs to be more than 3 A's in a row, otherwise "Ctrl A, Ctrl C, Ctrl V" will make fewer A's than directly
+         * copying A's with the equal number of steps.
+         * E.g. when n == 5,
+         * if we do 5 this: A, A, Ctrl A, Ctrl C, Ctrl V, => this will result in only AAAA (4 A's)
+         * while if we do A, A, A, A, A, => this will result in AAAAA (5 A's)
+         * So, at a minimum, we need to have 3 A's, then it's worth to do "Ctrl A, Ctrl C, Ctrl V"..
+         * That's why we have j = 3 in the inner for loop below.
+         */
+        public int maxA(int N) {
+            int[] dp = new int[N + 1];
+            for (int i = 1; i <= N; i++) {
+                dp[i] = i;
+                for (int j = 3; j < i; j++) {
+                    dp[i] = Math.max(dp[i], dp[i - j] * (j - 1));
+                }
             }
+            return dp[N];
         }
-        return dp[N];
     }
 
 }
diff --git a/src/test/java/com/fishercoder/_651Test.java b/src/test/java/com/fishercoder/_651Test.java
@@ -7,40 +7,40 @@
 import static org.junit.Assert.assertEquals;
 
 public class _651Test {
-    private static _651 test;
+    private static _651.Solution1 solution1;
 
     @BeforeClass
     public static void setup() {
-        test = new _651();
+        solution1 = new _651.Solution1();
     }
 
     @Test
     public void test1() {
-        assertEquals(3, test.maxA(3));
+        assertEquals(3, solution1.maxA(3));
     }
 
     @Test
     public void test2() {
-        assertEquals(324, test.maxA(20));
+        assertEquals(324, solution1.maxA(20));
     }
 
     @Test
     public void test3() {
-        assertEquals(256, test.maxA(19));
+        assertEquals(256, solution1.maxA(19));
     }
 
     @Test
     public void test4() {
-        assertEquals(1, test.maxA(1));
+        assertEquals(1, solution1.maxA(1));
     }
 
     @Test
     public void test5() {
-        assertEquals(1327104, test.maxA(50));
+        assertEquals(1327104, solution1.maxA(50));
     }
 
     @Test
     public void test6() {
-        assertEquals(9, test.maxA(7));
+        assertEquals(9, solution1.maxA(7));
     }
 }

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