feat: add solutions to lc problems: No.2578,2579,2582,2583

solution/2500-2599/2578.Split With Minimum Sum/README.md

@@ -216,6 +216,40 @@ func splitNum(num int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function splitNum(num: number): number {
+    const cnt = new Array(10).fill(0);
+    let n = 0;
+    for (; num > 0; num = Math.floor(num / 10)) {
+        ++cnt[num % 10];
+        ++n;
+    }
+    const ans = new Array(2).fill(0);
+    for (let i = 0, j = 0; i < n; ++i) {
+        while (cnt[j] === 0) {
+            ++j;
+        }
+        --cnt[j];
+        ans[i & 1] = ans[i & 1] * 10 + j;
+    }
+    return ans[0] + ans[1];
+}
+```
+
+```ts
+function splitNum(num: number): number {
+    const s: string[] = String(num).split('');
+    s.sort();
+    const ans: number[] = new Array(2).fill(0);
+    for (let i = 0; i < s.length; ++i) {
+        ans[i & 1] = ans[i & 1] * 10 + Number(s[i]);
+    }
+    return ans[0] + ans[1];
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2578.Split With Minimum Sum/README_EN.md

@@ -192,6 +192,40 @@ func splitNum(num int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function splitNum(num: number): number {
+    const cnt = new Array(10).fill(0);
+    let n = 0;
+    for (; num > 0; num = Math.floor(num / 10)) {
+        ++cnt[num % 10];
+        ++n;
+    }
+    const ans = new Array(2).fill(0);
+    for (let i = 0, j = 0; i < n; ++i) {
+        while (cnt[j] === 0) {
+            ++j;
+        }
+        --cnt[j];
+        ans[i & 1] = ans[i & 1] * 10 + j;
+    }
+    return ans[0] + ans[1];
+}
+```
+
+```ts
+function splitNum(num: number): number {
+    const s: string[] = String(num).split('');
+    s.sort();
+    const ans: number[] = new Array(2).fill(0);
+    for (let i = 0; i < s.length; ++i) {
+        ans[i & 1] = ans[i & 1] * 10 + Number(s[i]);
+    }
+    return ans[0] + ans[1];
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2578.Split With Minimum Sum/Solution.ts

@@ -0,0 +1,17 @@
+function splitNum(num: number): number {
+    const cnt = new Array(10).fill(0);
+    let n = 0;
+    for (; num > 0; num = Math.floor(num / 10)) {
+        ++cnt[num % 10];
+        ++n;
+    }
+    const ans = new Array(2).fill(0);
+    for (let i = 0, j = 0; i < n; ++i) {
+        while (cnt[j] === 0) {
+            ++j;
+        }
+        --cnt[j];
+        ans[i & 1] = ans[i & 1] * 10 + j;
+    }
+    return ans[0] + ans[1];
+}

solution/2500-2599/2579.Count Total Number of Colored Cells/README.md

@@ -94,6 +94,14 @@ func coloredCells(n int) int64 {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function coloredCells(n: number): number {
+    return 2 * n * (n - 1) + 1;
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2579.Count Total Number of Colored Cells/README_EN.md

@@ -80,6 +80,14 @@ func coloredCells(n int) int64 {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function coloredCells(n: number): number {
+    return 2 * n * (n - 1) + 1;
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2579.Count Total Number of Colored Cells/Solution.ts

@@ -0,0 +1,3 @@
+function coloredCells(n: number): number {
+    return 2 * n * (n - 1) + 1;
+}

solution/2500-2599/2582.Pass the Pillow/README.md

@@ -173,6 +173,30 @@ func passThePillow(n int, time int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function passThePillow(n: number, time: number): number {
+    let ans = 1,
+        k = 1;
+    while (time-- > 0) {
+        ans += k;
+        if (ans === 1 || ans === n) {
+            k *= -1;
+        }
+    }
+    return ans;
+}
+```
+
+```ts
+function passThePillow(n: number, time: number): number {
+    const k = time / (n - 1);
+    const mod = time % (n - 1);
+    return (k & 1) == 1 ? n - mod : mod + 1;
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2582.Pass the Pillow/README_EN.md

@@ -143,6 +143,30 @@ func passThePillow(n int, time int) int {
 }
 ```
 
+### **TypeScript**
+
+```ts
+function passThePillow(n: number, time: number): number {
+    let ans = 1,
+        k = 1;
+    while (time-- > 0) {
+        ans += k;
+        if (ans === 1 || ans === n) {
+            k *= -1;
+        }
+    }
+    return ans;
+}
+```
+
+```ts
+function passThePillow(n: number, time: number): number {
+    const k = time / (n - 1);
+    const mod = time % (n - 1);
+    return (k & 1) == 1 ? n - mod : mod + 1;
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2582.Pass the Pillow/Solution.ts

@@ -0,0 +1,5 @@
+function passThePillow(n: number, time: number): number {
+    const k = time / (n - 1);
+    const mod = time % (n - 1);
+    return (k & 1) == 1 ? n - mod : mod + 1;
+}

solution/2500-2599/2583.Kth Largest Sum in a Binary Tree/README.md

@@ -361,6 +361,85 @@ func kthLargestLevelSum(root *TreeNode, k int) int64 {
 }
 ```
 
+### **TypeScript**
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function kthLargestLevelSum(root: TreeNode | null, k: number): number {
+    const arr: number[] = [];
+    const q = [root];
+    while (q.length) {
+        let t = 0;
+        for (let n = q.length; n > 0; --n) {
+            root = q.shift();
+            t += root.val;
+            if (root.left) {
+                q.push(root.left);
+            }
+            if (root.right) {
+                q.push(root.right);
+            }
+        }
+        arr.push(t);
+    }
+    if (arr.length < k) {
+        return -1;
+    }
+    arr.sort((a, b) => b - a);
+    return arr[k - 1];
+}
+```
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function kthLargestLevelSum(root: TreeNode | null, k: number): number {
+    const dfs = (root: TreeNode, d: number) => {
+        if (!root) {
+            return;
+        }
+        if (arr.length <= d) {
+            arr.push(0);
+        }
+        arr[d] += root.val;
+        dfs(root.left, d + 1);
+        dfs(root.right, d + 1);
+    };
+    const arr: number[] = [];
+    dfs(root, 0);
+    if (arr.length < k) {
+        return -1;
+    }
+    arr.sort((a, b) => b - a);
+    return arr[k - 1];
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2583.Kth Largest Sum in a Binary Tree/README_EN.md

@@ -335,6 +335,85 @@ func kthLargestLevelSum(root *TreeNode, k int) int64 {
 }
 ```
 
+### **TypeScript**
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function kthLargestLevelSum(root: TreeNode | null, k: number): number {
+    const arr: number[] = [];
+    const q = [root];
+    while (q.length) {
+        let t = 0;
+        for (let n = q.length; n > 0; --n) {
+            root = q.shift();
+            t += root.val;
+            if (root.left) {
+                q.push(root.left);
+            }
+            if (root.right) {
+                q.push(root.right);
+            }
+        }
+        arr.push(t);
+    }
+    if (arr.length < k) {
+        return -1;
+    }
+    arr.sort((a, b) => b - a);
+    return arr[k - 1];
+}
+```
+
+```ts
+/**
+ * Definition for a binary tree node.
+ * class TreeNode {
+ *     val: number
+ *     left: TreeNode | null
+ *     right: TreeNode | null
+ *     constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.left = (left===undefined ? null : left)
+ *         this.right = (right===undefined ? null : right)
+ *     }
+ * }
+ */
+
+function kthLargestLevelSum(root: TreeNode | null, k: number): number {
+    const dfs = (root: TreeNode, d: number) => {
+        if (!root) {
+            return;
+        }
+        if (arr.length <= d) {
+            arr.push(0);
+        }
+        arr[d] += root.val;
+        dfs(root.left, d + 1);
+        dfs(root.right, d + 1);
+    };
+    const arr: number[] = [];
+    dfs(root, 0);
+    if (arr.length < k) {
+        return -1;
+    }
+    arr.sort((a, b) => b - a);
+    return arr[k - 1];
+}
+```
+
 ### **...**
 
 ```