feat: update solutions to lc problems: No.0762,0763

* No.0762.Prime Number of Set Bits in Binary Representation
* No.0763.Partition Labels

Author: yanglbme

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

@@ -57,11 +57,13 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-题目中 `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 的个数，判断此个数是否在上述列举的质数中，是则累加结果。
+题目中 $left$ 和 $right$ 的范围均在 $10^6$ 以内，而 $2^{20} = 1048576$，因此，二进制中 $1$ 的个数最多也就 $20$ 个，而 $20$ 以内的质数有 `[2, 3, 5, 7, 11, 13, 17, 19]`。
 
-时间复杂度 `O((right-left)*log right)`，其中求二进制中 1 的个数的时间为 `O(log right)`。
+我们枚举 $[left,.. right]$ 范围内的每个数，统计其二进制中 $1$ 的个数，然后判断该个数是否为质数，如果是，答案加一。
+
+时间复杂度 $O(n\times \log m)$。其中 $n = right - left + 1$，而 $m$ 为 $[left,.. right]$ 范围内的最大数。
 
 <!-- tabs:start -->
 
@@ -82,7 +84,7 @@ class Solution:
 
 ```java
 class Solution {
-    private static Set<Integer> primes = new HashSet<>(Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19));
+    private static Set<Integer> primes = Set.of(2, 3, 5, 7, 11, 13, 17, 19);
 
     public int countPrimeSetBits(int left, int right) {
         int ans = 0;
@@ -101,13 +103,10 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    unordered_set<int> primes {2, 3, 5, 7, 11, 13, 17, 19};
-
     int countPrimeSetBits(int left, int right) {
+        unordered_set<int> primes {2, 3, 5, 7, 11, 13, 17, 19};
         int ans = 0;
-        for (int i = left; i <= right; ++i)
-            if (primes.count(__builtin_popcount(i)))
-                ++ans;
+        for (int i = left; i <= right; ++i) ans += primes.count(__builtin_popcount(i));
         return ans;
     }
 };
@@ -116,15 +115,15 @@ public:
 ### **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
+func countPrimeSetBits(left int, right int) (ans int) {
+	primes := map[int]int{}
+	for _, v := range []int{2, 3, 5, 7, 11, 13, 17, 19} {
+		primes[v] = 1
+	}
 	for i := left; i <= right; i++ {
-		if primes[bits.OnesCount(uint(i))] {
-			ans++
-		}
+		ans += primes[bits.OnesCount(uint(i))]
 	}
-	return ans
+	return
 }
 ```
 

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

@@ -67,7 +67,7 @@ class Solution:
 
 ```java
 class Solution {
-    private static Set<Integer> primes = new HashSet<>(Arrays.asList(2, 3, 5, 7, 11, 13, 17, 19));
+    private static Set<Integer> primes = Set.of(2, 3, 5, 7, 11, 13, 17, 19);
 
     public int countPrimeSetBits(int left, int right) {
         int ans = 0;
@@ -86,13 +86,10 @@ class Solution {
 ```cpp
 class Solution {
 public:
-    unordered_set<int> primes {2, 3, 5, 7, 11, 13, 17, 19};
-
     int countPrimeSetBits(int left, int right) {
+        unordered_set<int> primes {2, 3, 5, 7, 11, 13, 17, 19};
         int ans = 0;
-        for (int i = left; i <= right; ++i)
-            if (primes.count(__builtin_popcount(i)))
-                ++ans;
+        for (int i = left; i <= right; ++i) ans += primes.count(__builtin_popcount(i));
         return ans;
     }
 };
@@ -101,15 +98,15 @@ public:
 ### **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
+func countPrimeSetBits(left int, right int) (ans int) {
+	primes := map[int]int{}
+	for _, v := range []int{2, 3, 5, 7, 11, 13, 17, 19} {
+		primes[v] = 1
+	}
 	for i := left; i <= right; i++ {
-		if primes[bits.OnesCount(uint(i))] {
-			ans++
-		}
+		ans += primes[bits.OnesCount(uint(i))]
 	}
-	return ans
+	return
 }
 ```
 

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

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

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

@@ -1,10 +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
+func countPrimeSetBits(left int, right int) (ans int) {
+	primes := map[int]int{}
+	for _, v := range []int{2, 3, 5, 7, 11, 13, 17, 19} {
+		primes[v] = 1
+	}
 	for i := left; i <= right; i++ {
-		if primes[bits.OnesCount(uint(i))] {
-			ans++
-		}
+		ans += primes[bits.OnesCount(uint(i))]
 	}
-	return ans
+	return
 }

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

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

solution/0700-0799/0763.Partition Labels/README.md

@@ -34,14 +34,21 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-先用数组或哈希表 last 记录每个字母最后一次出现的位置。
+**方法一：数组或哈希表 + 贪心**
+
+我们先用数组或哈希表 `last` 记录字符串 $s$ 中每个字母最后一次出现的位置。
 
 接下来使用贪心的方法，将字符串划分为尽可能多的片段：
 
--   从左到右遍历字符串，遍历的同时维护当前片段的开始下标 left 和结束下标 right，初始均为 0；
--   对于每个访问到的字母 c，获取到最后一次出现的位置 `last[c]`。由于当前片段的结束下标一定不会小于 `last[c]`，因此令 `right = max(right, last[c])`；
--   当访问到下标 right 时，当前片段访问结束，当前片段的下标范围是 `[left, right]`，长度为 `right - left + 1`，将其添加到结果数组中，然后令 left = right + 1, 继续寻找下一个片段；
--   重复上述过程，直至字符串遍历结束。
+从左到右遍历字符串，遍历的同时维护当前片段的开始下标 $left$ 和结束下标 $right$，初始均为 $0$。
+
+对于每个访问到的字母 $c$，获取到最后一次出现的位置 $last[c]$。由于当前片段的结束下标一定不会小于 $last[c]$，因此令 $right = \max(right, last[c])$。
+
+当访问到下标 $right$ 时，意味着当前片段访问结束，当前片段的下标范围是 $[left,.. right]$，长度为 $right - left + 1$，我们将其添加到结果数组中。然后令 $left = right + 1$, 继续寻找下一个片段。
+
+重复上述过程，直至字符串遍历结束，即可得到所有片段的长度。
+
+时间复杂度 $O(n)$，空间复杂度 $O(C)$。其中 $n$ 为字符串 $s$ 的长度，而 $C$ 为字符集的大小。本题中 $C = 26$。
 
 <!-- tabs:start -->
 
@@ -52,13 +59,11 @@
 ```python
 class Solution:
     def partitionLabels(self, s: str) -> List[int]:
-        last = [0] * 26
-        for i, c in enumerate(s):
-            last[ord(c) - ord('a')] = i
+        last = {c: i for i, c in enumerate(s)}
         ans = []
         left = right = 0
         for i, c in enumerate(s):
-            right = max(right, last[ord(c) - ord('a')])
+            right = max(right, last[c])
             if i == right:
                 ans.append(right - left + 1)
                 left = right + 1
@@ -90,36 +95,13 @@ class Solution {
 }
 ```
 
-### **TypeScript**
-
-```ts
-function partitionLabels(s: string): number[] {
-    const n = s.length;
-    let last = new Array(26);
-    for (let i = 0; i < n; i++) {
-        last[s.charCodeAt(i) - 'a'.charCodeAt(0)] = i;
-    }
-    let ans = [];
-    let left = 0,
-        right = 0;
-    for (let i = 0; i < n; i++) {
-        right = Math.max(right, last[s.charCodeAt(i) - 'a'.charCodeAt(0)]);
-        if (i == right) {
-            ans.push(right - left + 1);
-            left = right + 1;
-        }
-    }
-    return ans;
-}
-```
-
 ### **C++**
 
 ```cpp
 class Solution {
 public:
     vector<int> partitionLabels(string s) {
-        vector<int> last(26);
+        int last[26] = {0};
         int n = s.size();
         for (int i = 0; i < n; ++i) last[s[i] - 'a'] = i;
         vector<int> ans;
@@ -163,6 +145,29 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function partitionLabels(s: string): number[] {
+    const n = s.length;
+    let last = new Array(26);
+    for (let i = 0; i < n; i++) {
+        last[s.charCodeAt(i) - 'a'.charCodeAt(0)] = i;
+    }
+    let ans = [];
+    let left = 0,
+        right = 0;
+    for (let i = 0; i < n; i++) {
+        right = Math.max(right, last[s.charCodeAt(i) - 'a'.charCodeAt(0)]);
+        if (i == right) {
+            ans.push(right - left + 1);
+            left = right + 1;
+        }
+    }
+    return ans;
+}
+```
+
 ### **Rust**
 
 ```rust
@@ -189,6 +194,33 @@ impl Solution {
 }
 ```
 
+### **JavaScript**
+
+```js
+/**
+ * @param {string} s
+ * @return {number[]}
+ */
+var partitionLabels = function (s) {
+    const n = s.length;
+    let last = new Array(26);
+    for (let i = 0; i < n; i++) {
+        last[s.charCodeAt(i) - 'a'.charCodeAt(0)] = i;
+    }
+    let ans = [];
+    let left = 0,
+        right = 0;
+    for (let i = 0; i < n; i++) {
+        right = Math.max(right, last[s.charCodeAt(i) - 'a'.charCodeAt(0)]);
+        if (i == right) {
+            ans.push(right - left + 1);
+            left = right + 1;
+        }
+    }
+    return ans;
+};
+```
+
 ### **...**
 
 ```