diff --git a/articles/brick-wall.md b/articles/brick-wall.md
index f44d6db6a..d0fb6e56d 100644
--- a/articles/brick-wall.md
+++ b/articles/brick-wall.md
@@ -335,6 +335,41 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[][]} wall
+     * @return {number}
+     */
+    leastBricks(wall: number[][]): number {
+        const n = wall.length;
+        let m = 0;
+        for (const brick of wall[0]) {
+            m += brick;
+        }
+        const gaps: number[][] = Array.from({ length: n }, () => []);
+        for (let i = 0; i < n; i++) {
+            let gap = 0;
+            for (const brick of wall[i]) {
+                gap += brick;
+                gaps[i].push(gap);
+            }
+        }
+        let res = n;
+        for (let line = 1; line < m; line++) {
+            let cuts = 0;
+            for (let i = 0; i < n; i++) {
+                if (!gaps[i].includes(line)) {
+                    cuts++;
+                }
+            }
+            res = Math.min(res, cuts);
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -551,6 +586,27 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[][]} wall
+     * @return {number}
+     */
+    leastBricks(wall: number[][]): number {
+        const countGap = new Map<number, number>();
+        countGap.set(0, 0);
+        for (const row of wall) {
+            let total = 0;
+            for (let i = 0; i < row.length - 1; i++) {
+                total += row[i];
+                countGap.set(total, (countGap.get(total) || 0) + 1);
+            }
+        }
+        return wall.length - Math.max(...countGap.values());
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/make-sum-divisible-by-p.md b/articles/make-sum-divisible-by-p.md
index fcc4ceb33..1e37b7aa8 100644
--- a/articles/make-sum-divisible-by-p.md
+++ b/articles/make-sum-divisible-by-p.md
@@ -272,6 +272,31 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} p
+     * @return {number}
+     */
+    minSubarray(nums: number[], p: number): number {
+        const n = nums.length;
+        let totSum = nums.reduce((a, b) => a + b, 0);
+        if (totSum % p === 0) return 0;
+        for (let l = 1; l < n; l++) {
+            let curSum = 0;
+            for (let i = 0; i < n; i++) {
+                curSum += nums[i];
+                if (i >= l) curSum -= nums[i - l];
+                const remainSum = totSum - curSum;
+                if (remainSum % p === 0) return l;
+            }
+        }
+        return -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/minimum-index-of-a-valid-split.md b/articles/minimum-index-of-a-valid-split.md
index 605bc44c6..d538a0a44 100644
--- a/articles/minimum-index-of-a-valid-split.md
+++ b/articles/minimum-index-of-a-valid-split.md
@@ -282,6 +282,37 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    minimumIndex(nums: number[]): number {
+        const n = nums.length;
+        for (let i = 0; i < n - 1; i++) {
+            const leftCnt: Record<number, number> = {};
+            for (let l = 0; l <= i; l++) {
+                leftCnt[nums[l]] = (leftCnt[nums[l]] || 0) + 1;
+            }
+            const rightCnt: Record<number, number> = {};
+            for (let r = i + 1; r < n; r++) {
+                rightCnt[nums[r]] = (rightCnt[nums[r]] || 0) + 1;
+            }
+            for (const num in leftCnt) {
+                if (
+                    leftCnt[num] > Math.floor((i + 1) / 2) &&
+                    (rightCnt[num] || 0) > Math.floor((n - i - 1) / 2)
+                ) {
+                    return i;
+                }
+            }
+        }
+        return -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -565,6 +596,34 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    minimumIndex(nums: number[]): number {
+        const left: Record<number, number> = {};
+        const right: Record<number, number> = {};
+        const n = nums.length;
+        for (const num of nums) {
+            right[num] = (right[num] || 0) + 1;
+        }
+        for (let i = 0; i < n; i++) {
+            const num = nums[i];
+            left[num] = (left[num] || 0) + 1;
+            right[num] -= 1;
+            const leftLen = i + 1;
+            const rightLen = n - i - 1;
+            if (2 * left[num] > leftLen && 2 * right[num] > rightLen) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -894,6 +953,38 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    minimumIndex(nums: number[]): number {
+        let majority = 0,
+            count = 0;
+        for (const num of nums) {
+            if (count === 0) majority = num;
+            count += num === majority ? 1 : -1;
+        }
+        let leftCnt = 0;
+        let rightCnt = nums.filter((x) => x === majority).length;
+        const n = nums.length;
+        for (let i = 0; i < n; i++) {
+            if (nums[i] === majority) {
+                leftCnt++;
+                rightCnt--;
+            }
+            const leftLen = i + 1;
+            const rightLen = n - i - 1;
+            if (2 * leftCnt > leftLen && 2 * rightCnt > rightLen) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/minimum-number-of-operations-to-move-all-balls-to-each-box.md b/articles/minimum-number-of-operations-to-move-all-balls-to-each-box.md
index d5a7fa5bc..fa90d1579 100644
--- a/articles/minimum-number-of-operations-to-move-all-balls-to-each-box.md
+++ b/articles/minimum-number-of-operations-to-move-all-balls-to-each-box.md
@@ -200,6 +200,27 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} boxes
+     * @return {number[]}
+     */
+    minOperations(boxes: string): number[] {
+        const n = boxes.length;
+        const res: number[] = new Array(n).fill(0);
+        for (let pos = 0; pos < n; pos++) {
+            for (let i = 0; i < n; i++) {
+                if (boxes[i] === '1') {
+                    res[pos] += Math.abs(pos - i);
+                }
+            }
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -477,6 +498,33 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} boxes
+     * @return {number[]}
+     */
+    minOperations(boxes: string): number[] {
+        const n = boxes.length;
+        const res: number[] = new Array(n).fill(0);
+        const prefixCount: number[] = new Array(n + 1).fill(0);
+        const indexSum: number[] = new Array(n + 1).fill(0);
+        for (let i = 0; i < n; i++) {
+            prefixCount[i + 1] = prefixCount[i] + (boxes[i] === '1' ? 1 : 0);
+            indexSum[i + 1] = indexSum[i] + (boxes[i] === '1' ? i : 0);
+        }
+        for (let i = 0; i < n; i++) {
+            const left = prefixCount[i];
+            const leftSum = indexSum[i];
+            const right = prefixCount[n] - prefixCount[i + 1];
+            const rightSum = indexSum[n] - indexSum[i + 1];
+            res[i] = i * left - leftSum + (rightSum - i * right);
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -736,6 +784,33 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} boxes
+     * @return {number[]}
+     */
+    minOperations(boxes: string): number[] {
+        const n = boxes.length;
+        const res: number[] = new Array(n).fill(0);
+        let balls = 0,
+            moves = 0;
+        for (let i = 0; i < n; i++) {
+            res[i] = balls + moves;
+            moves += balls;
+            balls += Number(boxes[i]);
+        }
+        balls = moves = 0;
+        for (let i = n - 1; i >= 0; i--) {
+            res[i] += balls + moves;
+            moves += balls;
+            balls += Number(boxes[i]);
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/minimum-number-of-swaps-to-make-the-string-balanced.md b/articles/minimum-number-of-swaps-to-make-the-string-balanced.md
index dcda7d3c7..29fad9e1b 100644
--- a/articles/minimum-number-of-swaps-to-make-the-string-balanced.md
+++ b/articles/minimum-number-of-swaps-to-make-the-string-balanced.md
@@ -170,6 +170,26 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {number}
+     */
+    minSwaps(s: string): number {
+        const stack: string[] = [];
+        for (const c of s) {
+            if (c === '[') {
+                stack.push(c);
+            } else if (stack.length > 0) {
+                stack.pop();
+            }
+        }
+        return Math.floor((stack.length + 1) / 2);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -343,6 +363,25 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {number}
+     */
+    minSwaps(s: string): number {
+        let close = 0,
+            maxClose = 0;
+        for (let i = 0; i < s.length; i++) {
+            if (s.charAt(i) == '[') close--;
+            else close++;
+            maxClose = Math.max(maxClose, close);
+        }
+        return Math.floor((maxClose + 1) / 2);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -498,6 +537,23 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {number}
+     */
+    minSwaps(s: string): number {
+        let stackSize = 0;
+        for (let i = 0; i < s.length; i++) {
+            if (s.charAt(i) == '[') stackSize++;
+            else if (stackSize > 0) stackSize--;
+        }
+        return Math.floor((stackSize + 1) / 2);
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/number-of-sub-arrays-with-odd-sum.md b/articles/number-of-sub-arrays-with-odd-sum.md
index 80242438c..8d8e10581 100644
--- a/articles/number-of-sub-arrays-with-odd-sum.md
+++ b/articles/number-of-sub-arrays-with-odd-sum.md
@@ -216,6 +216,30 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} arr
+     * @return {number}
+     */
+    numOfSubarrays(arr: number[]): number {
+        const n = arr.length;
+        let res = 0;
+        const mod = 1e9 + 7;
+        for (let i = 0; i < n; i++) {
+            let curSum = 0;
+            for (let j = i; j < n; j++) {
+                curSum += arr[j];
+                if (curSum % 2 !== 0) {
+                    res = (res + 1) % mod;
+                }
+            }
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -504,6 +528,32 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} arr
+     * @return {number}
+     */
+    numOfSubarrays(arr: number[]): number {
+        const mod = 1e9 + 7;
+        const n = arr.length;
+        const memo: number[][] = Array.from({ length: n }, () => Array(2).fill(-1));
+        const dp = (i: number, parity: number): number => {
+            if (i === n) return 0;
+            if (memo[i][parity] !== -1) return memo[i][parity];
+            const newParity = (parity + arr[i]) % 2;
+            const res = newParity + dp(i + 1, newParity);
+            return (memo[i][parity] = res % mod);
+        };
+        let res = 0;
+        for (let i = 0; i < n; i++) {
+            res = (res + dp(i, 0)) % mod;
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -739,6 +789,31 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} arr
+     * @return {number}
+     */
+    numOfSubarrays(arr: number[]): number {
+        const n = arr.length;
+        const mod = 1e9 + 7;
+        const dp: number[][] = Array.from({ length: n + 1 }, () => [0, 0]);
+        for (let i = n - 1; i >= 0; i--) {
+            for (let parity = 0; parity <= 1; parity++) {
+                const newParity = (parity + arr[i]) % 2;
+                dp[i][parity] = (newParity + dp[i + 1][newParity]) % mod;
+            }
+        }
+        let res = 0;
+        for (let i = 0; i < n; i++) {
+            res = (res + dp[i][0]) % mod;
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -970,6 +1045,33 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} arr
+     * @return {number}
+     */
+    numOfSubarrays(arr: number[]): number {
+        let curSum = 0,
+            oddCnt = 0,
+            evenCnt = 0,
+            res = 0;
+        const MOD = 1e9 + 7;
+        for (const n of arr) {
+            curSum += n;
+            if (curSum % 2 !== 0) {
+                res = (res + 1 + evenCnt) % MOD;
+                oddCnt++;
+            } else {
+                res = (res + oddCnt) % MOD;
+                evenCnt++;
+            }
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1161,6 +1263,27 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} arr
+     * @return {number}
+     */
+    numOfSubarrays(arr: number[]): number {
+        const count: number[] = [1, 0];
+        let prefix = 0,
+            res = 0;
+        const MOD = 1e9 + 7;
+        for (const num of arr) {
+            prefix = (prefix + num) % 2;
+            res = (res + count[1 - prefix]) % MOD;
+            count[prefix]++;
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/sign-of-the-product-of-an-array.md b/articles/sign-of-the-product-of-an-array.md
index e28e90a31..fa6a85d08 100644
--- a/articles/sign-of-the-product-of-an-array.md
+++ b/articles/sign-of-the-product-of-an-array.md
@@ -177,6 +177,27 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    arraySign(nums: number[]): number {
+        let neg = 0;
+        for (const num of nums) {
+            if (num === 0) {
+                return 0;
+            }
+            if (num < 0) {
+                neg++;
+            }
+        }
+        return neg % 2 === 0 ? 1 : -1;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -353,6 +374,27 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @return {number}
+     */
+    arraySign(nums: number[]): number {
+        let sign = 1;
+        for (const num of nums) {
+            if (num === 0) {
+                return 0;
+            }
+            if (num < 0) {
+                sign *= -1;
+            }
+        }
+        return sign;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/subarray-sums-divisible-by-k.md b/articles/subarray-sums-divisible-by-k.md
index beaa24d8b..e8b3dd1f1 100644
--- a/articles/subarray-sums-divisible-by-k.md
+++ b/articles/subarray-sums-divisible-by-k.md
@@ -209,6 +209,30 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    subarraysDivByK(nums: number[], k: number): number {
+        const n = nums.length;
+        let res = 0;
+        for (let i = 0; i < n; i++) {
+            let curSum = 0;
+            for (let j = i; j < n; j++) {
+                curSum += nums[j];
+                if (curSum % k === 0) {
+                    res++;
+                }
+            }
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -437,6 +461,30 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    subarraysDivByK(nums: number[], k: number): number {
+        let prefixSum = 0,
+            res = 0;
+        const prefixCnt = new Map<number, number>();
+        prefixCnt.set(0, 1);
+        for (const n of nums) {
+            prefixSum += n;
+            let remain = prefixSum % k;
+            if (remain < 0) remain += k;
+            res += prefixCnt.get(remain) || 0;
+            prefixCnt.set(remain, (prefixCnt.get(remain) || 0) + 1);
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -632,6 +680,28 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {number[]} nums
+     * @param {number} k
+     * @return {number}
+     */
+    subarraysDivByK(nums: number[], k: number): number {
+        const count: number[] = Array(k).fill(0);
+        count[0] = 1;
+        let prefix = 0,
+            res = 0;
+        for (const num of nums) {
+            prefix = (prefix + (num % k) + k) % k;
+            res += count[prefix];
+            count[prefix]++;
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
diff --git a/articles/unique-length-3-palindromic-subsequences.md b/articles/unique-length-3-palindromic-subsequences.md
index ad444013b..632614d97 100644
--- a/articles/unique-length-3-palindromic-subsequences.md
+++ b/articles/unique-length-3-palindromic-subsequences.md
@@ -258,6 +258,33 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {number}
+     */
+    countPalindromicSubsequence(s: string): number {
+        const res = new Set<string>();
+        const rec = (i: number, cur: string): void => {
+            if (cur.length === 3) {
+                if (cur[0] === cur[2]) {
+                    res.add(cur);
+                }
+                return;
+            }
+            if (i === s.length) {
+                return;
+            }
+            rec(i + 1, cur);
+            rec(i + 1, cur + s[i]);
+        };
+        rec(0, '');
+        return res.size;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -465,6 +492,29 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {number}
+     */
+    countPalindromicSubsequence(s: string): number {
+        const res = new Set<string>();
+        for (let i = 0; i < s.length - 2; i++) {
+            for (let j = i + 1; j < s.length - 1; j++) {
+                for (let k = j + 1; k < s.length; k++) {
+                    if (s[i] !== s[k]) {
+                        continue;
+                    }
+                    res.add(s[i] + s[j] + s[k]);
+                }
+            }
+        }
+        return res.size;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -726,6 +776,39 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {number}
+     */
+    countPalindromicSubsequence(s: string): number {
+        let res = 0;
+        for (let ends = 'a'.charCodeAt(0); ends <= 'z'.charCodeAt(0); ends++) {
+            for (let mid = 'a'.charCodeAt(0); mid <= 'z'.charCodeAt(0); mid++) {
+                const seq =
+                    String.fromCharCode(ends) +
+                    String.fromCharCode(mid) +
+                    String.fromCharCode(ends);
+                let idx = 0,
+                    found = 0;
+                for (const c of s) {
+                    if (seq[idx] === c) {
+                        idx++;
+                        if (idx === 3) {
+                            found = 1;
+                            break;
+                        }
+                    }
+                }
+                res += found;
+            }
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1029,6 +1112,37 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {number}
+     */
+    countPalindromicSubsequence(s: string): number {
+        const res = new Set<string>();
+        const left = new Set<string>();
+        const right: number[] = Array(26).fill(0);
+        for (const c of s) {
+            right[c.charCodeAt(0) - 'a'.charCodeAt(0)]++;
+        }
+        for (let i = 0; i < s.length; i++) {
+            right[s.charCodeAt(i) - 'a'.charCodeAt(0)]--;
+            if (right[s.charCodeAt(i) - 'a'.charCodeAt(0)] === 0) {
+                right[s.charCodeAt(i) - 'a'.charCodeAt(0)] = -1;
+            }
+            for (let j = 0; j < 26; j++) {
+                const c = String.fromCharCode('a'.charCodeAt(0) + j);
+                if (left.has(c) && right[j] > 0) {
+                    res.add(s[i] + c);
+                }
+            }
+            left.add(s[i]);
+        }
+        return res.size;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1400,6 +1514,49 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {number}
+     */
+    countPalindromicSubsequence(s: string): number {
+        const n = s.length;
+        const prefix: number[][] = Array.from({ length: n + 1 }, () => Array(26).fill(0));
+        const firstIndex: number[] = Array(26).fill(-1);
+        const lastIndex: number[] = Array(26).fill(-1);
+        for (let i = 0; i < n; i++) {
+            const j = s.charCodeAt(i) - 'a'.charCodeAt(0);
+            if (firstIndex[j] === -1) {
+                firstIndex[j] = i;
+            }
+            lastIndex[j] = i;
+            for (let k = 0; k < 26; k++) {
+                prefix[i + 1][k] = prefix[i][k];
+            }
+            prefix[i + 1][j]++;
+        }
+        let res = 0;
+        for (let ends = 0; ends < 26; ends++) {
+            if (
+                firstIndex[ends] === -1 ||
+                firstIndex[ends] === lastIndex[ends]
+            ) {
+                continue;
+            }
+            const l = firstIndex[ends],
+                r = lastIndex[ends];
+            for (let mid = 0; mid < 26; mid++) {
+                if (prefix[r][mid] - prefix[l + 1][mid] > 0) {
+                    res++;
+                }
+            }
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1632,6 +1789,30 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {number}
+     */
+    countPalindromicSubsequence(s: string): number {
+        let res = 0;
+        for (let i = 0; i < 26; i++) {
+            const c = String.fromCharCode('a'.charCodeAt(0) + i);
+            const l = s.indexOf(c),
+                r = s.lastIndexOf(c);
+            if (l === -1 || l === r) continue;
+            const mids = new Set<string>();
+            for (let j = l + 1; j < r; j++) {
+                mids.add(s[j]);
+            }
+            res += mids.size;
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity
@@ -1989,6 +2170,47 @@ impl Solution {
 }
 ```
 
+```typescript
+class Solution {
+    /**
+     * @param {string} s
+     * @return {number}
+     */
+    countPalindromicSubsequence(s: string): number {
+        const firstIndex: number[] = Array(26).fill(-1);
+        const lastIndex: number[] = Array(26).fill(-1);
+        for (let i = 0; i < s.length; i++) {
+            const j = s.charCodeAt(i) - 'a'.charCodeAt(0);
+            if (firstIndex[j] === -1) {
+                firstIndex[j] = i;
+            }
+            lastIndex[j] = i;
+        }
+        let res = 0;
+        for (let ends = 0; ends < 26; ends++) {
+            if (
+                firstIndex[ends] === -1 ||
+                firstIndex[ends] === lastIndex[ends]
+            ) {
+                continue;
+            }
+            const l = firstIndex[ends],
+                r = lastIndex[ends];
+            let mask = 0;
+            for (let i = l + 1; i < r; i++) {
+                const c = s.charCodeAt(i) - 'a'.charCodeAt(0);
+                if (mask & (1 << c)) {
+                    continue;
+                }
+                mask |= 1 << c;
+                res++;
+            }
+        }
+        return res;
+    }
+}
+```
+
 ::tabs-end
 
 ### Time & Space Complexity