[N-0] refactor 326

Author: fishercoder1534

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

@@ -1,54 +1,46 @@
 package com.fishercoder.solutions;
 
-/**326. Power of Three
+/**
+ * 326. Power of Three
  *
-Given an integer, write a function to determine if it is a power of three.
-
-Follow up:
-Could you do it without using any loop / recursion?
+ * Given an integer, write a function to determine if it is a power of three.
+ *
+ * Follow up:
+ * Could you do it without using any loop / recursion?
 */
 
 public class _326 {
-    //then I turned to the Editorial solution, it's pretty elegant to use base conversion which can be easily extended to any radix k
-    //Idea: for a number in base 10, if it's power of 10, then it must be in this format: 10, 100, 1000... with a leading one and all trailing zeros
-    //similarly, if a number is power of 3, then in its base 3 format, it must be in this format as well: 10, 100, 1000, 1000...
-    //some Java built-in function could help us along the way:
-    public boolean isPowerOfThree_base_conversion(int n) {
-        return Integer.toString(n, n).matches("^10*$");
-    }
-
-    //it turns out they're using a trick to solve this question without using a loop: find the max possible integer that is a power of 3, then do modulor with this number
-    public boolean isPowerOfThree_without_loop(int n) {
-        return (n > 0 && 1162261467 % n == 0);
-    }
-
-    //I'm not able to think of a method that has no loop to do it, use regular method to solve it first
-    public boolean isPowerOfThree(int n) {
-        if (n < 3 && n != 1) {
-            return false;
-        }
-        while (n != 1) {
-            if (n % 3 != 0) {
+    public static class Solution1 {
+        //regular method that has a loop
+        public boolean isPowerOfThree(int n) {
+            if (n < 3 && n != 1) {
                 return false;
             }
-            n /= 3;
+            while (n != 1) {
+                if (n % 3 != 0) {
+                    return false;
+                }
+                n /= 3;
+            }
+            return true;
         }
-        return true;
     }
 
-    public static void main(String... strings) {
-        _326 test = new _326();
-        System.out.println(test.isPowerOfThree(12));
+    public static class Solution2 {
+        //find the max possible integer that is a power of 3, then do modulor with this number
+        public boolean isPowerOfThree(int n) {
+            return (n > 0 && 1162261467 % n == 0);
+        }
+    }
 
-        //find the max integer that is power of 3
-        int maxPowerOf3OneStepFurther = 3;
-        int maxPowerOf3 = 0;
-        while (maxPowerOf3OneStepFurther >= 0) {
-            maxPowerOf3OneStepFurther = (int) maxPowerOf3OneStepFurther * 3;
-            if (maxPowerOf3OneStepFurther > 0) {
-                maxPowerOf3 = maxPowerOf3OneStepFurther;
-            }
-            System.out.println("maxPowerOf3 is: " + maxPowerOf3);
+    public static class Solution3 {
+        //Editorial solution: it's pretty elegant to use base conversion which can be easily extended to any radix k
+        //Idea: for a number in base 10, if it's power of 10, then it must be in this format: 10, 100, 1000... with a leading one and all trailing zeros
+        //similarly, if a number is power of 3, then in its base 3 format, it must be in this format as well: 10, 100, 1000, 1000...
+        //some Java built-in function could help us along the way:
+        public boolean isPowerOfThree(int n) {
+            return Integer.toString(n, 3).matches("^10*$");
         }
     }
-}
+
+}

src/test/java/com/fishercoder/_326Test.java

@@ -0,0 +1,28 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._326;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.Assert.assertEquals;
+
+public class _326Test {
+    private static _326.Solution1 solution1;
+    private static _326.Solution2 solution2;
+    private static _326.Solution3 solution3;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _326.Solution1();
+        solution2 = new _326.Solution2();
+        solution3 = new _326.Solution3();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(false, solution1.isPowerOfThree(12));
+        assertEquals(false, solution2.isPowerOfThree(12));
+        assertEquals(false, solution3.isPowerOfThree(12));
+    }
+
+}