feat: add ts solution to lc problems

- No.0636.Exclusive Time of Functions
- No.2367.Number of Arithmetic Triplets
- No.2368.Reachable Nodes With Restrictions
- No.2369.Check if There is a Valid Partition For The Array
- No.2370.Longest Ideal Subsequence

Author: YangFong

solution/0600-0699/0636.Exclusive Time of Functions/README.md

@@ -106,6 +106,36 @@
 
 ```
 
+### **TypeScript**
+
+```ts
+function exclusiveTime(n: number, logs: string[]): number[] {
+    const res = new Array(n).fill(0);
+    const stack: [number, number][] = [];
+
+    for (const log of logs) {
+        const t = log.split(':');
+        const [id, state, time] = [Number(t[0]), t[1], Number(t[2])];
+
+        if (state === 'start') {
+            if (stack.length !== 0) {
+                const pre = stack[stack.length - 1];
+                res[pre[0]] += time - pre[1];
+            }
+            stack.push([id, time]);
+        } else {
+            const pre = stack.pop();
+            res[pre[0]] += time - pre[1] + 1;
+            if (stack.length !== 0) {
+                stack[stack.length - 1][1] = time + 1;
+            }
+        }
+    }
+    
+    return res;
+}
+```
+
 ### **...**
 
 ```

solution/0600-0699/0636.Exclusive Time of Functions/README_EN.md

@@ -84,6 +84,36 @@ So function 0 spends 2 + 4 + 1 = 7 units of total time executing, and function 1
 
 ```
 
+### **TypeScript**
+
+```ts
+function exclusiveTime(n: number, logs: string[]): number[] {
+    const res = new Array(n).fill(0);
+    const stack: [number, number][] = [];
+
+    for (const log of logs) {
+        const t = log.split(':');
+        const [id, state, time] = [Number(t[0]), t[1], Number(t[2])];
+
+        if (state === 'start') {
+            if (stack.length !== 0) {
+                const pre = stack[stack.length - 1];
+                res[pre[0]] += time - pre[1];
+            }
+            stack.push([id, time]);
+        } else {
+            const pre = stack.pop();
+            res[pre[0]] += time - pre[1] + 1;
+            if (stack.length !== 0) {
+                stack[stack.length - 1][1] = time + 1;
+            }
+        }
+    }
+    
+    return res;
+}
+```
+
 ### **...**
 
 ```

solution/0600-0699/0636.Exclusive Time of Functions/Solution.ts

@@ -0,0 +1,25 @@
+function exclusiveTime(n: number, logs: string[]): number[] {
+    const res = new Array(n).fill(0);
+    const stack: [number, number][] = [];
+
+    for (const log of logs) {
+        const t = log.split(':');
+        const [id, state, time] = [Number(t[0]), t[1], Number(t[2])];
+
+        if (state === 'start') {
+            if (stack.length !== 0) {
+                const pre = stack[stack.length - 1];
+                res[pre[0]] += time - pre[1];
+            }
+            stack.push([id, time]);
+        } else {
+            const pre = stack.pop();
+            res[pre[0]] += time - pre[1] + 1;
+            if (stack.length !== 0) {
+                stack[stack.length - 1][1] = time + 1;
+            }
+        }
+    }
+    
+    return res;
+}

solution/2300-2399/2367.Number of Arithmetic Triplets/README.md

@@ -140,7 +140,23 @@ func arithmeticTriplets(nums []int, diff int) int {
 ### **TypeScript**
 
 ```ts
-
+function arithmeticTriplets(nums: number[], diff: number): number {
+    let res = 0;
+    const n = nums.length;
+    for (let i = 0; i < n - 2; i++) {
+        for (let j = i + 1; j < n - 1; j++) {
+            for (let k = j + 1; k < n; k++) {
+                if (nums[k] - nums[j] > diff) {
+                    break;
+                }
+                if (nums[j] - nums[i] === diff && nums[k] - nums[j] === diff) {
+                    res++;
+                }
+            }
+        }
+    }
+    return res;
+}
 ```
 
 ### **...**

solution/2300-2399/2367.Number of Arithmetic Triplets/README_EN.md

@@ -130,7 +130,23 @@ func arithmeticTriplets(nums []int, diff int) int {
 ### **TypeScript**
 
 ```ts
-
+function arithmeticTriplets(nums: number[], diff: number): number {
+    let res = 0;
+    const n = nums.length;
+    for (let i = 0; i < n - 2; i++) {
+        for (let j = i + 1; j < n - 1; j++) {
+            for (let k = j + 1; k < n; k++) {
+                if (nums[k] - nums[j] > diff) {
+                    break;
+                }
+                if (nums[j] - nums[i] === diff && nums[k] - nums[j] === diff) {
+                    res++;
+                }
+            }
+        }
+    }
+    return res;
+}
 ```
 
 ### **...**

solution/2300-2399/2367.Number of Arithmetic Triplets/Solution.ts

@@ -0,0 +1,17 @@
+function arithmeticTriplets(nums: number[], diff: number): number {
+    let res = 0;
+    const n = nums.length;
+    for (let i = 0; i < n - 2; i++) {
+        for (let j = i + 1; j < n - 1; j++) {
+            for (let k = j + 1; k < n; k++) {
+                if (nums[k] - nums[j] > diff) {
+                    break;
+                }
+                if (nums[j] - nums[i] === diff && nums[k] - nums[j] === diff) {
+                    res++;
+                }
+            }
+        }
+    }
+    return res;
+}

solution/2300-2399/2368.Reachable Nodes With Restrictions/README.md

@@ -193,7 +193,32 @@ func reachableNodes(n int, edges [][]int, restricted []int) int {
 ### **TypeScript**
 
 ```ts
+function reachableNodes(
+    n: number,
+    edges: number[][],
+    restricted: number[],
+): number {
+    let res = 0;
+    const vis = new Array(n).fill(false);
+    const map = new Map<number, number[]>();
+    for (const [start, end] of edges) {
+        map.set(start, [...(map.get(start) ?? []), end]);
+        map.set(end, [...(map.get(end) ?? []), start]);
+    }
+    const dfs = (cur: number) => {
+        if (restricted.includes(cur) || vis[cur]) {
+            return;
+        }
+        res++;
+        vis[cur] = true;
+        for (const item of map.get(cur) ?? []) {
+            dfs(item);
+        }
+    };
+    dfs(0);
 
+    return res;
+}
 ```
 
 ### **...**

solution/2300-2399/2368.Reachable Nodes With Restrictions/README_EN.md

@@ -184,7 +184,32 @@ func reachableNodes(n int, edges [][]int, restricted []int) int {
 ### **TypeScript**
 
 ```ts
+function reachableNodes(
+    n: number,
+    edges: number[][],
+    restricted: number[],
+): number {
+    let res = 0;
+    const vis = new Array(n).fill(false);
+    const map = new Map<number, number[]>();
+    for (const [start, end] of edges) {
+        map.set(start, [...(map.get(start) ?? []), end]);
+        map.set(end, [...(map.get(end) ?? []), start]);
+    }
+    const dfs = (cur: number) => {
+        if (restricted.includes(cur) || vis[cur]) {
+            return;
+        }
+        res++;
+        vis[cur] = true;
+        for (const item of map.get(cur) ?? []) {
+            dfs(item);
+        }
+    };
+    dfs(0);
 
+    return res;
+}
 ```
 
 ### **...**

solution/2300-2399/2368.Reachable Nodes With Restrictions/Solution.ts

@@ -0,0 +1,26 @@
+function reachableNodes(
+    n: number,
+    edges: number[][],
+    restricted: number[],
+): number {
+    let res = 0;
+    const vis = new Array(n).fill(false);
+    const map = new Map<number, number[]>();
+    for (const [start, end] of edges) {
+        map.set(start, [...(map.get(start) ?? []), end]);
+        map.set(end, [...(map.get(end) ?? []), start]);
+    }
+    const dfs = (cur: number) => {
+        if (restricted.includes(cur) || vis[cur]) {
+            return;
+        }
+        res++;
+        vis[cur] = true;
+        for (const item of map.get(cur) ?? []) {
+            dfs(item);
+        }
+    };
+    dfs(0);
+
+    return res;
+}

solution/2300-2399/2369.Check if There is a Valid Partition For The Array/README.md

@@ -189,7 +189,35 @@ func validPartition(nums []int) bool {
 ### **TypeScript**
 
 ```ts
+function validPartition(nums: number[]): boolean {
+    const n = nums.length;
+    const vis = new Array(n).fill(false);
+    const queue = [0];
+    while (queue.length !== 0) {
+        const i = queue.shift() ?? 0;
+
+        if (i === n) {
+            return true;
+        }
+
+        if (!vis[i + 2] && i + 2 <= n && nums[i] === nums[i + 1]) {
+            queue.push(i + 2);
+            vis[i + 2] = true;
+        }
 
+        if (
+            !vis[i + 3] &&
+            i + 3 <= n &&
+            ((nums[i] === nums[i + 1] && nums[i + 1] === nums[i + 2]) ||
+                (nums[i] === nums[i + 1] - 1 &&
+                    nums[i + 1] === nums[i + 2] - 1))
+        ) {
+            queue.push(i + 3);
+            vis[i + 3] = true;
+        }
+    }
+    return false;
+}
 ```
 
 ### **...**