feat: add solutions to lc problems: No.0870, 1800

- No.0870.Advantage Shuffle
- No.1800.Maximum Ascending Subarray Sum

Author: YangFong

solution/0800-0899/0870.Advantage Shuffle/README.md

@@ -151,6 +151,57 @@ func advantageCount(nums1 []int, nums2 []int) []int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function advantageCount(nums1: number[], nums2: number[]): number[] {
+    const n = nums1.length;
+    const idx = Array.from({ length: n }, (_, i) => i);
+    idx.sort((i, j) => nums2[i] - nums2[j]);
+    nums1.sort((a, b) => a - b);
+
+    const ans = new Array(n).fill(0);
+    let left = 0;
+    let right = n - 1;
+    for (let i = 0; i < n; i++) {
+        if (nums1[i] > nums2[idx[left]]) {
+            ans[idx[left]] = nums1[i];
+            left++;
+        } else {
+            ans[idx[right]] = nums1[i];
+            right--;
+        }
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn advantage_count(mut nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
+        let n = nums1.len();
+        let mut idx = (0..n).collect::<Vec<usize>>();
+        idx.sort_by(|&i, &j| nums2[i].cmp(&nums2[j]));
+        nums1.sort();
+        let mut res = vec![0; n];
+        let mut left = 0;
+        let mut right = n - 1;
+        for &num in nums1.iter() {
+            if num > nums2[idx[left]] {
+                res[idx[left]] = num;
+                left += 1;
+            } else {
+                res[idx[right]] = num;
+                right -= 1;
+            }
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0800-0899/0870.Advantage Shuffle/README_EN.md

@@ -128,6 +128,57 @@ func advantageCount(nums1 []int, nums2 []int) []int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function advantageCount(nums1: number[], nums2: number[]): number[] {
+    const n = nums1.length;
+    const idx = Array.from({ length: n }, (_, i) => i);
+    idx.sort((i, j) => nums2[i] - nums2[j]);
+    nums1.sort((a, b) => a - b);
+
+    const ans = new Array(n).fill(0);
+    let left = 0;
+    let right = n - 1;
+    for (let i = 0; i < n; i++) {
+        if (nums1[i] > nums2[idx[left]]) {
+            ans[idx[left]] = nums1[i];
+            left++;
+        } else {
+            ans[idx[right]] = nums1[i];
+            right--;
+        }
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn advantage_count(mut nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
+        let n = nums1.len();
+        let mut idx = (0..n).collect::<Vec<usize>>();
+        idx.sort_by(|&i, &j| nums2[i].cmp(&nums2[j]));
+        nums1.sort();
+        let mut res = vec![0; n];
+        let mut left = 0;
+        let mut right = n - 1;
+        for &num in nums1.iter() {
+            if num > nums2[idx[left]] {
+                res[idx[left]] = num;
+                left += 1;
+            } else {
+                res[idx[right]] = num;
+                right -= 1;
+            }
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0800-0899/0870.Advantage Shuffle/Solution.rs

@@ -0,0 +1,21 @@
+impl Solution {
+    pub fn advantage_count(mut nums1: Vec<i32>, nums2: Vec<i32>) -> Vec<i32> {
+        let n = nums1.len();
+        let mut idx = (0..n).collect::<Vec<usize>>();
+        idx.sort_by(|&i, &j| nums2[i].cmp(&nums2[j]));
+        nums1.sort();
+        let mut res = vec![0; n];
+        let mut left = 0;
+        let mut right = n - 1;
+        for &num in nums1.iter() {
+            if num > nums2[idx[left]] {
+                res[idx[left]] = num;
+                left += 1;
+            } else {
+                res[idx[right]] = num;
+                right -= 1;
+            }
+        }
+        res
+    }
+}

solution/0800-0899/0870.Advantage Shuffle/Solution.ts

@@ -0,0 +1,20 @@
+function advantageCount(nums1: number[], nums2: number[]): number[] {
+    const n = nums1.length;
+    const idx = Array.from({ length: n }, (_, i) => i);
+    idx.sort((i, j) => nums2[i] - nums2[j]);
+    nums1.sort((a, b) => a - b);
+
+    const ans = new Array(n).fill(0);
+    let left = 0;
+    let right = n - 1;
+    for (let i = 0; i < n; i++) {
+        if (nums1[i] > nums2[idx[left]]) {
+            ans[idx[left]] = nums1[i];
+            left++;
+        } else {
+            ans[idx[right]] = nums1[i];
+            right--;
+        }
+    }
+    return ans;
+}

solution/1800-1899/1800.Maximum Ascending Subarray Sum/README.md

@@ -149,21 +149,60 @@ func maxAscendingSum(nums []int) int {
 }
 ```
 
+### **C**
+
+```c
+#define max(a,b) (((a) > (b)) ? (a) : (b))
+
+int maxAscendingSum(int* nums, int numsSize){
+    int res = nums[0];
+    int sum = nums[0];
+    for (int i = 1; i < numsSize; i++) {
+        if (nums[i - 1] >= nums[i]) {
+            res = max(res, sum);
+            sum = 0;
+        }
+        sum += nums[i];
+    }
+    return max(res, sum);
+}
+```
+
 ### **TypeScript**
 
 ```ts
 function maxAscendingSum(nums: number[]): number {
-    let ans = 0;
-    let t = 0;
-    for (let i = 0; i < nums.length; ++i) {
-        if (i == 0 || nums[i] > nums[i - 1]) {
-            t += nums[i];
-            ans = Math.max(ans, t);
-        } else {
-            t = nums[i];
+    const n = nums.length;
+    let res = nums[0];
+    let sum = nums[0];
+    for (let i = 1; i < n; i++) {
+        if (nums[i] <= nums[i - 1]) {
+            res = Math.max(res, sum);
+            sum = 0;
+        }
+        sum += nums[i];
+    }
+    return Math.max(res, sum);
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn max_ascending_sum(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut res = nums[0];
+        let mut sum = nums[0];
+        for i in 1..n {
+            if nums[i - 1] >= nums[i] {
+                res = res.max(sum);
+                sum = 0;
+            }
+            sum += nums[i];
         }
+        res.max(sum)
     }
-    return ans;
 }
 ```
 

solution/1800-1899/1800.Maximum Ascending Subarray Sum/README_EN.md

@@ -120,21 +120,60 @@ func maxAscendingSum(nums []int) int {
 }
 ```
 
+### **C**
+
+```c
+#define max(a,b) (((a) > (b)) ? (a) : (b))
+
+int maxAscendingSum(int* nums, int numsSize){
+    int res = nums[0];
+    int sum = nums[0];
+    for (int i = 1; i < numsSize; i++) {
+        if (nums[i - 1] >= nums[i]) {
+            res = max(res, sum);
+            sum = 0;
+        }
+        sum += nums[i];
+    }
+    return max(res, sum);
+}
+```
+
 ### **TypeScript**
 
 ```ts
 function maxAscendingSum(nums: number[]): number {
-    let ans = 0;
-    let t = 0;
-    for (let i = 0; i < nums.length; ++i) {
-        if (i == 0 || nums[i] > nums[i - 1]) {
-            t += nums[i];
-            ans = Math.max(ans, t);
-        } else {
-            t = nums[i];
+    const n = nums.length;
+    let res = nums[0];
+    let sum = nums[0];
+    for (let i = 1; i < n; i++) {
+        if (nums[i] <= nums[i - 1]) {
+            res = Math.max(res, sum);
+            sum = 0;
+        }
+        sum += nums[i];
+    }
+    return Math.max(res, sum);
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn max_ascending_sum(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut res = nums[0];
+        let mut sum = nums[0];
+        for i in 1..n {
+            if nums[i - 1] >= nums[i] {
+                res = res.max(sum);
+                sum = 0;
+            }
+            sum += nums[i];
         }
+        res.max(sum)
     }
-    return ans;
 }
 ```
 

solution/1800-1899/1800.Maximum Ascending Subarray Sum/Solution.c

@@ -0,0 +1,14 @@
+#define max(a,b) (((a) > (b)) ? (a) : (b))
+
+int maxAscendingSum(int* nums, int numsSize){
+    int res = nums[0];
+    int sum = nums[0];
+    for (int i = 1; i < numsSize; i++) {
+        if (nums[i - 1] >= nums[i]) {
+            res = max(res, sum);
+            sum = 0;
+        }
+        sum += nums[i];
+    }
+    return max(res, sum);
+}

solution/1800-1899/1800.Maximum Ascending Subarray Sum/Solution.rs

@@ -0,0 +1,15 @@
+impl Solution {
+    pub fn max_ascending_sum(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut res = nums[0];
+        let mut sum = nums[0];
+        for i in 1..n {
+            if nums[i - 1] >= nums[i] {
+                res = res.max(sum);
+                sum = 0;
+            }
+            sum += nums[i];
+        }
+        res.max(sum)
+    }
+}

solution/1800-1899/1800.Maximum Ascending Subarray Sum/Solution.ts

@@ -1,13 +1,13 @@
 function maxAscendingSum(nums: number[]): number {
-    let ans = 0;
-    let t = 0;
-    for (let i = 0; i < nums.length; ++i) {
-        if (i == 0 || nums[i] > nums[i - 1]) {
-            t += nums[i];
-            ans = Math.max(ans, t);
-        } else {
-            t = nums[i];
+    const n = nums.length;
+    let res = nums[0];
+    let sum = nums[0];
+    for (let i = 1; i < n; i++) {
+        if (nums[i] <= nums[i - 1]) {
+            res = Math.max(res, sum);
+            sum = 0;
         }
+        sum += nums[i];
     }
-    return ans;
+    return Math.max(res, sum);
 }