feat: add ts solution to lc problems: No.2325~2328

    * No.2325.Decode the Message
    * No.2326.Spiral Matrix IV
    * No.2327.Number of People Aware of a Secret
    * No.2328.Number of Increasing Paths in a Grid

Author: zhaocchen

solution/2300-2399/2325.Decode the Message/README.md

@@ -154,7 +154,22 @@ func decodeMessage(key string, message string) string {
 ### **TypeScript**
 
 ```ts
-
+function decodeMessage(key: string, message: string): string {
+    let decodeMap = new Map();
+    const m = key.length, n = 26;
+    for (let i = 0, j = 0; i < m; i++) {
+        let char = key.charAt(i);
+        if (char != ' ' && !decodeMap.has(char)) {
+            decodeMap.set(char, String.fromCharCode(j + 97));
+            j++;
+        }
+    }
+    let ans = [];
+    for (let char of message) {
+        ans.push(char == ' ' ? ' ' : decodeMap.get(char));
+    }
+    return ans.join('');
+};
 ```
 
 ### **...**

solution/2300-2399/2325.Decode the Message/README_EN.md

@@ -140,7 +140,22 @@ func decodeMessage(key string, message string) string {
 ### **TypeScript**
 
 ```ts
-
+function decodeMessage(key: string, message: string): string {
+    let decodeMap = new Map();
+    const m = key.length, n = 26;
+    for (let i = 0, j = 0; i < m; i++) {
+        let char = key.charAt(i);
+        if (char != ' ' && !decodeMap.has(char)) {
+            decodeMap.set(char, String.fromCharCode(j + 97));
+            j++;
+        }
+    }
+    let ans = [];
+    for (let char of message) {
+        ans.push(char == ' ' ? ' ' : decodeMap.get(char));
+    }
+    return ans.join('');
+};
 ```
 
 ### **...**

solution/2300-2399/2325.Decode the Message/Solution.ts

@@ -0,0 +1,16 @@
+function decodeMessage(key: string, message: string): string {
+    let decodeMap = new Map();
+    const m = key.length, n = 26;
+    for (let i = 0, j = 0; i < m; i++) {
+        let char = key.charAt(i);
+        if (char != ' ' && !decodeMap.has(char)) {
+            decodeMap.set(char, String.fromCharCode(j + 97));
+            j++;
+        }
+    }
+    let ans = [];
+    for (let char of message) {
+        ans.push(char == ' ' ? ' ' : decodeMap.get(char));
+    }
+    return ans.join('');
+};

solution/2300-2399/2326.Spiral Matrix IV/README.md

@@ -206,7 +206,35 @@ func spiralMatrix(m int, n int, head *ListNode) [][]int {
 ### **TypeScript**
 
 ```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
 
+ function spiralMatrix(m: number, n: number, head: ListNode | null): number[][] {
+    const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]];
+    let ans = Array.from({ length: m }, v => new Array(n).fill(-1));
+    let i = 0, j = 0, k = 0;
+    while (head) {
+        ans[i][j] = head.val;
+        head = head.next;
+        let x = i + dirs[k][0];
+        let y = j + dirs[k][1];
+        if (x < 0 || x > m - 1 || y < 0 || y > n - 1 || ans[x][y] != -1) {
+            k = (k + 1) % 4;
+        }
+        i = i + dirs[k][0];
+        j = j + dirs[k][1];
+    }
+    return ans;
+};
 ```
 
 ### **...**

solution/2300-2399/2326.Spiral Matrix IV/README_EN.md

@@ -198,7 +198,35 @@ func spiralMatrix(m int, n int, head *ListNode) [][]int {
 ### **TypeScript**
 
 ```ts
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
 
+ function spiralMatrix(m: number, n: number, head: ListNode | null): number[][] {
+    const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]];
+    let ans = Array.from({ length: m }, v => new Array(n).fill(-1));
+    let i = 0, j = 0, k = 0;
+    while (head) {
+        ans[i][j] = head.val;
+        head = head.next;
+        let x = i + dirs[k][0];
+        let y = j + dirs[k][1];
+        if (x < 0 || x > m - 1 || y < 0 || y > n - 1 || ans[x][y] != -1) {
+            k = (k + 1) % 4;
+        }
+        i = i + dirs[k][0];
+        j = j + dirs[k][1];
+    }
+    return ans;
+};
 ```
 
 ### **...**

solution/2300-2399/2326.Spiral Matrix IV/Solution.ts

@@ -0,0 +1,29 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *     val: number
+ *     next: ListNode | null
+ *     constructor(val?: number, next?: ListNode | null) {
+ *         this.val = (val===undefined ? 0 : val)
+ *         this.next = (next===undefined ? null : next)
+ *     }
+ * }
+ */
+
+ function spiralMatrix(m: number, n: number, head: ListNode | null): number[][] {
+    const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]];
+    let ans = Array.from({ length: m }, v => new Array(n).fill(-1));
+    let i = 0, j = 0, k = 0;
+    while (head) {
+        ans[i][j] = head.val;
+        head = head.next;
+        let x = i + dirs[k][0];
+        let y = j + dirs[k][1];
+        if (x < 0 || x > m - 1 || y < 0 || y > n - 1 || ans[x][y] != -1) {
+            k = (k + 1) % 4;
+        }
+        i = i + dirs[k][0];
+        j = j + dirs[k][1];
+    }
+    return ans;
+};

solution/2300-2399/2327.Number of People Aware of a Secret/README.md

@@ -176,7 +176,27 @@ func peopleAwareOfSecret(n int, delay int, forget int) int {
 ### **TypeScript**
 
 ```ts
-
+function peopleAwareOfSecret(n: number, delay: number, forget: number): number {
+    let dp = new Array(n + 1).fill(0n);
+    dp[1] = 1n;
+    for (let i = 2; i <= n; i++) {
+        let pre = 0n;
+        for (let j = i - forget + 1; j <= i - delay; j++) {
+            if (j > 0) {
+                pre += dp[j];
+            }
+        }
+        dp[i] = pre;
+    }
+    let pre = 0n;
+    let i = n + 1;
+    for (let j = i - forget; j < i; j++) {
+        if (j > 0) {
+            pre += dp[j];
+        }
+    }
+    return Number(pre % BigInt(10 ** 9 + 7));
+};
 ```
 
 ### **...**

solution/2300-2399/2327.Number of People Aware of a Secret/README_EN.md

@@ -164,7 +164,27 @@ func peopleAwareOfSecret(n int, delay int, forget int) int {
 ### **TypeScript**
 
 ```ts
-
+function peopleAwareOfSecret(n: number, delay: number, forget: number): number {
+    let dp = new Array(n + 1).fill(0n);
+    dp[1] = 1n;
+    for (let i = 2; i <= n; i++) {
+        let pre = 0n;
+        for (let j = i - forget + 1; j <= i - delay; j++) {
+            if (j > 0) {
+                pre += dp[j];
+            }
+        }
+        dp[i] = pre;
+    }
+    let pre = 0n;
+    let i = n + 1;
+    for (let j = i - forget; j < i; j++) {
+        if (j > 0) {
+            pre += dp[j];
+        }
+    }
+    return Number(pre % BigInt(10 ** 9 + 7));
+};
 ```
 
 ### **...**

solution/2300-2399/2327.Number of People Aware of a Secret/Solution.ts

@@ -0,0 +1,21 @@
+function peopleAwareOfSecret(n: number, delay: number, forget: number): number {
+    let dp = new Array(n + 1).fill(0n);
+    dp[1] = 1n;
+    for (let i = 2; i <= n; i++) {
+        let pre = 0n;
+        for (let j = i - forget + 1; j <= i - delay; j++) {
+            if (j > 0) {
+                pre += dp[j];
+            }
+        }
+        dp[i] = pre;
+    }
+    let pre = 0n;
+    let i = n + 1;
+    for (let j = i - forget; j < i; j++) {
+        if (j > 0) {
+            pre += dp[j];
+        }
+    }
+    return Number(pre % BigInt(10 ** 9 + 7));
+};

solution/2300-2399/2328.Number of Increasing Paths in a Grid/README.md

@@ -198,7 +198,32 @@ func countPaths(grid [][]int) int {
 ### **TypeScript**
 
 ```ts
+function countPaths(grid: number[][]): number {
+    const mod = BigInt(10 ** 9 + 7);
+    const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]];
+    const m = grid.length, n = grid[0].length;
+    const dp = Array.from({ length: m }, v => new Array(n).fill(-1n));
+
+    function dfs (x, y) {
+        if (dp[x][y] != -1) return dp[x][y];
+        let count = 1n;
+        for (let [dx, dy] of dirs) {
+            let i = x + dx, j = y + dy;
+            if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] <= grid[x][y]) continue;
+            count = (count + dfs(i, j)) % mod;
+        }
+        dp[x][y] = count;
+        return count;
+    }
 
+    let sum = 0n;
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            sum = (sum + dfs(i, j)) % mod;
+        }
+    }
+    return Number(sum);
+};
 ```
 
 ### **...**

solution/2300-2399/2328.Number of Increasing Paths in a Grid/README_EN.md

@@ -184,7 +184,32 @@ func countPaths(grid [][]int) int {
 ### **TypeScript**
 
 ```ts
+function countPaths(grid: number[][]): number {
+    const mod = BigInt(10 ** 9 + 7);
+    const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]];
+    const m = grid.length, n = grid[0].length;
+    const dp = Array.from({ length: m }, v => new Array(n).fill(-1n));
+
+    function dfs (x, y) {
+        if (dp[x][y] != -1) return dp[x][y];
+        let count = 1n;
+        for (let [dx, dy] of dirs) {
+            let i = x + dx, j = y + dy;
+            if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] <= grid[x][y]) continue;
+            count = (count + dfs(i, j)) % mod;
+        }
+        dp[x][y] = count;
+        return count;
+    }
 
+    let sum = 0n;
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            sum = (sum + dfs(i, j)) % mod;
+        }
+    }
+    return Number(sum);
+};
 ```
 
 ### **...**

solution/2300-2399/2328.Number of Increasing Paths in a Grid/Solution.ts

@@ -0,0 +1,26 @@
+function countPaths(grid: number[][]): number {
+    const mod = BigInt(10 ** 9 + 7);
+    const dirs = [[0, 1], [1, 0], [0, -1], [-1, 0]];
+    const m = grid.length, n = grid[0].length;
+    const dp = Array.from({ length: m }, v => new Array(n).fill(-1n));
+
+    function dfs (x, y) {
+        if (dp[x][y] != -1) return dp[x][y];
+        let count = 1n;
+        for (let [dx, dy] of dirs) {
+            let i = x + dx, j = y + dy;
+            if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] <= grid[x][y]) continue;
+            count = (count + dfs(i, j)) % mod;
+        }
+        dp[x][y] = count;
+        return count;
+    }
+
+    let sum = 0n;
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            sum = (sum + dfs(i, j)) % mod;
+        }
+    }
+    return Number(sum);
+};