refactor 201

fishercoder1534 · fishercoder1534 · commit d5335de4c644 · 2021-10-10T08:44:54.000-07:00
diff --git a/src/main/java/com/fishercoder/solutions/_201.java b/src/main/java/com/fishercoder/solutions/_201.java
@@ -1,19 +1,5 @@
 package com.fishercoder.solutions;
 
-/**
- * 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.
- *
- * Example 1:
- * Input: [5,7]
- * Output: 4
- *
- * Example 2:
- * Input: [0,1]
- * Output: 0
- *
- */
 public class _201 {
 
     public static class Solution1 {
@@ -22,15 +8,17 @@ public static class Solution1 {
          * 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
+         * <p>
+         * A more visual explanation here: https://leetcode.com/problems/bitwise-and-of-numbers-range/solution/
          */
-        public int rangeBitwiseAnd(int m, int n) {
-            int i = 0;
-            while (m != n) {
-                m >>= 1;
-                n >>= 1;
-                i++;
+        public int rangeBitwiseAnd(int left, int right) {
+            int shift = 0;
+            while (left != right) {
+                left >>= 1;
+                right >>= 1;
+                shift++;
             }
-            return (n << i);
+            return right << shift;
         }
     }
 }
diff --git a/src/test/java/com/fishercoder/_201Test.java b/src/test/java/com/fishercoder/_201Test.java
@@ -6,13 +6,10 @@
 
 import static org.junit.Assert.assertEquals;
 
-/**
- * Created by fishercoder on 5/3/17.
- */
 public class _201Test {
     private static _201.Solution1 solution1;
-    private static int m;
-    private static int n;
+    private static int left;
+    private static int right;
     private static int actual;
     private static int expected;
 
@@ -23,45 +20,45 @@ public static void setup() {
 
     @Test
     public void test1() {
-        m = 5;
-        n = 7;
-        actual = solution1.rangeBitwiseAnd(m, n);
+        left = 5;
+        right = 7;
+        actual = solution1.rangeBitwiseAnd(left, right);
         expected = 4;
         assertEquals(expected, actual);
-        actual = solution1.rangeBitwiseAnd(m, n);
+        actual = solution1.rangeBitwiseAnd(left, right);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test2() {
-        m = 1;
-        n = 2;
-        actual = solution1.rangeBitwiseAnd(m, n);
+        left = 1;
+        right = 2;
+        actual = solution1.rangeBitwiseAnd(left, right);
         expected = 0;
         assertEquals(expected, actual);
-        actual = solution1.rangeBitwiseAnd(m, n);
+        actual = solution1.rangeBitwiseAnd(left, right);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test3() {
-        m = 0;
-        n = 2147483647;
-        actual = solution1.rangeBitwiseAnd(m, n);
+        left = 0;
+        right = 2147483647;
+        actual = solution1.rangeBitwiseAnd(left, right);
         expected = 0;
         assertEquals(expected, actual);
-        actual = solution1.rangeBitwiseAnd(m, n);
+        actual = solution1.rangeBitwiseAnd(left, right);
         assertEquals(expected, actual);
     }
 
     @Test
     public void test4() {
-        m = 20000;
-        n = 2147483647;
-        actual = solution1.rangeBitwiseAnd(m, n);
+        left = 20000;
+        right = 2147483647;
+        actual = solution1.rangeBitwiseAnd(left, right);
         expected = 0;
         assertEquals(expected, actual);
-        actual = solution1.rangeBitwiseAnd(m, n);
+        actual = solution1.rangeBitwiseAnd(left, right);
         assertEquals(expected, actual);
     }
 }
