refactor 201

fishercoder1534 · fishercoder1534 · commit e54ccd7ee55f · 2018-09-10T07:50:09.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_201.java b/src/main/java/com/fishercoder/solutions/_201.java
@@ -4,35 +4,24 @@
  * 201. Bitwise AND of Numbers Range
  *
  * Given a range [m, n] where 0 <= m <= n <= 2147483647, return the bitwise AND of all numbers in this range, inclusive.
-
- For example, given the range [5, 7], you should return 4.
-
+ *
+ * For example, given the range [5, 7], you should return 4.
  */
 public class _201 {
 
-    //this naive approach works, but will result in TLE as expected for 8256/8266 test cases: (0, 2147483647)
-    public int rangeBitwiseAnd_TLE(int m, int n) {
-        if (m == 0) {
-            return m;
-        }
-        int result = m;
-        for (int i = m + 1; i <= n; i++) {
-            result &= i;
-        }
-        return result;
-    }
-
-    //credit: https://discuss.leetcode.com/topic/28538/java-python-easy-solution-with-explanation
-    //Bitwise AND operation within range actually turns out to be doing some operations with just these two boundary numbers: m and n
-    //e.g. 5 and 7, in binary, they are 101 and 111, the result for [5,7] is 5&6&7 which is 101&110&111
-    //this we can understand it to be shifting the digits of m and n from left to right until they become the same, then we pad that number with zeroes on the right side
-    public int rangeBitwiseAnd(int m, int n) {
-        int i = 0;
-        while (m != n) {
-            m >>= 1;
-            n >>= 1;
-            i++;
+    public static class Solution1 {
+        //credit: https://discuss.leetcode.com/topic/28538/java-python-easy-solution-with-explanation
+        //Bitwise AND operation within range actually turns out to be doing some operations with just these two boundary numbers: m and n
+        //e.g. 5 and 7, in binary, they are 101 and 111, the result for [5,7] is 5&6&7 which is 101&110&111
+        //this we can understand it to be shifting the digits of m and n from left to right until they become the same, then we pad that number with zeroes on the right side
+        public int rangeBitwiseAnd(int m, int n) {
+            int i = 0;
+            while (m != n) {
+                m >>= 1;
+                n >>= 1;
+                i++;
+            }
+            return (n << i);
         }
-        return (n << i);
     }
 }
diff --git a/src/test/java/com/fishercoder/_201Test.java b/src/test/java/com/fishercoder/_201Test.java
@@ -10,62 +10,58 @@
  * Created by fishercoder on 5/3/17.
  */
 public class _201Test {
-    private static _201 test;
+    private static _201.Solution1 solution1;
     private static int m;
     private static int n;
     private static int actual;
     private static int expected;
 
     @BeforeClass
     public static void setup() {
-        test = new _201();
+        solution1 = new _201.Solution1();
     }
 
     @Test
     public void test1() {
         m = 5;
         n = 7;
-        actual = test.rangeBitwiseAnd_TLE(m, n);
+        actual = solution1.rangeBitwiseAnd(m, n);
         expected = 4;
         assertEquals(expected, actual);
-        actual = test.rangeBitwiseAnd(m, n);
+        actual = solution1.rangeBitwiseAnd(m, n);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test2() {
         m = 1;
         n = 2;
-        actual = test.rangeBitwiseAnd_TLE(m, n);
+        actual = solution1.rangeBitwiseAnd(m, n);
         expected = 0;
         assertEquals(expected, actual);
-        actual = test.rangeBitwiseAnd(m, n);
+        actual = solution1.rangeBitwiseAnd(m, n);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test3() {
         m = 0;
         n = 2147483647;
-        long start = System.currentTimeMillis();
-        actual = test.rangeBitwiseAnd_TLE(m, n);
-        System.out.println("It took " + (System.currentTimeMillis() - start) + " ms to finish.");
+        actual = solution1.rangeBitwiseAnd(m, n);
         expected = 0;
         assertEquals(expected, actual);
-        actual = test.rangeBitwiseAnd(m, n);
+        actual = solution1.rangeBitwiseAnd(m, n);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test4() {
         m = 20000;
         n = 2147483647;
-        long start = System.currentTimeMillis();
-//        actual = test.rangeBitwiseAnd_TLE(m, n);
-        System.out.println("It took " + (System.currentTimeMillis() - start) + " ms to finish.");
+        actual = solution1.rangeBitwiseAnd(m, n);
         expected = 0;
         assertEquals(expected, actual);
-        actual = test.rangeBitwiseAnd(m, n);
+        actual = solution1.rangeBitwiseAnd(m, n);
         assertEquals(expected, actual);
     }
 }
