feat: add solutions to lc problems: No.2609~2611

* No.2609.Find the Longest Balanced Substring of a Binary String
* No.2610.Convert an Array Into a 2D Array With Conditions
* No.2611.Mice and Cheese

Author: yanglbme

solution/2600-2699/2609.Find the Longest Balanced Substring of a Binary String/README.md

@@ -204,7 +204,7 @@ class Solution {
 public:
     int findTheLongestBalancedSubstring(string s) {
         int zero = 0, one = 0;
-        int ans = 0, n = s.size();
+        int ans = 0;
         for (char& c : s) {
             if (c == '0') {
                 if (one > 0) {
@@ -287,6 +287,54 @@ func min(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findTheLongestBalancedSubstring(s: string): number {
+    const n = s.length;
+    let ans = 0;
+    const check = (i: number, j: number): boolean => {
+        let cnt = 0;
+        for (let k = i; k <= j; ++k) {
+            if (s[k] === '1') {
+                ++cnt;
+            } else if (cnt > 0) {
+                return false;
+            }
+        }
+        return cnt * 2 === j - i + 1;
+    };
+    for (let i = 0; i < n; ++i) {
+        for (let j = i + 1; j < n; j += 2) {
+            if (check(i, j)) {
+                ans = Math.max(ans, j - i + 1);
+            }
+        }
+    }
+    return ans;
+}
+```
+
+```ts
+function findTheLongestBalancedSubstring(s: string): number {
+    let zero = 0;
+    let one = 0;
+    let ans = 0;
+    for (const c of s) {
+        if (c === '0') {
+            if (one > 0) {
+                zero = 0;
+                one = 0;
+            }
+            ++zero;
+        } else {
+            ans = Math.max(ans, 2 * Math.min(zero, ++one));
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2609.Find the Longest Balanced Substring of a Binary String/README_EN.md

@@ -175,7 +175,7 @@ class Solution {
 public:
     int findTheLongestBalancedSubstring(string s) {
         int zero = 0, one = 0;
-        int ans = 0, n = s.size();
+        int ans = 0;
         for (char& c : s) {
             if (c == '0') {
                 if (one > 0) {
@@ -258,6 +258,54 @@ func min(a, b int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findTheLongestBalancedSubstring(s: string): number {
+    const n = s.length;
+    let ans = 0;
+    const check = (i: number, j: number): boolean => {
+        let cnt = 0;
+        for (let k = i; k <= j; ++k) {
+            if (s[k] === '1') {
+                ++cnt;
+            } else if (cnt > 0) {
+                return false;
+            }
+        }
+        return cnt * 2 === j - i + 1;
+    };
+    for (let i = 0; i < n; ++i) {
+        for (let j = i + 1; j < n; j += 2) {
+            if (check(i, j)) {
+                ans = Math.max(ans, j - i + 1);
+            }
+        }
+    }
+    return ans;
+}
+```
+
+```ts
+function findTheLongestBalancedSubstring(s: string): number {
+    let zero = 0;
+    let one = 0;
+    let ans = 0;
+    for (const c of s) {
+        if (c === '0') {
+            if (one > 0) {
+                zero = 0;
+                one = 0;
+            }
+            ++zero;
+        } else {
+            ans = Math.max(ans, 2 * Math.min(zero, ++one));
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2609.Find the Longest Balanced Substring of a Binary String/Solution.cpp

@@ -2,7 +2,7 @@ class Solution {
 public:
     int findTheLongestBalancedSubstring(string s) {
         int zero = 0, one = 0;
-        int ans = 0, n = s.size();
+        int ans = 0;
         for (char& c : s) {
             if (c == '0') {
                 if (one > 0) {

solution/2600-2699/2609.Find the Longest Balanced Substring of a Binary String/Solution.ts

@@ -0,0 +1,17 @@
+function findTheLongestBalancedSubstring(s: string): number {
+    let zero = 0;
+    let one = 0;
+    let ans = 0;
+    for (const c of s) {
+        if (c === '0') {
+            if (one > 0) {
+                zero = 0;
+                one = 0;
+            }
+            ++zero;
+        } else {
+            ans = Math.max(ans, 2 * Math.min(zero, ++one));
+        }
+    }
+    return ans;
+}

solution/2600-2699/2610.Convert an Array Into a 2D Array With Conditions/README.md

@@ -154,6 +154,28 @@ func findMatrix(nums []int) (ans [][]int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findMatrix(nums: number[]): number[][] {
+    const ans: number[][] = [];
+    const n = nums.length;
+    const cnt: number[] = new Array(n + 1).fill(0);
+    for (const x of nums) {
+        ++cnt[x];
+    }
+    for (let x = 1; x <= n; ++x) {
+        for (let j = 0; j < cnt[x]; ++j) {
+            if (ans.length <= j) {
+                ans.push([]);
+            }
+            ans[j].push(x);
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2610.Convert an Array Into a 2D Array With Conditions/README_EN.md

@@ -136,6 +136,28 @@ func findMatrix(nums []int) (ans [][]int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function findMatrix(nums: number[]): number[][] {
+    const ans: number[][] = [];
+    const n = nums.length;
+    const cnt: number[] = new Array(n + 1).fill(0);
+    for (const x of nums) {
+        ++cnt[x];
+    }
+    for (let x = 1; x <= n; ++x) {
+        for (let j = 0; j < cnt[x]; ++j) {
+            if (ans.length <= j) {
+                ans.push([]);
+            }
+            ans[j].push(x);
+        }
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2610.Convert an Array Into a 2D Array With Conditions/Solution.ts

@@ -0,0 +1,17 @@
+function findMatrix(nums: number[]): number[][] {
+    const ans: number[][] = [];
+    const n = nums.length;
+    const cnt: number[] = new Array(n + 1).fill(0);
+    for (const x of nums) {
+        ++cnt[x];
+    }
+    for (let x = 1; x <= n; ++x) {
+        for (let j = 0; j < cnt[x]; ++j) {
+            if (ans.length <= j) {
+                ans.push([]);
+            }
+            ans[j].push(x);
+        }
+    }
+    return ans;
+}

solution/2600-2699/2611.Mice and Cheese/README.md

@@ -207,6 +207,48 @@ func miceAndCheese(reward1 []int, reward2 []int, k int) (ans int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function miceAndCheese(
+    reward1: number[],
+    reward2: number[],
+    k: number,
+): number {
+    const n = reward1.length;
+    const idx = Array.from({ length: n }, (_, i) => i);
+    idx.sort((i, j) => reward1[j] - reward2[j] - (reward1[i] - reward2[i]));
+    let ans = 0;
+    for (let i = 0; i < k; ++i) {
+        ans += reward1[idx[i]];
+    }
+    for (let i = k; i < n; ++i) {
+        ans += reward2[idx[i]];
+    }
+    return ans;
+}
+```
+
+```ts
+function miceAndCheese(
+    reward1: number[],
+    reward2: number[],
+    k: number,
+): number {
+    const n = reward1.length;
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        ans += reward2[i];
+        reward1[i] -= reward2[i];
+    }
+    reward1.sort((a, b) => b - a);
+    for (let i = 0; i < k; ++i) {
+        ans += reward1[i];
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2611.Mice and Cheese/README_EN.md

@@ -189,6 +189,48 @@ func miceAndCheese(reward1 []int, reward2 []int, k int) (ans int) {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function miceAndCheese(
+    reward1: number[],
+    reward2: number[],
+    k: number,
+): number {
+    const n = reward1.length;
+    const idx = Array.from({ length: n }, (_, i) => i);
+    idx.sort((i, j) => reward1[j] - reward2[j] - (reward1[i] - reward2[i]));
+    let ans = 0;
+    for (let i = 0; i < k; ++i) {
+        ans += reward1[idx[i]];
+    }
+    for (let i = k; i < n; ++i) {
+        ans += reward2[idx[i]];
+    }
+    return ans;
+}
+```
+
+```ts
+function miceAndCheese(
+    reward1: number[],
+    reward2: number[],
+    k: number,
+): number {
+    const n = reward1.length;
+    let ans = 0;
+    for (let i = 0; i < n; ++i) {
+        ans += reward2[i];
+        reward1[i] -= reward2[i];
+    }
+    reward1.sort((a, b) => b - a);
+    for (let i = 0; i < k; ++i) {
+        ans += reward1[i];
+    }
+    return ans;
+}
+```
+
 ### **...**
 
 ```

solution/2600-2699/2611.Mice and Cheese/Solution.ts

@@ -0,0 +1,17 @@
+function miceAndCheese(
+    reward1: number[],
+    reward2: number[],
+    k: number,
+): number {
+    const n = reward1.length;
+    const idx = Array.from({ length: n }, (_, i) => i);
+    idx.sort((i, j) => reward1[j] - reward2[j] - (reward1[i] - reward2[i]));
+    let ans = 0;
+    for (let i = 0; i < k; ++i) {
+        ans += reward1[idx[i]];
+    }
+    for (let i = k; i < n; ++i) {
+        ans += reward2[idx[i]];
+    }
+    return ans;
+}