feat: add solutions to lc/lcof problems

lc No.0191 & lcof No.15.Number of 1 Bits

Author: yanglbme

lcof/面试题15. 二进制中1的个数/README.md

@@ -2,50 +2,70 @@
 
 ## 题目描述
 
-请实现一个函数，输入一个整数，输出该数二进制表示中 1 的个数。例如，把 9  表示成二进制是 1001，有 2 位是 1。因此，如果输入 9，则该函数输出 2。
+<p>编写一个函数，输入是一个无符号整数（以二进制串的形式），返回其二进制表达式中数字位数为 '1' 的个数（也被称为 <a href="http://en.wikipedia.org/wiki/Hamming_weight" target="_blank">汉明重量</a>).）。</p>
 
-**示例 1：**
+<p> </p>
 
-```
-输入：00000000000000000000000000001011
-输出：3
-解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 '1'。
-```
+<p><strong>提示：</strong></p>
 
-**示例 2：**
+<ul>
+	<li>请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。</li>
+	<li>在 Java 中，编译器使用 <a href="https://baike.baidu.com/item/二进制补码/5295284">二进制补码</a> 记法来表示有符号整数。因此，在上面的 <strong>示例 3 </strong>中，输入表示有符号整数 <code>-3</code>。</li>
+</ul>
 
-```
-输入：00000000000000000000000010000000
-输出：1
-解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 '1'。
-```
+<p> </p>
 
-**示例 3：**
+<p><strong>示例 1：</strong></p>
 
-```
-输入：11111111111111111111111111111101
-输出：31
-解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 '1'。
-```
+<pre>
+<strong>输入：</strong>n = 11 (控制台输入 00000000000000000000000000001011)
+<strong>输出：</strong>3
+<strong>解释：</strong>输入的二进制串 <code><strong>00000000000000000000000000001011</strong> 中，共有三位为 '1'。</code>
+</pre>
+
+<p><strong>示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 128 (控制台输入 00000000000000000000000010000000)
+<strong>输出：</strong>1
+<strong>解释：</strong>输入的二进制串 <strong>00000000000000000000000010000000</strong> 中，共有一位为 '1'。
+</pre>
+
+<p><strong>示例 3：</strong></p>
+
+<pre>
+<strong>输入：</strong>n = 4294967293 (控制台输入 11111111111111111111111111111101，部分语言中 n = -3）
+<strong>输出：</strong>31
+<strong>解释：</strong>输入的二进制串 <strong>11111111111111111111111111111101</strong> 中，共有 31 位为 '1'。</pre>
+
+<p> </p>
+
+<p><strong>提示：</strong></p>
+
+<ul>
+	<li>输入必须是长度为 <code>32</code> 的 <strong>二进制串</strong> 。</li>
+</ul>
+
+<p> </p>
+
+<p>注意：本题与主站 191 题相同：<a href="https://leetcode-cn.com/problems/number-of-1-bits/">https://leetcode-cn.com/problems/number-of-1-bits/</a></p>
 
 ## 解法
 
 `n & (n - 1)` 会消除 n 中最后一位中的 1。
 
-同 [LeetCode 191. 位 1 的个数](/solution/0100-0199/0191.Number%20of%201%20Bits/README.md)
-
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
 class Solution:
     def hammingWeight(self, n: int) -> int:
-        res = 0
+        ans = 0
         while n:
-            n &= (n - 1)
-            res += 1
-        return res
+            n &= n - 1
+            ans += 1
+        return ans
 ```
 
 ### **Java**
@@ -54,12 +74,12 @@ class Solution:
 public class Solution {
     // you need to treat n as an unsigned value
     public int hammingWeight(int n) {
-        int res = 0;
+        int ans = 0;
         while (n != 0) {
-            n &= (n - 1);
-            ++res;
+            n &= n - 1;
+            ++ans;
         }
-        return res;
+        return ans;
     }
 }
 ```
@@ -72,12 +92,12 @@ public class Solution {
  * @return {number}
  */
 var hammingWeight = function (n) {
-    let cnt = 0;
-    while (n) {
-        cnt += n & 1;
-        n >>>= 1;
+    let ans = 0;
+    while (n != 0) {
+        n &= n - 1;
+        ++ans;
     }
-    return cnt;
+    return ans;
 };
 ```
 
@@ -86,7 +106,6 @@ var hammingWeight = function (n) {
 ```go
 func hammingWeight(num uint32) int {
 	ans := 0
-	// num &=num-1 消除最右边的1
 	for num != 0 {
 		num &= num - 1
 		ans++
@@ -102,8 +121,9 @@ class Solution {
 public:
     int hammingWeight(uint32_t n) {
         int ans = 0;
-        while (n) {
-            n &= (n - 1);
+        while (n)
+        {
+            n &= n - 1;
             ++ans;
         }
         return ans;

lcof/面试题15. 二进制中1的个数/Solution.cpp

@@ -2,10 +2,11 @@ class Solution {
 public:
     int hammingWeight(uint32_t n) {
         int ans = 0;
-        while (n) {
-            n &= (n - 1);
+        while (n)
+        {
+            n &= n - 1;
             ++ans;
         }
         return ans;
     }
-};
+};

lcof/面试题15. 二进制中1的个数/Solution.go

@@ -1,6 +1,5 @@
 func hammingWeight(num uint32) int {
 	ans := 0
-	// num &=num-1 消除最右边的1
 	for num != 0 {
 		num &= num - 1
 		ans++

lcof/面试题15. 二进制中1的个数/Solution.java

@@ -1,11 +1,11 @@
 public class Solution {
     // you need to treat n as an unsigned value
     public int hammingWeight(int n) {
-        int res = 0;
+        int ans = 0;
         while (n != 0) {
-            n &= (n - 1);
-            ++res;
+            n &= n - 1;
+            ++ans;
         }
-        return res;
+        return ans;
     }
 }

lcof/面试题15. 二进制中1的个数/Solution.js

@@ -3,10 +3,10 @@
  * @return {number}
  */
 var hammingWeight = function (n) {
-    let cnt = 0;
-    while (n) {
-        cnt += n & 1;
-        n >>>= 1;
+    let ans = 0;
+    while (n != 0) {
+        n &= n - 1;
+        ++ans;
     }
-    return cnt;
+    return ans;
 };

lcof/面试题15. 二进制中1的个数/Solution.py

@@ -1,7 +1,7 @@
 class Solution:
     def hammingWeight(self, n: int) -> int:
-        res = 0
+        ans = 0
         while n:
-            n &= (n - 1)
-            res += 1
-        return res
+            n &= n - 1
+            ans += 1
+        return ans

solution/0100-0199/0191.Number of 1 Bits/README.md

@@ -78,11 +78,11 @@
 ```python
 class Solution:
     def hammingWeight(self, n: int) -> int:
-        res = 0
+        ans = 0
         while n:
-            n &= (n - 1)
-            res += 1
-        return res
+            n &= n - 1
+            ans += 1
+        return ans
 ```
 
 ### **Java**
@@ -93,16 +93,46 @@ class Solution:
 public class Solution {
     // you need to treat n as an unsigned value
     public int hammingWeight(int n) {
-        int res = 0;
+        int ans = 0;
         while (n != 0) {
-            n &= (n - 1);
-            ++res;
+            n &= n - 1;
+            ++ans;
         }
-        return res;
+        return ans;
     }
 }
 ```
 
+### **Go**
+
+```go
+func hammingWeight(num uint32) int {
+	ans := 0
+	for num != 0 {
+		num &= num - 1
+		ans++
+	}
+	return ans
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int hammingWeight(uint32_t n) {
+        int ans = 0;
+        while (n)
+        {
+            n &= n - 1;
+            ++ans;
+        }
+        return ans;
+    }
+};
+```
+
 ### **JavaScript**
 
 ```js
@@ -111,12 +141,12 @@ public class Solution {
  * @return {number}
  */
 var hammingWeight = function (n) {
-    let res = 0;
+    let ans = 0;
     while (n) {
         n &= n - 1;
-        ++res;
+        ++ans;
     }
-    return res;
+    return ans;
 };
 ```
 

solution/0100-0199/0191.Number of 1 Bits/README_EN.md

@@ -57,11 +57,11 @@
 ```python
 class Solution:
     def hammingWeight(self, n: int) -> int:
-        res = 0
+        ans = 0
         while n:
-            n &= (n - 1)
-            res += 1
-        return res
+            n &= n - 1
+            ans += 1
+        return ans
 ```
 
 ### **Java**
@@ -70,16 +70,46 @@ class Solution:
 public class Solution {
     // you need to treat n as an unsigned value
     public int hammingWeight(int n) {
-        int res = 0;
+        int ans = 0;
         while (n != 0) {
-            n &= (n - 1);
-            ++res;
+            n &= n - 1;
+            ++ans;
         }
-        return res;
+        return ans;
     }
 }
 ```
 
+### **C++**
+
+```cpp
+class Solution {
+public:
+    int hammingWeight(uint32_t n) {
+        int ans = 0;
+        while (n)
+        {
+            n &= n - 1;
+            ++ans;
+        }
+        return ans;
+    }
+};
+```
+
+### **Go**
+
+```go
+func hammingWeight(num uint32) int {
+	ans := 0
+	for num != 0 {
+		num &= num - 1
+		ans++
+	}
+	return ans
+}
+```
+
 ### **JavaScript**
 
 ```js
@@ -88,12 +118,12 @@ public class Solution {
  * @return {number}
  */
 var hammingWeight = function (n) {
-    let res = 0;
+    let ans = 0;
     while (n) {
         n &= n - 1;
-        ++res;
+        ++ans;
     }
-    return res;
+    return ans;
 };
 ```
 

solution/0100-0199/0191.Number of 1 Bits/Solution.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    int hammingWeight(uint32_t n) {
+        int ans = 0;
+        while (n)
+        {
+            n &= n - 1;
+            ++ans;
+        }
+        return ans;
+    }
+};