feat: add rust solutions to lc problems: No.2894,3581 (#4502)

Author: yanglbme

solution/2800-2899/2894.Divisible and Non-divisible Sums Difference/README.md

@@ -152,6 +152,24 @@ function differenceOfSums(n: number, m: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn difference_of_sums(n: i32, m: i32) -> i32 {
+        let mut ans = 0;
+        for i in 1..=n {
+            if i % m != 0 {
+                ans += i;
+            } else {
+                ans -= i;
+            }
+        }
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2800-2899/2894.Divisible and Non-divisible Sums Difference/README_EN.md

@@ -150,6 +150,24 @@ function differenceOfSums(n: number, m: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn difference_of_sums(n: i32, m: i32) -> i32 {
+        let mut ans = 0;
+        for i in 1..=n {
+            if i % m != 0 {
+                ans += i;
+            } else {
+                ans -= i;
+            }
+        }
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3581.Count Odd Letters from Number/README.md

@@ -233,6 +233,47 @@ function bitCount(i: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn count_odd_letters(mut n: i32) -> i32 {
+        use std::collections::HashMap;
+
+        let d: HashMap<i32, &str> = [
+            (0, "zero"),
+            (1, "one"),
+            (2, "two"),
+            (3, "three"),
+            (4, "four"),
+            (5, "five"),
+            (6, "six"),
+            (7, "seven"),
+            (8, "eight"),
+            (9, "nine"),
+        ]
+        .iter()
+        .cloned()
+        .collect();
+
+        let mut mask: u32 = 0;
+
+        while n > 0 {
+            let x = n % 10;
+            n /= 10;
+            if let Some(word) = d.get(&x) {
+                for c in word.chars() {
+                    let bit = 1 << (c as u8 - b'a');
+                    mask ^= bit as u32;
+                }
+            }
+        }
+
+        mask.count_ones() as i32
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3581.Count Odd Letters from Number/README_EN.md

@@ -233,6 +233,47 @@ function bitCount(i: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn count_odd_letters(mut n: i32) -> i32 {
+        use std::collections::HashMap;
+
+        let d: HashMap<i32, &str> = [
+            (0, "zero"),
+            (1, "one"),
+            (2, "two"),
+            (3, "three"),
+            (4, "four"),
+            (5, "five"),
+            (6, "six"),
+            (7, "seven"),
+            (8, "eight"),
+            (9, "nine"),
+        ]
+        .iter()
+        .cloned()
+        .collect();
+
+        let mut mask: u32 = 0;
+
+        while n > 0 {
+            let x = n % 10;
+            n /= 10;
+            if let Some(word) = d.get(&x) {
+                for c in word.chars() {
+                    let bit = 1 << (c as u8 - b'a');
+                    mask ^= bit as u32;
+                }
+            }
+        }
+
+        mask.count_ones() as i32
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3500-3599/3581.Count Odd Letters from Number/Solution.rs

@@ -0,0 +1,36 @@
+impl Solution {
+    pub fn count_odd_letters(mut n: i32) -> i32 {
+        use std::collections::HashMap;
+
+        let d: HashMap<i32, &str> = [
+            (0, "zero"),
+            (1, "one"),
+            (2, "two"),
+            (3, "three"),
+            (4, "four"),
+            (5, "five"),
+            (6, "six"),
+            (7, "seven"),
+            (8, "eight"),
+            (9, "nine"),
+        ]
+        .iter()
+        .cloned()
+        .collect();
+
+        let mut mask: u32 = 0;
+
+        while n > 0 {
+            let x = n % 10;
+            n /= 10;
+            if let Some(word) = d.get(&x) {
+                for c in word.chars() {
+                    let bit = 1 << (c as u8 - b'a');
+                    mask ^= bit as u32;
+                }
+            }
+        }
+
+        mask.count_ones() as i32
+    }
+}