feat: add solutions to lc problems: No.0899,1403

- No.0899.Orderly Queue
- No.1403.Minimum Subsequence in Non-Increasing Order

Author: YangFong

solution/0800-0899/0899.Orderly Queue/README.md

@@ -141,6 +141,25 @@ func orderlyQueue(s string, k int) string {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function orderlyQueue(s: string, k: number): string {
+    if (k > 1) {
+        return [...s].sort().join('');
+    }
+    const n = s.length;
+    let min = s;
+    for (let i = 1; i < n; i++) {
+        const t = s.slice(i) + s.slice(0, i);
+        if (t < min) {
+            min = t;
+        }
+    }
+    return min;
+}
+```
+
 ### **...**
 
 ```

solution/0800-0899/0899.Orderly Queue/README_EN.md

@@ -119,6 +119,25 @@ func orderlyQueue(s string, k int) string {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function orderlyQueue(s: string, k: number): string {
+    if (k > 1) {
+        return [...s].sort().join('');
+    }
+    const n = s.length;
+    let min = s;
+    for (let i = 1; i < n; i++) {
+        const t = s.slice(i) + s.slice(0, i);
+        if (t < min) {
+            min = t;
+        }
+    }
+    return min;
+}
+```
+
 ### **...**
 
 ```

solution/0800-0899/0899.Orderly Queue/Solution.ts

@@ -0,0 +1,14 @@
+function orderlyQueue(s: string, k: number): string {
+    if (k > 1) {
+        return [...s].sort().join('');
+    }
+    const n = s.length;
+    let min = s;
+    for (let i = 1; i < n; i++) {
+        const t = s.slice(i) + s.slice(0, i);
+        if (t < min) {
+            min = t;
+        }
+    }
+    return min;
+}

solution/1400-1499/1403.Minimum Subsequence in Non-Increasing Order/README.md

@@ -141,6 +141,46 @@ func minSubsequence(nums []int) []int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function minSubsequence(nums: number[]): number[] {
+    nums.sort((a, b) => b - a);
+    const sum = nums.reduce((r, c) => r + c);
+    const res: number[] = [];
+    let t = 0;
+    for (const num of nums) {
+        t += num;
+        res.push(num);
+        if (t > sum - t) {
+            break;
+        }
+    }
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn min_subsequence(mut nums: Vec<i32>) -> Vec<i32> {
+        nums.sort_by(|a, b| b.cmp(a));
+        let sum = nums.iter().sum::<i32>();
+        let mut res = vec![];
+        let mut t = 0;
+        for num in nums.into_iter() {
+            t += num;
+            res.push(num);
+            if t > sum - t {
+                break;
+            }
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1400-1499/1403.Minimum Subsequence in Non-Increasing Order/README_EN.md

@@ -143,6 +143,46 @@ func minSubsequence(nums []int) []int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function minSubsequence(nums: number[]): number[] {
+    nums.sort((a, b) => b - a);
+    const sum = nums.reduce((r, c) => r + c);
+    const res: number[] = [];
+    let t = 0;
+    for (const num of nums) {
+        t += num;
+        res.push(num);
+        if (t > sum - t) {
+            break;
+        }
+    }
+    return res;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn min_subsequence(mut nums: Vec<i32>) -> Vec<i32> {
+        nums.sort_by(|a, b| b.cmp(a));
+        let sum = nums.iter().sum::<i32>();
+        let mut res = vec![];
+        let mut t = 0;
+        for num in nums.into_iter() {
+            t += num;
+            res.push(num);
+            if t > sum - t {
+                break;
+            }
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1400-1499/1403.Minimum Subsequence in Non-Increasing Order/Solution.rs

@@ -0,0 +1,16 @@
+impl Solution {
+    pub fn min_subsequence(mut nums: Vec<i32>) -> Vec<i32> {
+        nums.sort_by(|a, b| b.cmp(a));
+        let sum = nums.iter().sum::<i32>();
+        let mut res = vec![];
+        let mut t = 0;
+        for num in nums.into_iter() {
+            t += num;
+            res.push(num);
+            if t > sum - t {
+                break;
+            }
+        }
+        res
+    }
+}

solution/1400-1499/1403.Minimum Subsequence in Non-Increasing Order/Solution.ts

@@ -0,0 +1,14 @@
+function minSubsequence(nums: number[]): number[] {
+    nums.sort((a, b) => b - a);
+    const sum = nums.reduce((r, c) => r + c);
+    const res: number[] = [];
+    let t = 0;
+    for (const num of nums) {
+        t += num;
+        res.push(num);
+        if (t > sum - t) {
+            break;
+        }
+    }
+    return res;
+}