feat: add solutions to lc problems: No.2490, 2491

- No.2490.Circular Sentence
- No.2491.Divide Players Into Teams of Equal Skill

Author: YangFong

solution/2400-2499/2490.Circular Sentence/README.md

@@ -153,7 +153,7 @@ func isCircularSentence(sentence string) bool {
 ### **JavaScript**
 
 ```js
-var isCircularSentence = function(sentence) {
+var isCircularSentence = function (sentence) {
     const words = sentence.split(' ');
     const post = words[0].charCodeAt(0);
     let prev = words[0].charCodeAt(words[0].length - 1);
@@ -169,6 +169,45 @@ var isCircularSentence = function(sentence) {
 };
 ```
 
+### **TypeScript**
+
+```ts
+function isCircularSentence(sentence: string): boolean {
+    const ss = sentence.split(' ');
+    const n = ss.length;
+    if (ss[0][0] !== ss[n - 1][ss[n - 1].length - 1]) {
+        return false;
+    }
+    for (let i = 0; i < n - 1; i++) {
+        if (ss[i][ss[i].length - 1] !== ss[i + 1][0]) {
+            return false;
+        }
+    }
+    return true;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn is_circular_sentence(sentence: String) -> bool {
+        let ss: Vec<String> = sentence.split(' ').map(String::from).collect();
+        let n = ss.len();
+        if ss[0].as_bytes()[0] != ss[n - 1].as_bytes()[ss[n - 1].len() - 1] {
+            return false;
+        }
+        for i in 1..n {
+            if ss[i - 1].as_bytes()[ss[i - 1].len() - 1] != ss[i].as_bytes()[0] {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
+
 ### **...**
 
 ```

solution/2400-2499/2490.Circular Sentence/README_EN.md

@@ -137,7 +137,7 @@ func isCircularSentence(sentence string) bool {
 ### **JavaScript**
 
 ```js
-var isCircularSentence = function(sentence) {
+var isCircularSentence = function (sentence) {
     const words = sentence.split(' ');
     const post = words[0].charCodeAt(0);
     let prev = words[0].charCodeAt(words[0].length - 1);
@@ -153,6 +153,44 @@ var isCircularSentence = function(sentence) {
 };
 ```
 
+### **TypeScript**
+
+```ts
+function isCircularSentence(sentence: string): boolean {
+    const ss = sentence.split(' ');
+    const n = ss.length;
+    if (ss[0][0] !== ss[n - 1][ss[n - 1].length - 1]) {
+        return false;
+    }
+    for (let i = 0; i < n - 1; i++) {
+        if (ss[i][ss[i].length - 1] !== ss[i + 1][0]) {
+            return false;
+        }
+    }
+    return true;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn is_circular_sentence(sentence: String) -> bool {
+        let ss: Vec<String> = sentence.split(' ').map(String::from).collect();
+        let n = ss.len();
+        if ss[0].as_bytes()[0] != ss[n - 1].as_bytes()[ss[n - 1].len() - 1] {
+            return false;
+        }
+        for i in 1..n {
+            if ss[i - 1].as_bytes()[ss[i - 1].len() - 1] != ss[i].as_bytes()[0] {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2400-2499/2490.Circular Sentence/Solution.rs

@@ -0,0 +1,15 @@
+impl Solution {
+    pub fn is_circular_sentence(sentence: String) -> bool {
+        let ss: Vec<String> = sentence.split(' ').map(String::from).collect();
+        let n = ss.len();
+        if ss[0].as_bytes()[0] != ss[n - 1].as_bytes()[ss[n - 1].len() - 1] {
+            return false;
+        }
+        for i in 1..n {
+            if ss[i - 1].as_bytes()[ss[i - 1].len() - 1] != ss[i].as_bytes()[0] {
+                return false;
+            }
+        }
+        return true;
+    }
+}

solution/2400-2499/2490.Circular Sentence/Solution.ts

@@ -0,0 +1,13 @@
+function isCircularSentence(sentence: string): boolean {
+    const ss = sentence.split(' ');
+    const n = ss.length;
+    if (ss[0][0] !== ss[n - 1][ss[n - 1].length - 1]) {
+        return false;
+    }
+    for (let i = 0; i < n - 1; i++) {
+        if (ss[i][ss[i].length - 1] !== ss[i + 1][0]) {
+            return false;
+        }
+    }
+    return true;
+}

solution/2400-2499/2491.Divide Players Into Teams of Equal Skill/README.md

@@ -163,6 +163,44 @@ var dividePlayers = function(skill) {
 };
 ```
 
+### **TypeScript**
+
+```ts
+function dividePlayers(skill: number[]): number {
+    const n = skill.length;
+    skill.sort((a, b) => a - b);
+    const target = skill[0] + skill[n - 1];
+    let ans = 0;
+    for (let i = 0; i < n >> 1; i++) {
+        if (target !== skill[i] + skill[n - 1 - i]) {
+            return -1;
+        }
+        ans += skill[i] * skill[n - 1 - i];
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn divide_players(mut skill: Vec<i32>) -> i64 {
+        let n = skill.len();
+        skill.sort();
+        let target = skill[0] + skill[n - 1];
+        let mut ans = 0;
+        for i in 0..n >> 1 {
+            if skill[i] + skill[n - 1 - i] != target {
+                return -1;
+            }
+            ans += (skill[i] * skill[n - 1 - i]) as i64;
+        }
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2400-2499/2491.Divide Players Into Teams of Equal Skill/README_EN.md

@@ -143,6 +143,44 @@ var dividePlayers = function(skill) {
 };
 ```
 
+### **TypeScript**
+
+```ts
+function dividePlayers(skill: number[]): number {
+    const n = skill.length;
+    skill.sort((a, b) => a - b);
+    const target = skill[0] + skill[n - 1];
+    let ans = 0;
+    for (let i = 0; i < n >> 1; i++) {
+        if (target !== skill[i] + skill[n - 1 - i]) {
+            return -1;
+        }
+        ans += skill[i] * skill[n - 1 - i];
+    }
+    return ans;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn divide_players(mut skill: Vec<i32>) -> i64 {
+        let n = skill.len();
+        skill.sort();
+        let target = skill[0] + skill[n - 1];
+        let mut ans = 0;
+        for i in 0..n >> 1 {
+            if skill[i] + skill[n - 1 - i] != target {
+                return -1;
+            }
+            ans += (skill[i] * skill[n - 1 - i]) as i64;
+        }
+        ans
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2400-2499/2491.Divide Players Into Teams of Equal Skill/Solution.rs

@@ -0,0 +1,15 @@
+impl Solution {
+    pub fn divide_players(mut skill: Vec<i32>) -> i64 {
+        let n = skill.len();
+        skill.sort();
+        let target = skill[0] + skill[n - 1];
+        let mut ans = 0;
+        for i in 0..n >> 1 {
+            if skill[i] + skill[n - 1 - i] != target {
+                return -1;
+            }
+            ans += (skill[i] * skill[n - 1 - i]) as i64;
+        }
+        ans
+    }
+}

solution/2400-2499/2491.Divide Players Into Teams of Equal Skill/Solution.ts

@@ -0,0 +1,13 @@
+function dividePlayers(skill: number[]): number {
+    const n = skill.length;
+    skill.sort((a, b) => a - b);
+    const target = skill[0] + skill[n - 1];
+    let ans = 0;
+    for (let i = 0; i < n >> 1; i++) {
+        if (target !== skill[i] + skill[n - 1 - i]) {
+            return -1;
+        }
+        ans += skill[i] * skill[n - 1 - i];
+    }
+    return ans;
+}