feat: add solutions to lc problem: No.2595 (doocs#2044)

No.2595.Number of Even and Odd Bits

Author: yanglbme

solution/2500-2599/2588.Count the Number of Beautiful Subarrays/README_EN.md

@@ -54,15 +54,15 @@
 
 **Solution 1: Prefix XOR + Hash Table**
 
-We observe that a subarray can become an array of all $0$ s if and only if the number of $1$s in each bit of all the elements in the subarray is even.
+We observe that a subarray can become an array of all $0$s if and only if the number of $1$s on each binary bit of all elements in the subarray is even.
 
-If there are indices $i$ and $j$ such that $i \lt j$ and the number of $1$s in each bit of the subarray $nums[0,..,i]$ and $nums[0,..,j]$ is the same, then we can make the subarray $nums[i + 1,..,j]$ an array of all $0$ s.
+If there exist indices $i$ and $j$ such that $i \lt j$ and the subarrays $nums[0,..,i]$ and $nums[0,..,j]$ have the same parity of the number of $1$s on each binary bit, then we can turn the subarray $nums[i + 1,..,j]$ into an array of all $0$s.
 
-Therefore, we can use the prefix XOR method and use the hash table $cnt$ to count the number of occurrences of each prefix XOR value. Traverse the array, for each element $x$, calculate the prefix XOR value $mask$, then add the number of occurrences of $mask$ to the answer. Then, add $1$ to the number of occurrences of $mask$.
+Therefore, we can use the prefix XOR method and a hash table $cnt$ to count the occurrences of each prefix XOR value. We traverse the array, for each element $x$, we calculate its prefix XOR value $mask$, then add the number of occurrences of $mask$ to the answer. Then, we increase the number of occurrences of $mask$ by $1$.
 
-Finally, return the answer.
+Finally, we return the answer.
 
-Time complexity $O(n)$, space complexity $O(n)$, where $n$ is the length of the array $nums$.
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array $nums$.
 
 <!-- tabs:start -->
 

solution/2500-2599/2589.Minimum Time to Complete All Tasks/README_EN.md

@@ -47,16 +47,18 @@ The computer will be on for a total of 4 seconds.
 
 ## Solutions
 
-**Solution 1: Greedy + Sort**
+**Solution 1: Greedy + Sorting**
 
-We find that the problem is equivalent to choosing $duration$ integer time points in each interval $[start,..,end]$ so that the total number of integer time points selected is the smallest.
+We observe that the problem is equivalent to selecting $duration$ integer time points in each interval $[start,..,end]$, so that the total number of selected integer time points is minimized.
 
-Therefore, we can sort the $tasks$ by the end time $end$ from small to large. Then greedily select. For each task, we start from the end time $end$ and choose as many points as possible from back to front, so that these points are more likely to be reused by later tasks.
+Therefore, we can first sort $tasks$ in ascending order of end time $end$. Then we greedily make selections. For each task, we start from the end time $end$ and choose the points as late as possible from back to front. This way, these points are more likely to be reused by later tasks.
 
-In implementation, we can use a length of $2010$ array $vis$ to record whether each time point has been selected. Then for each task, we first count the number of points that have been selected in the $[start,..,end]$ interval $cnt$, then choose $duration - cnt$ points from back to front, and record the number of points selected $ans$ and update the $vis$ array.
+In our implementation, we can use an array $vis$ of length $2010$ to record whether each time point has been selected. Then for each task, we first count the number of points $cnt$ that have been selected in the interval $[start,..,end]$, and then select $duration - cnt$ points from back to front, while recording the number of selected points $ans$ and updating the $vis$ array.
 
 Finally, we return $ans$.
 
+The time complexity is $O(n \times \log n + n \times m)$, and the space complexity is $O(m)$. Here, $n$ and $m$ are the lengths of $tasks$ and $vis$ array, respectively. In this problem, $m = 2010$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2594.Minimum Time to Repair Cars/README_EN.md

@@ -51,13 +51,13 @@ It can be proved that the cars cannot be repaired in less than 16 minutes.​​
 
 **Solution 1: Binary Search**
 
-We notice that the longer the repair time, the more repaired cars. Therefore, we can use binary search to find the minimum repair time.
+We notice that the longer the repair time, the more cars are repaired. Therefore, we can use the repair time as the target of binary search, and binary search for the minimum repair time.
 
-We define the left and right boundaries of binary search as $left=0$, $right=ranks[0] \times cars \times cars$. Next, we enumerate the repair time $mid$ in binary search. The number of cars that each mechanic can repair is $\lfloor \sqrt{\frac{mid}{r}} \rfloor$, where $\lfloor x \rfloor$ represents the floor function. If the number of cars repaired is greater than or equal to $cars$, then the repair time $mid$ is feasible, and we shrink the right boundary to $mid$, otherwise we increase the left boundary to $mid+1$.
+We define the left and right boundaries of the binary search as $left=0$, $right=ranks[0] \times cars \times cars$. Next, we binary search for the repair time $mid$, and the number of cars each mechanic can repair is $\lfloor \sqrt{\frac{mid}{r}} \rfloor$, where $\lfloor x \rfloor$ represents rounding down. If the number of cars repaired is greater than or equal to $cars$, it means that the repair time $mid$ is feasible, we reduce the right boundary to $mid$, otherwise we increase the left boundary to $mid+1$.
 
 Finally, we return the left boundary.
 
-Time complexity $(n \times \log n)$, space complexity $O(1)$. Where $n$ is the number of mechanics.
+The time complexity is $O(n \times \log M)$, and the space complexity is $O(1)$. Here, $n$ is the number of mechanics, and $M$ is the upper bound of the binary search.
 
 <!-- tabs:start -->
 

solution/2500-2599/2595.Number of Even and Odd Bits/README.md

@@ -70,6 +70,15 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def evenOddBit(self, n: int) -> List[int]:
+        mask = 0x5555
+        even = (n & mask).bit_count()
+        odd = (n & ~mask).bit_count()
+        return [even, odd]
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -86,6 +95,17 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int[] evenOddBit(int n) {
+        int mask = 0x5555;
+        int even = Integer.bitCount(n & mask);
+        int odd = Integer.bitCount(n & ~mask);
+        return new int[] {even, odd};
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -101,6 +121,18 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    vector<int> evenOddBit(int n) {
+        int mask = 0x5555;
+        int even = __builtin_popcount(n & mask);
+        int odd = __builtin_popcount(n & ~mask);
+        return {even, odd};
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -113,6 +145,15 @@ func evenOddBit(n int) []int {
 }
 ```
 
+```go
+func evenOddBit(n int) []int {
+	mask := 0x5555
+	even := bits.OnesCount32(uint32(n & mask))
+	odd := bits.OnesCount32(uint32(n & ^mask))
+	return []int{even, odd}
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -125,6 +166,24 @@ function evenOddBit(n: number): number[] {
 }
 ```
 
+```ts
+function evenOddBit(n: number): number[] {
+    const mask = 0x5555;
+    const even = bitCount(n & mask);
+    const odd = bitCount(n & ~mask);
+    return [even, odd];
+}
+
+function bitCount(i: number): number {
+    i = i - ((i >>> 1) & 0x55555555);
+    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
+    i = (i + (i >>> 4)) & 0x0f0f0f0f;
+    i = i + (i >>> 8);
+    i = i + (i >>> 16);
+    return i & 0x3f;
+}
+```
+
 ### **Rust**
 
 ```rust
@@ -145,6 +204,17 @@ impl Solution {
 }
 ```
 
+```rust
+impl Solution {
+    pub fn even_odd_bit(n: i32) -> Vec<i32> {
+        let mask: i32 = 0x5555;
+        let even = (n & mask).count_ones() as i32;
+        let odd = (n & !mask).count_ones() as i32;
+        vec![even, odd]
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2595.Number of Even and Odd Bits/README_EN.md

@@ -64,6 +64,15 @@ class Solution:
         return ans
 ```
 
+```python
+class Solution:
+    def evenOddBit(self, n: int) -> List[int]:
+        mask = 0x5555
+        even = (n & mask).bit_count()
+        odd = (n & ~mask).bit_count()
+        return [even, odd]
+```
+
 ### **Java**
 
 ```java
@@ -78,6 +87,17 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int[] evenOddBit(int n) {
+        int mask = 0x5555;
+        int even = Integer.bitCount(n & mask);
+        int odd = Integer.bitCount(n & ~mask);
+        return new int[] {even, odd};
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -93,6 +113,18 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    vector<int> evenOddBit(int n) {
+        int mask = 0x5555;
+        int even = __builtin_popcount(n & mask);
+        int odd = __builtin_popcount(n & ~mask);
+        return {even, odd};
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -105,6 +137,15 @@ func evenOddBit(n int) []int {
 }
 ```
 
+```go
+func evenOddBit(n int) []int {
+	mask := 0x5555
+	even := bits.OnesCount32(uint32(n & mask))
+	odd := bits.OnesCount32(uint32(n & ^mask))
+	return []int{even, odd}
+}
+```
+
 ### **TypeScript**
 
 ```ts
@@ -117,6 +158,24 @@ function evenOddBit(n: number): number[] {
 }
 ```
 
+```ts
+function evenOddBit(n: number): number[] {
+    const mask = 0x5555;
+    const even = bitCount(n & mask);
+    const odd = bitCount(n & ~mask);
+    return [even, odd];
+}
+
+function bitCount(i: number): number {
+    i = i - ((i >>> 1) & 0x55555555);
+    i = (i & 0x33333333) + ((i >>> 2) & 0x33333333);
+    i = (i + (i >>> 4)) & 0x0f0f0f0f;
+    i = i + (i >>> 8);
+    i = i + (i >>> 16);
+    return i & 0x3f;
+}
+```
+
 ### **Rust**
 
 ```rust
@@ -137,6 +196,17 @@ impl Solution {
 }
 ```
 
+```rust
+impl Solution {
+    pub fn even_odd_bit(n: i32) -> Vec<i32> {
+        let mask: i32 = 0x5555;
+        let even = (n & mask).count_ones() as i32;
+        let odd = (n & !mask).count_ones() as i32;
+        vec![even, odd]
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2595.Number of Even and Odd Bits/Solution.cpp

@@ -1,10 +1,9 @@
-class Solution {
-public:
-    vector<int> evenOddBit(int n) {
-        vector<int> ans(2);
-        for (int i = 0; n > 0; n >>= 1, i ^= 1) {
-            ans[i] += n & 1;
-        }
-        return ans;
-    }
+class Solution {
+public:
+    vector<int> evenOddBit(int n) {
+        int mask = 0x5555;
+        int even = __builtin_popcount(n & mask);
+        int odd = __builtin_popcount(n & ~mask);
+        return {even, odd};
+    }
 };

solution/2500-2599/2595.Number of Even and Odd Bits/Solution.go

@@ -1,7 +1,6 @@
 func evenOddBit(n int) []int {
-	ans := make([]int, 2)
-	for i := 0; n != 0; n, i = n>>1, i^1 {
-		ans[i] += n & 1
-	}
-	return ans
+	mask := 0x5555
+	even := bits.OnesCount32(uint32(n & mask))
+	odd := bits.OnesCount32(uint32(n & ^mask))
+	return []int{even, odd}
 }

solution/2500-2599/2595.Number of Even and Odd Bits/Solution.java

@@ -1,9 +1,8 @@
-class Solution {
-    public int[] evenOddBit(int n) {
-        int[] ans = new int[2];
-        for (int i = 0; n > 0; n >>= 1, i ^= 1) {
-            ans[i] += n & 1;
-        }
-        return ans;
-    }
+class Solution {
+    public int[] evenOddBit(int n) {
+        int mask = 0x5555;
+        int even = Integer.bitCount(n & mask);
+        int odd = Integer.bitCount(n & ~mask);
+        return new int[] {even, odd};
+    }
 }

solution/2500-2599/2595.Number of Even and Odd Bits/Solution.py

@@ -1,9 +1,6 @@
-class Solution:
-    def evenOddBit(self, n: int) -> List[int]:
-        ans = [0, 0]
-        i = 0
-        while n:
-            ans[i] += n & 1
-            i ^= 1
-            n >>= 1
-        return ans
+class Solution:
+    def evenOddBit(self, n: int) -> List[int]:
+        mask = 0x5555
+        even = (n & mask).bit_count()
+        odd = (n & ~mask).bit_count()
+        return [even, odd]

solution/2500-2599/2595.Number of Even and Odd Bits/Solution.rs

@@ -1,15 +1,8 @@
 impl Solution {
-    pub fn even_odd_bit(mut n: i32) -> Vec<i32> {
-        let mut ans = vec![0; 2];
-
-        let mut i = 0;
-        while n != 0 {
-            ans[i] += n & 1;
-
-            n >>= 1;
-            i ^= 1;
-        }
-
-        ans
+    pub fn even_odd_bit(n: i32) -> Vec<i32> {
+        let mask: i32 = 0x5555;
+        let even = (n & mask).count_ones() as i32;
+        let odd = (n & !mask).count_ones() as i32;
+        vec![even, odd]
     }
 }