feat: add solutions to lc problem: No.0762

No.0762.Prime Number of Set Bits in Binary Representation

Author: yanglbme

solution/0700-0799/0762.Prime Number of Set Bits in Binary Representation/README.md

@@ -6,63 +6,126 @@
 
 <!-- 这里写题目描述 -->
 
-<p>给定两个整数&nbsp;<code>L</code>&nbsp;和&nbsp;<code>R</code>&nbsp;，找到闭区间&nbsp;<code>[L, R]</code>&nbsp;范围内，计算置位位数为质数的整数个数。</p>
+<p>给你两个整数&nbsp;<code>left</code>&nbsp;和&nbsp;<code>right</code> ，在闭区间 <code>[left, right]</code>&nbsp;范围内，统计并返回 <strong>计算置位位数为质数</strong> 的整数个数。</p>
 
-<p>（注意，计算置位代表二进制表示中1的个数。例如&nbsp;<code>21</code>&nbsp;的二进制表示&nbsp;<code>10101</code>&nbsp;有 3 个计算置位。还有，1 不是质数。）</p>
+<p><strong>计算置位位数</strong> 就是二进制表示中 <code>1</code> 的个数。</p>
 
-<p><strong>示例 1:</strong></p>
+<ul>
+	<li>例如， <code>21</code>&nbsp;的二进制表示&nbsp;<code>10101</code>&nbsp;有 <code>3</code> 个计算置位。</li>
+</ul>
+
+<p>&nbsp;</p>
+
+<p><strong>示例 1：</strong></p>
 
 <pre>
-<strong>输入:</strong> L = 6, R = 10
-<strong>输出:</strong> 4
-<strong>解释:</strong>
+<strong>输入：</strong>left = 6, right = 10
+<strong>输出：</strong>4
+<strong>解释：</strong>
 6 -&gt; 110 (2 个计算置位，2 是质数)
 7 -&gt; 111 (3 个计算置位，3 是质数)
 9 -&gt; 1001 (2 个计算置位，2 是质数)
 10-&gt; 1010 (2 个计算置位，2 是质数)
+共计 4 个计算置位为质数的数字。
 </pre>
 
-<p><strong>示例 2:</strong></p>
+<p><strong>示例 2：</strong></p>
 
 <pre>
-<strong>输入:</strong> L = 10, R = 15
-<strong>输出:</strong> 5
-<strong>解释:</strong>
+<strong>输入：</strong>left = 10, right = 15
+<strong>输出：</strong>5
+<strong>解释：</strong>
 10 -&gt; 1010 (2 个计算置位, 2 是质数)
 11 -&gt; 1011 (3 个计算置位, 3 是质数)
 12 -&gt; 1100 (2 个计算置位, 2 是质数)
 13 -&gt; 1101 (3 个计算置位, 3 是质数)
 14 -&gt; 1110 (3 个计算置位, 3 是质数)
 15 -&gt; 1111 (4 个计算置位, 4 不是质数)
+共计 5 个计算置位为质数的数字。
 </pre>
 
-<p><strong>注意:</strong></p>
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
 
-<ol>
-	<li><code>L, R</code>&nbsp;是&nbsp;<code>L &lt;= R</code>&nbsp;且在&nbsp;<code>[1, 10^6]</code>&nbsp;中的整数。</li>
-	<li><code>R - L</code>&nbsp;的最大值为 10000。</li>
-</ol>
+<ul>
+	<li><code>1 &lt;= left &lt;= right &lt;= 10<sup>6</sup></code></li>
+	<li><code>0 &lt;= right - left &lt;= 10<sup>4</sup></code></li>
+</ul>
 
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+题目中 `left` 和 `right` 的范围均在 10<sup>6</sup> 内，而 2<sup>20</sup>=1048576，因此二进制中 1 的个数最多也就 20 个，20 以内的质数为 {2, 3, 5, 7, 11, 13, 17, 19}。
+
+我们可以遍历 `[left, right]` 范围内的每个数，计算出每个数的二进制表示中 1 的个数，判断此个数是否在上述列举的质数中，是则累加结果。
+
+时间复杂度 `O((right-left)*log right)`，其中求二进制中 1 的个数的时间为 `O(log right)`。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def countPrimeSetBits(self, left: int, right: int) -> int:
+        primes = {2, 3, 5, 7, 11, 13, 17, 19}
+        return sum(i.bit_count() in primes for i in range(left, right + 1))
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    private static Set<Integer> primes = new HashSet<>(Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19));
+
+    public int countPrimeSetBits(int left, int right) {
+        int ans = 0;
+        for (int i = left; i <= right; ++i) {
+            if (primes.contains(Integer.bitCount(i))) {
+                ++ans;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    unordered_set<int> primes{2, 3, 5, 7, 11, 13, 17, 19};
+
+    int countPrimeSetBits(int left, int right) {
+        int ans = 0;
+        for (int i = left; i <= right; ++i)
+            if (primes.count(__builtin_popcount(i)))
+                ++ans;
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func countPrimeSetBits(left int, right int) int {
+	primes := map[int]bool{2: true, 3: true, 5: true, 7: true, 11: true, 13: true, 17: true, 19: true}
+	ans := 0
+	for i := left; i <= right; i++ {
+		if primes[bits.OnesCount(uint(i))] {
+			ans++
+		}
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/0700-0799/0762.Prime Number of Set Bits in Binary Representation/README_EN.md

@@ -57,13 +57,60 @@
 ### **Python3**
 
 ```python
-
+class Solution:
+    def countPrimeSetBits(self, left: int, right: int) -> int:
+        primes = {2, 3, 5, 7, 11, 13, 17, 19}
+        return sum(i.bit_count() in primes for i in range(left, right + 1))
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    private static Set<Integer> primes = new HashSet<>(Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19));
+
+    public int countPrimeSetBits(int left, int right) {
+        int ans = 0;
+        for (int i = left; i <= right; ++i) {
+            if (primes.contains(Integer.bitCount(i))) {
+                ++ans;
+            }
+        }
+        return ans;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    unordered_set<int> primes{2, 3, 5, 7, 11, 13, 17, 19};
+
+    int countPrimeSetBits(int left, int right) {
+        int ans = 0;
+        for (int i = left; i <= right; ++i)
+            if (primes.count(__builtin_popcount(i)))
+                ++ans;
+        return ans;
+    }
+};
+```
 
+### **Go**
+
+```go
+func countPrimeSetBits(left int, right int) int {
+	primes := map[int]bool{2: true, 3: true, 5: true, 7: true, 11: true, 13: true, 17: true, 19: true}
+	ans := 0
+	for i := left; i <= right; i++ {
+		if primes[bits.OnesCount(uint(i))] {
+			ans++
+		}
+	}
+	return ans
+}
 ```
 
 ### **...**

solution/0700-0799/0762.Prime Number of Set Bits in Binary Representation/Solution.cpp

@@ -0,0 +1,12 @@
+class Solution {
+public:
+    unordered_set<int> primes{2, 3, 5, 7, 11, 13, 17, 19};
+
+    int countPrimeSetBits(int left, int right) {
+        int ans = 0;
+        for (int i = left; i <= right; ++i)
+            if (primes.count(__builtin_popcount(i)))
+                ++ans;
+        return ans;
+    }
+};

solution/0700-0799/0762.Prime Number of Set Bits in Binary Representation/Solution.go

@@ -0,0 +1,10 @@
+func countPrimeSetBits(left int, right int) int {
+	primes := map[int]bool{2: true, 3: true, 5: true, 7: true, 11: true, 13: true, 17: true, 19: true}
+	ans := 0
+	for i := left; i <= right; i++ {
+		if primes[bits.OnesCount(uint(i))] {
+			ans++
+		}
+	}
+	return ans
+}

solution/0700-0799/0762.Prime Number of Set Bits in Binary Representation/Solution.java

@@ -0,0 +1,13 @@
+class Solution {
+    private static Set<Integer> primes = new HashSet<>(Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19));
+
+    public int countPrimeSetBits(int left, int right) {
+        int ans = 0;
+        for (int i = left; i <= right; ++i) {
+            if (primes.contains(Integer.bitCount(i))) {
+                ++ans;
+            }
+        }
+        return ans;
+    }
+}

solution/0700-0799/0762.Prime Number of Set Bits in Binary Representation/Solution.py

@@ -1,13 +1,4 @@
-class Solution:
-    def countPrimeSetBits(self, L, R):
-        """
-        :type L: int
-        :type R: int
-        :rtype: int
-        """
-        res = 0
-        flag = [2, 3, 5, 7, 11, 13, 17, 19]
-        for i in range(L, R + 1):
-            if bin(i).count('1') in flag:
-                res += 1
-        return res
+class Solution:
+    def countPrimeSetBits(self, left: int, right: int) -> int:
+        primes = {2, 3, 5, 7, 11, 13, 17, 19}
+        return sum(i.bit_count() in primes for i in range(left, right + 1))

solution/1300-1399/1356.Sort Integers by The Number of 1 Bits/README.md

@@ -72,7 +72,7 @@
 ```python
 class Solution:
     def sortByBits(self, arr: List[int]) -> List[int]:
-        arr.sort(key=lambda x: (bin(x).count("1"), x))
+        arr.sort(key=lambda x : (x.bit_count(), x))
         return arr
 ```
 

solution/1300-1399/1356.Sort Integers by The Number of 1 Bits/README_EN.md

@@ -46,7 +46,7 @@ The sorted array by bits is [0,1,2,4,8,3,5,6,7]
 ```python
 class Solution:
     def sortByBits(self, arr: List[int]) -> List[int]:
-        arr.sort(key=lambda x: (bin(x).count("1"), x))
+        arr.sort(key=lambda x : (x.bit_count(), x))
         return arr
 ```
 

solution/1300-1399/1356.Sort Integers by The Number of 1 Bits/Solution.py

@@ -1,4 +1,4 @@
-class Solution:
-    def sortByBits(self, arr: List[int]) -> List[int]:
-        arr.sort(key=lambda x: (bin(x).count("1"), x))
-        return arr
+class Solution:
+    def sortByBits(self, arr: List[int]) -> List[int]:
+        arr.sort(key=lambda x: (x.bit_count(), x))
+        return arr