feat: add solutions to lc problems: No.0268,0645 (#1803)

* No.0268.Missing Number
* No.0645.Set Mismatch

Author: yanglbme

solution/0100-0199/0136.Single Number/README.md

@@ -60,7 +60,7 @@
 
 我们对该数组所有元素进行异或运算，结果就是那个只出现一次的数字。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 是数组 `nums` 的长度。
+时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 是数组 $nums$ 的长度。
 
 <!-- tabs:start -->
 

solution/0100-0199/0136.Single Number/README_EN.md

@@ -30,6 +30,17 @@
 
 ## Solutions
 
+**Solution 1: Bitwise Operation**
+
+The XOR operation has the following properties:
+
+-   Any number XOR 0 is still the original number, i.e., $x \oplus 0 = x$;
+-   Any number XOR itself is 0, i.e., $x \oplus x = 0$;
+
+Performing XOR operation on all elements in the array will result in the number that only appears once.
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/0200-0299/0268.Missing Number/README.md

@@ -62,15 +62,20 @@
 
 **方法一：位运算**
 
-对于数组中的每个元素，都可以与下标进行异或运算，最终的结果就是缺失的数字。
+异或运算的性质：
+
+-   任何数和 $0$ 做异或运算，结果仍然是原来的数，即 $x \oplus 0 = x$；
+-   任何数和其自身做异或运算，结果是 $0$，即 $x \oplus x = 0$；
+
+因此，我们可以遍历数组，将数字 $[0,..n]$ 与数组中的元素进行异或运算，最后的结果就是缺失的数字。
 
 时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组长度。
 
 **方法二：数学**
 
 我们也可以用数学求解。求出 $[0,..n]$ 的和，减去数组中所有数的和，就得到了缺失的数字。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 为数组长度。
+时间复杂度 $O(n)$，其中 $n$ 为数组长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -171,6 +176,58 @@ func missingNumber(nums []int) (ans int) {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn missing_number(nums: Vec<i32>) -> i32 {
+        let n = nums.len() as i32;
+        let mut ans = n;
+        for (i, v) in nums.iter().enumerate() {
+            ans ^= i as i32 ^ v;
+        }
+        ans
+    }
+}
+```
+
+```rust
+impl Solution {
+    pub fn missing_number(nums: Vec<i32>) -> i32 {
+        let n = nums.len() as i32;
+        let mut ans = n;
+        for (i, &v) in nums.iter().enumerate() {
+            ans += i as i32 - v;
+        }
+        ans
+    }
+}
+```
+
+### **TypeScript**
+
+```ts
+function missingNumber(nums: number[]): number {
+    const n = nums.length;
+    let ans = n;
+    for (let i = 0; i < n; ++i) {
+        ans ^= i ^ nums[i];
+    }
+    return ans;
+}
+```
+
+```ts
+function missingNumber(nums: number[]): number {
+    const n = nums.length;
+    let ans = n;
+    for (let i = 0; i < n; ++i) {
+        ans += i - nums[i];
+    }
+    return ans;
+}
+```
+
 ### **JavaScript**
 
 ```js

solution/0200-0299/0268.Missing Number/README_EN.md

@@ -46,6 +46,23 @@
 
 ## Solutions
 
+**Solution 1: Bitwise Operation**
+
+The XOR operation has the following properties:
+
+-   Any number XOR 0 is still the original number, i.e., $x \oplus 0 = x$;
+-   Any number XOR itself is 0, i.e., $x \oplus x = 0$;
+
+Therefore, we can traverse the array, perform XOR operation between each element and the numbers $[0,..n]$, and the final result will be the missing number.
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
+
+**Solution 2: Mathematics**
+
+We can also solve this problem using mathematics. By calculating the sum of $[0,..n]$, subtracting the sum of all numbers in the array, we can obtain the missing number.
+
+The time complexity is $O(n)$, where $n$ is the length of the array. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -141,6 +158,58 @@ func missingNumber(nums []int) (ans int) {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn missing_number(nums: Vec<i32>) -> i32 {
+        let n = nums.len() as i32;
+        let mut ans = n;
+        for (i, v) in nums.iter().enumerate() {
+            ans ^= i as i32 ^ v;
+        }
+        ans
+    }
+}
+```
+
+```rust
+impl Solution {
+    pub fn missing_number(nums: Vec<i32>) -> i32 {
+        let n = nums.len() as i32;
+        let mut ans = n;
+        for (i, &v) in nums.iter().enumerate() {
+            ans += i as i32 - v;
+        }
+        ans
+    }
+}
+```
+
+### **TypeScript**
+
+```ts
+function missingNumber(nums: number[]): number {
+    const n = nums.length;
+    let ans = n;
+    for (let i = 0; i < n; ++i) {
+        ans ^= i ^ nums[i];
+    }
+    return ans;
+}
+```
+
+```ts
+function missingNumber(nums: number[]): number {
+    const n = nums.length;
+    let ans = n;
+    for (let i = 0; i < n; ++i) {
+        ans += i - nums[i];
+    }
+    return ans;
+}
+```
+
 ### **JavaScript**
 
 ```js

solution/0200-0299/0268.Missing Number/Solution.rs

@@ -0,0 +1,10 @@
+impl Solution {
+    pub fn missing_number(nums: Vec<i32>) -> i32 {
+        let n = nums.len() as i32;
+        let mut ans = n; 
+        for (i, v) in nums.iter().enumerate() {
+            ans ^= i as i32 ^ v;
+        }
+        ans
+    }
+}

solution/0200-0299/0268.Missing Number/Solution.ts

@@ -0,0 +1,8 @@
+function missingNumber(nums: number[]): number {
+    const n = nums.length;
+    let ans = n;
+    for (let i = 0; i < n; ++i) {
+        ans ^= i ^ nums[i];
+    }
+    return ans;
+}

solution/0200-0299/0287.Find the Duplicate Number/README_EN.md

@@ -45,6 +45,14 @@
 
 ## Solutions
 
+**Solution 1: Binary Search**
+
+We can observe that if the number of elements in $[1,..x]$ is greater than $x$, then the duplicate number must be in $[1,..x]$, otherwise the duplicate number must be in $[x+1,..n]$.
+
+Therefore, we can use binary search to find $x$, and check whether the number of elements in $[1,..x]$ is greater than $x$ at each iteration. This way, we can determine which interval the duplicate number is in, and narrow down the search range until we find the duplicate number.
+
+The time complexity is $O(n \times \log n)$, where $n$ is the length of the array $nums$. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**