refactor 190

Author: fishercoder1534

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

@@ -4,11 +4,15 @@
  * 190. Reverse Bits
  * Reverse bits of a given 32 bits unsigned integer.
 
-For example, given input 43261596 (represented in binary as 00000010100101000001111010011100),
- return 964176192 (represented in binary as 00111001011110000010100101000000).
+ Example:
+ Input: 43261596
+ Output: 964176192
 
-Follow up:
-If this function is called many times, how would you optimize it?
+ Explanation: 43261596 represented in binary as 00000010100101000001111010011100,
+ return 964176192 represented in binary as 00111001011110000010100101000000.
+
+ Follow up:
+ If this function is called many times, how would you optimize it?
  */
 
 public class _190 {
@@ -23,47 +27,24 @@ public class _190 {
      * gives a good explanation between logical right shift: ">>>" and arithmetic right shift: ">>".
      * Basically, ">>" preserves the most left bit and treats it as the sign for this number,
      * e.g. -2 represented in 8 bits is 11111110, thus -2 >> 1 will become 11111111, i.e. -1
-     * notice its sign bit (the most left one bit) is preserved   
-     * However, logical right shift ">>>" doesn't care about the first bit on the most left, 
+     * notice its sign bit (the most left one bit) is preserved
+     * However, logical right shift ">>>" doesn't care about the first bit on the most left,
      * it simply shifts every bit to the right.
      * e.g. -2 >>> 1 would become 1111111111111111111111111111111, i.e. 2147483647*/
-    
-    
- // you need treat n as an unsigned value
-    public int reverseBits(int n) {
+
+ public static class Solution1 {
+      // you need treat n as an unsigned value
+      public int reverseBits(int n) {
         int res = 0;
         for (int i = 0; i < 32; i++) {
-            res += n & 1;//get the most right bit each time
-            n >>>= 1;//do UN-signed right shift by 1 each time
-            if (i < 31) {
-                res <<= 1;//shift this number to the left by 1 each time, so that eventually, this number is reversed
-            }
+          res += n & 1;//get the most right bit each time
+          n >>>= 1;//do UN-signed right shift by 1 each time
+          if (i < 31) {
+            res <<=
+                1;//shift this number to the left by 1 each time, so that eventually, this number is reversed
+          }
         }
         return res;
-    }
-
-    /**follow-up: if this function is called many times, how to improve it?
-    Divide the integer into 4 bytes,
-     reverse each byte and then combine them into one in the end,
-     use cache to store the reversed results for reuse if possible.*/
-
-    public static void main(String... strings) {
-        _190 test = new _190();
-//        int n = 43261596;
-        int n = 4;
-        System.out.println("original number : " + n);
-        System.out.println("original number in binary format: " + Integer.toBinaryString(n));
-        int result = test.reverseBits(n);
-        System.out.println("reversed bit result: " + result);
-        System.out.println("reversed bit result in binary format: " + Integer.toBinaryString(result));
-
-        //        System.out.println(Integer.toBinaryString(4));
-//        System.out.println(Integer.parseInt("11000", 2));
-//        System.out.println(Integer.parseInt("00011", 2));
-//        System.out.println(-2 >>> 1);
-//        System.out.println(Integer.toBinaryString(-2 >>> 1));
-//        System.out.println(Integer.toBinaryString(-2));
-//        System.out.println(Integer.toBinaryString(-1));
-//        System.out.println(Integer.toBinaryString(6));
+      }
     }
 }

src/test/java/com/fishercoder/_190Test.java

@@ -0,0 +1,27 @@
+package com.fishercoder;
+
+import com.fishercoder.solutions._190;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+
+public class _190Test {
+  private static _190.Solution1 solution1;
+
+  @BeforeClass
+  public static void setup() {
+    solution1 = new _190.Solution1();
+  }
+
+  @Test
+  public void test1() {
+    assertEquals(536870912, solution1.reverseBits(4));
+  }
+
+
+  @Test
+  public void test2() {
+    assertEquals(964176192, solution1.reverseBits(  43261596));
+  }
+}