fix name

Author: luliyucoordinate

README.md

@@ -253,13 +253,13 @@ LeetCode
 |0371|[Sum of Two Integers](https://leetcode.com/problems/russian-doll-envelopes/) | c | [c++](./src/0371-Sum-of-Two-Integers/0371.cpp) |[python](./src/0371-Sum-of-Two-Integers/0371.py)||||[rust](./src/0371-Sum-of-Two-Integers/0371.rs)|Medium|
 |0377|[Combination Sum IV](https://leetcode.com/problems/combination-sum-iv/) | c | [c++](./src/0377-Combination-Sum-IV/0377.cpp) |[python](./src/0377-Combination-Sum-IV/0377.py)|||||Medium|
 |0389|[Find the Difference](https://leetcode.com/problems/find-the-difference/) | c | [c++](./src/0389-Find-the-Difference/0389.cpp) |[python](./src/0389-Find-the-Difference/0389.py)|||||Easy|
-|0384|[Shuffle an Array](https://leetcode.com/problems/shuffle-an-array/) | c | [c++](./src/0384-shuffle-an-array/0384.cpp) |||||[rust](./src/0384-shuffle-an-array/0384.rs)|Medium|
+|0384|[Shuffle an Array](https://leetcode.com/problems/shuffle-an-array/) | c | [c++](./src/0384-Shuffle-an-Array/0384.cpp) |||||[rust](./src/0384-Shuffle-an-Array/0384.rs)|Medium|
 |0392|[Is Subsequence](https://leetcode.com/problems/is-subsequence/) | c | [c++](./src/0392-Is-Subsequence/0392.cpp) |[python](./src/0392-Is-Subsequence/0392.py)|||||Medium|
 |0401|[Binary Watch](https://leetcode.com/problems/binary-watch/) | c | [c++](./src/0401-Binary-Watch/0401.cpp) |[python](./src/0401-Binary-Watch/0401.py)|||||Easy|
 |0404|[Sum of Left Leaves](https://leetcode.com/problems/sum-of-left-leaves/) | c | [c++](./src/0404-Sum-of-Left-Leaves/0404.cpp) |[python](./src/0404-Sum-of-Left-Leaves/0404.py)|||||Easy|
 |0409|[Longest Palindrome](https://leetcode.com/problems/longest-palindrome/)|c|[c++](./src/0409-Longest-Palindrome/0409.cpp)|[python](./src/0409-Longest-Palindrome/0409.py)|[go](./src/0409-Longest-Palindrome/0409.go)|[js](./src/0409-Longest-Palindrome/0409.js)|[java](./src/0409-Longest-Palindrome/0409.java)||Easy|
 |0416|[Partition Equal Subset Sum](https://leetcode.com/problems/partition-equal-subset-sum/) | c | [c++](./src/0416-Partition-Equal-Subset-Sum/0416.cpp) |[python](./src/0416-Partition-Equal-Subset-Sum/0416.py)|[go](./src/0416-Partition-Equal-Subset-Sum/0416.go)|[js](./src/0416-Partition-Equal-Subset-Sum/0416.js)|[java](./src/0416-Partition-Equal-Subset-Sum/0416.java)||Medium|
-|0423|[Reconstruct Original Digits from English](https://leetcode.com/problems/reconstruct-original-digits-from-english/) || [c++](./src/0423-reconstruct-original-digits-from-english/0423.cpp) |||||[rust](./src/0423-reconstruct-original-digits-from-english/0423.rs)|Medium|
+|0423|[Reconstruct Original Digits from English](https://leetcode.com/problems/reconstruct-original-digits-from-english/) || [c++](./src/0423-Reconstruct-Original-Digits-from-English/0423.cpp) |||||[rust](./src/0423-Reconstruct-Original-Digits-from-English/0423.rs)|Medium|
 |0424|[Longest Repeating Character Replacement](https://leetcode.com/problems/partition-equal-subset-sum/) | c | [c++](./src/0424-Longest-Repeating-Character-Replacement/0424.cpp) |[python](./src/0424-Longest-Repeating-Character-Replacement/0424.py)|[go](./src/0424-Longest-Repeating-Character-Replacement/0424.go)|[js](./src/0424-Longest-Repeating-Character-Replacement/0424.js)|||Medium|
 |0435|[Non-overlapping Intervals](https://leetcode.com/problems/non-overlapping-intervals/) | c | [c++](./src/0435-Non-overlapping-Intervals/0435.cpp) |[python](./src/0435-Non-overlapping-Intervals/0435.py)|[go](./src/0435-Non-overlapping-Intervals/0435.go)||||Medium|
 |0437|[Path Sum III](https://leetcode.com/problems/path-sum-iii/) | c | [c++](./src/0437-Path-Sum-III/0437.cpp) |[python](./src/0437-Path-Sum-III/0437.py)|||||Easy|
@@ -289,10 +289,10 @@ LeetCode
 |0530|[Minimum Absolute Difference in BST](https://leetcode.com/problems/minimum-absolute-difference-in-bst/) | c | [c++](./src/0530-Minimum-Absolute-Difference-in-BST/0530.cpp) |[python](./src/0530-Minimum-Absolute-Difference-in-BST/0530.py)|||||Easy|
 |0543|[Diameter of Binary Tree](https://leetcode.com/problems/diameter-of-binary-tree/) | c | [c++](./src/0543-Diameter-of-Binary-Tree/0543.cpp) |[python](./src/0543-Diameter-of-Binary-Tree/0543.py)|||||Easy|
 |0547|[Friend Circles](https://leetcode.com/problems/friend-circles/) | c | [c++](./src/0547-Friend-Circles/0547.cpp) |[python](./src/0547-Friend-Circles/0547.py)|||||Medium|
-|0559|[Maximum Depth of N-ary Tree](https://leetcode.com/problems/maximum-depth-of-n-ary-tree/) || [c++](./src/0559-maximum-depth-of-n-ary-tree/0559.cpp) ||||||Easy|
+|0559|[Maximum Depth of N-ary Tree](https://leetcode.com/problems/maximum-depth-of-n-ary-tree/) || [c++](./src/0559-Maximum-Depth-of-N-ary-Tree/0559.cpp) ||||||Easy|
 |0560|[Subarray Sum Equals K](https://leetcode.com/problems/subarray-sum-equals-k/) | c | [c++](./src/0560-Subarray-Sum-Equals-K/0560.cpp) |[python](./src/0560-Subarray-Sum-Equals-K/0560.py)|||||Medium|
 |0583|[Delete Operation for Two Strings](https://leetcode.com/problems/delete-operation-for-two-strings/)|c|[c++](./src/0583-Delete-Operation-for-Two-Strings/0583.cpp)|||||[rust](./src/0583-Delete-Operation-for-Two-Strings/0583.rs)|Medium|
-|0594|[Longest Harmonious Subsequence](https://leetcode.com/problems/longest-harmonious-subsequence/) ||[c++](./src/0594-longest-harmonious-subsequence/0594.cpp)|||||[rust](./src/0594-longest-harmonious-subsequence/0594.rs)|Easy|
+|0594|[Longest Harmonious Subsequence](https://leetcode.com/problems/longest-harmonious-subsequence/) ||[c++](./src/0594-Longest-Harmonious-Subsequence/0594.cpp)|||||[rust](./src/0594-Longest-Harmonious-Subsequence/0594.rs)|Easy|
 |0637|[Average of Levels in Binary Tree](https://leetcode.com/problems/subarray-sum-equals-k/) | c | [c++](./src/0637-Average-of-Levels-in-Binary-Tree/0637.cpp) |[python](./src/0637-Average-of-Levels-in-Binary-Tree/0637.py)|||||Easy|
 |0638|[Shopping Offers](https://leetcode.com/problems/shopping-offers/)||[c++](./src/0638-Shopping-Offers/0638.cpp)|||||[rust](./src/0638-Shopping-Offers/0638.rs)|Medium|
 |0650|[2 Keys Keyboard](https://leetcode.com/problems/2-keys-keyboard/) | c | [c++](./src/0650-2-Keys-Keyboard/0650.cpp) |[python](./src/0650-2-Keys-Keyboard/0650.py)|||||Medium|
@@ -327,7 +327,7 @@ LeetCode
 |0847|[Shortest Path Visiting All Nodes](https://leetcode.com/problems/shortest-path-visiting-all-nodes/) | c | [c++](./src/0847-Shortest-Path-Visiting-All-Nodes/0847.cpp) |[python](./src/0847-Shortest-Path-Visiting-All-Nodes/0847.py)|[go](./src/0847-Shortest-Path-Visiting-All-Nodes/0847.go)|[js](./src/0847-Shortest-Path-Visiting-All-Nodes/0847.js)|||Hard|
 |0852|[Peak Index in a Mountain Array](https://leetcode.com/problems/peak-index-in-a-mountain-array/) | c | [c++](./src/0852-Peak-Index-in-a-Mountain-Array/0852.cpp) |[python](./src/0852-Peak-Index-in-a-Mountain-Array/0852.py)|||||Easy|
 |0857|[Minimum Cost to Hire K Workers](https://leetcode.com/problems/minimum-cost-to-hire-k-workers/)|c|[c++](./src/0857-Minimum-Cost-to-Hire-K-Workers/0857.cpp)|[python](./src/0857-Minimum-Cost-to-Hire-K-Workers/0857.py)|[go](./src/0857-Minimum-Cost-to-Hire-K-Workers/0857.go)|[js](./src/0857-Minimum-Cost-to-Hire-K-Workers/0857.js)|[java](./src/0857-Minimum-Cost-to-Hire-K-Workers/0857.java)||Hard|
-|0859|[Buddy Strings](https://leetcode.com/problems/buddy-strings/) || [c++](./src/0859-buddy-strings/0859.cpp) |||||[rust](./src/0859-buddy-strings/0859.rs)|Easy|
+|0859|[Buddy Strings](https://leetcode.com/problems/buddy-strings/) || [c++](./src/0859-Buddy-Strings/0859.cpp) |||||[rust](./src/0859-Buddy-Strings/0859.rs)|Easy|
 |0872|[Leaf-Similar Trees](https://leetcode.com/problems/peak-index-in-a-mountain-array/) | c | [c++](./src/0852-Peak-Index-in-a-Mountain-Array/0852.cpp) |[python](./src/0852-Peak-Index-in-a-Mountain-Array/0852.py)|||||Easy|
 |0873|[Length of Longest Fibonacci Subsequence](https://leetcode.com/problems/length-of-longest-fibonacci-subsequence/) | c | [c++](./src/0873-Length-of-Longest-Fibonacci-Subsequence/0873.cpp) |[python](./src/0873-Length-of-Longest-Fibonacci-Subsequence/0873.py)|||||Medium|
 |0874|[Walking Robot Simulation](https://leetcode.com/problems/walking-robot-simulation/) | c | [c++](./src/0874-Walking-Robot-Simulation/0874.cpp) |[python](./src/0874-Walking-Robot-Simulation/0874.py)|||||Easy|

src/0384-Shuffle-an-Array/0384.cpp

@@ -0,0 +1,23 @@
+class Solution {
+ public:
+  Solution(vector<int>& nums) {
+    this->nums = nums;
+    this->org = nums;
+  }
+
+  vector<int> reset() {
+    nums = org;
+    return nums;
+  }
+
+  vector<int> shuffle() {
+    for (int i = 0; i < nums.size(); i++) {
+      int j = i + rand() % (nums.size() - i);
+      swap(nums[i], nums[j]);
+    }
+    return nums;
+  }
+
+ private:
+  vector<int> nums, org;
+};

src/0384-Shuffle-an-Array/0384.rs

@@ -0,0 +1,32 @@
+use rand::Rng;
+
+struct Solution {
+    nums: Vec<i32>,
+    org: Vec<i32>,
+}
+
+/**
+ * `&self` means the method takes an immutable reference.
+ * If you need a mutable reference, change it to `&mut self` instead.
+ */
+impl Solution {
+    fn new(nums: Vec<i32>) -> Self {
+        Self {
+            nums: nums.clone(),
+            org: nums.clone(),
+        }
+    }
+
+    fn reset(&self) -> Vec<i32> {
+        self.org.clone()
+    }
+
+    fn shuffle(&self) -> Vec<i32> {
+        let mut res = self.nums.clone();
+        for i in 0..res.len() {
+            let j = i + rand::thread_rng().gen_range(0..res.len() - i);
+            res.swap(i, j);
+        }
+        res
+    }
+}

src/0423-Reconstruct-Original-Digits-from-English/0423.cpp

@@ -0,0 +1,25 @@
+class Solution {
+ public:
+  string originalDigits(string s) {
+    int nums[10] = {};
+    int cnt[26] = {};
+    for (auto c : s) cnt[c - 'a']++;
+    nums[0] = cnt['z' - 'a'];
+    nums[2] = cnt['w' - 'a'];
+    nums[4] = cnt['u' - 'a'];
+    nums[6] = cnt['x' - 'a'];
+    nums[8] = cnt['g' - 'a'];
+    nums[1] = cnt['o' - 'a'] - nums[0] - nums[2] - nums[4];
+    nums[3] = cnt['h' - 'a'] - nums[8];
+    nums[5] = cnt['f' - 'a'] - nums[4];
+    nums[7] = cnt['s' - 'a'] - nums[6];
+    nums[9] = cnt['i' - 'a'] - nums[5] - nums[6] - nums[8];
+    stringstream ss;
+    for (int i = 0; i < 10; i++) {
+      for (int j = 0; j < nums[i]; j++) {
+        ss << i;
+      }
+    }
+    return ss.str();
+  }
+};

src/0423-Reconstruct-Original-Digits-from-English/0423.rs

@@ -0,0 +1,24 @@
+impl Solution {
+    pub fn original_digits(s: String) -> String {
+        let mut nums = vec![0; 10];
+        let mut cnt = vec![0; 26];
+        for c in s.as_bytes() {
+            cnt[(c - b'a') as usize] += 1;
+        }
+        nums[0] = cnt[(b'z' - b'a') as usize];
+        nums[2] = cnt[(b'w' - b'a') as usize];
+        nums[4] = cnt[(b'u' - b'a') as usize];
+        nums[6] = cnt[(b'x' - b'a') as usize];
+        nums[8] = cnt[(b'g' - b'a') as usize];
+        nums[1] = cnt[(b'o' - b'a') as usize] - nums[0] - nums[2] - nums[4];
+        nums[3] = cnt[(b'h' - b'a') as usize] - nums[8];
+        nums[5] = cnt[(b'f' - b'a') as usize] - nums[4];
+        nums[7] = cnt[(b's' - b'a') as usize] - nums[6];
+        nums[9] = cnt[(b'i' - b'a') as usize] - nums[5] - nums[6] - nums[8];
+        let mut res = String::new();
+        for i in 0..10 {
+            res.push_str(i.to_string().repeat(nums[i]).as_str());
+        }
+        res
+    }
+}

src/0559-Maximum-Depth-of-N-ary-Tree/0559.cpp

@@ -0,0 +1,13 @@
+class Solution {
+ public:
+  int maxDepth(Node* root) {
+    if (root == nullptr) {
+      return 0;
+    }
+    int res = 0;
+    for (auto c : root->children) {
+      res = max(res, maxDepth(c));
+    }
+    return res + 1;
+  }
+};

src/0594-Longest-Harmonious-Subsequence/0594.cpp

@@ -0,0 +1,14 @@
+class Solution {
+ public:
+  int findLHS(vector<int>& nums) {
+    unordered_map<int, int> cnt;
+    int res = 0;
+    for (int num : nums) cnt[num]++;
+    for (auto& [k, v] : cnt) {
+      if (cnt.count(k + 1)) {
+        res = max(res, v + cnt[k + 1]);
+      }
+    }
+    return res;
+  }
+};

src/0594-Longest-Harmonious-Subsequence/0594.rs

@@ -0,0 +1,17 @@
+use std::collections::HashMap;
+
+impl Solution {
+    pub fn find_lhs(nums: Vec<i32>) -> i32 {
+        let mut cnt = HashMap::new();
+        for num in nums {
+            *cnt.entry(num).or_insert(0) += 1;
+        }
+        let mut res = 0;
+        for (&k, &v) in cnt.iter() {
+            if let Some(&c) = cnt.get(&(k + 1)) {
+                res = res.max(v + c);
+            }
+        }
+        res
+    }
+}

src/0859-Buddy-Strings/0859.cpp

@@ -0,0 +1,20 @@
+class Solution {
+ public:
+  bool buddyStrings(string s, string goal) {
+    int n = s.size(), m = goal.size();
+    if (n != m) return false;
+    int a[26] = {};
+    int b[26] = {};
+    int t = 0;
+    for (int i = 0; i < n; i++) {
+      a[s[i] - 'a']++, b[goal[i] - 'a']++;
+      if (s[i] != goal[i]) t++;
+    }
+    bool ok = false;
+    for (int i = 0; i < 26; i++) {
+      if (a[i] != b[i]) return false;
+      if (a[i] > 1) ok = true;
+    }
+    return t == 2 || (t == 0 && ok);
+  }
+};

src/0859-Buddy-Strings/0859.rs

@@ -0,0 +1,32 @@
+impl Solution {
+    pub fn buddy_strings(s: String, goal: String) -> bool {
+        let n = s.len();
+        if n != goal.len() {
+            return false;
+        }
+        let mut t = 0;
+        let mut ok = false;
+
+        let mut a = vec![0; 26];
+        let mut b = vec![0; 26];
+        let s = s.as_bytes();
+        let goal = goal.as_bytes();
+        for i in 0..n {
+            a[(s[i] - b'a') as usize] += 1;
+            b[(goal[i] - b'a') as usize] += 1;
+            if s[i] != goal[i] {
+                t += 1;
+            }
+        }
+
+        for i in 0..26 {
+            if a[i] != b[i] {
+                return false;
+            }
+            if a[i] > 1 {
+                ok = true;
+            }
+        }
+        t == 2 || (t == 0 && ok)
+    }
+}