feat: add solutions to lc problem: No.2210,2212

- No.2210.Count Hills and Valleys in an Array
- No.2212.Maximum Points in an Archery Competition

Author: YangFong

solution/2200-2299/2210.Count Hills and Valleys in an Array/README.md

@@ -161,7 +161,47 @@ func countHillValley(nums []int) int {
 ### **TypeScript**
 
 ```ts
+function countHillValley(nums: number[]): number {
+    const n = nums.length;
+    let res = 0;
+    let prev = nums[0];
+    for (let i = 1; i < n - 1; i++) {
+        const num = nums[i];
+        const next = nums[i + 1];
+        if (num == next) {
+            continue;
+        }
+        if ((num > prev && num > next) || (num < prev && num < next)) {
+            res += 1;
+        }
+        prev = num;
+    }
+    return res;
+}
+```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn count_hill_valley(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut res = 0;
+        let mut prev = nums[0];
+        for i in 1..n - 1 {
+            let num = nums[i];
+            let next = nums[i + 1];
+            if num == next {
+                continue;
+            }
+            if num > prev && num > next || num < prev && num < next {
+                res += 1;
+            }
+            prev = num;
+        }
+        res
+    }
+}
 ```
 
 ### **...**

solution/2200-2299/2210.Count Hills and Valleys in an Array/README_EN.md

@@ -150,7 +150,47 @@ func countHillValley(nums []int) int {
 ### **TypeScript**
 
 ```ts
+function countHillValley(nums: number[]): number {
+    const n = nums.length;
+    let res = 0;
+    let prev = nums[0];
+    for (let i = 1; i < n - 1; i++) {
+        const num = nums[i];
+        const next = nums[i + 1];
+        if (num == next) {
+            continue;
+        }
+        if ((num > prev && num > next) || (num < prev && num < next)) {
+            res += 1;
+        }
+        prev = num;
+    }
+    return res;
+}
+```
 
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn count_hill_valley(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut res = 0;
+        let mut prev = nums[0];
+        for i in 1..n - 1 {
+            let num = nums[i];
+            let next = nums[i + 1];
+            if num == next {
+                continue;
+            }
+            if num > prev && num > next || num < prev && num < next {
+                res += 1;
+            }
+            prev = num;
+        }
+        res
+    }
+}
 ```
 
 ### **...**

solution/2200-2299/2210.Count Hills and Valleys in an Array/Solution.rs

@@ -0,0 +1,19 @@
+impl Solution {
+    pub fn count_hill_valley(nums: Vec<i32>) -> i32 {
+        let n = nums.len();
+        let mut res = 0;
+        let mut prev = nums[0];
+        for i in 1..n - 1 {
+            let num = nums[i];
+            let next = nums[i + 1];
+            if num == next {
+                continue;
+            }
+            if num > prev && num > next || num < prev && num < next {
+                res += 1;
+            }
+            prev = num;
+        }
+        res
+    }
+}

solution/2200-2299/2210.Count Hills and Valleys in an Array/Solution.ts

@@ -0,0 +1,17 @@
+function countHillValley(nums: number[]): number {
+    const n = nums.length;
+    let res = 0;
+    let prev = nums[0];
+    for (let i = 1; i < n - 1; i++) {
+        const num = nums[i];
+        const next = nums[i + 1];
+        if (num == next) {
+            continue;
+        }
+        if ((num > prev && num > next) || (num < prev && num < next)) {
+            res += 1;
+        }
+        prev = num;
+    }
+    return res;
+}

solution/2200-2299/2212.Maximum Points in an Archery Competition/README.md

@@ -93,7 +93,62 @@ Bob 获得总分 8 + 9 + 10 = 27 。
 ### **TypeScript**
 
 ```ts
+function maximumBobPoints(numArrows: number, aliceArrows: number[]): number[] {
+    const dfs = (arr: number[], i: number, c: number): number[] => {
+        if (i < 0 || c === 0) {
+            arr[0] += c;
+            return arr;
+        }
+        const a1 = dfs([...arr], i - 1, c);
+        if (c > aliceArrows[i]) {
+            arr[i] = aliceArrows[i] + 1;
+            const a2 = dfs(arr, i - 1, c - aliceArrows[i] - 1);
+            if (
+                a2.reduce((p, v, i) => p + (v > 0 ? i : 0), 0) >=
+                a1.reduce((p, v, i) => p + (v > 0 ? i : 0), 0)
+            ) {
+                return a2;
+            }
+        }
+        return a1;
+    };
+    return dfs(new Array(12).fill(0), 11, numArrows);
+}
+```
 
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(alice_arrows: &Vec<i32>, mut res: Vec<i32>, count: i32, i: usize) -> Vec<i32> {
+        if i == 0 || count == 0 {
+            res[0] += count;
+            return res;
+        }
+        let r1 = Self::dfs(alice_arrows, res.clone(), count, i - 1);
+        if count > alice_arrows[i] {
+            res[i] = alice_arrows[i] + 1;
+            let r2 = Self::dfs(alice_arrows, res, count - alice_arrows[i] - 1, i - 1);
+            if r2
+                .iter()
+                .enumerate()
+                .map(|(i, v)| if v > &0 { i } else { 0 })
+                .sum::<usize>()
+                > r1.iter()
+                    .enumerate()
+                    .map(|(i, v)| if v > &0 { i } else { 0 })
+                    .sum::<usize>()
+            {
+                return r2;
+            }
+        }
+        r1
+    }
+
+    pub fn maximum_bob_points(num_arrows: i32, alice_arrows: Vec<i32>) -> Vec<i32> {
+        Self::dfs(&alice_arrows, vec![0; 12], num_arrows, 11)
+    }
+}
 ```
 
 ### **...**

solution/2200-2299/2212.Maximum Points in an Archery Competition/README_EN.md

@@ -79,7 +79,62 @@ It can be shown that Bob cannot obtain a score higher than 27 points.
 ### **TypeScript**
 
 ```ts
+function maximumBobPoints(numArrows: number, aliceArrows: number[]): number[] {
+    const dfs = (arr: number[], i: number, c: number): number[] => {
+        if (i < 0 || c === 0) {
+            arr[0] += c;
+            return arr;
+        }
+        const a1 = dfs([...arr], i - 1, c);
+        if (c > aliceArrows[i]) {
+            arr[i] = aliceArrows[i] + 1;
+            const a2 = dfs(arr, i - 1, c - aliceArrows[i] - 1);
+            if (
+                a2.reduce((p, v, i) => p + (v > 0 ? i : 0), 0) >=
+                a1.reduce((p, v, i) => p + (v > 0 ? i : 0), 0)
+            ) {
+                return a2;
+            }
+        }
+        return a1;
+    };
+    return dfs(new Array(12).fill(0), 11, numArrows);
+}
+```
 
+### **Rust**
+
+```rust
+impl Solution {
+    fn dfs(alice_arrows: &Vec<i32>, mut res: Vec<i32>, count: i32, i: usize) -> Vec<i32> {
+        if i == 0 || count == 0 {
+            res[0] += count;
+            return res;
+        }
+        let r1 = Self::dfs(alice_arrows, res.clone(), count, i - 1);
+        if count > alice_arrows[i] {
+            res[i] = alice_arrows[i] + 1;
+            let r2 = Self::dfs(alice_arrows, res, count - alice_arrows[i] - 1, i - 1);
+            if r2
+                .iter()
+                .enumerate()
+                .map(|(i, v)| if v > &0 { i } else { 0 })
+                .sum::<usize>()
+                > r1.iter()
+                    .enumerate()
+                    .map(|(i, v)| if v > &0 { i } else { 0 })
+                    .sum::<usize>()
+            {
+                return r2;
+            }
+        }
+        r1
+    }
+
+    pub fn maximum_bob_points(num_arrows: i32, alice_arrows: Vec<i32>) -> Vec<i32> {
+        Self::dfs(&alice_arrows, vec![0; 12], num_arrows, 11)
+    }
+}
 ```
 
 ### **...**

solution/2200-2299/2212.Maximum Points in an Archery Competition/Solution.rs

@@ -0,0 +1,30 @@
+impl Solution {
+    fn dfs(alice_arrows: &Vec<i32>, mut res: Vec<i32>, count: i32, i: usize) -> Vec<i32> {
+        if i == 0 || count == 0 {
+            res[0] += count;
+            return res;
+        }
+        let r1 = Self::dfs(alice_arrows, res.clone(), count, i - 1);
+        if count > alice_arrows[i] {
+            res[i] = alice_arrows[i] + 1;
+            let r2 = Self::dfs(alice_arrows, res, count - alice_arrows[i] - 1, i - 1);
+            if r2
+                .iter()
+                .enumerate()
+                .map(|(i, v)| if v > &0 { i } else { 0 })
+                .sum::<usize>()
+                > r1.iter()
+                    .enumerate()
+                    .map(|(i, v)| if v > &0 { i } else { 0 })
+                    .sum::<usize>()
+            {
+                return r2;
+            }
+        }
+        r1
+    }
+
+    pub fn maximum_bob_points(num_arrows: i32, alice_arrows: Vec<i32>) -> Vec<i32> {
+        Self::dfs(&alice_arrows, vec![0; 12], num_arrows, 11)
+    }
+}

solution/2200-2299/2212.Maximum Points in an Archery Competition/Solution.ts

@@ -0,0 +1,21 @@
+function maximumBobPoints(numArrows: number, aliceArrows: number[]): number[] {
+    const dfs = (arr: number[], i: number, c: number): number[] => {
+        if (i < 0 || c === 0) {
+            arr[0] += c;
+            return arr;
+        }
+        const a1 = dfs([...arr], i - 1, c);
+        if (c > aliceArrows[i]) {
+            arr[i] = aliceArrows[i] + 1;
+            const a2 = dfs(arr, i - 1, c - aliceArrows[i] - 1);
+            if (
+                a2.reduce((p, v, i) => p + (v > 0 ? i : 0), 0) >=
+                a1.reduce((p, v, i) => p + (v > 0 ? i : 0), 0)
+            ) {
+                return a2;
+            }
+        }
+        return a1;
+    };
+    return dfs(new Array(12).fill(0), 11, numArrows);
+}