feat: add solutions to lc problems: No.2544~2546

- No.2544.Alternating Digit Sum
- No.2545.Sort the Students by Their Kth Score
- No.2546.Apply Bitwise Operations to Make Strings Equal

Author: YangFong

solution/2500-2599/2544.Alternating Digit Sum/README.md

@@ -126,6 +126,53 @@ func alternateDigitSum(n int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function alternateDigitSum(n: number): number {
+    let ans = 0;
+    let sign = 1;
+    while (n) {
+        ans += (n % 10) * sign;
+        sign = -sign;
+        n = Math.floor(n / 10);
+    }
+    return ans * -sign;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn alternate_digit_sum(mut n: i32) -> i32 {
+        let mut ans = 0;
+        let mut sign = 1;
+        while n != 0 {
+            ans += (n % 10) * sign;
+            sign = -sign;
+            n /= 10;
+        }
+        ans * -sign
+    }
+}
+```
+
+### **C**
+
+```c
+int alternateDigitSum(int n) {
+    int ans = 0;
+    int sign = 1;
+    while (n) {
+        ans += (n % 10) * sign;
+        sign = -sign;
+        n /= 10;
+    }
+    return ans * -sign;
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2544.Alternating Digit Sum/README_EN.md

@@ -118,6 +118,53 @@ func alternateDigitSum(n int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function alternateDigitSum(n: number): number {
+    let ans = 0;
+    let sign = 1;
+    while (n) {
+        ans += (n % 10) * sign;
+        sign = -sign;
+        n = Math.floor(n / 10);
+    }
+    return ans * -sign;
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn alternate_digit_sum(mut n: i32) -> i32 {
+        let mut ans = 0;
+        let mut sign = 1;
+        while n != 0 {
+            ans += (n % 10) * sign;
+            sign = -sign;
+            n /= 10;
+        }
+        ans * -sign
+    }
+}
+```
+
+### **C**
+
+```c
+int alternateDigitSum(int n) {
+    int ans = 0;
+    int sign = 1;
+    while (n) {
+        ans += (n % 10) * sign;
+        sign = -sign;
+        n /= 10;
+    }
+    return ans * -sign;
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2544.Alternating Digit Sum/Solution.c

@@ -0,0 +1,10 @@
+int alternateDigitSum(int n) {
+    int ans = 0;
+    int sign = 1;
+    while (n) {
+        ans += (n % 10) * sign;
+        sign = -sign;
+        n /= 10;
+    }
+    return ans * -sign;
+}

solution/2500-2599/2544.Alternating Digit Sum/Solution.rs

@@ -0,0 +1,12 @@
+impl Solution {
+    pub fn alternate_digit_sum(mut n: i32) -> i32 {
+        let mut ans = 0;
+        let mut sign = 1;
+        while n != 0 {
+            ans += (n % 10) * sign;
+            sign = -sign;
+            n /= 10;
+        }
+        ans * -sign
+    }
+}

solution/2500-2599/2544.Alternating Digit Sum/Solution.ts

@@ -0,0 +1,10 @@
+function alternateDigitSum(n: number): number {
+    let ans = 0;
+    let sign = 1;
+    while (n) {
+        ans += (n % 10) * sign;
+        sign = -sign;
+        n = Math.floor(n / 10);
+    }
+    return ans * -sign;
+}

solution/2500-2599/2545.Sort the Students by Their Kth Score/README.md

@@ -108,6 +108,26 @@ func sortTheStudents(score [][]int, k int) [][]int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function sortTheStudents(score: number[][], k: number): number[][] {
+    return score.sort((a, b) => b[k] - a[k]);
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn sort_the_students(mut score: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
+        let k = k as usize;
+        score.sort_by(|a, b| b[k].cmp(&a[k]));
+        score
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2545.Sort the Students by Their Kth Score/README_EN.md

@@ -88,6 +88,26 @@ func sortTheStudents(score [][]int, k int) [][]int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function sortTheStudents(score: number[][], k: number): number[][] {
+    return score.sort((a, b) => b[k] - a[k]);
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn sort_the_students(mut score: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
+        let k = k as usize;
+        score.sort_by(|a, b| b[k].cmp(&a[k]));
+        score
+    }
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2545.Sort the Students by Their Kth Score/Solution.rs

@@ -0,0 +1,7 @@
+impl Solution {
+    pub fn sort_the_students(mut score: Vec<Vec<i32>>, k: i32) -> Vec<Vec<i32>> {
+        let k = k as usize;
+        score.sort_by(|a, b| b[k].cmp(&a[k]));
+        score
+    }
+}

solution/2500-2599/2545.Sort the Students by Their Kth Score/Solution.ts

@@ -0,0 +1,3 @@
+function sortTheStudents(score: number[][], k: number): number[][] {
+    return score.sort((a, b) => b[k] - a[k]);
+}

solution/2500-2599/2546.Apply Bitwise Operations to Make Strings Equal/README.md

@@ -101,6 +101,45 @@ func makeStringsEqual(s string, target string) bool {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function makeStringsEqual(s: string, target: string): boolean {
+    return s.includes('1') === target.includes('1');
+}
+```
+
+### **Rust**
+
+```rust
+impl Solution {
+    pub fn make_strings_equal(s: String, target: String) -> bool {
+        s.contains('1') == target.contains('1')
+    }
+}
+```
+
+### **C**
+
+```c
+bool makeStringsEqual(char *s, char *target) {
+    int count = 0;
+    for (int i = 0; s[i]; i++) {
+        if (s[i] == '1') {
+            count++;
+            break;
+        }
+    }
+    for (int i = 0; target[i]; i++) {
+        if (target[i] == '1') {
+            count++;
+            break;
+        }
+    }
+    return !(count & 1);
+}
+```
+
 ### **...**
 
 ```