feat: add solutions to lc problems: No.2678,2679,2680 (#1866)

* No.2678.Number of Senior Citizens
* No.2679.Sum in a Matrix
* No.2680.Maximum OR

Author: yanglbme

solution/2600-2699/2678.Number of Senior Citizens/README.md

@@ -57,7 +57,7 @@
 
 遍历结束后，返回答案即可。
 
-时间复杂度 $O(n)$，空间复杂度 $O(1)$。其中 $n$ 是 `details` 的长度。
+时间复杂度 $O(n)$，其中 $n$ 是 `details` 的长度。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
@@ -152,6 +152,21 @@ impl Solution {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function countSeniors(details: string[]): number {
+    let ans = 0;
+    for (const x of details) {
+        const age = parseInt(x.slice(11, 13));
+        if (age > 60) {
+            ++ans;
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2678.Number of Senior Citizens/README_EN.md

@@ -45,6 +45,14 @@
 
 ## Solutions
 
+**Solution 1: Traversal and Counting**
+
+We can traverse each string $x$ in `details` and convert the $12$th and $13$th characters (indexed at $11$ and $12$) of $x$ to integers, and check if they are greater than $60$. If so, we add one to the answer.
+
+After the traversal, we return the answer.
+
+The time complexity is $O(n)$, where $n$ is the length of `details`. The space complexity is $O(1)`.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -134,6 +142,21 @@ impl Solution {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function countSeniors(details: string[]): number {
+    let ans = 0;
+    for (const x of details) {
+        const age = parseInt(x.slice(11, 13));
+        if (age > 60) {
+            ++ans;
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2678.Number of Senior Citizens/Solution.ts

@@ -0,0 +1,10 @@
+function countSeniors(details: string[]): number {
+    let ans = 0;
+    for (const x of details) {
+        const age = parseInt(x.slice(11, 13));
+        if (age > 60) {
+            ++ans;
+        }
+    }
+    return ans;
+}

solution/2600-2699/2679.Sum in a Matrix/README.md

@@ -157,6 +157,46 @@ function matrixSum(nums: number[][]): number {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn matrix_sum(nums: Vec<Vec<i32>>) -> i32 {
+        let mut nums = nums;
+        for row in nums.iter_mut() {
+            row.sort();
+        }
+        let transposed: Vec<Vec<i32>> = (0..nums[0].len()).map(|i| {
+            nums.iter().map(|row| row[i]).collect()
+        }).collect();
+
+        transposed.iter().map(|row| row.iter().max().unwrap()).sum()
+    }
+}
+```
+
+```rust
+impl Solution {
+    pub fn matrix_sum(nums: Vec<Vec<i32>>) -> i32 {
+        let mut nums = nums.clone();
+        for row in nums.iter_mut() {
+            row.sort();
+        }
+
+        let mut ans = 0;
+        for j in 0..nums[0].len() {
+            let mut mx = 0;
+            for row in &nums {
+                mx = mx.max(row[j]);
+            }
+            ans += mx;
+        }
+
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2679.Sum in a Matrix/README_EN.md

@@ -138,6 +138,46 @@ function matrixSum(nums: number[][]): number {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn matrix_sum(nums: Vec<Vec<i32>>) -> i32 {
+        let mut nums = nums;
+        for row in nums.iter_mut() {
+            row.sort();
+        }
+        let transposed: Vec<Vec<i32>> = (0..nums[0].len()).map(|i| {
+            nums.iter().map(|row| row[i]).collect()
+        }).collect();
+
+        transposed.iter().map(|row| row.iter().max().unwrap()).sum()
+    }
+}
+```
+
+```rust
+impl Solution {
+    pub fn matrix_sum(nums: Vec<Vec<i32>>) -> i32 {
+        let mut nums = nums.clone();
+        for row in nums.iter_mut() {
+            row.sort();
+        }
+
+        let mut ans = 0;
+        for j in 0..nums[0].len() {
+            let mut mx = 0;
+            for row in &nums {
+                mx = mx.max(row[j]);
+            }
+            ans += mx;
+        }
+
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2679.Sum in a Matrix/Solution.rs

@@ -0,0 +1,19 @@
+impl Solution {
+    pub fn matrix_sum(nums: Vec<Vec<i32>>) -> i32 {
+        let mut nums = nums.clone();
+        for row in nums.iter_mut() {
+            row.sort();
+        }
+        
+        let mut ans = 0;
+        for j in 0..nums[0].len() {
+            let mut mx = 0;
+            for row in &nums {
+                mx = mx.max(row[j]);
+            }
+            ans += mx;
+        }
+        
+        ans
+    }
+}

solution/2600-2699/2680.Maximum OR/README.md

@@ -143,6 +143,49 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function maximumOr(nums: number[], k: number): number {
+    const n = nums.length;
+    const suf: bigint[] = Array(n + 1).fill(0n);
+    for (let i = n - 1; i >= 0; i--) {
+        suf[i] = suf[i + 1] | BigInt(nums[i]);
+    }
+    let [ans, pre] = [0, 0n];
+    for (let i = 0; i < n; i++) {
+        ans = Math.max(Number(ans), Number(pre | (BigInt(nums[i]) << BigInt(k)) | suf[i + 1]));
+        pre |= BigInt(nums[i]);
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn maximum_or(nums: Vec<i32>, k: i32) -> i64 {
+        let n = nums.len();
+        let mut suf = vec![0; n + 1];
+
+        for i in (0..n).rev() {
+            suf[i] = suf[i + 1] | nums[i] as i64;
+        }
+
+        let mut ans = 0i64;
+        let mut pre = 0i64;
+        let k64 = k as i64;
+        for i in 0..n {
+            ans = ans.max(pre | ((nums[i] as i64) << k64) | suf[i + 1]);
+            pre |= nums[i] as i64;
+        }
+
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2680.Maximum OR/README_EN.md

@@ -38,6 +38,16 @@
 
 ## Solutions
 
+**Solution 1: Greedy + Preprocessing**
+
+We notice that in order to maximize the answer, we should apply $k$ times of bitwise OR to the same number.
+
+First, we preprocess the suffix OR value array $suf$ of the array $nums$, where $suf[i]$ represents the bitwise OR value of $nums[i], nums[i + 1], \cdots, nums[n - 1]$.
+
+Next, we traverse the array $nums$ from left to right, and maintain the current prefix OR value $pre$. For the current position $i$, we perform $k$ times of bitwise left shift on $nums[i]$, i.e., $nums[i] \times 2^k$, and perform bitwise OR operation with $pre$ to obtain the intermediate result. Then, we perform bitwise OR operation with $suf[i + 1]$ to obtain the maximum OR value with $nums[i]$ as the last number. By enumerating all possible positions $i$, we can obtain the final answer.
+
+The time complexity is $O(n)$, and the space complexity is $O(n)$. Here, $n$ is the length of the array $nums$.
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -123,6 +133,49 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function maximumOr(nums: number[], k: number): number {
+    const n = nums.length;
+    const suf: bigint[] = Array(n + 1).fill(0n);
+    for (let i = n - 1; i >= 0; i--) {
+        suf[i] = suf[i + 1] | BigInt(nums[i]);
+    }
+    let [ans, pre] = [0, 0n];
+    for (let i = 0; i < n; i++) {
+        ans = Math.max(Number(ans), Number(pre | (BigInt(nums[i]) << BigInt(k)) | suf[i + 1]));
+        pre |= BigInt(nums[i]);
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn maximum_or(nums: Vec<i32>, k: i32) -> i64 {
+        let n = nums.len();
+        let mut suf = vec![0; n + 1];
+
+        for i in (0..n).rev() {
+            suf[i] = suf[i + 1] | nums[i] as i64;
+        }
+
+        let mut ans = 0i64;
+        let mut pre = 0i64;
+        let k64 = k as i64;
+        for i in 0..n {
+            ans = ans.max(pre | ((nums[i] as i64) << k64) | suf[i + 1]);
+            pre |= nums[i] as i64;
+        }
+
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2680.Maximum OR/Solution.rs

@@ -0,0 +1,20 @@
+impl Solution {
+    pub fn maximum_or(nums: Vec<i32>, k: i32) -> i64 {
+        let n = nums.len();
+        let mut suf = vec![0; n + 1];
+        
+        for i in (0..n).rev() {
+            suf[i] = suf[i + 1] | nums[i] as i64;
+        }
+
+        let mut ans = 0i64;
+        let mut pre = 0i64;
+        let k64 = k as i64;
+        for i in 0..n {
+            ans = ans.max(pre | ((nums[i] as i64) << k64) | suf[i + 1]);
+            pre |= nums[i] as i64;
+        }
+        
+        ans
+    }
+}

solution/2600-2699/2680.Maximum OR/Solution.ts

@@ -0,0 +1,13 @@
+function maximumOr(nums: number[], k: number): number {
+    const n = nums.length;
+    const suf: bigint[] = Array(n + 1).fill(0n);
+    for (let i = n - 1; i >= 0; i--) {
+        suf[i] = suf[i + 1] | BigInt(nums[i]);
+    }
+    let [ans, pre] = [0, 0n];
+    for (let i = 0; i < n; i++) {
+        ans = Math.max(Number(ans), Number(pre | (BigInt(nums[i]) << BigInt(k)) | suf[i + 1]));
+        pre |= BigInt(nums[i]);
+    }
+    return ans;
+}