feat: add solutions to lc problem: No.0810

No.0810.Chalkboard XOR Game

Author: yanglbme

solution/0400-0499/0420.Strong Password Checker/README_EN.md

@@ -9,7 +9,7 @@
 <ul>
 	<li>It has at least <code>6</code> characters and at most <code>20</code> characters.</li>
 	<li>It contains at least <strong>one lowercase</strong> letter, at least <strong>one uppercase</strong> letter, and at least <strong>one digit</strong>.</li>
-	<li>It does&nbsp;not contain three repeating characters in a row (i.e.,&nbsp;<code>&quot;...aaa...&quot;</code> is weak, but <code>&quot;...aa...a...&quot;</code> is strong, assuming other conditions are met).</li>
+	<li>It does not contain three repeating characters in a row (i.e., <code>&quot;B<u><strong>aaa</strong></u>bb0&quot;</code> is weak, but <code>&quot;B<strong><u>aa</u></strong>b<u><strong>a</strong></u>0&quot;</code> is strong).</li>
 </ul>
 
 <p>Given a string <code>password</code>, return <em>the minimum number of steps required to make <code>password</code> strong. if <code>password</code> is already strong, return <code>0</code>.</em></p>
@@ -19,7 +19,7 @@
 <ul>
 	<li>Insert one character to <code>password</code>,</li>
 	<li>Delete one character from <code>password</code>, or</li>
-	<li>Replace&nbsp;one character of <code>password</code> with another character.</li>
+	<li>Replace one character of <code>password</code> with another character.</li>
 </ul>
 
 <p>&nbsp;</p>

solution/0500-0599/0554.Brick Wall/README.md

@@ -28,6 +28,8 @@
 <strong>输出：</strong>3
 </pre>
 
+
+
 <p><strong>提示：</strong></p>
 
 <ul>

solution/0800-0899/0810.Chalkboard XOR Game/README.md

@@ -54,22 +54,103 @@ Alice 有两个选择: 擦掉数字 1 或 2。
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：位运算**
+
+根据游戏规则，轮到某个玩家时，如果当前黑板上所有数字按位异或运算结果为 $0$，这个玩家获胜。由于 Alice 先手，因此当 `nums` 中所有数字的异或结果为 $0$ 时，Alice 可以获胜。
+
+当 `nums` 中所有数字的异或结果不为 $0$ 时，我们不妨考虑从数组 `nums` 的长度奇偶性来分析 Alice 的获胜情况。
+
+当 `nums` 的长度为偶数时，如果 Alice 必败，那么只有一种情况，就是 Alice 无论擦掉哪个数字，剩余所有数字的异或结果都等于 $0$。我们来分析一下是否存在这种情况。
+
+假设数组 `nums` 长度为 $n$，并且 $n$ 是偶数，记所有数字异或结尾为 $S$，则有：
+
+$$
+S = nums[0] \oplus nums[1] \oplus \cdots \oplus nums[n-1] \neq 0
+$$
+
+我们记 $S_i$ 为数组 `nums` 擦掉第 $i$ 个数字后的异或结果，那么有：
+
+$$
+S_i \oplus nums[i] = S
+$$
+
+等式两边同时异或 $nums[i]$，得到：
+
+$$
+S_i = S \oplus nums[i]
+$$
+
+如果无论 Alice 擦掉哪个数字，剩余所有数字的异或结果都等于 $0$，那么对所有 $i$，都有 $S_i = 0$，即：
+
+$$
+S_0 \oplus S_1 \oplus \cdots \oplus S_{n-1} = 0
+$$
+
+我们将 $S_i = S \oplus nums[i]$ 代入上式，得到：
+
+$$
+S \oplus nums[0] \oplus S \oplus nums[1] \oplus \cdots \oplus S \oplus nums[n-1] = 0
+$$
+
+上式共有 $n$（偶数）个 $S$，而 $nums[0] \oplus nums[1] \oplus \cdots \oplus nums[n-1]$ 也等于 $S$，因此上式等价于 $0 \oplus S = 0$。这与 $S \neq 0$ 矛盾，因此不存在这种情况。因此当 `nums` 的长度为偶数时，Alice 必胜。
+
+如果长度为奇数，那么 Alice 擦掉一个数字后，剩余数字个数为偶数，也就是将偶数长度的情况留给 Bob，那么 Bob 必胜，也即 Alice 必败。
+
+综上，当 `nums` 的长度为偶数，或者 `nums` 中所有数字的异或结果为 $0$ 时，Alice 可以获胜。
+
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组 `nums` 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def xorGame(self, nums: List[int]) -> bool:
+        return len(nums) % 2 == 0 or reduce(xor, nums) == 0
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public boolean xorGame(int[] nums) {
+        return nums.length % 2 == 0 || Arrays.stream(nums).reduce(0, (a, b) -> a ^ b) == 0;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool xorGame(vector<int>& nums) {
+        if (nums.size() % 2 == 0) return true;
+        int x = 0;
+        for (int& v : nums) x ^= v;
+        return x == 0;
+    }
+};
+```
 
+### **Go**
+
+```go
+func xorGame(nums []int) bool {
+	if len(nums)%2 == 0 {
+		return true
+	}
+	x := 0
+	for _, v := range nums {
+		x ^= v
+	}
+	return x == 0
+}
 ```
 
 ### **...**

solution/0800-0899/0810.Chalkboard XOR Game/README_EN.md

@@ -53,13 +53,48 @@ If Alice erases 2 first, now nums become [1, 1]. The bitwise XOR of all the elem
 ### **Python3**
 
 ```python
-
+class Solution:
+    def xorGame(self, nums: List[int]) -> bool:
+        return len(nums) % 2 == 0 or reduce(xor, nums) == 0
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public boolean xorGame(int[] nums) {
+        return nums.length % 2 == 0 || Arrays.stream(nums).reduce(0, (a, b) -> a ^ b) == 0;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool xorGame(vector<int>& nums) {
+        if (nums.size() % 2 == 0) return true;
+        int x = 0;
+        for (int& v : nums) x ^= v;
+        return x == 0;
+    }
+};
+```
 
+### **Go**
+
+```go
+func xorGame(nums []int) bool {
+	if len(nums)%2 == 0 {
+		return true
+	}
+	x := 0
+	for _, v := range nums {
+		x ^= v
+	}
+	return x == 0
+}
 ```
 
 ### **...**

solution/0800-0899/0810.Chalkboard XOR Game/Solution.cpp

@@ -0,0 +1,9 @@
+class Solution {
+public:
+    bool xorGame(vector<int>& nums) {
+        if (nums.size() % 2 == 0) return true;
+        int x = 0;
+        for (int& v : nums) x ^= v;
+        return x == 0;
+    }
+};

solution/0800-0899/0810.Chalkboard XOR Game/Solution.go

@@ -0,0 +1,10 @@
+func xorGame(nums []int) bool {
+	if len(nums)%2 == 0 {
+		return true
+	}
+	x := 0
+	for _, v := range nums {
+		x ^= v
+	}
+	return x == 0
+}

solution/0800-0899/0810.Chalkboard XOR Game/Solution.java

@@ -0,0 +1,5 @@
+class Solution {
+    public boolean xorGame(int[] nums) {
+        return nums.length % 2 == 0 || Arrays.stream(nums).reduce(0, (a, b) -> a ^ b) == 0;
+    }
+}

solution/0800-0899/0810.Chalkboard XOR Game/Solution.py

@@ -0,0 +1,3 @@
+class Solution:
+    def xorGame(self, nums: List[int]) -> bool:
+        return len(nums) % 2 == 0 or reduce(xor, nums) == 0

solution/0900-0999/0932.Beautiful Array/README.md

@@ -6,35 +6,37 @@
 
 <!-- 这里写题目描述 -->
 
-<p>对于某些固定的&nbsp;<code>N</code>，如果数组&nbsp;<code>A</code>&nbsp;是整数&nbsp;<code>1, 2, ..., N</code>&nbsp;组成的排列，使得：</p>
+<p>如果长度为 <code>n</code> 的数组 <code>nums</code> 满足下述条件，则认为该数组是一个 <strong>漂亮数组</strong> ：</p>
 
-<p>对于每个&nbsp;<code>i &lt; j</code>，都<strong>不存在</strong>&nbsp;<code>k</code> 满足&nbsp;<code>i &lt; k &lt; j</code>&nbsp;使得&nbsp;<code>A[k] * 2 = A[i] + A[j]</code>。</p>
-
-<p>那么数组 <code>A</code>&nbsp;是漂亮数组。</p>
-
-<p>&nbsp;</p>
+<ul>
+	<li><code>nums</code> 是由范围 <code>[1, n]</code> 的整数组成的一个排列。</li>
+	<li>对于每个 <code>0 &lt;= i &lt; j &lt; n</code> ，均不存在下标 <code>k</code>（<code>i &lt; k &lt; j</code>）使得 <code>2 * nums[k] == nums[i] + nums[j]</code> 。</li>
+</ul>
 
-<p>给定&nbsp;<code>N</code>，返回<strong>任意</strong>漂亮数组&nbsp;<code>A</code>（保证存在一个）。</p>
+<p>给你整数 <code>n</code> ，返回长度为 <code>n</code> 的任一 <strong>漂亮数组</strong> 。本题保证对于给定的 <code>n</code> 至少存在一个有效答案。</p>
 
 <p>&nbsp;</p>
 
-<p><strong>示例 1：</strong></p>
+<p><strong class="example">示例 1 ：</strong></p>
 
-<pre><strong>输入：</strong>4
+<pre>
+<strong>输入：</strong>n = 4
 <strong>输出：</strong>[2,1,4,3]
 </pre>
 
-<p><strong>示例 2：</strong></p>
+<p><strong class="example">示例 2 ：</strong></p>
 
-<pre><strong>输入：</strong>5
-<strong>输出：</strong>[3,1,2,5,4]</pre>
+<pre>
+<strong>输入：</strong>n = 5
+<strong>输出：</strong>[3,1,2,5,4]
+</pre>
 
 <p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li><code>1 &lt;= N &lt;= 1000</code></li>
+	<li><code>1 &lt;= n &lt;= 1000</code></li>
 </ul>
 
 <p>&nbsp;</p>

solution/1100-1199/1166.Design File System/README_EN.md

@@ -53,9 +53,10 @@ fileSystem.get("/c"); // return -1 because this path doesn't exist
 <p><strong>Constraints:</strong></p>
 
 <ul>
-	<li>The number of&nbsp;calls to the two functions&nbsp;is less than or equal to <code>10<sup>4</sup></code> in total.</li>
 	<li><code>2 &lt;= path.length &lt;= 100</code></li>
 	<li><code>1 &lt;= value &lt;= 10<sup>9</sup></code></li>
+	<li>Each <code>path</code> is <strong>valid</strong> and consists of lowercase English letters and <code>&#39;/&#39;</code>.</li>
+	<li>At most <code>10<sup>4</sup></code> calls <strong>in total</strong> will be made to <code>createPath</code> and <code>get</code>.</li>
 </ul>
 
 ## Solutions

solution/1500-1599/1527.Patients With a Condition/README_EN.md

@@ -21,7 +21,7 @@ This table contains information of the patients in the hospital.
 
 <p>&nbsp;</p>
 
-<p>Write an SQL query to report the patient_id, patient_name all conditions of patients who have Type I Diabetes. Type I Diabetes always starts with <code>DIAB1</code> prefix</p>
+<p>Write an SQL query to report the patient_id, patient_name and conditions of the patients who have Type I Diabetes. Type I Diabetes always starts with <code>DIAB1</code> prefix.</p>
 
 <p>Return the result table in <strong>any order</strong>.</p>
 

solution/2400-2499/2474.Customers With Strictly Increasing Purchases/README.md

@@ -18,7 +18,7 @@
 | price        | int  |
 +--------------+------+
 order_id is the primary key for this table.
-Each row contains the id of an order, the id of 
+Each row contains the id of an order, the id of customer that ordered it, the date of the order, and its price.
 </pre>
 
 <p>&nbsp;</p>

solution/2400-2499/2474.Customers With Strictly Increasing Purchases/README_EN.md

@@ -16,7 +16,7 @@
 | price        | int  |
 +--------------+------+
 order_id is the primary key for this table.
-Each row contains the id of an order, the id of 
+Each row contains the id of an order, the id of customer that ordered it, the date of the order, and its price.
 </pre>
 
 <p>&nbsp;</p>

solution/2400-2499/2479.Maximum XOR of Two Non-Overlapping Subtrees/README.md

@@ -0,0 +1,93 @@
+# [2479. Maximum XOR of Two Non-Overlapping Subtrees](https://leetcode.cn/problems/maximum-xor-of-two-non-overlapping-subtrees)
+
+[English Version](/solution/2400-2499/2479.Maximum%20XOR%20of%20Two%20Non-Overlapping%20Subtrees/README_EN.md)
+
+## 题目描述
+
+<!-- 这里写题目描述 -->
+
+<p>There is an undirected tree with n nodes labeled from <code>0</code> to <code>n - 1</code>. You are given the integer n and a 2D integer array <code>edges</code> of length <code>n - 1</code>, where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> in the tree.</p>
+
+<p>Each node has an associated <strong>value</strong>. You are given an array <code>values</code> of length <code>n</code>, where <code>values[i]</code> is the <strong>value</strong> of the <code>i<sup>th</sup></code> node.</p>
+
+<p>Select any two <strong>non-overlapping</strong> subtrees. Your <strong>score</strong> is the bitwise XOR of the sum of the values within those subtrees.</p>
+
+<p>Return <em>the</em> <em><strong>maximum</strong></em> <i>possible <strong>score</strong> you can achieve</i>. <em>If it is impossible to find two nonoverlapping subtrees</em>, return <code>0</code>.</p>
+
+<p><strong>Note</strong> that:</p>
+
+<ul>
+	<li>The <strong>subtree</strong> of a node is the tree consisting of that node and all of its descendants.</li>
+	<li>Two subtrees are <strong>non-overlapping </strong>if they do not share <strong>any common</strong> node.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong class="example">Example 1:</strong></p>
+<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/2400-2499/2479.Maximum%20XOR%20of%20Two%20Non-Overlapping%20Subtrees/images/treemaxxor.png" style="width: 346px; height: 249px;" />
+<pre>
+<strong>Input:</strong> n = 6, edges = [[0,1],[0,2],[1,3],[1,4],[2,5]], values = [2,8,3,6,2,5]
+<strong>Output:</strong> 24
+<strong>Explanation:</strong> Node 1&#39;s subtree has sum of values 16, while node 2&#39;s subtree has sum of values 8, so choosing these nodes will yield a score of 16 XOR 8 = 24. It can be proved that is the maximum possible score we can obtain.
+</pre>
+
+<p><strong class="example">Example 2:</strong></p>
+<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/2400-2499/2479.Maximum%20XOR%20of%20Two%20Non-Overlapping%20Subtrees/images/tree3drawio.png" style="width: 240px; height: 261px;" />
+<pre>
+<strong>Input:</strong> n = 3, edges = [[0,1],[1,2]], values = [4,6,1]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong> There is no possible way to select two non-overlapping subtrees, so we just return 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= n &lt;= 5 * 10<sup>4</sup></code></li>
+	<li><code>edges.length == n - 1</code></li>
+	<li><code>0 &lt;= a<sub>i</sub>, b<sub>i</sub> &lt; n</code></li>
+	<li><code>values.length == n</code></li>
+	<li><code>1 &lt;= values[i] &lt;= 10<sup>9</sup></code></li>
+	<li>It is guaranteed that <code>edges</code> represents a valid tree.</li>
+</ul>
+
+## 解法
+
+<!-- 这里可写通用的实现逻辑 -->
+
+<!-- tabs:start -->
+
+### **Python3**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```python
+
+```
+
+### **Java**
+
+<!-- 这里可写当前语言的特殊实现逻辑 -->
+
+```java
+
+```
+
+### **C++**
+
+```cpp
+
+```
+
+### **Go**
+
+```go
+
+```
+
+### **...**
+
+```
+
+```
+
+<!-- tabs:end -->