feat: add Rust solution for lc No.1878

Author: yanglbme

solution/1800-1899/1878.Get Biggest Three Rhombus Sums in a Grid/README.md

@@ -928,6 +928,68 @@ class TreeMultiSet<T = number> {
 }
 ```
 
+#### Rust
+
+```rust
+use std::collections::BTreeSet;
+
+impl Solution {
+    pub fn get_biggest_three(grid: Vec<Vec<i32>>) -> Vec<i32> {
+        let m = grid.len();
+        let n = grid[0].len();
+
+        let mut s1 = vec![vec![0; n + 2]; m + 1];
+        let mut s2 = vec![vec![0; n + 2]; m + 1];
+
+        for i in 1..=m {
+            for j in 1..=n {
+                s1[i][j] = s1[i - 1][j - 1] + grid[i - 1][j - 1];
+                s2[i][j] = s2[i - 1][j + 1] + grid[i - 1][j - 1];
+            }
+        }
+
+        let mut ss = BTreeSet::new();
+
+        for i in 1..=m {
+            for j in 1..=n {
+                let l = (i - 1)
+                    .min(m - i)
+                    .min(j - 1)
+                    .min(n - j);
+
+                ss.insert(grid[i - 1][j - 1]);
+
+                for k in 1..=l {
+                    let a = s1[i + k][j] - s1[i][j - k];
+                    let b = s1[i][j + k] - s1[i - k][j];
+                    let c = s2[i][j - k] - s2[i - k][j];
+                    let d = s2[i + k][j] - s2[i][j + k];
+
+                    let v = a + b + c + d
+                        - grid[i + k - 1][j - 1]
+                        + grid[i - k - 1][j - 1];
+
+                    ss.insert(v);
+                }
+
+                while ss.len() > 3 {
+                    let first = *ss.iter().next().unwrap();
+                    ss.remove(&first);
+                }
+            }
+        }
+
+        let mut ans = Vec::with_capacity(ss.len());
+        while let Some(&v) = ss.iter().next_back() {
+            ans.push(v);
+            ss.remove(&v);
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1800-1899/1878.Get Biggest Three Rhombus Sums in a Grid/README_EN.md

@@ -924,6 +924,68 @@ class TreeMultiSet<T = number> {
 }
 ```
 
+#### Rust
+
+```rust
+use std::collections::BTreeSet;
+
+impl Solution {
+    pub fn get_biggest_three(grid: Vec<Vec<i32>>) -> Vec<i32> {
+        let m = grid.len();
+        let n = grid[0].len();
+
+        let mut s1 = vec![vec![0; n + 2]; m + 1];
+        let mut s2 = vec![vec![0; n + 2]; m + 1];
+
+        for i in 1..=m {
+            for j in 1..=n {
+                s1[i][j] = s1[i - 1][j - 1] + grid[i - 1][j - 1];
+                s2[i][j] = s2[i - 1][j + 1] + grid[i - 1][j - 1];
+            }
+        }
+
+        let mut ss = BTreeSet::new();
+
+        for i in 1..=m {
+            for j in 1..=n {
+                let l = (i - 1)
+                    .min(m - i)
+                    .min(j - 1)
+                    .min(n - j);
+
+                ss.insert(grid[i - 1][j - 1]);
+
+                for k in 1..=l {
+                    let a = s1[i + k][j] - s1[i][j - k];
+                    let b = s1[i][j + k] - s1[i - k][j];
+                    let c = s2[i][j - k] - s2[i - k][j];
+                    let d = s2[i + k][j] - s2[i][j + k];
+
+                    let v = a + b + c + d
+                        - grid[i + k - 1][j - 1]
+                        + grid[i - k - 1][j - 1];
+
+                    ss.insert(v);
+                }
+
+                while ss.len() > 3 {
+                    let first = *ss.iter().next().unwrap();
+                    ss.remove(&first);
+                }
+            }
+        }
+
+        let mut ans = Vec::with_capacity(ss.len());
+        while let Some(&v) = ss.iter().next_back() {
+            ans.push(v);
+            ss.remove(&v);
+        }
+
+        ans
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/1800-1899/1878.Get Biggest Three Rhombus Sums in a Grid/Solution.rs

@@ -0,0 +1,57 @@
+use std::collections::BTreeSet;
+
+impl Solution {
+    pub fn get_biggest_three(grid: Vec<Vec<i32>>) -> Vec<i32> {
+        let m = grid.len();
+        let n = grid[0].len();
+
+        let mut s1 = vec![vec![0; n + 2]; m + 1];
+        let mut s2 = vec![vec![0; n + 2]; m + 1];
+
+        for i in 1..=m {
+            for j in 1..=n {
+                s1[i][j] = s1[i - 1][j - 1] + grid[i - 1][j - 1];
+                s2[i][j] = s2[i - 1][j + 1] + grid[i - 1][j - 1];
+            }
+        }
+
+        let mut ss = BTreeSet::new();
+
+        for i in 1..=m {
+            for j in 1..=n {
+                let l = (i - 1)
+                    .min(m - i)
+                    .min(j - 1)
+                    .min(n - j);
+
+                ss.insert(grid[i - 1][j - 1]);
+
+                for k in 1..=l {
+                    let a = s1[i + k][j] - s1[i][j - k];
+                    let b = s1[i][j + k] - s1[i - k][j];
+                    let c = s2[i][j - k] - s2[i - k][j];
+                    let d = s2[i + k][j] - s2[i][j + k];
+
+                    let v = a + b + c + d
+                        - grid[i + k - 1][j - 1]
+                        + grid[i - k - 1][j - 1];
+
+                    ss.insert(v);
+                }
+
+                while ss.len() > 3 {
+                    let first = *ss.iter().next().unwrap();
+                    ss.remove(&first);
+                }
+            }
+        }
+
+        let mut ans = Vec::with_capacity(ss.len());
+        while let Some(&v) = ss.iter().next_back() {
+            ans.push(v);
+            ss.remove(&v);
+        }
+
+        ans
+    }
+}

solution/3800-3899/3870.Count Commas in Range/README_EN.md

@@ -63,7 +63,15 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3870.Co
 
 <!-- solution:start -->
 
-### Solution 1
+### Solution 1: Brain Teaser
+
+Numbers from 1 to 999 contain no commas, so when $n$ is less than or equal to 999, the answer is 0.
+
+Since the range of $n$ is $[1, 10^5]$, when $n$ is greater than or equal to 1000, each number contains exactly one comma, so the answer is $n - 999$.
+
+Therefore, the answer is $\max(0, n - 999)$.
+
+The time complexity is $O(1)$, and the space complexity is $O(1)$.
 
 <!-- tabs:start -->
 
@@ -78,19 +86,38 @@ class Solution:
 #### Java
 
 ```java
-
+class Solution {
+    public int countCommas(int n) {
+        return Math.max(0, n - 999);
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int countCommas(int n) {
+        return max(0, n - 999);
+    }
+};
 ```
 
 #### Go
 
 ```go
+func countCommas(n int) int {
+	return max(0, n-999)
+}
+```
+
+#### TypeScript
 
+```ts
+function countCommas(n: number): number {
+    return Math.max(0, n - 999)
+};
 ```
 
 <!-- tabs:end -->