feat: add solutions for lc No.3069,3070 (#5093)

Author: yanglbme

solution/3000-3099/3069.Distribute Elements Into Two Arrays I/README.md

@@ -74,13 +74,13 @@ tags:
 
 ### 方法一：模拟
 
-我们创建两个数组 `arr1` 和 `arr2`，分别存放 `nums` 中的元素，初始时 `arr1` 中只有 `nums[0]`，`arr2` 中只有 `nums[1]`。
+我们创建两个数组 $\textit{arr1}$ 和 $\textit{arr2}$，分别存放数组 $\textit{nums}$ 中的元素，初始时 $\textit{arr1}$ 中只有 $\textit{nums[0]}$，$\textit{arr2}$ 中只有 $\textit{nums[1]}$。
 
-然后遍历 `nums` 下标从 $2$ 开始的元素，如果 `arr1` 的最后一个元素大于 `arr2` 的最后一个元素，就将当前元素追加到 `arr1`，否则追加到 `arr2`。
+然后遍历 $\textit{nums}$ 下标从 $2$ 开始的元素，如果 $\textit{arr1}$ 的最后一个元素大于 $\textit{arr2}$ 的最后一个元素，就将当前元素追加到 $\textit{arr1}$，否则追加到 $\textit{arr2}$。
 
-最后将 `arr2` 中的元素追加到 `arr1` 中，返回 `arr1`。
+最后将 $\textit{arr2}$ 中的元素追加到 $\textit{arr1}$ 中，返回 $\textit{arr1}$。
 
-时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 `nums` 的长度。
+时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $\textit{nums}$ 的长度。
 
 <!-- tabs:start -->
 
@@ -181,6 +181,50 @@ function resultArray(nums: number[]): number[] {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn result_array(nums: Vec<i32>) -> Vec<i32> {
+        let n = nums.len();
+        let mut arr1 = vec![nums[0]];
+        let mut arr2 = vec![nums[1]];
+        for k in 2..n {
+            if arr1[arr1.len() - 1] > arr2[arr2.len() - 1] {
+                arr1.push(nums[k]);
+            } else {
+                arr2.push(nums[k]);
+            }
+        }
+        arr1.extend(arr2);
+        arr1
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int[] ResultArray(int[] nums) {
+        int n = nums.Length;
+        var arr1 = new List<int> { nums[0] };
+        var arr2 = new List<int> { nums[1] };
+
+        for (int k = 2; k < n; ++k) {
+            if (arr1[arr1.Count - 1] > arr2[arr2.Count - 1]) {
+                arr1.Add(nums[k]);
+            } else {
+                arr2.Add(nums[k]);
+            }
+        }
+
+        arr1.AddRange(arr2);
+        return arr1.ToArray();
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3000-3099/3069.Distribute Elements Into Two Arrays I/README_EN.md

@@ -72,13 +72,13 @@ Hence, the array result formed by concatenation is [5,3,4,8].
 
 ### Solution 1: Simulation
 
-We create two arrays `arr1` and `arr2`, which store the elements in `nums`. Initially, `arr1` only contains `nums[0]`, and `arr2` only contains `nums[1]`.
+We create two arrays $\textit{arr1}$ and $\textit{arr2}$ to store the elements of $\textit{nums}$. Initially, $\textit{arr1}$ contains only $\textit{nums[0]}$, and $\textit{arr2}$ contains only $\textit{nums[1]}$.
 
-Then we traverse the elements of `nums` starting from index 2. If the last element of `arr1` is greater than the last element of `arr2`, we append the current element to `arr1`, otherwise we append it to `arr2`.
+Then we iterate over the elements of $\textit{nums}$ starting from index $2$. If the last element of $\textit{arr1}$ is greater than the last element of $\textit{arr2}$, we append the current element to $\textit{arr1}$; otherwise, we append it to $\textit{arr2}$.
 
-Finally, we append the elements in `arr2` to `arr1` and return `arr1`.
+Finally, we append the elements of $\textit{arr2}$ to $\textit{arr1}$ and return $\textit{arr1}$.
 
-The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array `nums`.
+The time complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the length of the array $\textit{nums}$.
 
 <!-- tabs:start -->
 
@@ -179,6 +179,50 @@ function resultArray(nums: number[]): number[] {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn result_array(nums: Vec<i32>) -> Vec<i32> {
+        let n = nums.len();
+        let mut arr1 = vec![nums[0]];
+        let mut arr2 = vec![nums[1]];
+        for k in 2..n {
+            if arr1[arr1.len() - 1] > arr2[arr2.len() - 1] {
+                arr1.push(nums[k]);
+            } else {
+                arr2.push(nums[k]);
+            }
+        }
+        arr1.extend(arr2);
+        arr1
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int[] ResultArray(int[] nums) {
+        int n = nums.Length;
+        var arr1 = new List<int> { nums[0] };
+        var arr2 = new List<int> { nums[1] };
+
+        for (int k = 2; k < n; ++k) {
+            if (arr1[arr1.Count - 1] > arr2[arr2.Count - 1]) {
+                arr1.Add(nums[k]);
+            } else {
+                arr2.Add(nums[k]);
+            }
+        }
+
+        arr1.AddRange(arr2);
+        return arr1.ToArray();
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3000-3099/3069.Distribute Elements Into Two Arrays I/Solution.cs

@@ -0,0 +1,18 @@
+public class Solution {
+    public int[] ResultArray(int[] nums) {
+        int n = nums.Length;
+        var arr1 = new List<int> { nums[0] };
+        var arr2 = new List<int> { nums[1] };
+
+        for (int k = 2; k < n; ++k) {
+            if (arr1[arr1.Count - 1] > arr2[arr2.Count - 1]) {
+                arr1.Add(nums[k]);
+            } else {
+                arr2.Add(nums[k]);
+            }
+        }
+
+        arr1.AddRange(arr2);
+        return arr1.ToArray();
+    }
+}

solution/3000-3099/3069.Distribute Elements Into Two Arrays I/Solution.rs

@@ -0,0 +1,16 @@
+impl Solution {
+    pub fn result_array(nums: Vec<i32>) -> Vec<i32> {
+        let n = nums.len();
+        let mut arr1 = vec![nums[0]];
+        let mut arr2 = vec![nums[1]];
+        for k in 2..n {
+            if arr1[arr1.len() - 1] > arr2[arr2.len() - 1] {
+                arr1.push(nums[k]);
+            } else {
+                arr2.push(nums[k]);
+            }
+        }
+        arr1.extend(arr2);
+        arr1
+    }
+}

solution/3000-3099/3070.Count Submatrices with Top-Left Element and Sum Less Than k/README.md

@@ -171,6 +171,45 @@ function countSubmatrices(grid: number[][], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn count_submatrices(grid: Vec<Vec<i32>>, k: i32) -> i32 {
+        let m = grid.len();
+        let n = grid[0].len();
+        let mut s = vec![vec![0; n + 1]; m + 1];
+        let mut ans = 0;
+        for i in 1..=m {
+            for j in 1..=n {
+                s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + grid[i - 1][j - 1];
+                if s[i][j] <= k { ans += 1; }
+            }
+        }
+        ans
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int CountSubmatrices(int[][] grid, int k) {
+        int m = grid.Length, n = grid[0].Length;
+        int[,] s = new int[m + 1, n + 1];
+        int ans = 0;
+        for (int i = 1; i <= m; ++i) {
+            for (int j = 1; j <= n; ++j) {
+                s[i, j] = s[i - 1, j] + s[i, j - 1] - s[i - 1, j - 1] + grid[i - 1][j - 1];
+                if (s[i, j] <= k) ++ans;
+            }
+        }
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3000-3099/3070.Count Submatrices with Top-Left Element and Sum Less Than k/README_EN.md

@@ -169,6 +169,45 @@ function countSubmatrices(grid: number[][], k: number): number {
 }
 ```
 
+#### Rust
+
+```rust
+impl Solution {
+    pub fn count_submatrices(grid: Vec<Vec<i32>>, k: i32) -> i32 {
+        let m = grid.len();
+        let n = grid[0].len();
+        let mut s = vec![vec![0; n + 1]; m + 1];
+        let mut ans = 0;
+        for i in 1..=m {
+            for j in 1..=n {
+                s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + grid[i - 1][j - 1];
+                if s[i][j] <= k { ans += 1; }
+            }
+        }
+        ans
+    }
+}
+```
+
+#### C#
+
+```cs
+public class Solution {
+    public int CountSubmatrices(int[][] grid, int k) {
+        int m = grid.Length, n = grid[0].Length;
+        int[,] s = new int[m + 1, n + 1];
+        int ans = 0;
+        for (int i = 1; i <= m; ++i) {
+            for (int j = 1; j <= n; ++j) {
+                s[i, j] = s[i - 1, j] + s[i, j - 1] - s[i - 1, j - 1] + grid[i - 1][j - 1];
+                if (s[i, j] <= k) ++ans;
+            }
+        }
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/3000-3099/3070.Count Submatrices with Top-Left Element and Sum Less Than k/Solution.cs

@@ -0,0 +1,14 @@
+public class Solution {
+    public int CountSubmatrices(int[][] grid, int k) {
+        int m = grid.Length, n = grid[0].Length;
+        int[,] s = new int[m + 1, n + 1];
+        int ans = 0;
+        for (int i = 1; i <= m; ++i) {
+            for (int j = 1; j <= n; ++j) {
+                s[i, j] = s[i - 1, j] + s[i, j - 1] - s[i - 1, j - 1] + grid[i - 1][j - 1];
+                if (s[i, j] <= k) ++ans;
+            }
+        }
+        return ans;
+    }
+}

solution/3000-3099/3070.Count Submatrices with Top-Left Element and Sum Less Than k/Solution.rs

@@ -0,0 +1,15 @@
+impl Solution {
+    pub fn count_submatrices(grid: Vec<Vec<i32>>, k: i32) -> i32 {
+        let m = grid.len();
+        let n = grid[0].len();
+        let mut s = vec![vec![0; n + 1]; m + 1];
+        let mut ans = 0;
+        for i in 1..=m {
+            for j in 1..=n {
+                s[i][j] = s[i - 1][j] + s[i][j - 1] - s[i - 1][j - 1] + grid[i - 1][j - 1];
+                if s[i][j] <= k { ans += 1; }
+            }
+        }
+        ans
+    }
+}

solution/3000-3099/3072.Distribute Elements Into Two Arrays II/README.md

@@ -151,33 +151,6 @@ class Solution:
         return arr1 + arr2
 ```
 
-#### Python3
-
-```python
-class Solution:
-    def resultArray(self, nums: List[int]) -> List[int]:
-        arr1 = [nums[0]]
-        arr2 = [nums[1]]
-        sl1 = SortedList(arr1)
-        sl2 = SortedList(arr2)
-        for x in nums[2:]:
-            i = sl1.bisect_right(x)
-            j = sl2.bisect_right(x)
-            if len(sl1) - i > len(sl2) - j:
-                arr1.append(x)
-                sl1.add(x)
-            elif len(sl1) - i < len(sl2) - j:
-                arr2.append(x)
-                sl2.add(x)
-            elif len(sl1) <= len(sl2):
-                arr1.append(x)
-                sl1.add(x)
-            else:
-                arr2.append(x)
-                sl2.add(x)
-        return arr1 + arr2
-```
-
 #### Java
 
 ```java

solution/3000-3099/3072.Distribute Elements Into Two Arrays II/README_EN.md

@@ -149,33 +149,6 @@ class Solution:
         return arr1 + arr2
 ```
 
-#### Python3
-
-```python
-class Solution:
-    def resultArray(self, nums: List[int]) -> List[int]:
-        arr1 = [nums[0]]
-        arr2 = [nums[1]]
-        sl1 = SortedList(arr1)
-        sl2 = SortedList(arr2)
-        for x in nums[2:]:
-            i = sl1.bisect_right(x)
-            j = sl2.bisect_right(x)
-            if len(sl1) - i > len(sl2) - j:
-                arr1.append(x)
-                sl1.add(x)
-            elif len(sl1) - i < len(sl2) - j:
-                arr2.append(x)
-                sl2.add(x)
-            elif len(sl1) <= len(sl2):
-                arr1.append(x)
-                sl1.add(x)
-            else:
-                arr2.append(x)
-                sl2.add(x)
-        return arr1 + arr2
-```
-
 #### Java
 
 ```java