feat: add solutions to lc problems: No.0973,1630

- No.0973.K Closest Points to Origin
- No.1630.Arithmetic Subarrays

Author: YangFong

solution/0900-0999/0973.K Closest Points to Origin/README.md

@@ -115,6 +115,19 @@ function kClosest(points: number[][], k: number): number[][] {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn k_closest(mut points: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
+        points.sort_unstable_by(|a, b| {
+            (a[0].pow(2) + a[1].pow(2)).cmp(&(b[0].pow(2) + b[1].pow(2)))
+        });
+        points[0..k as usize].to_vec()
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0900-0999/0973.K Closest Points to Origin/README_EN.md

@@ -103,6 +103,19 @@ function kClosest(points: number[][], k: number): number[][] {
 }
 ```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn k_closest(mut points: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
+        points.sort_unstable_by(|a, b| {
+            (a[0].pow(2) + a[1].pow(2)).cmp(&(b[0].pow(2) + b[1].pow(2)))
+        });
+        points[0..k as usize].to_vec()
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0900-0999/0973.K Closest Points to Origin/Solution.rs

@@ -0,0 +1,8 @@
+impl Solution {
+    pub fn k_closest(mut points: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
+        points.sort_unstable_by(|a, b| {
+            (a[0].pow(2) + a[1].pow(2)).cmp(&(b[0].pow(2) + b[1].pow(2)))
+        });
+        points[0..k as usize].to_vec()
+    }
+}

solution/1600-1699/1630.Arithmetic Subarrays/README.md

@@ -206,6 +206,52 @@ func min(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function checkArithmeticSubarrays(
+    nums: number[],
+    l: number[],
+    r: number[],
+): boolean[] {
+    const m = l.length;
+    const res = new Array(m).fill(true);
+    for (let i = 0; i < m; i++) {
+        const arr = nums.slice(l[i], r[i] + 1).sort((a, b) => b - a);
+        for (let j = 2; j < arr.length; j++) {
+            if (arr[j - 2] - arr[j - 1] !== arr[j - 1] - arr[j]) {
+                res[i] = false;
+                break;
+            }
+        }
+    }
+    return res;
+}
+
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn check_arithmetic_subarrays(nums: Vec<i32>, l: Vec<i32>, r: Vec<i32>) -> Vec<bool> {
+        let m = l.len();
+        let mut res = vec![true; m];
+        for i in 0..m {
+            let mut arr = nums[l[i] as usize..=r[i] as usize].to_vec();
+            arr.sort();
+            for j in 2..arr.len() {
+                if arr[j - 2] - arr[j - 1] != arr[j - 1] - arr[j] {
+                    res[i] = false;
+                    break;
+                }
+            }
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1630.Arithmetic Subarrays/README_EN.md

@@ -200,6 +200,52 @@ func min(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function checkArithmeticSubarrays(
+    nums: number[],
+    l: number[],
+    r: number[],
+): boolean[] {
+    const m = l.length;
+    const res = new Array(m).fill(true);
+    for (let i = 0; i < m; i++) {
+        const arr = nums.slice(l[i], r[i] + 1).sort((a, b) => b - a);
+        for (let j = 2; j < arr.length; j++) {
+            if (arr[j - 2] - arr[j - 1] !== arr[j - 1] - arr[j]) {
+                res[i] = false;
+                break;
+            }
+        }
+    }
+    return res;
+}
+
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn check_arithmetic_subarrays(nums: Vec<i32>, l: Vec<i32>, r: Vec<i32>) -> Vec<bool> {
+        let m = l.len();
+        let mut res = vec![true; m];
+        for i in 0..m {
+            let mut arr = nums[l[i] as usize..=r[i] as usize].to_vec();
+            arr.sort();
+            for j in 2..arr.len() {
+                if arr[j - 2] - arr[j - 1] != arr[j - 1] - arr[j] {
+                    res[i] = false;
+                    break;
+                }
+            }
+        }
+        res
+    }
+}
+```
+
 ### **...**
 
 ```

solution/1600-1699/1630.Arithmetic Subarrays/Solution.rs

@@ -0,0 +1,17 @@
+impl Solution {
+    pub fn check_arithmetic_subarrays(nums: Vec<i32>, l: Vec<i32>, r: Vec<i32>) -> Vec<bool> {
+        let m = l.len();
+        let mut res = vec![true; m];
+        for i in 0..m {
+            let mut arr = nums[l[i] as usize..=r[i] as usize].to_vec();
+            arr.sort();
+            for j in 2..arr.len() {
+                if arr[j - 2] - arr[j - 1] != arr[j - 1] - arr[j] {
+                    res[i] = false;
+                    break;
+                }
+            }
+        }
+        res
+    }
+}

solution/1600-1699/1630.Arithmetic Subarrays/Solution.ts

@@ -0,0 +1,18 @@
+function checkArithmeticSubarrays(
+    nums: number[],
+    l: number[],
+    r: number[],
+): boolean[] {
+    const m = l.length;
+    const res = new Array(m).fill(true);
+    for (let i = 0; i < m; i++) {
+        const arr = nums.slice(l[i], r[i] + 1).sort((a, b) => b - a);
+        for (let j = 2; j < arr.length; j++) {
+            if (arr[j - 2] - arr[j - 1] !== arr[j - 1] - arr[j]) {
+                res[i] = false;
+                break;
+            }
+        }
+    }
+    return res;
+}