feat: add rust solutions to lc/lcof problems

- lcof No.01
- lc No.0189,0528

Author: maolonglong

lcof/面试题03. 数组中重复的数字/README.md

@@ -163,6 +163,25 @@ function swap(nums: number[], i: number, j: number): void {
 }
 ```
 
+### **Rust**
+
+```rs
+impl Solution {
+    pub fn find_repeat_number(mut nums: Vec<i32>) -> i32 {
+        for i in 0..nums.len() {
+            while i as i32 != nums[i] {
+                if nums[i] == nums[nums[i] as usize] {
+                    return nums[i];
+                }
+                let j = nums[i] as usize;
+                nums.swap(i, j);
+            }
+        }
+        -1
+    }
+}
+```
+
 ### **...**
 
 ```

lcof/面试题03. 数组中重复的数字/Solution.rs

@@ -0,0 +1,14 @@
+impl Solution {
+    pub fn find_repeat_number(mut nums: Vec<i32>) -> i32 {
+        for i in 0..nums.len() {
+            while i as i32 != nums[i] {
+                if nums[i] == nums[nums[i] as usize] {
+                    return nums[i];
+                }
+                let j = nums[i] as usize;
+                nums.swap(i, j);
+            }
+        }
+        -1
+    }
+}

solution/0100-0199/0189.Rotate Array/README.md

@@ -157,6 +157,24 @@ func reverse(nums []int, i, j int) {
 }
 ```
 
+### **Rust**
+
+```rs
+impl Solution {
+    pub fn rotate(nums: &mut Vec<i32>, k: i32) {
+        let n = nums.len();
+        let k = k as usize % n;
+        if n == 1 || k == 0 {
+            return;
+        }
+
+        nums.reverse();
+        nums[..k].reverse();
+        nums[k..].reverse();
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0100-0199/0189.Rotate Array/README_EN.md

@@ -132,6 +132,24 @@ func reverse(nums []int, i, j int) {
 }
 ```
 
+### **Rust**
+
+```rs
+impl Solution {
+    pub fn rotate(nums: &mut Vec<i32>, k: i32) {
+        let n = nums.len();
+        let k = k as usize % n;
+        if n == 1 || k == 0 {
+            return;
+        }
+
+        nums.reverse();
+        nums[..k].reverse();
+        nums[k..].reverse();
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0100-0199/0189.Rotate Array/Solution.rs

@@ -0,0 +1,13 @@
+impl Solution {
+    pub fn rotate(nums: &mut Vec<i32>, k: i32) {
+        let n = nums.len();
+        let k = k as usize % n;
+        if n == 1 || k == 0 {
+            return;
+        }
+
+        nums.reverse();
+        nums[..k].reverse();
+        nums[k..].reverse();
+    }
+}

solution/0500-0599/0528.Random Pick with Weight/README.md

@@ -250,6 +250,51 @@ Solution.prototype.pickIndex = function () {
  */
 ```
 
+### **Rust**
+
+```rs
+use rand::{thread_rng, Rng};
+
+struct Solution {
+    sum: 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(w: Vec<i32>) -> Self {
+        let n = w.len();
+        let mut sum = vec![0; n + 1];
+        for i in 1..=n {
+            sum[i] = sum[i - 1] + w[i - 1];
+        }
+        Self { sum }
+    }
+
+    fn pick_index(&self) -> i32 {
+        let x = thread_rng().gen_range(1, self.sum.last().unwrap() + 1);
+        let (mut left, mut right) = (1, self.sum.len() - 1);
+        while left < right {
+            let mid = (left + right) >> 1;
+            if self.sum[mid] < x {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        (left - 1) as i32
+    }
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * let obj = Solution::new(w);
+ * let ret_1: i32 = obj.pick_index();
+ */
+```
+
 ### **...**
 
 ```

solution/0500-0599/0528.Random Pick with Weight/README_EN.md

@@ -240,6 +240,51 @@ Solution.prototype.pickIndex = function () {
  */
 ```
 
+### **Rust**
+
+```rs
+use rand::{thread_rng, Rng};
+
+struct Solution {
+    sum: 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(w: Vec<i32>) -> Self {
+        let n = w.len();
+        let mut sum = vec![0; n + 1];
+        for i in 1..=n {
+            sum[i] = sum[i - 1] + w[i - 1];
+        }
+        Self { sum }
+    }
+
+    fn pick_index(&self) -> i32 {
+        let x = thread_rng().gen_range(1, self.sum.last().unwrap() + 1);
+        let (mut left, mut right) = (1, self.sum.len() - 1);
+        while left < right {
+            let mid = (left + right) >> 1;
+            if self.sum[mid] < x {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        (left - 1) as i32
+    }
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * let obj = Solution::new(w);
+ * let ret_1: i32 = obj.pick_index();
+ */
+```
+
 ### **...**
 
 ```

solution/0500-0599/0528.Random Pick with Weight/Solution.rs

@@ -0,0 +1,40 @@
+use rand::{thread_rng, Rng};
+
+struct Solution {
+    sum: 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(w: Vec<i32>) -> Self {
+        let n = w.len();
+        let mut sum = vec![0; n + 1];
+        for i in 1..=n {
+            sum[i] = sum[i - 1] + w[i - 1];
+        }
+        Self { sum }
+    }
+
+    fn pick_index(&self) -> i32 {
+        let x = thread_rng().gen_range(1, self.sum.last().unwrap() + 1);
+        let (mut left, mut right) = (1, self.sum.len() - 1);
+        while left < right {
+            let mid = (left + right) >> 1;
+            if self.sum[mid] < x {
+                left = mid + 1;
+            } else {
+                right = mid;
+            }
+        }
+        (left - 1) as i32
+    }
+}
+
+/**
+ * Your Solution object will be instantiated and called as such:
+ * let obj = Solution::new(w);
+ * let ret_1: i32 = obj.pick_index();
+ */