refactor 338

Author: fishercoder1534

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

@@ -1,7 +1,5 @@
 package com.fishercoder.solutions;
 
-import com.fishercoder.common.utils.CommonUtils;
-
 /**338. Counting Bits
 Given a non negative integer number num. For every numbers i in the range 0 ≤ i ≤ num calculate the number of 1's in their binary representation and return them as an array.
 
@@ -24,45 +22,39 @@ Space complexity should be O(n).
 *
 */
 public class _338 {
-    private class DPSolution {
-        //lixx2100's post is cool:https://discuss.leetcode.com/topic/40162/three-line-java-solution
-        //An easy recurrence for this problem is f[i] = f[i / 2] + i % 2
-        //and then we'll use bit manipulation to express the above recursion function
-        // right shift by 1 means to divide by 2
-        //AND with 1 means to modulo 2
-        //this is so cool!
+    public static class Solution1 {
+        //use the most regular method to get it AC'ed first
         public int[] countBits(int num) {
             int[] ones = new int[num + 1];
-            for (int i = 1; i <= num; i++) {
-                ones[i] = ones[i >> 1] + (i & 1);
+            for (int i = 0; i <= num; i++) {
+                ones[i] = countOnes(i);
             }
             return ones;
         }
-    }
 
-
-    //use the most regular method to get it AC'ed first
-    public int[] countBits(int num) {
-        int[] ones = new int[num + 1];
-        for (int i = 0; i <= num; i++) {
-            ones[i] = countOnes(i);
+        private int countOnes(int i) {
+            int ones = 0;
+            while (i != 0) {
+                ones++;
+                i &= (i - 1);
+            }
+            return ones;
         }
-        return ones;
     }
 
-    private int countOnes(int i) {
-        int ones = 0;
-        while (i != 0) {
-            ones++;
-            i &= (i - 1);
+    private class Solution2 {
+        /**lixx2100's post is cool:https://discuss.leetcode.com/topic/40162/three-line-java-solution
+        An easy recurrence for this problem is f[i] = f[i / 2] + i % 2
+        and then we'll use bit manipulation to express the above recursion function
+         right shift by 1 means to divide by 2
+        AND with 1 means to modulo 2
+        this is so cool!*/
+        public int[] countBits(int num) {
+            int[] ones = new int[num + 1];
+            for (int i = 1; i <= num; i++) {
+                ones[i] = ones[i >> 1] + (i & 1);
+            }
+            return ones;
         }
-        return ones;
-    }
-
-    public static void main(String... strings) {
-        _338 test = new _338();
-        int num = 15;
-        int[] ones = test.countBits(num);
-        CommonUtils.printArray(ones);
     }
 }

src/test/java/com/fishercoder/_338Test.java

@@ -0,0 +1,27 @@
+package com.fishercoder;
+
+import com.fishercoder.common.utils.CommonUtils;
+import com.fishercoder.solutions._338;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertArrayEquals;
+
+public class _338Test {
+  private static _338.Solution1 test;
+  private static int[] expected;
+  private static int[] actual;
+
+  @BeforeClass
+  public static void setup() {
+    test = new _338.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    expected = new int[] {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};
+    actual = test.countBits(15);
+    CommonUtils.printArray(actual);
+    assertArrayEquals(expected, actual);
+  }
+}