feat: add solutions to lc problems: No.2511, 2512

- No.2511.Maximum Enemy Forts That Can Be Captured
- No.2512.Reward Top K Students

Author: YangFong

solution/2500-2599/2511.Maximum Enemy Forts That Can Be Captured/README.md

@@ -165,6 +165,54 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function captureForts(forts: number[]): number {
+    const n = forts.length;
+    let ans = 0;
+    let i = 0;
+    while (i < n) {
+        let j = i + 1;
+        if (forts[i] !== 0) {
+            while (j < n && forts[j] === 0) {
+                j++;
+            }
+            if (j < n && forts[i] + forts[j] === 0) {
+                ans = Math.max(ans, j - i - 1);
+            }
+        }
+        i = j;
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn capture_forts(forts: Vec<i32>) -> i32 {
+        let n = forts.len();
+        let mut ans = 0;
+        let mut i = 0;
+        while i < n {
+            let mut j = i + 1;
+            if forts[i] != 0 {
+                while j < n && forts[j] == 0 {
+                    j += 1;
+                }
+                if j < n && forts[i] + forts[j] == 0 {
+                    ans = ans.max(j - i - 1);
+                }
+            }
+            i = j;
+        }
+        ans as i32
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2511.Maximum Enemy Forts That Can Be Captured/README_EN.md

@@ -151,6 +151,54 @@ func max(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function captureForts(forts: number[]): number {
+    const n = forts.length;
+    let ans = 0;
+    let i = 0;
+    while (i < n) {
+        let j = i + 1;
+        if (forts[i] !== 0) {
+            while (j < n && forts[j] === 0) {
+                j++;
+            }
+            if (j < n && forts[i] + forts[j] === 0) {
+                ans = Math.max(ans, j - i - 1);
+            }
+        }
+        i = j;
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn capture_forts(forts: Vec<i32>) -> i32 {
+        let n = forts.len();
+        let mut ans = 0;
+        let mut i = 0;
+        while i < n {
+            let mut j = i + 1;
+            if forts[i] != 0 {
+                while j < n && forts[j] == 0 {
+                    j += 1;
+                }
+                if j < n && forts[i] + forts[j] == 0 {
+                    ans = ans.max(j - i - 1);
+                }
+            }
+            i = j;
+        }
+        ans as i32
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2511.Maximum Enemy Forts That Can Be Captured/Solution.rs

@@ -0,0 +1,20 @@
+impl Solution {
+    pub fn capture_forts(forts: Vec<i32>) -> i32 {
+        let n = forts.len();
+        let mut ans = 0;
+        let mut i = 0;
+        while i < n {
+            let mut j = i + 1;
+            if forts[i] != 0 {
+                while j < n && forts[j] == 0 {
+                    j += 1;
+                }
+                if j < n && forts[i] + forts[j] == 0 {
+                    ans = ans.max(j - i - 1);
+                }
+            }
+            i = j;
+        }
+        ans as i32
+    }
+}

solution/2500-2599/2511.Maximum Enemy Forts That Can Be Captured/Solution.ts

@@ -0,0 +1,18 @@
+function captureForts(forts: number[]): number {
+    const n = forts.length;
+    let ans = 0;
+    let i = 0;
+    while (i < n) {
+        let j = i + 1;
+        if (forts[i] !== 0) {
+            while (j < n && forts[j] === 0) {
+                j++;
+            }
+            if (j < n && forts[i] + forts[j] === 0) {
+                ans = Math.max(ans, j - i - 1);
+            }
+        }
+        i = j;
+    }
+    return ans;
+}

solution/2500-2599/2512.Reward Top K Students/README.md

@@ -202,6 +202,87 @@ func topStudents(positive_feedback []string, negative_feedback []string, report
 }
 ```
 
+### **TypeScript**
+
+```ts
+function topStudents(
+    positive_feedback: string[],
+    negative_feedback: string[],
+    report: string[],
+    student_id: number[],
+    k: number,
+): number[] {
+    const n = student_id.length;
+    const map = new Map<number, number>();
+    const ps = new Set(positive_feedback);
+    const ns = new Set(negative_feedback);
+    for (let i = 0; i < n; i++) {
+        map.set(
+            student_id[i],
+            report[i].split(' ').reduce((r, s) => {
+                if (ps.has(s)) {
+                    return r + 3;
+                }
+                if (ns.has(s)) {
+                    return r - 1;
+                }
+                return r;
+            }, 0),
+        );
+    }
+    return [...map.entries()]
+        .sort((a, b) => {
+            if (a[1] === b[1]) {
+                return a[0] - b[0];
+            }
+            return b[1] - a[1];
+        })
+        .map(v => v[0])
+        .slice(0, k);
+}
+```
+
+### **Rust**
+
+```rust
+use std::collections::{HashMap, HashSet};
+impl Solution {
+    pub fn top_students(
+        positive_feedback: Vec<String>,
+        negative_feedback: Vec<String>,
+        report: Vec<String>,
+        student_id: Vec<i32>,
+        k: i32,
+    ) -> Vec<i32> {
+        let n = student_id.len();
+        let ps = positive_feedback.iter().collect::<HashSet<&String>>();
+        let ns = negative_feedback.iter().collect::<HashSet<&String>>();
+        let mut map = HashMap::new();
+        for i in 0..n {
+            let id = student_id[i];
+            let mut count = 0;
+            for s in report[i].split(' ') {
+                let s = &s.to_string();
+                if ps.contains(s) {
+                    count += 3;
+                } else if ns.contains(s) {
+                    count -= 1;
+                }
+            }
+            map.insert(id, count);
+        }
+        let mut t = map.into_iter().collect::<Vec<(i32, i32)>>();
+        t.sort_by(|a, b| {
+            if a.1 == b.1 {
+                return a.0.cmp(&b.0);
+            }
+            b.1.cmp(&a.1)
+        });
+        t.iter().map(|v| v.0).collect::<Vec<i32>>()[0..k as usize].to_vec()
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2512.Reward Top K Students/README_EN.md

@@ -194,6 +194,87 @@ func topStudents(positive_feedback []string, negative_feedback []string, report
 }
 ```
 
+### **TypeScript**
+
+```ts
+function topStudents(
+    positive_feedback: string[],
+    negative_feedback: string[],
+    report: string[],
+    student_id: number[],
+    k: number,
+): number[] {
+    const n = student_id.length;
+    const map = new Map<number, number>();
+    const ps = new Set(positive_feedback);
+    const ns = new Set(negative_feedback);
+    for (let i = 0; i < n; i++) {
+        map.set(
+            student_id[i],
+            report[i].split(' ').reduce((r, s) => {
+                if (ps.has(s)) {
+                    return r + 3;
+                }
+                if (ns.has(s)) {
+                    return r - 1;
+                }
+                return r;
+            }, 0),
+        );
+    }
+    return [...map.entries()]
+        .sort((a, b) => {
+            if (a[1] === b[1]) {
+                return a[0] - b[0];
+            }
+            return b[1] - a[1];
+        })
+        .map(v => v[0])
+        .slice(0, k);
+}
+```
+
+### **Rust**
+
+```rust
+use std::collections::{HashMap, HashSet};
+impl Solution {
+    pub fn top_students(
+        positive_feedback: Vec<String>,
+        negative_feedback: Vec<String>,
+        report: Vec<String>,
+        student_id: Vec<i32>,
+        k: i32,
+    ) -> Vec<i32> {
+        let n = student_id.len();
+        let ps = positive_feedback.iter().collect::<HashSet<&String>>();
+        let ns = negative_feedback.iter().collect::<HashSet<&String>>();
+        let mut map = HashMap::new();
+        for i in 0..n {
+            let id = student_id[i];
+            let mut count = 0;
+            for s in report[i].split(' ') {
+                let s = &s.to_string();
+                if ps.contains(s) {
+                    count += 3;
+                } else if ns.contains(s) {
+                    count -= 1;
+                }
+            }
+            map.insert(id, count);
+        }
+        let mut t = map.into_iter().collect::<Vec<(i32, i32)>>();
+        t.sort_by(|a, b| {
+            if a.1 == b.1 {
+                return a.0.cmp(&b.0);
+            }
+            b.1.cmp(&a.1)
+        });
+        t.iter().map(|v| v.0).collect::<Vec<i32>>()[0..k as usize].to_vec()
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2512.Reward Top K Students/Solution.rs

@@ -0,0 +1,36 @@
+use std::collections::{HashMap, HashSet};
+impl Solution {
+    pub fn top_students(
+        positive_feedback: Vec<String>,
+        negative_feedback: Vec<String>,
+        report: Vec<String>,
+        student_id: Vec<i32>,
+        k: i32,
+    ) -> Vec<i32> {
+        let n = student_id.len();
+        let ps = positive_feedback.iter().collect::<HashSet<&String>>();
+        let ns = negative_feedback.iter().collect::<HashSet<&String>>();
+        let mut map = HashMap::new();
+        for i in 0..n {
+            let id = student_id[i];
+            let mut count = 0;
+            for s in report[i].split(' ') {
+                let s = &s.to_string();
+                if ps.contains(s) {
+                    count += 3;
+                } else if ns.contains(s) {
+                    count -= 1;
+                }
+            }
+            map.insert(id, count);
+        }
+        let mut t = map.into_iter().collect::<Vec<(i32, i32)>>();
+        t.sort_by(|a, b| {
+            if a.1 == b.1 {
+                return a.0.cmp(&b.0);
+            }
+            b.1.cmp(&a.1)
+        });
+        t.iter().map(|v| v.0).collect::<Vec<i32>>()[0..k as usize].to_vec()
+    }
+}

solution/2500-2599/2512.Reward Top K Students/Solution.ts

@@ -0,0 +1,35 @@
+function topStudents(
+    positive_feedback: string[],
+    negative_feedback: string[],
+    report: string[],
+    student_id: number[],
+    k: number,
+): number[] {
+    const n = student_id.length;
+    const map = new Map<number, number>();
+    const ps = new Set(positive_feedback);
+    const ns = new Set(negative_feedback);
+    for (let i = 0; i < n; i++) {
+        map.set(
+            student_id[i],
+            report[i].split(' ').reduce((r, s) => {
+                if (ps.has(s)) {
+                    return r + 3;
+                }
+                if (ns.has(s)) {
+                    return r - 1;
+                }
+                return r;
+            }, 0),
+        );
+    }
+    return [...map.entries()]
+        .sort((a, b) => {
+            if (a[1] === b[1]) {
+                return a[0] - b[0];
+            }
+            return b[1] - a[1];
+        })
+        .map(v => v[0])
+        .slice(0, k);
+}