Improvement

Signed-off-by: begeekmyfriend <begeekmyfriend@gmail.com>

Author: begeekmyfriend

0039_combination_sum/combination_sum.cc

@@ -20,7 +20,7 @@ class Solution {
         } else {
             for (int i = start; i < candidates.size(); i++) {
                 stack.push_back(candidates[i]);
-                /* The elements in solution can be duplicate for the purpose of the problem */
+                /* The elements in solution can be taken as many times as you can for the purpose of the problem */
                 dfs(candidates, i, target - candidates[i], res);
                 stack.pop_back();
             }

0045_jump_game_ii/jump_game.c

@@ -12,10 +12,10 @@ static int jump(int* nums, int numsSize)
     int i, right = 0;
     int steps = 0;
     int fartest = 0;
-    /* 1. Exhaust all the right boundries in the location range of [i...right]
-     * 2. When the search ends up with i==right, update the right boundry as
-     *    the fartest position.
-     * 3. When the search ends up with i==right, it records as one jump step */
+    /* 1. Exhaust all the right boundries in the location range of [i...farthest]
+     * 2. When i reaches the farthest boundary, update the farthest boundry
+     * and the step number.
+     * 3. Apply condition i < size - 1 and iterator i++ to avoid overflow. */
     for (i = 0; i < numsSize; i++) {
         fartest = max(i + nums[i], fartest);
         if (i == right) {

0045_jump_game_ii/jump_game.cc

@@ -8,14 +8,14 @@ class Solution {
         int steps = 0;
         int right = 0;
         int farthest = 0;
-        // 1. Exhaust all the right boundries in the location range of [i...right]
-        // 2. When the search ends up with i==right, update the right boundry as
-        //    the fartest position.
-        // 3. When the search ends up with i==right, it records as one jump step */
+        // 1. Exhaust all the right boundries in the location range of [i...farthest]
+        // 2. When i reaches the farthest boundary, update the farthest boundry
+        // and the step number.
+        // 3. Apply condition i < size - 1 and iterator i++ to avoid overflow.
         for (int i = 0; i < nums.size() - 1; i++) {
-            fartest = max(i + nums[i], fartest);
-            for (i == right) {
-                right = fartest;
+            right = max(i + nums[i], right);
+            if (i == farthest) {
+                farthest = right;
                 steps++;
             }
         }

0069_sqrt/sqrt.c

@@ -60,6 +60,9 @@ int mySqrt(int x)
     unsigned int lo = 1;
     unsigned int hi = (unsigned int) x;
     unsigned int mid = lo + (hi - lo) / 2;
+    // Firstly test mid > x / mid to decide whether hi = mid;
+    // else then test mid + 1 > x / (mid + 1) to decide whether the mid is located;
+    // Otherwise assign low = mid.
     for (; ;) {
         if (mid > x/mid) {
             hi = mid;

0069_sqrt/sqrt.cc

@@ -11,6 +11,9 @@ class Solution {
 
         unsigned int lo = 1, hi = x;
         unsigned int mid = (lo + hi) / 2;
+        // Firstly test mid > x / mid to decide whether hi = mid;
+        // else then test mid + 1 > x / (mid + 1) to decide whether the mid is located;
+        // Otherwise assign low = mid.
         for (; ;) {
             if (mid > x / mid) {
                 hi = mid;

0076_minimum_window_substring/window_substring.cc

@@ -11,20 +11,25 @@ class Solution {
         }
 
         int l = 0, r = 0;
-        int need_to_meet = t.length();
-        int start, min_len = INT_MAX;
+        int hit_num = 0;
+        int start = 0, min_len = INT_MAX;
         while (r < s.length()) {
+            // counting each letter in the string. The zero and positive
+            // countings indicate ones in pattern. And the negative ones
+            // indicate those out of the pattern.
             if (--count[s[r++]] >= 0) {
-                need_to_meet--;
+                hit_num++;
             }
 
-            while (need_to_meet == 0) {
+            while (hit_num == t.length()) {
                 if (r - l < min_len) {
                     start = l;
                     min_len = r - l;
                 }
+                // The countings of the letter larger than zero shall be
+                // the ones in the pattern.
                 if (++count[s[l++]] > 0) {
-                    need_to_meet++;
+                    hit_num--;
                 }
             }
         }

0137_single_number_ii/single_number.c

@@ -39,6 +39,7 @@ static int singleNumber(int *nums, int numsSize)
                 count[i]++;
             }
         }
+        /* The specified bit counting should be multiple of 3 without the outlier */
         mask |= (count[i] % 3) << i;
     }
     return mask;

0190_reverse_bits/reverse_bits.c

@@ -4,14 +4,17 @@
 
 static uint32_t reverseBits(uint32_t n)
 {
-    int i;
-    uint32_t res = 0;
-    for (i = 0; i < 32; i++) {
-        res <<= 1;
-        res |= n & 0x1;
-        n >>= 1;
-    }
-    return res;
+    const uint32_t MASK1 = 0x55555555;
+    const uint32_t MASK2 = 0x33333333;
+    const uint32_t MASK4 = 0x0f0f0f0f;
+    const uint32_t MASK8 = 0x00ff00ff;
+
+    // Extract and swap the even and odd bit groups.
+    n = (n & MASK1) << 1 | ((n >> 1) & MASK1);
+    n = (n & MASK2) << 2 | ((n >> 2) & MASK2);
+    n = (n & MASK4) << 4 | ((n >> 4) & MASK4);
+    n = (n & MASK8) << 8 | ((n >> 8) & MASK8);
+    return n << 16 | n >> 16;
 }
 
 int main(int argc, char **argv)