refactor 191

Author: fishercoder1534

README.md

@@ -431,7 +431,7 @@ Your ideas/fixes/algorithms are more than welcome!
 |200|[Number of Islands](https://leetcode.com/problems/number-of-islands/)|[Solution](../master/MEDIUM/src/medium/_200.java)| O(m*n)|O(m*n) | Medium| Union Find, DFS
 |199|[Binary Tree Right Side View](https://leetcode.com/problems/binary-tree-right-side-view/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_199.java)| O(n)|O(h)| Medium | BFS 
 |198|[House Robber](https://leetcode.com/problems/house-robber/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_198.java)| O(n)|O(n)| Easy | DP
-|191|[Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_191.java)| O(n)|O(1)| Easy | Bit Manipulation
+|191|[Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_191.java)| O(1)|O(1)| Easy | Bit Manipulation
 |190|[Reverse Bits](https://leetcode.com/problems/reverse-bits/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_190.java)| O(n)|O(1)| Easy | Bit Manipulation
 |189|[Rotate Array](https://leetcode.com/problems/rotate-array/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_189.java)| O(n)|O(n), could be optimized to O(1) | Easy
 |188|[Best Time to Buy and Sell Stock IV](https://leetcode.com/problems/best-time-to-buy-and-sell-stock-iv/)|[Solution](../master/src/main/java/com/fishercoder/solutions/_188.java)| O(n*k)|O(n*k) | Hard | DP

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

@@ -1,55 +1,55 @@
 package com.fishercoder.solutions;
-/**191. Number of 1 Bits
+
+/**
+ * 191. Number of 1 Bits
+ * Write a function that takes an unsigned integer and returns the number of ’1' bits it has (also known as the Hamming weight).
  *
-Write a function that takes an unsigned integer and returns the number of ’1' bits it has (also known as the Hamming weight).
+ * For example, the 32-bit integer ’11' has binary representation 00000000000000000000000000001011, so the function should return 3.*/
 
-For example, the 32-bit integer ’11' has binary representation 00000000000000000000000000001011, so the function should return 3.*/
 public class _191 {
-    //another cool trick that I learned: doing bitwise AND operation between n and n-1 will always flip the least significant 1 bit in n
-    //to zero, here's the solution from Editorial:
-    //example run for the above editorial solution: input 5, n will be 5&4 and becomes 4, then in the next run, n will become 4&3 which is 0, thus exit the while loop.
-    public int hammingWeight_editorial(int n) {
-        int count = 0;
-        while (n != 0) {
-            count++;
-            n &= (n - 1);
-        }
-        return count;
-    }
 
-    public static void main(String... strings) {
-        System.out.println(4 & 5);
-        _191 test = new _191();
-        System.out.println(test.hammingWeight_editorial(5));
+    public static class Solution1 {
+        /**Doing bitwise AND operation between n and n-1 will always flip the least significant 1 bit in n to zero
+         example run for the above editorial solution: input 5, n will be 5&4 and becomes 4,
+         then in the next run, n will become 4&3 which is 0, thus exit the while loop.*/
+        public int hammingWeight(int n) {
+            int bits = 0;
+            while (n != 0) {
+                bits++;
+                n &= (n - 1);
+            }
+            return bits;
+        }
     }
 
-    // you need to treat n as an unsigned value
-    public int hammingWeight(int n) {
-        //cheers! Made it AC'ed on my own with an ease!
-        int count = 0;
-        for (int i = 0; i < 32; i++) {
-            int one = (n >>> i) & 1;//must use unsigned right shift operator
-            if (one == 1) {
-                count++;
+    public static class Solution2 {
+        public int hammingWeight(int n) {
+            int bits = 0;
+            int mask = 1;
+            for (int i = 0; i < 32; i++) {
+                if ((n & mask) != 0) {
+                    bits++;
+                }
+                mask <<= 1;
             }
+            return bits;
         }
-        return count;
     }
 
-    //then I turned to its Editorial solution: we can make it a little faster: at any time, when n becomes zero, that means there's
-    //no more 1's there, then we could safely return! Cool!
-    public int hammingWeight_faster(int n) {
-        int count = 0;
-        for (int i = 0; i < 32; i++) {
-            int one = (n >>> i) & 1;//must use unsigned right shift operator
-            if (one == 1) {
-                count++;
-            }
-            if (n == 0) {
-                return count;
+    public static class Solution3 {
+        public int hammingWeight(int n) {
+            int bits = 0;
+            for (int i = 0; i < 32; i++) {
+                if ((n & 1) == 1) {
+                    bits++;
+                }
+                if (n == 0) {
+                    return bits;
+                }
+                /**must use unsigned right shift operator since the problem says this is an unsigned value*/
+                n >>>= 1;
             }
+            return bits;
         }
-        return count;
     }
-    
 }

src/test/java/com/fishercoder/_191Test.java

@@ -0,0 +1,34 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._191;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static junit.framework.TestCase.assertEquals;
+
+public class _191Test {
+    private static _191.Solution1 solution1;
+    private static _191.Solution2 solution2;
+    private static _191.Solution3 solution3;
+
+    @BeforeClass
+    public static void setup() {
+        solution1 = new _191.Solution1();
+        solution2 = new _191.Solution2();
+        solution3 = new _191.Solution3();
+    }
+
+    @Test
+    public void test1() {
+        assertEquals(1, solution1.hammingWeight(1));
+        assertEquals(1, solution2.hammingWeight(1));
+        assertEquals(1, solution3.hammingWeight(1));
+    }
+
+    @Test
+    public void test2() {
+//        System.out.println(Integer.MAX_VALUE);
+//        assertEquals(2147483648, Integer.MAX_VALUE);
+    }
+
+}