Added tasks 30-58

Author: ThanhNIT

README.md

@@ -0,0 +1,35 @@
+30\. Substring with Concatenation of All Words
+
+Hard
+
+You are given a string `s` and an array of strings `words` of **the same length**. Return all starting indices of substring(s) in `s` that is a concatenation of each word in `words` **exactly once**, **in any order**, and **without any intervening characters**.
+
+You can return the answer in **any order**.
+
+**Example 1:**
+
+**Input:** s = "barfoothefoobarman", words = ["foo","bar"]
+
+**Output:** [0,9]
+
+**Explanation:** Substrings starting at index 0 and 9 are "barfoo" and "foobar" respectively. The output order does not matter, returning [9,0] is fine too. 
+
+**Example 2:**
+
+**Input:** s = "wordgoodgoodgoodbestword", words = ["word","good","best","word"]
+
+**Output:** [] 
+
+**Example 3:**
+
+**Input:** s = "barfoofoobarthefoobarman", words = ["bar","foo","the"]
+
+**Output:** [6,9,12] 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 10<sup>4</sup></code>
+*   `s` consists of lower-case English letters.
+*   `1 <= words.length <= 5000`
+*   `1 <= words[i].length <= 30`
+*   `words[i]` consists of lower-case English letters.

src/main/ts/g0001_0100/s0030_substring_with_concatenation_of_all_words/readme.md

@@ -0,0 +1,48 @@
+// #Hard #String #Hash_Table #Sliding_Window #Top_Interview_150_Sliding_Window
+// #2025_04_01_Time_13_ms_(97.44%)_Space_63.70_MB_(46.03%)
+
+function findSubstring(s: string, words: string[]): number[] {
+    let ans: number[] = [];
+    let n1 = words[0].length;
+    let n2 = s.length;
+    let map1 = new Map<string, number>();
+
+    for (let ch of words) {
+        map1.set(ch, (map1.get(ch) ?? 0) + 1);
+    }
+
+    for (let i = 0; i < n1; i++) {
+        let left = i;
+        let j = i;
+        let c = 0;
+        let map2 = new Map<string, number>();
+
+        while (j + n1 <= n2) {
+            let word1 = s.substring(j, j + n1);
+            j += n1;
+
+            if (map1.has(word1)) {
+                map2.set(word1, (map2.get(word1) ?? 0) + 1);
+                c++;
+
+                while ((map2.get(word1) ?? 0) > (map1.get(word1) ?? 0)) {
+                    let word2 = s.substring(left, left + n1);
+                    map2.set(word2, (map2.get(word2) ?? 0) - 1);
+                    left += n1;
+                    c--;
+                }
+
+                if (c === words.length) {
+                    ans.push(left);
+                }
+            } else {
+                map2.clear();
+                c = 0;
+                left = j;
+            }
+        }
+    }
+    return ans;
+}
+
+export { findSubstring }

src/main/ts/g0001_0100/s0030_substring_with_concatenation_of_all_words/solution.ts

@@ -0,0 +1,58 @@
+36\. Valid Sudoku
+
+Medium
+
+Determine if a `9 x 9` Sudoku board is valid. Only the filled cells need to be validated **according to the following rules**:
+
+1.  Each row must contain the digits `1-9` without repetition.
+2.  Each column must contain the digits `1-9` without repetition.
+3.  Each of the nine `3 x 3` sub-boxes of the grid must contain the digits `1-9` without repetition.
+
+**Note:**
+
+*   A Sudoku board (partially filled) could be valid but is not necessarily solvable.
+*   Only the filled cells need to be validated according to the mentioned rules.
+
+**Example 1:**
+
+![](https://upload.wikimedia.org/wikipedia/commons/thumb/f/ff/Sudoku-by-L2G-20050714.svg/250px-Sudoku-by-L2G-20050714.svg.png)
+
+**Input:**
+
+    board =
+    [["5","3",".",".","7",".",".",".","."]
+    ,["6",".",".","1","9","5",".",".","."]
+    ,[".","9","8",".",".",".",".","6","."]
+    ,["8",".",".",".","6",".",".",".","3"]
+    ,["4",".",".","8",".","3",".",".","1"]
+    ,["7",".",".",".","2",".",".",".","6"]
+    ,[".","6",".",".",".",".","2","8","."]
+    ,[".",".",".","4","1","9",".",".","5"]
+    ,[".",".",".",".","8",".",".","7","9"]]
+
+**Output:** true 
+
+**Example 2:**
+
+**Input:**
+
+    board =
+    [["8","3",".",".","7",".",".",".","."]
+    ,["6",".",".","1","9","5",".",".","."]
+    ,[".","9","8",".",".",".",".","6","."]
+    ,["8",".",".",".","6",".",".",".","3"]
+    ,["4",".",".","8",".","3",".",".","1"]
+    ,["7",".",".",".","2",".",".",".","6"]
+    ,[".","6",".",".",".",".","2","8","."]
+    ,[".",".",".","4","1","9",".",".","5"]
+    ,[".",".",".",".","8",".",".","7","9"]]
+
+**Output:** false
+
+**Explanation:** Same as Example 1, except with the **5** in the top left corner being modified to **8**. Since there are two 8's in the top left 3x3 sub-box, it is invalid. 
+
+**Constraints:**
+
+*   `board.length == 9`
+*   `board[i].length == 9`
+*   `board[i][j]` is a digit `1-9` or `'.'`.

src/main/ts/g0001_0100/s0036_valid_sudoku/readme.md

@@ -0,0 +1,29 @@
+// #Medium #Top_Interview_Questions #Array #Hash_Table #Matrix #Data_Structure_I_Day_5_Array
+// #Top_Interview_150_Matrix #2025_04_01_Time_1_ms_(99.60%)_Space_58.94_MB_(52.85%)
+
+function isValidSudoku(board: string[][]): boolean {
+    let rowSet: number[] = new Array(9).fill(0);
+    let colSet: number[] = new Array(9).fill(0);
+    let boxSet: number[] = new Array(9).fill(0);
+
+    for (let i = 0; i < 9; i++) {
+        for (let j = 0; j < 9; j++) {
+            if (board[i][j] === '.') {
+                continue;
+            }
+            let val = board[i][j].charCodeAt(0) - '0'.charCodeAt(0);
+            let boxIndex = Math.floor(i / 3) * 3 + Math.floor(j / 3);
+
+            if ((rowSet[i] & (1 << val)) || (colSet[j] & (1 << val)) || (boxSet[boxIndex] & (1 << val))) {
+                return false;
+            }
+
+            rowSet[i] |= 1 << val;
+            colSet[j] |= 1 << val;
+            boxSet[boxIndex] |= 1 << val;
+        }
+    }
+    return true;
+}
+
+export { isValidSudoku }

src/main/ts/g0001_0100/s0036_valid_sudoku/solution.ts

@@ -0,0 +1,31 @@
+50\. Pow(x, n)
+
+Medium
+
+Implement [pow(x, n)](http://www.cplusplus.com/reference/valarray/pow/), which calculates `x` raised to the power `n` (i.e., <code>x<sup>n</sup></code>).
+
+**Example 1:**
+
+**Input:** x = 2.00000, n = 10
+
+**Output:** 1024.00000 
+
+**Example 2:**
+
+**Input:** x = 2.10000, n = 3
+
+**Output:** 9.26100 
+
+**Example 3:**
+
+**Input:** x = 2.00000, n = -2
+
+**Output:** 0.25000
+
+**Explanation:** 2<sup>\-2</sup> = 1/2<sup>2</sup> = 1/4 = 0.25 
+
+**Constraints:**
+
+*   `-100.0 < x < 100.0`
+*   <code>-2<sup>31</sup> <= n <= 2<sup>31</sup>-1</code>
+*   <code>-10<sup>4</sup> <= x<sup>n</sup> <= 10<sup>4</sup></code>

src/main/ts/g0001_0100/s0050_powx_n/readme.md

@@ -0,0 +1,22 @@
+// #Medium #Top_Interview_Questions #Math #Recursion #Udemy_Integers #Top_Interview_150_Math
+// #2025_04_01_Time_0_ms_(100.00%)_Space_57.31_MB_(7.22%)
+
+function myPow(x: number, n: number): number {
+    let nn = BigInt(n);
+    let res = 1.0;
+    if (n < 0) {
+        nn = -nn;
+    }
+    while (nn > 0) {
+        if (nn % 2n === 1n) {
+            nn--;
+            res *= x;
+        } else {
+            x *= x;
+            nn /= 2n;
+        }
+    }
+    return n < 0 ? 1.0 / res : res;
+}
+
+export { myPow }

src/main/ts/g0001_0100/s0050_powx_n/solution.ts

@@ -0,0 +1,27 @@
+52\. N-Queens II
+
+Hard
+
+The **n-queens** puzzle is the problem of placing `n` queens on an `n x n` chessboard such that no two queens attack each other.
+
+Given an integer `n`, return _the number of distinct solutions to the **n-queens puzzle**_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/queens.jpg)
+
+**Input:** n = 4
+
+**Output:** 2
+
+**Explanation:** There are two distinct solutions to the 4-queens puzzle as shown. 
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 1 
+
+**Constraints:**
+
+*   `1 <= n <= 9`

src/main/ts/g0001_0100/s0052_n_queens_ii/readme.md

@@ -0,0 +1,22 @@
+// #Hard #Backtracking #Top_Interview_150_Backtracking
+// #2025_04_01_Time_1_ms_(96.89%)_Space_56.94_MB_(52.17%)
+
+function totalNQueens(n: number): number {
+    function solve(r: number, cols: boolean[], diag: boolean[], antiDiag: boolean[]): number {
+        if (r === n) {
+            return 1;
+        }
+        let count = 0;
+        for (let c = 0; c < n; c++) {
+            if (!cols[c] && !diag[r + c] && !antiDiag[r - c + n - 1]) {
+                cols[c] = diag[r + c] = antiDiag[r - c + n - 1] = true;
+                count += solve(r + 1, cols, diag, antiDiag);
+                cols[c] = diag[r + c] = antiDiag[r - c + n - 1] = false;
+            }
+        }
+        return count;
+    }
+    return solve(0, new Array(n).fill(false), new Array(2 * n - 1).fill(false), new Array(2 * n - 1).fill(false));
+}
+
+export { totalNQueens }

src/main/ts/g0001_0100/s0052_n_queens_ii/solution.ts

@@ -0,0 +1,28 @@
+54\. Spiral Matrix
+
+Medium
+
+Given an `m x n` `matrix`, return _all elements of the_ `matrix` _in spiral order_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/spiral1.jpg)
+
+**Input:** matrix = [[1,2,3],[4,5,6],[7,8,9]]
+
+**Output:** [1,2,3,6,9,8,7,4,5] 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2020/11/13/spiral.jpg)
+
+**Input:** matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
+
+**Output:** [1,2,3,4,8,12,11,10,9,5,6,7] 
+
+**Constraints:**
+
+*   `m == matrix.length`
+*   `n == matrix[i].length`
+*   `1 <= m, n <= 10`
+*   `-100 <= matrix[i][j] <= 100`

src/main/ts/g0001_0100/s0054_spiral_matrix/readme.md

@@ -0,0 +1,36 @@
+// #Medium #Top_100_Liked_Questions #Top_Interview_Questions #Array #Matrix #Simulation
+// #Programming_Skills_II_Day_8 #Level_2_Day_1_Implementation/Simulation #Udemy_2D_Arrays/Matrix
+// #Top_Interview_150_Matrix #2025_04_01_Time_0_ms_(100.00%)_Space_55.71_MB_(30.13%)
+
+function spiralOrder(matrix: number[][]): number[] {
+    const result: number[] = [];
+    let r = 0, c = 0;
+    let bigR = matrix.length - 1;
+    let bigC = matrix[0].length - 1;
+
+    while (r <= bigR && c <= bigC) {
+        for (let i = c; i <= bigC; i++) {
+            result.push(matrix[r][i]);
+        }
+        r++;
+
+        for (let i = r; i <= bigR; i++) {
+            result.push(matrix[i][bigC]);
+        }
+        bigC--;
+
+        for (let i = bigC; i >= c && r <= bigR; i--) {
+            result.push(matrix[bigR][i]);
+        }
+        bigR--;
+
+        for (let i = bigR; i >= r && c <= bigC; i--) {
+            result.push(matrix[i][c]);
+        }
+        c++;
+    }
+
+    return result;
+}
+
+export { spiralOrder }

src/main/ts/g0001_0100/s0054_spiral_matrix/solution.ts

@@ -0,0 +1,15 @@
+// tslint:disable:no-magic-numbers
+import { findSubstring } from 'src/main/ts/g0001_0100/s0030_substring_with_concatenation_of_all_words/solution'
+import { expect, test } from 'vitest'
+
+test('findSubstring', () => {
+    expect(findSubstring('barfoothefoobarman', ['foo','bar'])).toEqual([0,9])
+})
+
+test('findSubstring2', () => {
+    expect(findSubstring('wordgoodgoodgoodbestword', ['word','good','best','word'])).toEqual([])
+})
+
+test('findSubstring3', () => {
+    expect(findSubstring('barfoofoobarthefoobarman', ['bar','foo','the'])).toEqual([6,9,12])
+})

src/test/ts/g0001_0100/s0030_substring_with_concatenation_of_all_words/solution.test.ts

@@ -0,0 +1,27 @@
+// tslint:disable:no-magic-numbers
+import { isValidSudoku } from 'src/main/ts/g0001_0100/s0036_valid_sudoku/solution'
+import { expect, test } from 'vitest'
+
+test('isValidSudoku', () => {
+    expect(isValidSudoku([['5','3','.','.','7','.','.','.','.']
+                         ,['6','.','.','1','9','5','.','.','.']
+                         ,['.','9','8','.','.','.','.','6','.']
+                         ,['8','.','.','.','6','.','.','.','3']
+                         ,['4','.','.','8','.','3','.','.','1']
+                         ,['7','.','.','.','2','.','.','.','6']
+                         ,['.','6','.','.','.','.','2','8','.']
+                         ,['.','.','.','4','1','9','.','.','5']
+                         ,['.','.','.','.','8','.','.','7','9']])).toEqual(true)
+})
+
+test('isValidSudoku2', () => {
+    expect(isValidSudoku([['8','3','.','.','7','.','.','.','.']
+                         ,['6','.','.','1','9','5','.','.','.']
+                         ,['.','9','8','.','.','.','.','6','.']
+                         ,['8','.','.','.','6','.','.','.','3']
+                         ,['4','.','.','8','.','3','.','.','1']
+                         ,['7','.','.','.','2','.','.','.','6']
+                         ,['.','6','.','.','.','.','2','8','.']
+                         ,['.','.','.','4','1','9','.','.','5']
+                         ,['.','.','.','.','8','.','.','7','9']])).toEqual(false)
+})