Added tasks 127-137

Author: ThanhNIT

README.md

@@ -570,6 +570,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0127 |[Word Ladder](src/main/ts/g0101_0200/s0127_word_ladder/solution.ts)| Hard | Top_Interview_Questions, String, Hash_Table, Breadth_First_Search | 41 | 95.63
 
 #### Day 13 Graph Theory
 
@@ -1025,6 +1026,8 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | 0055 |[Jump Game](src/main/ts/g0001_0100/s0055_jump_game/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Greedy, Big_O_Time_O(n)_Space_O(1) | 0 | 100.00
 | 0045 |[Jump Game II](src/main/ts/g0001_0100/s0045_jump_game_ii/solution.ts)| Medium | Top_100_Liked_Questions, Array, Dynamic_Programming, Greedy, Big_O_Time_O(n)_Space_O(1) | 1 | 84.27
 | 0238 |[Product of Array Except Self](src/main/ts/g0201_0300/s0238_product_of_array_except_self/solution.ts)| Medium | Top_100_Liked_Questions, Array, Prefix_Sum, Big_O_Time_O(n^2)_Space_O(n) | 3 | 92.81
+| 0134 |[Gas Station](src/main/ts/g0101_0200/s0134_gas_station/solution.ts)| Medium | Top_Interview_Questions, Array, Greedy | 0 | 100.00
+| 0135 |[Candy](src/main/ts/g0101_0200/s0135_candy/solution.ts)| Hard | Array, Greedy | 2 | 96.15
 | 0042 |[Trapping Rain Water](src/main/ts/g0001_0100/s0042_trapping_rain_water/solution.ts)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Array, Dynamic_Programming, Two_Pointers, Stack, Monotonic_Stack, Big_O_Time_O(n)_Space_O(1) | 0 | 100.00
 | 0013 |[Roman to Integer](src/main/ts/g0001_0100/s0013_roman_to_integer/solution.ts)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Math | 3 | 94.58
 | 0012 |[Integer to Roman](src/main/ts/g0001_0100/s0012_integer_to_roman/solution.ts)| Medium | String, Hash_Table, Math | 3 | 93.02
@@ -1110,6 +1113,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | 0117 |[Populating Next Right Pointers in Each Node II](src/main/ts/g0101_0200/s0117_populating_next_right_pointers_in_each_node_ii/solution.ts)| Medium | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree, Linked_List | 47 | 97.74
 | 0114 |[Flatten Binary Tree to Linked List](src/main/ts/g0101_0200/s0114_flatten_binary_tree_to_linked_list/solution.ts)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Stack, Linked_List, Big_O_Time_O(N)_Space_O(N) | 0 | 100.00
 | 0112 |[Path Sum](src/main/ts/g0101_0200/s0112_path_sum/solution.ts)| Easy | Depth_First_Search, Breadth_First_Search, Tree, Binary_Tree | 0 | 100.00
+| 0129 |[Sum Root to Leaf Numbers](src/main/ts/g0101_0200/s0129_sum_root_to_leaf_numbers/solution.ts)| Medium | Depth_First_Search, Tree, Binary_Tree | 0 | 100.00
 | 0124 |[Binary Tree Maximum Path Sum](src/main/ts/g0101_0200/s0124_binary_tree_maximum_path_sum/solution.ts)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Depth_First_Search, Tree, Binary_Tree, Big_O_Time_O(N)_Space_O(N) | 2 | 71.11
 | 0236 |[Lowest Common Ancestor of a Binary Tree](src/main/ts/g0201_0300/s0236_lowest_common_ancestor_of_a_binary_tree/solution.ts)| Medium | Top_100_Liked_Questions, Depth_First_Search, Tree, Binary_Tree, Big_O_Time_O(n)_Space_O(n) | 61 | 75.97
 
@@ -1138,6 +1142,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 
 | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- --> | <!-- -->
 |-|-|-|-|-|-
+| 0127 |[Word Ladder](src/main/ts/g0101_0200/s0127_word_ladder/solution.ts)| Hard | Top_Interview_Questions, String, Hash_Table, Breadth_First_Search | 41 | 95.63
 
 #### Top Interview 150 Trie
 
@@ -1195,6 +1200,7 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 |-|-|-|-|-|-
 | 0067 |[Add Binary](src/main/ts/g0001_0100/s0067_add_binary/solution.ts)| Easy | String, Math, Bit_Manipulation, Simulation | 0 | 100.00
 | 0136 |[Single Number](src/main/ts/g0101_0200/s0136_single_number/solution.ts)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Bit_Manipulation, Big_O_Time_O(N)_Space_O(1) | 1 | 78.27
+| 0137 |[Single Number II](src/main/ts/g0101_0200/s0137_single_number_ii/solution.ts)| Medium | Array, Bit_Manipulation | 0 | 100.00
 
 #### Top Interview 150 Math
 
@@ -1714,9 +1720,14 @@ TypeScript-based LeetCode algorithm problem solutions, regularly updated.
 | 0141 |[Linked List Cycle](src/main/ts/g0101_0200/s0141_linked_list_cycle/solution.ts)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Hash_Table, Two_Pointers, Linked_List, Data_Structure_I_Day_7_Linked_List, Udemy_Linked_List, Top_Interview_150_Linked_List, Big_O_Time_O(N)_Space_O(1) | 47 | 89.37
 | 0139 |[Word Break](src/main/ts/g0101_0200/s0139_word_break/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Hash_Table, Dynamic_Programming, Trie, Memoization, Algorithm_II_Day_15_Dynamic_Programming, Dynamic_Programming_I_Day_9, Udemy_Dynamic_Programming, Top_Interview_150_1D_DP, Big_O_Time_O(M+max\*N)_Space_O(M+N+max) | 4 | 76.41
 | 0138 |[Copy List with Random Pointer](src/main/ts/g0101_0200/s0138_copy_list_with_random_pointer/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Hash_Table, Linked_List, Programming_Skills_II_Day_14, Udemy_Linked_List, Top_Interview_150_Linked_List, Big_O_Time_O(N)_Space_O(N) | 49 | 72.42
+| 0137 |[Single Number II](src/main/ts/g0101_0200/s0137_single_number_ii/solution.ts)| Medium | Array, Bit_Manipulation, Top_Interview_150_Bit_Manipulation | 0 | 100.00
 | 0136 |[Single Number](src/main/ts/g0101_0200/s0136_single_number/solution.ts)| Easy | Top_100_Liked_Questions, Top_Interview_Questions, Array, Bit_Manipulation, Data_Structure_II_Day_1_Array, Algorithm_I_Day_14_Bit_Manipulation, Udemy_Integers, Top_Interview_150_Bit_Manipulation, Big_O_Time_O(N)_Space_O(1) | 1 | 78.27
+| 0135 |[Candy](src/main/ts/g0101_0200/s0135_candy/solution.ts)| Hard | Array, Greedy, Top_Interview_150_Array/String | 2 | 96.15
+| 0134 |[Gas Station](src/main/ts/g0101_0200/s0134_gas_station/solution.ts)| Medium | Top_Interview_Questions, Array, Greedy, Top_Interview_150_Array/String | 0 | 100.00
 | 0131 |[Palindrome Partitioning](src/main/ts/g0101_0200/s0131_palindrome_partitioning/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, String, Dynamic_Programming, Backtracking, Big_O_Time_O(N\*2^N)_Space_O(2^N\*N) | 13 | 94.96
+| 0129 |[Sum Root to Leaf Numbers](src/main/ts/g0101_0200/s0129_sum_root_to_leaf_numbers/solution.ts)| Medium | Depth_First_Search, Tree, Binary_Tree, Top_Interview_150_Binary_Tree_General | 0 | 100.00
 | 0128 |[Longest Consecutive Sequence](src/main/ts/g0101_0200/s0128_longest_consecutive_sequence/solution.ts)| Medium | Top_100_Liked_Questions, Top_Interview_Questions, Array, Hash_Table, Union_Find, Top_Interview_150_Hashmap, Big_O_Time_O(N_log_N)_Space_O(1) | 34 | 90.07
+| 0127 |[Word Ladder](src/main/ts/g0101_0200/s0127_word_ladder/solution.ts)| Hard | Top_Interview_Questions, String, Hash_Table, Breadth_First_Search, Graph_Theory_I_Day_12_Breadth_First_Search, Top_Interview_150_Graph_BFS | 41 | 95.63
 | 0125 |[Valid Palindrome](src/main/ts/g0101_0200/s0125_valid_palindrome/solution.ts)| Easy | Top_Interview_Questions, String, Two_Pointers, Udemy_Two_Pointers, Top_Interview_150_Two_Pointers | 0 | 100.00
 | 0124 |[Binary Tree Maximum Path Sum](src/main/ts/g0101_0200/s0124_binary_tree_maximum_path_sum/solution.ts)| Hard | Top_100_Liked_Questions, Top_Interview_Questions, Dynamic_Programming, Depth_First_Search, Tree, Binary_Tree, Udemy_Tree_Stack_Queue, Top_Interview_150_Binary_Tree_General, Big_O_Time_O(N)_Space_O(N) | 2 | 71.11
 | 0123 |[Best Time to Buy and Sell Stock III](src/main/ts/g0101_0200/s0123_best_time_to_buy_and_sell_stock_iii/solution.ts)| Hard | Array, Dynamic_Programming, Top_Interview_150_Multidimensional_DP | 5 | 85.07

src/main/ts/g0101_0200/s0127_word_ladder/readme.md

@@ -0,0 +1,37 @@
+127\. Word Ladder
+
+Hard
+
+A **transformation sequence** from word `beginWord` to word `endWord` using a dictionary `wordList` is a sequence of words <code>beginWord -> s<sub>1</sub> -> s<sub>2</sub> -> ... -> s<sub>k</sub></code> such that:
+
+*   Every adjacent pair of words differs by a single letter.
+*   Every <code>s<sub>i</sub></code> for `1 <= i <= k` is in `wordList`. Note that `beginWord` does not need to be in `wordList`.
+*   <code>s<sub>k</sub> == endWord</code>
+
+Given two words, `beginWord` and `endWord`, and a dictionary `wordList`, return _the **number of words** in the **shortest transformation sequence** from_ `beginWord` _to_ `endWord`_, or_ `0` _if no such sequence exists._
+
+**Example 1:**
+
+**Input:** beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
+
+**Output:** 5
+
+**Explanation:** One shortest transformation sequence is "hit" -> "hot" -> "dot" -> "dog" -> cog", which is 5 words long. 
+
+**Example 2:**
+
+**Input:** beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
+
+**Output:** 0
+
+**Explanation:** The endWord "cog" is not in wordList, therefore there is no valid transformation sequence. 
+
+**Constraints:**
+
+*   `1 <= beginWord.length <= 10`
+*   `endWord.length == beginWord.length`
+*   `1 <= wordList.length <= 5000`
+*   `wordList[i].length == beginWord.length`
+*   `beginWord`, `endWord`, and `wordList[i]` consist of lowercase English letters.
+*   `beginWord != endWord`
+*   All the words in `wordList` are **unique**.

src/main/ts/g0101_0200/s0127_word_ladder/solution.ts

@@ -0,0 +1,44 @@
+// #Hard #Top_Interview_Questions #String #Hash_Table #Breadth_First_Search
+// #Graph_Theory_I_Day_12_Breadth_First_Search #Top_Interview_150_Graph_BFS
+// #2025_04_07_Time_41_ms_(95.63%)_Space_63.50_MB_(82.78%)
+
+function ladderLength(beginWord: string, endWord: string, wordList: string[]): number {
+    const wordSet: Set<string> = new Set(wordList)
+    if (!wordSet.has(endWord)) {
+        return 0
+    }
+    let beginSet: Set<string> = new Set([beginWord])
+    let endSet: Set<string> = new Set([endWord])
+    const visited: Set<string> = new Set()
+    let len = 1
+    const wordLen = beginWord.length
+    while (beginSet.size > 0 && endSet.size > 0) {
+        if (beginSet.size > endSet.size) {
+            [beginSet, endSet] = [endSet, beginSet]
+        }
+        const tempSet: Set<string> = new Set()
+        for (const word of beginSet) {
+            const chars = word.split('')
+            for (let i = 0; i < wordLen; i++) {
+                const oldChar = chars[i]
+                for (let c = 97; c <= 122; c++) {
+                    chars[i] = String.fromCharCode(c)
+                    const nextWord = chars.join('')
+                    if (endSet.has(nextWord)) {
+                        return len + 1
+                    }
+                    if (!visited.has(nextWord) && wordSet.has(nextWord)) {
+                        tempSet.add(nextWord)
+                        visited.add(nextWord)
+                    }
+                }
+                chars[i] = oldChar
+            }
+        }
+        beginSet = tempSet
+        len++
+    }
+    return 0
+}
+
+export { ladderLength }

src/main/ts/g0101_0200/s0129_sum_root_to_leaf_numbers/readme.md

@@ -0,0 +1,39 @@
+129\. Sum Root to Leaf Numbers
+
+Medium
+
+You are given the `root` of a binary tree containing digits from `0` to `9` only.
+
+Each root-to-leaf path in the tree represents a number.
+
+*   For example, the root-to-leaf path `1 -> 2 -> 3` represents the number `123`.
+
+Return _the total sum of all root-to-leaf numbers_. Test cases are generated so that the answer will fit in a **32-bit** integer.
+
+A **leaf** node is a node with no children.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/num1tree.jpg)
+
+**Input:** root = [1,2,3]
+
+**Output:** 25
+
+**Explanation:** The root-to-leaf path `1->2` represents the number `12`. The root-to-leaf path `1->3` represents the number `13`. Therefore, sum = 12 + 13 = `25`. 
+
+**Example 2:**
+
+![](https://assets.leetcode.com/uploads/2021/02/19/num2tree.jpg)
+
+**Input:** root = [4,9,0,5,1]
+
+**Output:** 1026
+
+**Explanation:** The root-to-leaf path `4->9->5` represents the number 495. The root-to-leaf path `4->9->1` represents the number 491. The root-to-leaf path `4->0` represents the number 40. Therefore, sum = 495 + 491 + 40 = `1026`. 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[1, 1000]`.
+*   `0 <= Node.val <= 9`
+*   The depth of the tree will not exceed `10`.

src/main/ts/g0101_0200/s0129_sum_root_to_leaf_numbers/solution.ts

@@ -0,0 +1,41 @@
+// #Medium #Depth_First_Search #Tree #Binary_Tree #Top_Interview_150_Binary_Tree_General
+// #2025_04_07_Time_0_ms_(100.00%)_Space_57.72_MB_(19.07%)
+
+import { TreeNode } from "../../com_github_leetcode/treenode"
+
+/**
+ * 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 sumNumbers(root: TreeNode | null): number {
+    let sum = 0
+    function recurseSum(node: TreeNode | null, curNum: number): void {
+        if (node === null) {
+            return
+        }
+        const newNum = 10 * curNum + node.val
+        if (node.left === null && node.right === null) {
+            sum += newNum
+            return
+        }
+        if (node.left !== null) {
+            recurseSum(node.left, newNum)
+        }
+        if (node.right !== null) {
+            recurseSum(node.right, newNum)
+        }
+    }
+    recurseSum(root, 0)
+    return sum
+}
+
+export { sumNumbers }

src/main/ts/g0101_0200/s0134_gas_station/readme.md

@@ -0,0 +1,47 @@
+134\. Gas Station
+
+Medium
+
+There are `n` gas stations along a circular route, where the amount of gas at the <code>i<sup>th</sup></code> station is `gas[i]`.
+
+You have a car with an unlimited gas tank and it costs `cost[i]` of gas to travel from the <code>i<sup>th</sup></code> station to its next <code>(i + 1)<sup>th</sup></code> station. You begin the journey with an empty tank at one of the gas stations.
+
+Given two integer arrays `gas` and `cost`, return _the starting gas station's index if you can travel around the circuit once in the clockwise direction, otherwise return_ `-1`. If there exists a solution, it is **guaranteed** to be **unique**
+
+**Example 1:**
+
+**Input:** gas = [1,2,3,4,5], cost = [3,4,5,1,2]
+
+**Output:** 3
+
+**Explanation:**
+
+    Start at station 3 (index 3) and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
+    Travel to station 4. Your tank = 4 - 1 + 5 = 8
+    Travel to station 0. Your tank = 8 - 2 + 1 = 7
+    Travel to station 1. Your tank = 7 - 3 + 2 = 6
+    Travel to station 2. Your tank = 6 - 4 + 3 = 5
+    Travel to station 3. The cost is 5. Your gas is just enough to travel back to station 3.
+    Therefore, return 3 as the starting index. 
+
+**Example 2:**
+
+**Input:** gas = [2,3,4], cost = [3,4,3]
+
+**Output:** -1
+
+**Explanation:**
+
+    You can't start at station 0 or 1, as there is not enough gas to travel to the next station.
+    Let's start at station 2 and fill up with 4 unit of gas. Your tank = 0 + 4 = 4
+    Travel to station 0. Your tank = 4 - 3 + 2 = 3
+    Travel to station 1. Your tank = 3 - 3 + 3 = 3
+    You cannot travel back to station 2, as it requires 4 unit of gas but you only have 3.
+    Therefore, you can't travel around the circuit once no matter where you start. 
+
+**Constraints:**
+
+*   `gas.length == n`
+*   `cost.length == n`
+*   <code>1 <= n <= 10<sup>5</sup></code>
+*   <code>0 <= gas[i], cost[i] <= 10<sup>4</sup></code>

src/main/ts/g0101_0200/s0134_gas_station/solution.ts

@@ -0,0 +1,20 @@
+// #Medium #Top_Interview_Questions #Array #Greedy #Top_Interview_150_Array/String
+// #2025_04_07_Time_0_ms_(100.00%)_Space_66.31_MB_(63.11%)
+
+function canCompleteCircuit(gas: number[], cost: number[]): number {
+    let index = 0
+    let total = 0
+    let current = 0
+    for (let i = 0; i < gas.length; i++) {
+        const balance = gas[i] - cost[i]
+        total += balance
+        current += balance
+        if (current < 0) {
+            index = i + 1
+            current = 0
+        }
+    }
+    return total >= 0 ? index : -1
+}
+
+export { canCompleteCircuit }

src/main/ts/g0101_0200/s0135_candy/readme.md

@@ -0,0 +1,34 @@
+135\. Candy
+
+Hard
+
+There are `n` children standing in a line. Each child is assigned a rating value given in the integer array `ratings`.
+
+You are giving candies to these children subjected to the following requirements:
+
+*   Each child must have at least one candy.
+*   Children with a higher rating get more candies than their neighbors.
+
+Return _the minimum number of candies you need to have to distribute the candies to the children_.
+
+**Example 1:**
+
+**Input:** ratings = [1,0,2]
+
+**Output:** 5
+
+**Explanation:** You can allocate to the first, second and third child with 2, 1, 2 candies respectively. 
+
+**Example 2:**
+
+**Input:** ratings = [1,2,2]
+
+**Output:** 4
+
+**Explanation:** You can allocate to the first, second and third child with 1, 2, 1 candies respectively. The third child gets 1 candy because it satisfies the above two conditions. 
+
+**Constraints:**
+
+*   `n == ratings.length`
+*   <code>1 <= n <= 2 * 10<sup>4</sup></code>
+*   <code>0 <= ratings[i] <= 2 * 10<sup>4</sup></code>

src/main/ts/g0101_0200/s0135_candy/solution.ts

@@ -0,0 +1,20 @@
+// #Hard #Array #Greedy #Top_Interview_150_Array/String
+// #2025_04_07_Time_2_ms_(96.15%)_Space_61.00_MB_(33.47%)
+
+function candy(ratings: number[]): number {
+    const n = ratings.length
+    const candies: number[] = new Array(n).fill(1)
+    for (let i = 0; i < n - 1; i++) {
+        if (ratings[i + 1] > ratings[i]) {
+            candies[i + 1] = candies[i] + 1
+        }
+    }
+    for (let i = n - 1; i > 0; i--) {
+        if (ratings[i - 1] > ratings[i] && candies[i - 1] < candies[i] + 1) {
+            candies[i - 1] = candies[i] + 1
+        }
+    }
+    return candies.reduce((sum, c) => sum + c, 0)
+}
+
+export { candy }

src/main/ts/g0101_0200/s0137_single_number_ii/readme.md

@@ -0,0 +1,25 @@
+137\. Single Number II
+
+Medium
+
+Given an integer array `nums` where every element appears **three times** except for one, which appears **exactly once**. _Find the single element and return it_.
+
+You must implement a solution with a linear runtime complexity and use only constant extra space.
+
+**Example 1:**
+
+**Input:** nums = [2,2,3,2]
+
+**Output:** 3 
+
+**Example 2:**
+
+**Input:** nums = [0,1,0,1,0,1,99]
+
+**Output:** 99 
+
+**Constraints:**
+
+*   <code>1 <= nums.length <= 3 * 10<sup>4</sup></code>
+*   <code>-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1</code>
+*   Each element in `nums` appears exactly **three times** except for one element which appears **once**.

src/main/ts/g0101_0200/s0137_single_number_ii/solution.ts

@@ -0,0 +1,14 @@
+// #Medium #Array #Bit_Manipulation #Top_Interview_150_Bit_Manipulation
+// #2025_04_07_Time_0_ms_(100.00%)_Space_59.11_MB_(24.16%)
+
+function singleNumber(nums: number[]): number {
+    let ones = 0
+    let twos = 0
+    for (const num of nums) {
+        ones = (ones ^ num) & (~twos)
+        twos = (twos ^ num) & (~ones)
+    }
+    return ones
+}
+
+export { singleNumber }

src/test/ts/g0101_0200/s0127_word_ladder/solution.test.ts

@@ -0,0 +1,11 @@
+// tslint:disable:no-magic-numbers
+import { ladderLength } from 'src/main/ts/g0101_0200/s0127_word_ladder/solution'
+import { expect, test } from 'vitest'
+
+test('ladderLength', () => {
+    expect(ladderLength('hit', 'cog', ['hot', 'dot', 'dog', 'lot', 'log', 'cog'])).toEqual(5)
+})
+
+test('ladderLength2', () => {
+    expect(ladderLength('hit', 'cog', ['hot', 'dot', 'dog', 'lot', 'log'])).toEqual(0)
+})