offcode 0.0.0-stage → 0.1.1

package/data/problems/sudoku-solver.json

@@ -0,0 +1 @@
+{"basic": false, "label": "263", "slug": "sudoku-solver", "id": 263, "title": "Sudoku Solver", "difficulty": "Hard", "category": "array", "link": "https://leetcode.com/problems/sudoku-solver/", "examples": [{"input": "board = [\"53..7....\",\"6..195...\",\".98....6.\",\"8...6...3\",\"4..8.3..1\",\"7...2...6\",\".6....28.\",\"...419..5\",\"....8..79\"]", "output": "[\"534678912\",\"672195348\",\"198342567\",\"859761423\",\"426853791\",\"713924856\",\"961537284\",\"287419635\",\"345286179\"]", "explanation": "The completed grid meets the row, column, and box rules while keeping all given digits."}, {"input": "board = [\"5.4.7.9.2\",\"6.2.9.3.8\",\"1.8.4.5.7\",\"8.9.6.4.3\",\"4.6.5.7.1\",\"7.3.2.8.6\",\"9.1.3.2.4\",\"2.7.1.6.5\",\"3.5.8.1.9\"]", "output": "[\"534678912\",\"672195348\",\"198342567\",\"859761423\",\"426853791\",\"713924856\",\"961537284\",\"287419635\",\"345286179\"]", "explanation": "With every other cell blanked, the givens still determine the same full solution."}], "hints": ["Try digits cell by cell with depth-first search, undoing (backtracking) whenever a cell has no legal digit left.", "Track used digits per row, column, and box as bit masks, and always branch on the empty cell with the fewest candidates."], "statement": "Fill a 9x9 Sudoku grid so that every row, every column, and each of the nine 3x3 sub-boxes contains the digits `1` through `9` exactly once. Empty cells are written as `'.'`; the pre-filled digits must stay untouched.\n\nEach board is passed as nine strings of nine characters, and you must return the completed board in the same shape: nine strings with every `'.'` replaced by the correct digit.\n\n**Constraints:**\n- `board.length == 9`\n- `board[i].length == 9`\n- Each cell holds a digit `'1'`-`'9'` or `'.'`.\n- Every test board admits at least one valid completion.\n\n*Adaptation note:* the classic statement edits a `char[][]` in place with no return value. Because this judge compares returned values, each row is encoded as a string and you return the nine completed row-strings instead. Any fully valid completion is accepted.\n", "solution": "## Approach\n\nRecord the digits already used in each row, column, and 3x3 box as bit masks, and collect the empty cells. Repeatedly pick the empty cell with the fewest legal candidates, try each one while updating the masks, and recurse; restore the masks when a branch dead-ends. Bit operations make candidate checks and updates constant time.\n\n## Complexity Analysis\n\n- **Time Complexity:** Worst-case exponential in the number of blanks, but mask pruning plus fewest-candidates-first keeps real puzzles fast.\n- **Space Complexity:** O(1) extra space besides the recursion stack and the board itself.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def solveSudoku(self, board: List[str]) -> List[str]:\n        g = [list(row) for row in board]\n        rows, cols, boxes = [0] * 9, [0] * 9, [0] * 9\n        empties = []\n        for r in range(9):\n            for c in range(9):\n                if g[r][c] == '.':\n                    empties.append((r, c))\n                else:\n                    b = 1 << (ord(g[r][c]) - ord('1'))\n                    rows[r] |= b\n                    cols[c] |= b\n                    boxes[(r // 3) * 3 + c // 3] |= b\n\n        def cands(r, c):\n            return (~(rows[r] | cols[c] | boxes[(r // 3) * 3 + c // 3])) & 0x1FF\n\n        def dfs(k):\n            if k == len(empties):\n                return True\n            best = min(range(k, len(empties)),\n                       key=lambda i: bin(cands(*empties[i])).count('1'))\n            empties[k], empties[best] = empties[best], empties[k]\n            r, c = empties[k]\n            b = (r // 3) * 3 + c // 3\n            m = cands(r, c)\n            d = 1\n            while m:\n                if m & 1:\n                    bit = 1 << (d - 1)\n                    g[r][c] = str(d)\n                    rows[r] |= bit\n                    cols[c] |= bit\n                    boxes[b] |= bit\n                    if dfs(k + 1):\n                        return True\n                    rows[r] &= ~bit\n                    cols[c] &= ~bit\n                    boxes[b] &= ~bit\n                d += 1\n                m >>= 1\n            g[r][c] = '.'\n            empties[k], empties[best] = empties[best], empties[k]\n            return False\n\n        dfs(0)\n        return [''.join(row) for row in g]\n```\n", "starter": {"go": "package main\n\nfunc SolveSudoku(board []string) []string {\n    return []string{}\n}", "python": "from typing import List\n\nclass Solution:\n    def solveSudoku(self, board: List[str]) -> List[str]:\n        return []\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<string> solveSudoku(vector<string>& board) {\n        return {};\n    }\n};"}, "fn": "solveSudoku", "params": [{"name": "board", "type": "string_array"}], "outputType": "string_list", "tests": [["[\"53..7....\", \"6..195...\", \".98....6.\", \"8...6...3\", \"4..8.3..1\", \"7...2...6\", \".6....28.\", \"...419..5\", \"....8..79\"]"], ["[\"5.4.7.9.2\", \".7.1.5.4.\", \"1.8.4.5.7\", \".5.7.1.2.\", \"4.6.5.7.1\", \".1.9.4.5.\", \"9.1.3.2.4\", \".8.4.9.3.\", \"3.5.8.1.9\"]"], ["[\".34.78.12\", \"67.19.34.\", \"1.83.25.7\", \".59.61.23\", \"42.85.79.\", \"7.39.48.6\", \".61.37.84\", \"28.41.63.\", \"3.52.61.9\"]"], ["[\"534678912\", \".........\", \"198342567\", \".........\", \"426853791\", \".........\", \"961537284\", \".........\", \"345286179\"]"], ["[\"5.4.7.9.2\", \"6.2.9.3.8\", \"1.8.4.5.7\", \"8.9.6.4.3\", \"4.6.5.7.1\", \"7.3.2.8.6\", \"9.1.3.2.4\", \"2.7.1.6.5\", \"3.5.8.1.9\"]"], ["[\".346.891.\", \"672.953.8\", \"19.342.67\", \"8.976.423\", \".268.379.\", \"713.248.6\", \"96.537.84\", \"2.741.635\", \".452.617.\"]"], ["[\".3467.912\", \"6.2195.48\", \"19.3425.7\", \"859.6142.\", \"4268.3791\", \".1392.856\", \"9.1537.84\", \"28.4196.5\", \"345.8617.\"]"], ["[\"534678912\", \"672195348\", \"198342567\", \"859761423\", \"426853791\", \"713924856\", \".........\", \".........\", \".........\"]"], ["[\"534678912\", \"6..1..3..\", \"1..3..5..\", \"859761423\", \"4..8..7..\", \"7..9..8..\", \"961537284\", \"2..4..6..\", \"3..2..1..\"]"], ["[\"53.67.91.\", \"67.19.34.\", \"19.34.56.\", \"85.76.42.\", \"42.85.79.\", \"71.92.85.\", \"96.53.28.\", \"28.41.63.\", \"34.28.17.\"]"], ["[\"534678...\", \"672195...\", \"198342...\", \"859761...\", \"426853...\", \"713924...\", \"961537...\", \"287419...\", \"345286...\"]"], ["[\"53.67.91.\", \".72.95.48\", \"1.83.25.7\", \"85.76.42.\", \".26.53.91\", \"7.39.48.6\", \"96.53.28.\", \".87.19.35\", \"3.52.61.9\"]"], ["[\"534678912\", \"672195348\", \"198342567\", \"859761423\", \"4.6.5.7.1\", \"713924856\", \"961537284\", \"287419635\", \"345286179\"]"], ["[\"1.3.5.7.9\", \".5.7.9.2.\", \"7.9.2.4.6\", \".1.3.5.9.\", \"3.5.9.2.4\", \".9.2.4.6.\", \"5.1.3.9.8\", \".3.9.8.4.\", \"9.8.4.6.2\"]"], ["[\".23.56.89\", \"45.78.12.\", \"7.91.34.6\", \".14.65.97\", \"36.89.21.\", \"8.72.43.5\", \".41.32.78\", \"63.97.54.\", \"9.85.16.2\"]"], ["[\".........\", \"456789123\", \".........\", \"214365897\", \".........\", \"897214365\", \".........\", \"632978541\", \".........\"]"], ["[\".2.4.6.8.\", \".5.7.9.2.\", \".8.1.3.5.\", \".1.3.5.9.\", \".6.8.7.1.\", \".9.2.4.6.\", \".4.6.2.7.\", \".3.9.8.4.\", \".7.5.1.3.\"]"], ["[\"1.345.789\", \".567.912.\", \"789.234.6\", \"21.365.97\", \"3.589.214\", \".972.436.\", \"541.329.8\", \"63.978.41\", \"9.854.632\"]"], ["[\"123456789\", \"456789123\", \"789123456\", \"214365897\", \"365897214\", \"897214365\", \"541632978\", \".........\", \".........\"]"], ["[\"1234567..\", \"4567891..\", \"7891234..\", \"2143658..\", \"3658972..\", \"8972143..\", \"5416329..\", \"6329785..\", \"9785416..\"]"], ["[\".23.56.89\", \".56.89.23\", \".89.23.56\", \".14.65.97\", \".65.97.14\", \".97.14.65\", \".41.32.78\", \".32.78.41\", \".78.41.32\"]"], ["[\"12.45.78.\", \".56.89.23\", \"7.91.34.6\", \"21.36.89.\", \".65.97.14\", \"8.72.43.5\", \"54.63.97.\", \".32.78.41\", \"9.85.16.2\"]"], ["[\"123456789\", \"456789123\", \"789123456\", \"214365897\", \"365897214\", \"897214365\", \"541632978\", \"632978541\", \".7.5.1.3.\"]"], ["[\"123.567.9\", \"45.789.23\", \"7.912.456\", \".143.589.\", \"365.972.4\", \"89.214.65\", \"5.163.978\", \".329.854.\", \"978.416.2\"]"], ["[\"534.78912\", \"6.219534.\", \"198342.67\", \"8597.1423\", \"42.853791\", \".139248.6\", \"96153.284\", \"287.19635\", \"3.528617.\"]"]], "expected": [["534678912", "672195348", "198342567", "859761423", "426853791", "713924856", "961537284", "287419635", "345286179"], ["534678912", "672195348", "198342567", "859761423", "426853791", "713924856", "961537284", "287419635", "345286179"], ["534678912", "672195348", "198342567", "859761423", "426853791", "713924856", "961537284", "287419635", "345286179"], ["534678912", "672195438", "198342567", "819764325", "426853791", "753921846", "961537284", "287419653", "345286179"], ["534678912", "672591348", "198342567", "859167423", "426853791", "713429856", "961735284", "287914635", "345286179"], ["534678912", "672195348", "198342567", "859761423", "426853791", "713924856", "961537284", "287419635", "345286179"], ["534678912", "672195348", "198342567", "859761423", "426853791", "713924856", "961537284", "287419635", "345286179"], ["534678912", "672195348", "198342567", "859761423", "426853791", "713924856", "265437189", "341289675", "987516234"], ["534678912", "682195347", "197342568", "859761423", "426853791", "713924856", "961537284", "278419635", "345286179"], ["534672918", "678195342", "192348567", "859761423", "426853791", "713924856", "961537284", "287419635", "345286179"], ["534678129", "672195348", "198342675", "859761234", "426853791", "713924856", "961537482", "287419563", "345286917"], ["534678912", "672195348", "198342567", "859761423", "426853791", "713924856", "961537284", "287419635", "345286179"], ["534678912", "672195348", "198342567", "859761423", "426853791", "713924856", "961537284", "287419635", "345286179"], ["123456789", "456789321", "789123456", "214365897", "365897214", "897214563", "541632978", "632978145", "978541632"], ["123456789", "456789123", "789123456", "214365897", "365897214", "897214365", "541632978", "632978541", "978541632"], ["783126459", "456789123", "129453786", "214365897", "365897214", "897214365", "541632978", "632978541", "978541632"], ["129456387", "356789421", "487123659", "812365794", "564897213", "793214865", "941632578", "235978146", "678541932"], ["123456789", "456789123", "789123456", "214365897", "365897214", "897214365", "541632978", "632978541", "978541632"], ["123456789", "456789123", "789123456", "214365897", "365897214", "897214365", "541632978", "632978541", "978541632"], ["123456789", "456789132", "789123465", "214365897", "365897241", "897214356", "541632978", "632978514", "978541623"], ["123456789", "456789123", "789123456", "214365897", "365897214", "897214365", "541632978", "632978541", "978541632"], ["123456789", "456789123", "789123456", "214365897", "365897214", "897214365", "541632978", "632978541", "978541632"], ["123456789", "456789123", "789123456", "214365897", "365897214", "897214365", "541632978", "632978541", "978541632"], ["123456789", "456789123", "789123456", "214365897", "365897214", "897214365", "541632978", "632978541", "978541632"], ["534678912", "672195348", "198342567", "859761423", "426853791", "713924856", "961537284", "287419635", "345286179"]], "loose": false}

package/data/problems/sum-of-all-subset-xor-totals.json

@@ -0,0 +1 @@
+{"basic": false, "label": "207", "slug": "sum-of-all-subset-xor-totals", "id": 207, "title": "Sum of All Subset XOR Totals", "difficulty": "Easy", "category": "backtracking", "link": "https://leetcode.com/problems/sum-of-all-subset-xor-totals/", "examples": [{"input": "nums = [1,3]", "output": "6", "explanation": "The 4 subsets of [1,3] are: [], [1], [3], [1,3]. Their XOR totals are 0, 1, 3, and 1 XOR 3 = 2, and 0 + 1 + 3 + 2 = 6."}, {"input": "nums = [5,1,6]", "output": "28", "explanation": "The 8 subsets of [5,1,6] are: [], [5], [1], [6], [5,1], [5,6], [1,6], [5,1,6]. The sum of their XOR totals is 28."}, {"input": "nums = [3,4,5,6,7,8]", "output": "480", "explanation": "The sum of all XOR totals for every subset is 480."}], "hints": ["Is there a way to iterate through all the subsets of the array?", "Use recursion to explore include/exclude choices and accumulate the running XOR total."], "statement": "Call the XOR-combination of a list the result of XOR-ing all of its entries together, with the empty list assigned `0`.\n\n- As an illustration, the XOR-combination of `[2,5,6]` is `2 XOR 5 XOR 6 = 1`.\n\nStarting from an input list `nums`, consider each of its subsets and compute that subset's XOR-combination. Return the total obtained by adding all of those values together.\n\n**Note:** Selections that look alike but arise from different positions count separately.\n\nHere a subset means any collection obtainable from `b` by discarding zero or more entries, keeping the rest, when written as `a` drawn from `b`.\n\n**Constraints:**\n\n- `1 <= nums.length <= 12`\n- `1 <= nums[i] <= 20`\n", "solution": "## Approach\n\nEnumerate every subset with a recursive include/exclude search. At each position we branch into two choices: leave `nums[i]` out of the subset (keeping the current XOR total unchanged) or include it (XOR-ing `nums[i]` into the current total). When the end of the array is reached, the accumulated XOR total of that subset is added to the result.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(2^n), where n is the length of `nums`, since every subset is visited exactly once.\n- **Space Complexity:** O(n) for the recursion stack (excluding the implicit output of the aggregate sum).\n\n## Implementation\n\n```python\nfrom typing import List\n\n\nclass Solution:\n    def subsetXORSum(self, nums: List[int]) -> int:\n        def collect(index: int, current: int) -> int:\n            if index == len(nums):\n                return current\n            skip = collect(index + 1, current)\n            take = collect(index + 1, current ^ nums[index])\n            return skip + take\n\n        return collect(0, 0)\n```", "starter": {"go": "package main\n\nfunc SubsetXORSum(nums []int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def subsetXORSum(self, nums: List[int]) -> int:\n        ", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    int subsetXORSum(vector<int>& nums) {\n        \n    }\n};"}, "fn": "subsetXORSum", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[1]"], ["[1,3]"], ["[5,1,6]"], ["[3,4,5,6,7,8]"], ["[2]"], ["[1,1]"], ["[20]"], ["[1,2,3]"], ["[1,1,1,1]"], ["[1,2,4,8]"], ["[10,11,12]"], ["[1,2,3,4,5]"], ["[3]"], ["[1,2]"], ["[4,4]"], ["[7,7,7]"], ["[1,20]"], ["[20,20]"], ["[2,5,8]"], ["[9,10]"], ["[1,1,2]"], ["[6,6,6,6]"], ["[15,3,7]"], ["[1,2,3,4]"], ["[11,13,17]"], ["[19,20,1]"], ["[5,5,5,5,5]"], ["[2,4,6,8,10]"], ["[12,14,16]"], ["[18,19,20]"]], "expected": [1, 6, 28, 480, 2, 2, 20, 12, 8, 120, 60, 112, 3, 6, 8, 28, 42, 40, 60, 22, 12, 48, 60, 56, 124, 92, 80, 224, 120, 92], "loose": false}

package/data/problems/sum-of-distances-in-tree.json

@@ -0,0 +1 @@
+{"basic": false, "label": "832", "slug": "sum-of-distances-in-tree", "id": 832, "title": "Sum of Distances in Tree", "difficulty": "Hard", "category": "tree", "link": "https://leetcode.com/problems/sum-of-distances-in-tree/", "examples": [{"input": "n = 6, edges = [[0,1],[0,2],[2,3],[2,4],[2,5]]", "output": "[8,12,6,10,10,10]", "explanation": "Node 2 is the most central with total 6."}, {"input": "n = 1, edges = []", "output": "[0]"}, {"input": "n = 2, edges = [[1,0]]", "output": "[1,1]"}], "hints": ["Root the tree at 0: a bottom-up pass counts subtree sizes and the distance sums inside each subtree.", "Reroot with the relation childAnswer = parentAnswer - subtreeSize[child] + (n - subtreeSize[child]), since moving the root across one edge shortens paths into the child subtree and lengthens all others.", "A second top-down pass propagates the root answer to every node in linear time."], "statement": "You are given an undirected tree with `n` nodes labelled `0` to `n - 1` and an edge list `edges`, where each entry connects two nodes. For every node `i`, compute the sum of the distances (number of edges on the shortest path) from `i` to all other nodes. Return these sums as an array `answer` where `answer[i]` belongs to node `i`.\n\n**Constraints:**\n- `1 <= n <= 3 * 10^4`\n- `edges.length == n - 1`\n- `0 <= edges[i][0], edges[i][1] < n`\n- The edges form a valid tree\n", "solution": "## Approach\n\nRoot the tree at node 0 and run a post-order pass that counts each subtree's size and sums distances inside it: a parent's total is the children's totals plus one extra edge per descendant. Then run a pre-order pass that reroots across each edge \u2014 moving the root from parent to child shortens every path into the child's subtree by one and lengthens every other path by one, giving childAnswer = parentAnswer - size[child] + (n - size[child]). Both passes are linear.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) where n is the node count; each edge is traversed twice.\n- **Space Complexity:** O(n) for the adjacency list, counts, and answers (plus recursion depth).\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n    def sumOfDistancesInTree(self, n: int, edges: List[List[int]]) -> List[int]:\n        import sys\n        sys.setrecursionlimit(100000)\n        g = [[] for _ in range(n)]\n        for a, b in edges:\n            g[a].append(b)\n            g[b].append(a)\n        cnt = [0] * n\n        ans = [0] * n\n\n        def dfs1(u, p):\n            cnt[u] = 1\n            for v in g[u]:\n                if v == p:\n                    continue\n                dfs1(v, u)\n                cnt[u] += cnt[v]\n                ans[u] += ans[v] + cnt[v]\n\n        def dfs2(u, p):\n            for v in g[u]:\n                if v == p:\n                    continue\n                ans[v] = ans[u] - cnt[v] + (n - cnt[v])\n                dfs2(v, u)\n\n        dfs1(0, -1)\n        dfs2(0, -1)\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc SumOfDistancesInTree(n int, edges [][]int) []int {\n    return nil\n}", "python": "from typing import List\nclass Solution:\n    def sumOfDistancesInTree(self, n: int, edges: List[List[int]]) -> List[int]:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<int> sumOfDistancesInTree(int n, vector<vector<int>>& edges) {\n        return {};\n    }\n};"}, "fn": "sumOfDistancesInTree", "params": [{"name": "n", "type": "int"}, {"name": "edges", "type": "int_array_2d"}], "outputType": "int_array", "tests": [["6", "[[0, 1], [0, 2], [2, 3], [2, 4], [2, 5]]"], ["1", "[]"], ["2", "[[1, 0]]"], ["3", "[[0, 1], [1, 2]]"], ["3", "[[0, 1], [0, 2]]"], ["4", "[[0, 1], [1, 2], [2, 3]]"], ["4", "[[0, 1], [0, 2], [0, 3]]"], ["5", "[[0, 1], [0, 2], [0, 3], [0, 4]]"], ["5", "[[0, 1], [1, 2], [2, 3], [3, 4]]"], ["5", "[[4, 0], [3, 0], [2, 0], [1, 0]]"], ["7", "[[0, 1], [0, 2], [1, 3], [1, 4], [2, 5], [2, 6]]"], ["7", "[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]"], ["8", "[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7]]"], ["6", "[[0, 1], [1, 2], [1, 3], [3, 4], [3, 5]]"], ["9", "[[0, 1], [0, 2], [0, 3], [1, 4], [1, 5], [2, 6], [3, 7], [3, 8]]"], ["10", "[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9]]"], ["10", "[[0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [0, 7], [0, 8], [0, 9]]"], ["6", "[[5, 4], [4, 3], [3, 2], [2, 1], [1, 0]]"], ["11", "[[0, 1], [0, 2], [1, 3], [1, 4], [2, 5], [2, 6], [3, 7], [4, 8], [5, 9], [6, 10]]"], ["4", "[[2, 0], [2, 1], [2, 3]]"], ["12", "[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 10], [10, 11]]"], ["5", "[[1, 0], [2, 1], [3, 2], [4, 3]]"], ["13", "[[0, 1], [0, 2], [1, 3], [1, 4], [4, 5], [5, 6], [2, 7], [7, 8], [8, 9], [2, 10], [10, 11], [11, 12]]"], ["15", "[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 10], [10, 11], [11, 12], [12, 13], [13, 14]]"], ["15", "[[0, 1], [0, 2], [0, 3], [0, 4], [1, 5], [1, 6], [2, 7], [2, 8], [3, 9], [3, 10], [4, 11], [4, 12], [5, 13], [5, 14]]"], ["2", "[[0, 1]]"], ["20", "[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 10], [10, 11], [11, 12], [12, 13], [13, 14], [14, 15], [15, 16], [16, 17], [17, 18], [18, 19]]"], ["9", "[[8, 0], [7, 1], [6, 2], [5, 3], [4, 0], [3, 0], [2, 0], [1, 0]]"]], "expected": [[8, 12, 6, 10, 10, 10], [0], [1, 1], [3, 2, 3], [2, 3, 3], [6, 4, 4, 6], [3, 5, 5, 5], [4, 7, 7, 7, 7], [10, 7, 6, 7, 10], [4, 7, 7, 7, 7], [10, 11, 11, 16, 16, 16, 16], [21, 16, 13, 12, 13, 16, 21], [28, 22, 18, 16, 16, 18, 22, 28], [11, 7, 11, 7, 11, 11], [13, 16, 18, 16, 23, 23, 25, 23, 23], [45, 37, 31, 27, 25, 25, 27, 31, 37, 45], [9, 17, 17, 17, 17, 17, 17, 17, 17, 17], [15, 11, 9, 9, 11, 15], [22, 23, 23, 30, 30, 30, 30, 39, 39, 39, 39], [5, 5, 3, 5], [66, 56, 48, 42, 38, 36, 36, 38, 42, 48, 56, 66], [10, 7, 6, 7, 10], [31, 34, 30, 45, 41, 50, 61, 37, 46, 57, 37, 46, 57], [105, 92, 81, 72, 65, 60, 57, 56, 57, 60, 65, 72, 81, 92, 105], [26, 31, 35, 35, 35, 40, 44, 48, 48, 48, 48, 48, 48, 53, 53], [1, 1], [190, 172, 156, 142, 130, 120, 112, 106, 102, 100, 100, 102, 106, 112, 120, 130, 142, 156, 172, 190], [11, 16, 16, 16, 18, 23, 23, 23, 18]], "loose": false}

package/data/problems/sum-of-even-numbers-after-queries.json

@@ -0,0 +1 @@
+{"basic": false, "label": "968", "slug": "sum-of-even-numbers-after-queries", "id": 968, "title": "Sum of Even Numbers After Queries", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/sum-of-even-numbers-after-queries/", "examples": [{"input": "nums = [1,2,3,4], queries = [[1,0],[-3,1],[-4,0],[2,3]]", "output": "[8,6,2,4]", "explanation": "After each addition the even total becomes 8, then 6, then 2, then 4."}, {"input": "nums = [1], queries = [[4,0]]", "output": "[0]", "explanation": "The single entry becomes 5 (odd), so the even total is 0."}], "hints": ["Maintain the sum of currently even entries instead of rescanning the array per query.", "Before applying queries[i] = [val, idx], subtract nums[idx] from the total if it is even.", "After the update, add nums[idx] back if it is even, and record the total."], "statement": "You are given an integer array `nums` and a list of `queries`, where each query is a pair `[val, index]` meaning add `val` to `nums[index]`.\n\nAfter applying each query in order, compute the sum of all even-valued entries in the array. Collect these sums into an answer array of the same length as `queries` and return it.\n\n**Constraints:**\n- `1 <= nums.length <= 10000`\n- `-10000 <= nums[i] <= 10000`\n- `1 <= queries.length <= 10000`\n- `queries[i] = [val, index]`, `-10000 <= val <= 10000`, `0 <= index < nums.length`.\n", "solution": "## Approach\n\nKeep the sum of the currently even entries. For each query [val, idx], remove nums[idx] from that sum if it is even, apply the addition, then add it back if it is now even. Recording the running sum after every query yields the answer without rescanning the array.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + q), where n is the array length and q is the number of queries.\n- **Space Complexity:** O(q) for the answer array (O(1) extra).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:\n        even = sum(x for x in nums if x % 2 == 0)\n        ans = []\n        for v, i in queries:\n            if nums[i] % 2 == 0:\n                even -= nums[i]\n            nums[i] += v\n            if nums[i] % 2 == 0:\n                even += nums[i]\n            ans.append(even)\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc SumEvenAfterQueries(nums []int, queries [][]int) []int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<int> sumEvenAfterQueries(vector<int>& nums, vector<vector<int>>& queries) {\n        return {};\n    }\n};"}, "fn": "sumEvenAfterQueries", "params": [{"name": "nums", "type": "int_array"}, {"name": "queries", "type": "int_array_2d"}], "outputType": "int_array", "tests": [["[1,2,3,4]", "[[1,0],[-3,1],[-4,0],[2,3]]"], ["[1]", "[[4,0]]"], ["[2,2,2]", "[[1,0],[1,1],[1,2]]"], ["[1,3,5]", "[[1,0],[1,1],[1,2]]"], ["[0,0,0]", "[[0,0],[0,1],[0,2]]"], ["[2,4,6]", "[[-2,0],[-4,1],[-6,2]]"], ["[1,2]", "[[3,0],[3,1]]"], ["[-1,-2,-3]", "[[1,0],[2,1],[3,2]]"], ["[5,5,5,5]", "[[5,0],[5,1],[5,2],[5,3]]"], ["[0]", "[[1,0],[-1,0],[2,0]]"], ["[10,-10,10,-10]", "[[10,1],[-10,0],[5,2]]"], ["[3,1,2]", "[[0,0],[0,1],[0,2]]"], ["[4,4]", "[[1,0],[1,0],[1,0]]"], ["[1,1,1,1,1]", "[[1,0],[1,1],[1,2],[1,3],[1,4]]"], ["[2,0]", "[[1,1],[1,1],[1,1]]"], ["[10000,-10000]", "[[10000,0],[-10000,1]]"], ["[7,8,9]", "[[-7,0],[-8,1],[-9,2]]"], ["[1,2,3]", "[[2,2],[2,2],[2,2]]"], ["[6,6,6]", "[[3,0],[3,1],[3,2]]"], ["[0,1,2,3,4,5]", "[[1,0],[1,1],[1,2],[1,3],[1,4],[1,5]]"], ["[-4,-2,0,2,4]", "[[2,0],[2,2],[2,4]]"], ["[11,13,17]", "[[1,0],[2,1],[3,2]]"], ["[2,4]", "[[0,0],[0,1]]"], ["[8]", "[[1,0],[2,0],[3,0]]"], ["[3,3,3]", "[[-1,0],[-1,1],[-1,2]]"], ["[1,4,6,8]", "[[1,0],[1,0],[1,0],[1,0]]"], ["[5,6,7,8,9]", "[[5,4],[-5,0],[3,2]]"], ["[0,2,4,6,8]", "[[-1,0],[-1,1],[-1,2],[-1,3],[-1,4]]"]], "expected": [[8, 6, 2, 4], [0], [4, 2, 0], [2, 6, 12], [0, 0, 0], [10, 6, 0], [6, 4], [-2, 0, 0], [10, 20, 30, 40], [0, 0, 2], [10, 0, -10], [2, 2, 2], [4, 10, 4], [2, 4, 6, 8, 10], [2, 4, 2], [10000, 0], [8, 0, 0], [2, 2, 2], [12, 6, 0], [6, 8, 6, 10, 6, 12], [2, 4, 6], [12, 12, 32], [6, 6], [0, 0, 14], [2, 4, 6], [20, 18, 22, 18], [28, 28, 38], [20, 18, 14, 8, 0]], "loose": false}

package/data/problems/sum-of-left-leaves.json

@@ -0,0 +1 @@
+{"basic": false, "label": "478", "slug": "sum-of-left-leaves", "id": 478, "title": "Sum of Left Leaves", "difficulty": "Easy", "category": "tree", "link": "https://leetcode.com/problems/sum-of-left-leaves/", "examples": [{"input": "root = [3,9,20,null,null,15,7]", "output": "24", "explanation": "Left leaves are 9 and 15, summing to 24."}, {"input": "root = [1]", "output": "0", "explanation": "The single node has no children, so there is no left leaf."}, {"input": "root = [1,2,3,4,5]", "output": "4", "explanation": "Only node 4 is a leaf reached as a left child."}], "hints": ["A left leaf is a node without children that hangs off the left side of its parent.", "Walk depth-first, carrying whether the current node is a left child.", "Add the value only when both conditions hold: left-child status and leaf status."], "statement": "You receive the root of a binary tree. Add up the values of certain special nodes: those that are leaves and sit as the left child of their parent.\n\nA leaf means a node with neither a left nor a right child. The root itself never counts, because it has no parent. Any leaf reached via a right edge is ignored.\n\nReturn the total of all qualifying left-leaf values.\n\n**Constraints:**\n- `1 <= number of nodes <= 1000`\n- `-1000 <= Node.val <= 1000`\n", "solution": "## Approach\n\nDepth-first search carries one extra flag telling whether the current node arrived as a left child. An empty child contributes nothing; a leaf contributes its value only when the flag is set; an inner node sums both sides with updated flags. Starting the walk at the root with the flag cleared counts exactly the left leaves.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the node count.\n- **Space Complexity:** O(h) recursion depth, O(n) worst case.\n\n## Implementation\n\n```python\nclass Solution:\n    def sumOfLeftLeaves(self, root) -> int:\n        def dfs(node, is_left: bool) -> int:\n            if node is None:\n                return 0\n            if node.left is None and node.right is None:\n                return node.val if is_left else 0\n            return dfs(node.left, True) + dfs(node.right, False)\n        return dfs(root, False)\n```\n", "starter": {"go": "package main\n\nfunc SumOfLeftLeaves(root *TreeNode) int {\n    return 0\n}", "python": "# Definition for a binary tree node.\n# class TreeNode:\n#     def __init__(self, val=0, left=None, right=None):\n#         self.val = val\n#         self.left = left\n#         self.right = right\n\nclass Solution:\n    def sumOfLeftLeaves(self, root) -> int:\n        pass\n", "cpp": "/*\nstruct TreeNode {\n    int val;\n    TreeNode *left;\n    TreeNode *right;\n    TreeNode(): val(0), left(nullptr), right(nullptr) {}\n    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}\n    TreeNode(int x, TreeNode *left, TreeNode *right): val(x), left(left), right(right) {}\n};\n*/\nclass Solution {\npublic:\n    int sumOfLeftLeaves(TreeNode* root) {\n        return 0;\n    }\n};"}, "fn": "sumOfLeftLeaves", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}], "outputType": "int", "tests": [["[3,9,20,null,null,15,7]"], ["[1]"], ["[1,2,3,4,5]"], ["[1,2,null,3]"], ["[1,null,2]"], ["[1,2,3]"], ["[0]"], ["[1,2,3,4,null,null,5]"], ["[1,2,3,null,4,5,null]"], ["[5,4,6,3,null,null,7]"], ["[-1,-2,-3]"], ["[1,2,3,4,5,6,7]"], ["[1,null,2,3]"], ["[1,2,null,null,3]"], ["[2,1,3]"], ["[10,5,15,3,7,12,18]"], ["[1,2,3,4,null,5,null]"], ["[0,0,0,0,0]"], ["[1000,-1000,1000]"], ["[1,2,null,3,null,4]"], ["[1,null,2,null,3]"], ["[3,9,20,4,5,15,7]"], ["[1,2,2,3,4,4,3]"], ["[1,null,2,null,3,null,4]"], ["[2,null,3,null,4,null,5]"], ["[1,2,3,null,null,4,5]"], ["[7,3,9,1,5]"], ["[4,2,6,1,3,5,7]"], ["[1,2,3,4,5,null,null,6]"], ["[9,8,7,6,5]"]], "expected": [24, 0, 4, 3, 0, 2, 0, 4, 5, 3, -2, 10, 3, 0, 1, 15, 9, 0, -1000, 4, 0, 19, 7, 0, 0, 6, 1, 6, 6, 6], "loose": false}

package/data/problems/sum-of-square-numbers.json

@@ -0,0 +1 @@
+{"basic": false, "label": "655", "slug": "sum-of-square-numbers", "id": 655, "title": "Sum of Square Numbers", "difficulty": "Medium", "category": "math", "link": "https://leetcode.com/problems/sum-of-square-numbers/", "examples": [{"input": "c = 5", "output": "true", "explanation": "1^2 + 2^2 = 5."}, {"input": "c = 3", "output": "false", "explanation": "No pair of squares sums to 3."}, {"input": "c = 4", "output": "true", "explanation": "0^2 + 2^2 = 4."}], "hints": ["Think of a at 0 and b at floor(sqrt(c)) as two ends of the search.", "Compare a*a + b*b with c: too small moves a up, too large moves b down.", "Squares can reuse the same root (e.g. 2 = 1^2 + 1^2)."], "statement": "Given a non-negative integer `c`, decide whether two integer squares add up to it. That is, do there exist integers `a >= 0` and `b >= 0` with `a*a + b*b = c`?\n\nReturn true when such a pair exists and false otherwise.\n\n**Constraints:**\n- `0 <= c <= 2^31 - 1`\n", "solution": "## Approach\n\nPin one root at 0 and the other at the integer square root of c, then squeeze inward: the square sum grows when the low end rises and shrinks when the high end falls, so step the side indicated by the comparison with c. Meeting in the middle without a hit proves impossibility.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(sqrt(c)) steps.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nimport math\nclass Solution:\n    def judgeSquareSum(self, c: int) -> bool:\n        l, r = 0, math.isqrt(c)\n        while l <= r:\n            s = l * l + r * r\n            if s == c:\n                return True\n            if s < c:\n                l += 1\n            else:\n                r -= 1\n        return False\n```\n", "starter": {"go": "package main\n\nfunc JudgeSquareSum(c int) bool {\n    \n}", "python": "class Solution:\n    def judgeSquareSum(self, c: int) -> bool:\n        pass", "cpp": "class Solution {\npublic:\n    bool judgeSquareSum(int c) {\n        return false;\n    }\n};"}, "fn": "judgeSquareSum", "params": [{"name": "c", "type": "int"}], "outputType": "boolean", "tests": [["5"], ["3"], ["4"], ["0"], ["1"], ["2"], ["6"], ["7"], ["8"], ["9"], ["10"], ["13"], ["16"], ["25"], ["50"], ["65"], ["100"], ["1000"], ["1000000"], ["2147483647"], ["18"], ["20"], ["26"], ["29"], ["41"], ["45"], ["72"], ["122"]], "expected": [true, false, true, true, true, true, false, false, true, true, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true], "loose": false}

package/data/problems/sum-of-subarray-minimums.json

@@ -0,0 +1 @@
+{"basic": false, "label": "896", "slug": "sum-of-subarray-minimums", "id": 896, "title": "Sum of Subarray Minimums", "difficulty": "Medium", "category": "stack", "link": "https://leetcode.com/problems/sum-of-subarray-minimums/", "examples": [{"input": "arr = [3,1,2,4]", "output": "17", "explanation": "Ten slice minima sum to 17."}, {"input": "arr = [11,81,94,43,3]", "output": "444", "explanation": "All slice minima sum to 444."}, {"input": "arr = [1,2,3]", "output": "10", "explanation": "Minima 1,2,3,1,2,1 total 10."}], "hints": ["Each position serves as the minimum for a rectangle of subarrays bounded by the previous strictly smaller element and the next smaller-or-equal element.", "Use a monotone increasing stack to find those borders in linear time, then add arr[i] * leftCount * rightCount."], "statement": "For every contiguous slice of `arr` (the slice must be non-empty and keep neighbours together), note its tiniest entry. Add those minima together and report the sum modulo `10^9 + 7`.\n\n**Constraints:**\n- `1 <= arr.length <= 3 * 10^4`\n- `1 <= arr[i] <= 3 * 10^4`\n", "solution": "## Approach\n\nEvery index dominates exactly those subarrays where it is the chosen minimum. Scanning with an increasing stack finds for each slot how far it stretches left until a strictly smaller value and right until a smaller-or-equal value; the asymmetric tie-break guarantees each subarray is credited once. Multiplying the value by the two stretch lengths and summing modulo `1_000_000_007` yields the total.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) for the two stack passes plus the final accumulation.\n- **Space Complexity:** O(n) for the border arrays and the stack.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def sumSubarrayMins(self, arr: List[int]) -> int:\n        MOD = 10 ** 9 + 7\n        n = len(arr)\n        left = [0] * n\n        right = [0] * n\n        st = []\n        for i in range(n):\n            while st and arr[st[-1]] > arr[i]:\n                st.pop()\n            left[i] = i + 1 if not st else i - st[-1]\n            st.append(i)\n        st.clear()\n        for i in range(n - 1, -1, -1):\n            while st and arr[st[-1]] >= arr[i]:\n                st.pop()\n            right[i] = n - i if not st else st[-1] - i\n            st.append(i)\n        return sum(a * l * r for a, l, r in zip(arr, left, right)) % MOD\n```\n", "starter": {"go": "package main\n\nfunc SumSubarrayMins(arr []int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def sumSubarrayMins(self, arr: List[int]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int sumSubarrayMins(vector<int>& arr) {\n        return 0;\n    }\n};"}, "fn": "sumSubarrayMins", "params": [{"name": "arr", "type": "int_array"}], "outputType": "int", "tests": [["[3,1,2,4]"], ["[11,81,94,43,3]"], ["[1,2,3]"], ["[1]"], ["[2,2,2]"], ["[3,3,3,3]"], ["[4,3,2,1]"], ["[1,2,3,4]"], ["[5,4,3,2,1]"], ["[1,1,1,1]"], ["[2,1]"], ["[1,2]"], ["[3,1,2]"], ["[2,3,1]"], ["[7,5,7,5]"], ["[10,5,10]"], ["[1,3,2,4,5]"], ["[5,1,4,2,3]"], ["[30000,30000]"], ["[1,2,3,4,5,6]"], ["[6,5,4,3,2,1]"], ["[3,2,1,2,3]"], ["[4,4,1,4,4]"], ["[2,5,1,5,2]"], ["[11,11,11]"], ["[100,1,100]"], ["[3,1,2,4,5]"], ["[2,9,7,8,3,4,6,1]"]], "expected": [17, 444, 10, 1, 12, 30, 20, 20, 35, 10, 4, 4, 9, 10, 54, 40, 33, 28, 90000, 56, 56, 23, 33, 27, 66, 204, 30, 117], "loose": false}

package/data/problems/sum-of-subsequence-widths.json

@@ -0,0 +1 @@
+{"basic": false, "label": "882", "slug": "sum-of-subsequence-widths", "id": 882, "title": "Sum of Subsequence Widths", "difficulty": "Hard", "category": "array", "link": "https://leetcode.com/problems/sum-of-subsequence-widths/", "examples": [{"input": "nums = [2,1,3]", "output": "6", "explanation": "Singletons give 0; pairs give 1+1+2 and the triple gives 2."}, {"input": "nums = [2]", "output": "0", "explanation": "Only one subsequence with gap 0."}, {"input": "nums = [1,2,3,4]", "output": "23", "explanation": "Sorted contributions of maxima minus minima total 23."}], "hints": ["Sort a copy of the array first; the original order does not affect the collection of subsequence value-sets.", "In sorted order, the element at index i is the largest in exactly 2^i subsequences and the smallest in exactly 2^(n-1-i) of them.", "Precompute powers of two modulo 1000000007 and accumulate a[i] * (2^i - 2^(n-1-i))."], "statement": "For any non-empty collection of numbers, look at the gap between its biggest entry and its tiniest entry. A lone element therefore has a gap of zero.\n\nYou are handed an integer array `nums`. Think about every subsequence you can build by keeping some elements and dropping the rest while preserving their relative order (the kept elements need not sit next to each other). Add up the gap of each such subsequence, then give the total modulo `10^9 + 7`.\n\n**Constraints:**\n- `1 <= nums.length <= 10^5`\n- `1 <= nums[i] <= 10^5`\n", "solution": "## Approach\n\nSort the numbers so that order no longer matters for counting value-sets. In the sorted line-up, the element at position `i` serves as the biggest entry in precisely `2^i` subsequences (choose any subset of the `i` smaller items to join it) and as the tiniest entry in precisely `2^(n-1-i)` subsequences. Its net contribution is therefore `a[i] * (2^i - 2^(n-1-i))`. Adding those terms with powers of two prepared modulo `1_000_000_007` gives the wanted total.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n log n) for the sort plus O(n) for the sweep.\n- **Space Complexity:** O(n) for the sorted copy and the power table (O(1) extra besides sorting if done in place).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def sumSubseqWidths(self, nums: List[int]) -> int:\n        MOD = 10 ** 9 + 7\n        a = sorted(nums)\n        n = len(a)\n        pw = [1] * n\n        for i in range(1, n):\n            pw[i] = (pw[i - 1] * 2) % MOD\n        ans = 0\n        for i, v in enumerate(a):\n            ans = (ans + v * (pw[i] - pw[n - 1 - i])) % MOD\n        return ans % MOD\n```\n", "starter": {"go": "package main\n\nfunc SumSubseqWidths(nums []int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def sumSubseqWidths(self, nums: List[int]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int sumSubseqWidths(vector<int>& nums) {\n        return 0;\n    }\n};"}, "fn": "sumSubseqWidths", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[2,1,3]"], ["[2]"], ["[1,2,3,4]"], ["[1,1,1]"], ["[1,2]"], ["[5,4,3,2,1]"], ["[1,100000]"], ["[100000,1]"], ["[3,3,3,3]"], ["[1,2,3]"], ["[10,20,30]"], ["[5]"], ["[2,2,1]"], ["[1,3,2]"], ["[7,7,7,7,7,7]"], ["[1,2,3,4,5]"], ["[5,1,4,2,3]"], ["[10000,20000,30000]"], ["[1,1,2,2,3,3]"], ["[9,8,7,6,5,4,3,2,1]"], ["[1]"], ["[100000,100000]"], ["[2,1]"], ["[4,3,2,1]"], ["[6,1,5,2,4,3]"], ["[10,1,10,1,10]"], ["[1,2,3,4,5,6,7,8,9,10]"], ["[3,1,2,4,5]"]], "expected": [6, 0, 23, 0, 1, 72, 99999, 99999, 0, 6, 60, 0, 3, 6, 0, 72, 72, 60000, 90, 3084, 0, 0, 1, 23, 201, 189, 7181, 72], "loose": false}

package/data/problems/sum-of-two-integers.json

@@ -0,0 +1 @@
+{"basic": false, "label": "11", "slug": "sum-of-two-integers", "id": 11, "title": "Sum of Two Integers", "difficulty": "Medium", "category": "binary", "link": "https://leetcode.com/problems/sum-of-two-integers/", "examples": [{"input": "a = 1, b = 2", "output": "3", "explanation": "1 + 2 = 3."}, {"input": "a = 2, b = 3", "output": "5", "explanation": "2 + 3 = 5."}], "hints": ["Use bitwise operations: the partial sum is `a ^ b` and the carry is `(a & b) << 1`. Iterate until the carry is zero."], "statement": "You are given two integers `a` and `b`. Compute their combined total while steering clear of the `+` and `-` operators.\n\n**Constraints:**\n\n- -1000 \u2264 a, b \u2264 1000\n", "solution": "## Approach\n\nAddition without `+` or `-` can be done entirely with bitwise operations:\n\n- **XOR** (`a ^ b`) computes the sum of each bit *without* considering carries \u2014 it's like adding binary digits where `1+1 = 0` with a carry of `1` that gets lost.\n- **AND with left shift** (`(a & b) << 1`) computes the *carry* \u2014 bits where both operands are `1` produce a carry that must be added to the next higher bit.\n\nThe process repeats, adding the carry back to the sum, until no carry remains (`b == 0`). This naturally bottoms out because each iteration shifts the carry left, eventually making it zero.\n\nIn languages with fixed-width integers (e.g., Go's `int`, Java's `int`), a recursive version is clean and intuitive: the base case `b == 0` returns `a`, and the recursive call adds the carry to the sum.\n\nPython's unbounded integers require an extra 32-bit mask to simulate fixed-width overflow, which obscures the core idea.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1)\n- **Space Complexity:** O(1)\n\n## Implementation\n\n```python\nclass Solution:\n    def getSum(self, a: int, b: int) -> int:\n        mask = 0xFFFFFFFF\n        while b:\n            a, b = (a ^ b) & mask, ((a & b) << 1) & mask\n        return a if a < 0x80000000 else ~(a ^ mask)\n```\n\n```go\nfunc GetSum(a int, b int) int {\n    if b == 0 {\n        return a\n    }\n    sum := a ^ b\n    carry := (a & b) << 1\n    return GetSum(sum, carry)\n}\n```\n", "starter": {"go": "package main\n\nfunc GetSum(a int, b int) int {\n    \n}", "python": "class Solution:\n    def getSum(self, a: int, b: int) -> int:\n        pass\n", "cpp": "class Solution {\npublic:\n    int getSum(int a, int b) {\n        return 0;\n    }\n};"}, "fn": "getSum", "params": [{"name": "a", "type": "int"}, {"name": "b", "type": "int"}], "outputType": "int", "tests": [["1", "2"], ["2", "3"], ["-1", "1"], ["-5", "-7"], ["0", "0"], ["-1000", "1000"], ["1000", "0"], ["-500", "-500"], ["777", "222"], ["0", "1"], ["-1", "-1"], ["1000", "1000"], ["-1000", "-1000"], ["500", "500"], ["-999", "999"], ["1", "-1"], ["123", "456"], ["-123", "-456"], ["0", "-1000"], ["1000", "-1000"], ["42", "-42"], ["17", "83"], ["-300", "700"], ["999", "1"], ["-1", "0"], ["11", "22"], ["-15", "40"], ["600", "-200"], ["321", "123"], ["-700", "-100"]], "expected": [3, 5, 0, -12, 0, 0, 1000, -1000, 999, 1, -2, 2000, -2000, 1000, 0, 0, 579, -579, -1000, 0, 0, 100, 400, 1000, -1, 33, 25, 400, 444, -800], "loose": false}

package/data/problems/sum-root-to-leaf-numbers.json

@@ -0,0 +1 @@
+{"basic": false, "label": "300", "slug": "sum-root-to-leaf-numbers", "id": 300, "title": "Sum Root to Leaf Numbers", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/sum-root-to-leaf-numbers/", "examples": [{"input": "root = [1,2,3]", "output": "25", "explanation": "Paths 1->2 (12) and 1->3 (13) sum to 25."}, {"input": "root = [4,9,0,5,1]", "output": "1026", "explanation": "Paths give 495 + 491 + 40 = 1026."}], "hints": ["Carry the prefix value down: child prefix = parent prefix * 10 + child digit.", "Add the prefix to the answer only at leaves.", "Both DFS and BFS with the running number work."], "statement": "You are given the root of a binary tree whose nodes hold digits `0` through `9`. Every path from the root down to a leaf spells a decimal number by concatenating the digits along the way.\n\nFor instance, the path `1 -> 2 -> 3` stands for `123`.\n\nAdd up the numbers spelled by all root-to-leaf paths and return the total. The answer fits in a 32-bit integer. A leaf is a node with no children.\n\n**Constraints:**\n- The tree holds between 1 and 1000 nodes.\n- `0 <= Node.val <= 9`\n- Tree depth is at most 10.\n", "solution": "## Approach\n\nDo a depth-first walk that carries the number formed so far. Entering a child multiplies the prefix by ten and adds the child's digit; reaching a leaf returns the completed number, while internal nodes return the sum of both subtrees.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of nodes. Each node is visited once.\n- **Space Complexity:** O(h) for the recursion stack, where h is the tree height.\n\n## Implementation\n\n```python\nclass Solution:\n    def sumNumbers(self, root) -> int:\n        def dfs(node, cur):\n            if not node:\n                return 0\n            v = cur * 10 + node.val\n            if not node.left and not node.right:\n                return v\n            return dfs(node.left, v) + dfs(node.right, v)\n        return dfs(root, 0)\n```\n", "starter": {"go": "// Definition for a binary tree node.\n// type TreeNode struct {\n//     Val int\n//     Left *TreeNode\n//     Right *TreeNode\n// }\npackage main\n\nfunc SumNumbers(root *TreeNode) int {\n    \n}", "python": "# Definition for a binary tree node.\n# class TreeNode:\n#     def __init__(self, val=0, left=None, right=None):\n#         self.val = val\n#         self.left = left\n#         self.right = right\n\nclass Solution:\n    def sumNumbers(self, root):\n        pass", "cpp": "/*\nDefinition for a binary tree node.\nstruct TreeNode {\n    int val;\n    TreeNode *left;\n    TreeNode *right;\n    TreeNode(): val(0), left(nullptr), right(nullptr) {}\n    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}\n    TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}\n};\n*/\nclass Solution {\npublic:\n    int sumNumbers(TreeNode* root) {\n        return 0;\n    }\n};"}, "fn": "sumNumbers", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}], "outputType": "int", "tests": [["[1,2,3]"], ["[4,9,0,5,1]"], ["[0]"], ["[1]"], ["[9]"], ["[1,0]"], ["[1,null,2]"], ["[1,2,null,3]"], ["[0,0,0]"], ["[9,9,9]"], ["[2,null,3,null,4]"], ["[5,4,8,1,null,3,null]"], ["[1,2,3,4,5]"], ["[4,9,5,1,null,2]"], ["[0,1,0]"], ["[3,5,1,6,2,9,8,null,null,7,4]"], ["[1,2,3,4,null,null,5]"], ["[8,3,null,1,6]"], ["[7,null,8,null,9]"], ["[2,2,2,2,2,2,2]"], ["[1,0,1,0,1]"], ["[6,1,9,0,2]"], ["[3,null,4,null,5,null,6]"], ["[9,1,0]"], ["[4,0,0]"], ["[5,3,null,2,null,1]"], ["[1,2,3,null,4,null,5]"], ["[0,null,0,null,0]"]], "expected": [25, 1026, 0, 1, 9, 10, 12, 123, 0, 198, 234, 1124, 262, 943, 1, 8044, 259, 1667, 789, 888, 212, 1291, 3456, 181, 80, 5321, 259, 0], "loose": false}

package/data/problems/summary-ranges.json

@@ -0,0 +1 @@
+{"basic": false, "label": "341", "slug": "summary-ranges", "id": 341, "title": "Summary Ranges", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/summary-ranges/", "examples": [{"explanation": "0,1,2 form one run (\"0->2\"), 4,5 form another (\"4->5\"), and 7 stands alone.", "input": "nums = [0,1,2,4,5,7]", "output": "[\"0->2\",\"4->5\",\"7\"]"}, {"explanation": "0 and 6 are solitary; 2,3,4 collapse to \"2->4\" and 8,9 to \"8->9\".", "input": "nums = [0,2,3,4,6,8,9]", "output": "[\"0\",\"2->4\",\"6\",\"8->9\"]"}, {"explanation": "There are no runs at all.", "input": "nums = []", "output": "[]"}], "hints": ["Walk the array tracking where the current consecutive run started.", "A run ends where the next value is not exactly one more; emit \"start\" for a lone value and \"start->end\" otherwise.", "Compare with nums[i] + 1 using long arithmetic to stay safe at the integer extremes."], "statement": "You are given a sorted array `nums` of distinct integers. Compress every maximal run of consecutive numbers into a short label: a lone value `a` becomes `\"a\"`, while a run from `a` to `b` (with `b > a`) becomes `\"a->b\"`.\n\nReturn the labels in the order the runs appear.\n\n**Constraints:**\n- `0 <= nums.length <= 20`\n- `-2^31 <= nums[i] <= 2^31 - 1`\n- `nums` is sorted in strictly increasing order.\n", "solution": "## Approach\n\nSweep the sorted array while remembering where the current consecutive run began. Extend the run while each next value is exactly one more than the previous; when the run breaks, emit the start alone for a single value or `start->end` for a longer run. Widening to 64-bit arithmetic before adding one keeps the extreme 32-bit values safe.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), a single pass.\n- **Space Complexity:** O(1) besides the output labels.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n    def summaryRanges(self, nums: List[int]) -> List[str]:\n        res: List[str] = []\n        i = 0\n        while i < len(nums):\n            start = nums[i]\n            while i + 1 < len(nums) and nums[i + 1] == nums[i] + 1:\n                i += 1\n            end = nums[i]\n            if start == end:\n                res.append(str(start))\n            else:\n                res.append(f\"{start}->{end}\")\n            i += 1\n        return res\n```\n", "starter": {"go": "package main\n\nfunc SummaryRanges(nums []int) []string {\n    return []string{}\n}", "python": "from typing import List\n\nclass Solution:\n    def summaryRanges(self, nums: List[int]) -> List[str]:\n        return []\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<string> summaryRanges(vector<int>& nums) {\n        return {};\n    }\n};"}, "fn": "summaryRanges", "params": [{"name": "nums", "type": "int_array"}], "outputType": "string_list", "tests": [["[0,1,2,4,5,7]"], ["[0,2,3,4,6,8,9]"], ["[]"], ["[1]"], ["[-1]"], ["[0]"], ["[1,2]"], ["[1,3]"], ["[-3,-2,-1,0,1]"], ["[-5,-3,-1,1,3]"], ["[1,2,3,4,5]"], ["[-5,-4,-3,0,2,3,4]"], ["[0,1,2,3,4,5,6,7,8,9]"], ["[10,20,30]"], ["[-2147483648,-2147483647,2147483646,2147483647]"], ["[2147483647]"], ["[-2147483648]"], ["[1,3,5,6,7,9]"], ["[0,2,4,6,8]"], ["[-2,-1,0,2,3,5]"], ["[100]"], ["[1,2,3,5,6,8,9,10,12]"], ["[-10,-9,-8,-5,-4,0]"], ["[7,8,9,11,12,14,15,16]"], ["[0,1,3,4,5,7,8,9,11]"], ["[-1,0,1,3,5,6,7]"], ["[2]"], ["[1,2,3,4,6,7,9,10,11,13,14,15,16]"]], "expected": [["0->2", "4->5", "7"], ["0", "2->4", "6", "8->9"], [], ["1"], ["-1"], ["0"], ["1->2"], ["1", "3"], ["-3->1"], ["-5", "-3", "-1", "1", "3"], ["1->5"], ["-5->-3", "0", "2->4"], ["0->9"], ["10", "20", "30"], ["-2147483648->-2147483647", "2147483646->2147483647"], ["2147483647"], ["-2147483648"], ["1", "3", "5->7", "9"], ["0", "2", "4", "6", "8"], ["-2->0", "2->3", "5"], ["100"], ["1->3", "5->6", "8->10", "12"], ["-10->-8", "-5->-4", "0"], ["7->9", "11->12", "14->16"], ["0->1", "3->5", "7->9", "11"], ["-1->1", "3", "5->7"], ["2"], ["1->4", "6->7", "9->11", "13->16"]], "loose": false}

package/data/problems/super-egg-drop.json

@@ -0,0 +1 @@
+{"basic": false, "label": "878", "slug": "super-egg-drop", "id": 878, "title": "Super Egg Drop", "difficulty": "Hard", "category": "dp", "link": "https://leetcode.com/problems/super-egg-drop/", "examples": [{"input": "k = 1, n = 2", "output": "2", "explanation": "With one egg there is no room for risk, so both floors must be tried from the bottom up."}, {"input": "k = 2, n = 6", "output": "3", "explanation": "Three drops always suffice (for instance, first try floor 3), and two drops cannot cover 6 floors."}, {"input": "k = 3, n = 14", "output": "4", "explanation": "Four drops cover up to 4 + 6 + 4 = 14 floors with three eggs, and three drops fall short."}], "hints": ["Flip the question: with m drops and e eggs, the tallest tower you can resolve is dp[m][e] = dp[m-1][e-1] + dp[m-1][e] + 1.", "Grow the drop count until the coverage reaches n; a one-dimensional table updated from high eggs to low eggs is enough."], "statement": "You have `k` identical eggs and a tower with `n` floors. An egg dropped from floor `f` either breaks (then the critical floor is below `f`) or survives (then it is at or above `f`). Find the smallest number of drops that guarantees locating the critical floor in the worst case, no matter where it is.\n\nReturn that minimum number of drops.\n\n**Constraints:**\n- `1 <= k <= 100`\n- `1 <= n <= 10^4`\n", "solution": "## Approach\n\nInstead of asking how many drops a tower needs, ask how tall a tower `m` drops can resolve: one more drop lets you test a floor, then handle the `dp[m-1][e-1]` floors below it if the egg breaks or the `dp[m-1][e]` floors above it if it survives, giving `dp[m][e] = dp[m-1][e-1] + dp[m-1][e] + 1`. Increase `m` until the coverage reaches `n`, keeping a single array swept from high egg counts downward.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(k * m), where m is the answer (at most n). Each round updates k entries.\n- **Space Complexity:** O(k) for the coverage array.\n\n## Implementation\n\n```python\nclass Solution:\n    def superEggDrop(self, k: int, n: int) -> int:\n        dp = [0] * (k + 1)\n        moves = 0\n        while dp[k] < n:\n            moves += 1\n            for e in range(k, 0, -1):\n                dp[e] = dp[e] + dp[e - 1] + 1\n        return moves\n```\n", "starter": {"go": "package main\n\nfunc SuperEggDrop(k int, n int) int {\n    \n}", "python": "class Solution:\n    def superEggDrop(self, k: int, n: int) -> int:\n        pass", "cpp": "class Solution {\npublic:\n    int superEggDrop(int k, int n) {\n        return 0;\n    }\n};"}, "fn": "superEggDrop", "params": [{"name": "k", "type": "int"}, {"name": "n", "type": "int"}], "outputType": "int", "tests": [["1", "2"], ["2", "6"], ["3", "14"], ["1", "1"], ["2", "1"], ["2", "2"], ["2", "3"], ["2", "4"], ["2", "100"], ["3", "100"], ["4", "100"], ["100", "10000"], ["2", "1000"], ["3", "1000"], ["5", "1000"], ["1", "100"], ["1", "10000"], ["10", "1"], ["10", "2"], ["3", "25"], ["4", "50"], ["2", "10"], ["3", "7"], ["4", "15"], ["5", "31"], ["7", "1000"], ["100", "1"], ["6", "500"]], "expected": [2, 3, 4, 1, 1, 2, 2, 3, 14, 9, 8, 14, 45, 19, 11, 100, 10000, 1, 2, 5, 6, 4, 3, 4, 5, 11, 1, 10], "loose": false}

package/data/problems/super-palindromes.json

@@ -0,0 +1 @@
+{"basic": false, "label": "895", "slug": "super-palindromes", "id": 895, "title": "Super Palindromes", "difficulty": "Hard", "category": "math", "link": "https://leetcode.com/problems/super-palindromes/", "examples": [{"input": "left = \"4\", right = \"1000\"", "output": "4", "explanation": "4, 9, 121 and 484 qualify."}, {"input": "left = \"1\", right = \"2\"", "output": "1", "explanation": "Only 1 qualifies."}, {"input": "left = \"1\", right = \"100000\"", "output": "10", "explanation": "Ten qualify below 100000."}], "hints": ["Square roots of candidates stay below 1e9 and must themselves be palindromes, so only about 1e5 halves need trying.", "Mirror each half i into odd and even palindromes, square them, and keep those whose square is a palindrome inside the interval."], "statement": "A palindrome reads identically forward and backward, like `121`. Call a positive integer a super-palindrome when it is itself a palindrome and it equals the square of another palindrome (for instance `121` is `11 * 11`).\n\nYou are given interval ends `left` and `right` as decimal strings (they may be far too large for casual handling, yet they always denote values below `10^18`). Count the super-palindromes lying inside the inclusive interval.\n\n**Constraints:**\n- `1 <= left.length, right.length <= 18`\n- Both strings hold only digits with no leading zeros.\n- They denote integers in `[1, 10^18 - 1]` with `left <= right`.\n", "solution": "## Approach\n\nAny super-palindrome below `10^18` has a palindromic root below `10^9`. Such roots are fully described by their left half: mirroring the half yields both odd-length and even-length candidates. Trying halves from `1` to `100000` (covering all roots up to `10^9` when mirrored) produces every possible square; keeping those whose square reads as a palindrome builds the complete catalogue once. Each query then counts catalogue entries inside `[left, right]`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(H * L) with H = 1e5 halves and L digits for palindrome checks, once; each query scans the small catalogue.\n- **Space Complexity:** O(1) besides the catalogue of a few dozen values.\n\n## Implementation\n\n```python\nclass Solution:\n    def superpalindromesInRange(self, left: str, right: str) -> int:\n        def is_pal(x: int) -> bool:\n            s = str(x)\n            return s == s[::-1]\n        cands = set()\n        for half in range(1, 100000):\n            h = str(half)\n            r = h[::-1]\n            for root in (int(h + r[1:]), int(h + r)):\n                sq = root * root\n                if sq < 10 ** 18 and is_pal(sq):\n                    cands.add(sq)\n        L, R = int(left), int(right)\n        return sum(1 for v in cands if L <= v <= R)\n```\n", "starter": {"go": "package main\n\nfunc SuperpalindromesInRange(left string, right string) int {\n    \n}", "python": "class Solution:\n    def superpalindromesInRange(self, left: str, right: str) -> int:\n        pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    int superpalindromesInRange(string left, string right) {\n        return 0;\n    }\n};"}, "fn": "superpalindromesInRange", "params": [{"name": "left", "type": "string"}, {"name": "right", "type": "string"}], "outputType": "int", "tests": [["4", "1000"], ["1", "2"], ["1", "100000"], ["1", "1"], ["2", "2"], ["9", "9"], ["10", "100"], ["121", "121"], ["1", "1000"], ["100", "10000"], ["1", "100000000000000000"], ["4", "4"], ["5", "8"], ["11", "22"], ["100", "121"], ["484", "484"], ["1", "10"], ["1000", "100000"], ["10000000000000000", "99999999999999999"], ["1", "999"], ["10000", "1000000"], ["14641", "14641"], ["10201", "10201"], ["1000000", "10000000"], ["2", "100"], ["1000000000", "10000000000"], ["942345", "1294828"], ["1", "1000000000"]], "expected": [4, 1, 10, 1, 0, 1, 0, 1, 5, 2, 70, 1, 0, 0, 1, 1, 3, 5, 22, 5, 5, 1, 1, 3, 2, 0, 2, 21], "loose": false}

package/data/problems/super-pow.json

@@ -0,0 +1 @@
+{"basic": false, "label": "450", "slug": "super-pow", "id": 450, "title": "Super Pow", "difficulty": "Medium", "category": "math", "link": "https://leetcode.com/problems/super-pow/", "examples": [{"input": "a = 2, b = [3]", "output": "8", "explanation": "Exponent 3 gives 2^3 = 8."}, {"input": "a = 2, b = [1,0]", "output": "1024", "explanation": "Exponent 10 gives 1024."}, {"input": "a = 1, b = [4,3,3,8,5,2]", "output": "1", "explanation": "Powers of 1 stay 1."}], "hints": ["Fold digits with result = result^10 * a^digit (mod 1337) at each step.", "Write a small modular power helper using binary exponentiation.", "Reduce the base modulo 1337 first; large exponents never fit in one integer."], "statement": "Raise a base to an enormous exponent given digit by digit, then reduce modulo 1337.\n\nYou receive an integer `a` and an array `b` whose entries are the decimal digits of a huge exponent (most significant first, no leading zeros). Compute `a` raised to that exponent, modulo `1337`. The exponent can have up to 2000 digits, so it must never be rebuilt as one machine integer; instead fold the digits in one at a time with modular arithmetic.\n\n**Constraints:**\n- `1 <= a <= 2^31 - 1`\n- `1 <= b.length <= 2000`\n- `0 <= b[i] <= 9`\n- `b` has no leading zeros.\n", "solution": "## Approach\n\nProcess the exponent digits left to right while keeping everything modulo 1337. Appending a digit `d` multiplies the previous exponent by ten and adds `d`, so update the answer as `ans = ans^10 * a^d`. Both powers use fast binary exponentiation after reducing the base.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m log 1337), where m is the number of digits in `b`; each digit needs two small modular powers.\n- **Space Complexity:** O(1) extra.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def superPow(self, a: int, b: List[int]) -> int:\n        MOD = 1337\n        def pow_mod(x, e):\n            r = 1 % MOD\n            x %= MOD\n            while e:\n                if e & 1:\n                    r = (r * x) % MOD\n                x = (x * x) % MOD\n                e >>= 1\n            return r\n        res = 1\n        for d in b:\n            res = pow_mod(res, 10)\n            res = (res * pow_mod(a, d)) % MOD\n        return res\n```\n", "starter": {"go": "package main\n\nfunc SuperPow(a int, b []int) int {\n    return 0\n}", "python": "from typing import List\n\nclass Solution:\n    def superPow(self, a: int, b: List[int]) -> int:\n        return 0\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    int superPow(int a, vector<int>& b) {\n        return 0;\n    }\n};"}, "fn": "superPow", "params": [{"name": "a", "type": "int"}, {"name": "b", "type": "int_array"}], "outputType": "int", "tests": [["2", "[3]"], ["2", "[1,0]"], ["1", "[4,3,3,8,5,2]"], ["2147483647", "[1]"], ["2", "[0]"], ["3", "[1]"], ["3", "[2]"], ["10", "[2]"], ["1337", "[5]"], ["1338", "[1]"], ["2", "[1,1]"], ["2", "[2,0]"], ["5", "[3]"], ["7", "[1,2]"], ["100", "[1,0,0]"], ["3", "[9,9]"], ["4", "[5,0]"], ["9", "[9]"], ["2", "[1,0,0,0]"], ["6", "[2,5]"], ["11", "[7]"], ["12", "[1,3]"], ["1000", "[9,9,9]"], ["2147483647", "[9,9,9,9]"], ["1", "[0]"], ["2", "[5]"], ["3", "[1,0,0]"], ["8", "[4]"], ["15", "[2,0]"], ["100", "[5]"], ["1000000", "[1,2,3,4,5]"]], "expected": [8, 1024, 1, 932, 1, 3, 9, 100, 0, 1, 711, 368, 125, 49, 562, 272, 1178, 673, 345, 1007, 396, 40, 20, 939, 1, 32, 816, 85, 680, 753, 414], "loose": false}

package/data/problems/super-ugly-number.json

@@ -0,0 +1 @@
+{"basic": false, "label": "402", "slug": "super-ugly-number", "id": 402, "title": "Super Ugly Number", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/super-ugly-number/", "examples": [{"explanation": "The ordered sequence starts [1,2,4,7,8,13,14,16,19,26,28,32], whose 12th entry is 32.", "input": "n = 12, primes = [2,7,13,19]", "output": "32"}, {"explanation": "The first super ugly number is always 1, which has no prime factors.", "input": "n = 1, primes = [2,3,5]", "output": "1"}, {"explanation": "The ordered sequence starts [1,2,3,4,5,6,8,9,10,12,15], whose 11th entry is 15.", "input": "n = 11, primes = [2,3,5]", "output": "15"}], "hints": ["Maintain one index per prime pointing into the ugly sequence; the next candidate from prime p is ugly[idx] * p.", "Always take the smallest candidate, then advance every index that produced it (duplicates must all move).", "Use 64-bit arithmetic for the products and cast back, since intermediate values can exceed 32 bits."], "statement": "A positive integer is called a *super ugly number* when every prime divisor it has appears in a given list `primes`. By convention, `1` counts as a super ugly number since it has no prime divisors at all.\n\nYou are given an integer `n` and a strictly increasing array `primes` of prime numbers. Consider all super ugly numbers built from `primes`, sorted from smallest to largest, and return the `n`-th value in that ordering (counting from 1). The answer always fits into a 32-bit signed integer.\n\n**Constraints:**\n- `1 <= n <= 10^5`\n- `1 <= primes.length <= 100`\n- `2 <= primes[i] <= 1000`\n- Each `primes[i]` is prime, and the values are distinct and sorted increasingly.\n", "solution": "## Approach\n\nKeep one pointer per prime into the ugly sequence built so far. Each prime proposes a candidate equal to its prime times the ugly number at its pointer. Repeatedly append the smallest candidate and advance every pointer that produced it, which merges the multiples in order while skipping duplicates.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * k), where n is the requested position and k is the number of primes.\n- **Space Complexity:** O(n + k) for the sequence and the pointers.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def nthSuperUglyNumber(self, n: int, primes: List[int]) -> int:\n        ugly = [1] * n\n        idx = [0] * len(primes)\n        nxt = list(primes)\n        for i in range(1, n):\n            m = min(nxt)\n            ugly[i] = m\n            for j, p in enumerate(primes):\n                if nxt[j] == m:\n                    idx[j] += 1\n                    nxt[j] = ugly[idx[j]] * p\n        return ugly[n - 1]\n```\n", "starter": {"go": "package main\n\nfunc NthSuperUglyNumber(n int, primes []int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def nthSuperUglyNumber(self, n: int, primes: List[int]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int nthSuperUglyNumber(int n, vector<int>& primes) {\n        return 0;\n    }\n};"}, "fn": "nthSuperUglyNumber", "params": [{"name": "n", "type": "int"}, {"name": "primes", "type": "int_array"}], "outputType": "int", "tests": [["12", "[2,7,13,19]"], ["1", "[2,3,5]"], ["11", "[2,3,5]"], ["2", "[2,3,5]"], ["15", "[2,3,5]"], ["10", "[2,3,5]"], ["100", "[2,3,5]"], ["1000", "[2,3,5]"], ["5", "[2]"], ["1", "[2]"], ["10", "[2]"], ["7", "[3,5,7,11]"], ["20", "[3,5,7,11]"], ["50", "[2,7,13,19]"], ["100", "[2,7,13,19]"], ["3", "[5,7,11]"], ["25", "[5,7,11]"], ["30", "[2,3,7,43]"], ["2", "[1000]"], ["4", "[2,3]"], ["40", "[2,3]"], ["60", "[2,3,5,7,11,13]"], ["200", "[2,3,5,7,11,13]"], ["500", "[2,3,5]"], ["1500", "[2,3,5]"], ["8", "[7,13,19]"], ["16", "[7,13,19]"], ["100", "[11,13,17,19,23]"], ["6", "[2,5]"], ["9", "[2,5]"]], "expected": [32, 1, 15, 2, 24, 12, 1536, 51200000, 16, 1, 512, 15, 99, 728, 5408, 7, 1715, 86, 1000, 4, 972, 98, 700, 937500, 859963392, 169, 2197, 83521, 10, 25], "loose": false}

package/data/problems/super-washing-machines.json

@@ -0,0 +1 @@
+{"basic": false, "label": "577", "slug": "super-washing-machines", "id": 577, "title": "Super Washing Machines", "difficulty": "Hard", "category": "array", "link": "https://leetcode.com/problems/super-washing-machines/", "examples": [{"input": "machines = [1,0,5]", "output": "3", "explanation": "The average is 2. The left machine needs 1 more and the right one must give 3 away; balancing takes 3 moves."}, {"input": "machines = [0,3,0]", "output": "2", "explanation": "The average is 1. Both outer machines pull one garment from the middle, finishing in 2 moves."}, {"input": "machines = [0,2,0]", "output": "-1", "explanation": "The total 2 cannot be split evenly across 3 machines."}], "hints": ["If the total is not divisible by n, answer -1; otherwise each machine targets total / n garments.", "Scan left to right tracking the running imbalance; a machine's bottleneck is the larger of its own surplus/deficit and the flow passing through it."], "statement": "A row of `n` washing machines holds `machines[i]` garments each. In one move, any number of machines may each hand a single garment to a neighboring machine (left or right). The goal is an even split where every machine ends with the same count.\n\nReturn the smallest number of moves that achieves the split, or `-1` when the total garment count is not divisible by `n` and sharing is therefore impossible.\n\n**Constraints:**\n- `1 <= machines.length <= 10^4`\n- `0 <= machines[i] <= 10^5`\n", "solution": "## Approach\n\nWhen the total is not divisible by the machine count, equal sharing is impossible. Otherwise each machine aims for the average load. Sweeping left to right, keep the cumulative surplus or deficit that must flow across the current boundary; each position's bottleneck is the larger of its own gap to the average and the absolute flow passing through. The overall answer is the worst bottleneck encountered.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) for the total plus one sweep.\n- **Space Complexity:** O(1) extra memory.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n    def findMinMoves(self, machines: List[int]) -> int:\n        n = len(machines)\n        total = sum(machines)\n        if total % n != 0:\n            return -1\n        avg = total // n\n        ans = 0\n        balance = 0\n        for x in machines:\n            diff = x - avg\n            balance += diff\n            ans = max(ans, abs(balance), diff)\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc FindMinMoves(machines []int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def findMinMoves(self, machines: List[int]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int findMinMoves(vector<int>& machines) {\n        return -1;\n    }\n};"}, "fn": "findMinMoves", "params": [{"name": "machines", "type": "int_array"}], "outputType": "int", "tests": [["[1,0,5]"], ["[0,3,0]"], ["[0,2,0]"], ["[1,1,1]"], ["[0,0,0]"], ["[5]"], ["[4,0,0,4]"], ["[9,1,8,8,9]"], ["[1,2,3,4,5]"], ["[5,4,3,2,1]"], ["[0,0,11,5]"], ["[2,2,2,2]"], ["[10,0,0,0,0,0,0,0,0,0]"], ["[0,0,0,0,0,0,0,0,0,10]"], ["[3,3,3]"], ["[7,0,7,0,7,0,7]"], ["[100000,0,0,0]"], ["[1,0,0,0,0,0,0,0,0,0,0,2]"], ["[4,4,4,0]"], ["[8,4,12]"], ["[0,4,0,4,0,4]"], ["[6,0,6]"], ["[2,4,6,8]"], ["[5,5,0,0,5]"], ["[1,10,1,10,1]"], ["[0,1,0,1,0,1]"], ["[12,0,0,0]"], ["[3,1,4,1,5,9,2,6]"]], "expected": [3, 2, -1, 0, 0, 0, 2, 4, 3, 3, 8, 0, 9, 9, 0, 3, 75000, -1, 3, 4, 2, 2, 4, 4, -1, -1, 9, -1], "loose": false}

package/data/problems/surface-area-of-3d-shapes.json

@@ -0,0 +1 @@
+{"basic": false, "label": "883", "slug": "surface-area-of-3d-shapes", "id": 883, "title": "Surface Area of 3D Shapes", "difficulty": "Easy", "category": "math", "link": "https://leetcode.com/problems/surface-area-of-3d-shapes/", "examples": [{"input": "grid = [[1,2],[3,4]]", "output": "34", "explanation": "Sum of lone-tower areas minus shared sides gives 34."}, {"input": "grid = [[1,1,1],[1,0,1],[1,1,1]]", "output": "32", "explanation": "Ring of eight cubes around a hole shows 32 faces."}, {"input": "grid = [[2,2,2],[2,1,2],[2,2,2]]", "output": "46", "explanation": "Border towers of height 2 plus centre of height 1 total 46."}], "hints": ["A lone tower of height v shows 4*v+2 faces when v is positive and 0 otherwise.", "Each pair of side-adjacent cells hides 2*min(v1,v2) faces; count each pair once by looking only right and down."], "statement": "Picture an `n` by `n` board. On the cell in row `i`, column `j` you pile up `grid[i][j]` unit cubes, one on top of another, forming a small tower (a zero means the cell stays empty). Towers that touch side-by-side hide the faces where they meet, and cubes stacked vertically hide the faces between them.\n\nCount every square that remains visible from the outside, counting the underside that rests on the table as well.\n\n**Constraints:**\n- `n == grid.length == grid[i].length`\n- `1 <= n <= 50`\n- `0 <= grid[i][j] <= 50`\n", "solution": "## Approach\n\nTreat every cell on its own: a tower of height `v > 0` exposes `4*v + 2` unit squares (four sides per cube plus a top and a bottom). Adding those overcounts only where two towers stand shoulder to shoulder. A neighbouring pair of heights `a` and `b` conceals `min(a, b)` squares on each of the two touching walls, so subtract `2*min(a,b)` once per adjacent pair by scanning right and down neighbours only.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2) for an n by n board, one pass for towers and one for adjacencies.\n- **Space Complexity:** O(1) besides the input.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def surfaceArea(self, grid: List[List[int]]) -> int:\n        n = len(grid)\n        ans = 0\n        for i in range(n):\n            for j in range(len(grid[i])):\n                v = grid[i][j]\n                if v > 0:\n                    ans += 4 * v + 2\n        for i in range(n):\n            for j in range(len(grid[i])):\n                if j + 1 < len(grid[i]):\n                    ans -= 2 * min(grid[i][j], grid[i][j + 1])\n                if i + 1 < n and j < len(grid[i + 1]):\n                    ans -= 2 * min(grid[i][j], grid[i + 1][j])\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc SurfaceArea(grid [][]int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def surfaceArea(self, grid: List[List[int]]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int surfaceArea(vector<vector<int>>& grid) {\n        return 0;\n    }\n};"}, "fn": "surfaceArea", "params": [{"name": "grid", "type": "int_array_2d"}], "outputType": "int", "tests": [["[[1,2],[3,4]]"], ["[[1,1,1],[1,0,1],[1,1,1]]"], ["[[2,2,2],[2,1,2],[2,2,2]]"], ["[[1]]"], ["[[0]]"], ["[[2]]"], ["[[1,2]]"], ["[[1],[2]]"], ["[[0,0],[0,0]]"], ["[[1,0],[0,2]]"], ["[[2,2],[2,2]]"], ["[[1,3,1],[1,2,1],[1,3,1]]"], ["[[0,1,0],[1,1,1],[0,1,0]]"], ["[[3]]"], ["[[50]]"], ["[[1,1],[1,1]]"], ["[[2,1],[1,2]]"], ["[[0,0,0],[0,1,0],[0,0,0]]"], ["[[5,5,5],[5,5,5],[5,5,5]]"], ["[[1,2,3],[4,5,6]]"], ["[[4]]"], ["[[1,0,1],[0,1,0],[1,0,1]]"], ["[[3,2],[1,4]]"], ["[[10,10],[10,10]]"], ["[[0,2,0],[2,0,2],[0,2,0]]"], ["[[1,2,3,4]]"], ["[[1],[2],[3],[4]]"], ["[[2,0,2],[0,0,0],[2,0,2]]"]], "expected": [34, 32, 46, 6, 0, 10, 14, 14, 0, 16, 24, 46, 22, 14, 202, 16, 24, 6, 78, 60, 18, 30, 36, 88, 40, 36, 36, 40], "loose": false}

package/data/problems/surrounded-regions.json

@@ -0,0 +1 @@
+{"basic": false, "label": "118", "slug": "surrounded-regions", "id": 118, "title": "Surrounded Regions", "difficulty": "Medium", "category": "graph", "link": "https://leetcode.com/problems/surrounded-regions/", "examples": [{"input": "board = [\"XXXX\",\"XOOX\",\"XXOX\",\"XOXX\"]", "output": "[\"XXXX\",\"XXXX\",\"XXXX\",\"XOXX\"]", "explanation": "The lower-left `O` touches the boundary; the other `O` cells are captured."}, {"input": "board = [\"X\"]", "output": "[\"X\"]", "explanation": "There are no 'O's to flip, so the board remains [\"X\"]."}], "hints": ["Start from boundary `O` cells and mark every `O` reachable from them.", "After the traversal, capture only unmarked `O` cells and restore the marked cells."], "statement": "Given a nonempty rectangular board represented by an array of equal-width strings, capture every region of `O` cells that is completely surrounded by `X` cells.\n\nCells connect horizontally and vertically. An `O` connected to any boundary `O` is not surrounded and must remain unchanged. Replace every other `O` with `X` and return the transformed rows.\n\nThis version adapts the usual in-place character-grid operation to `solve(board: string_array) -> string_list`.\n\n**Constraints:**\n- `1 <= board.length <= 200`\n- `1 <= board[r].length <= 200`\n- Every row has the same length.\n- Every character is `X` or `O`.\n", "solution": "## Approach\n\nConvert the immutable input strings into a character grid and mark every `O` connected to the boundary with a breadth-first search. These marked cells cannot be captured. After the traversal, replace unmarked `O` cells with `X`, restore marked cells to `O`, and join each row for the adapted return value.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n), because every board cell is examined a constant number of times.\n- **Space Complexity:** O(m * n) for the mutable character grid and breadth-first-search queue.\n\n## Implementation\n\n```python\nfrom collections import deque\nfrom typing import List\n\n\nclass Solution:\n    def solve(self, board: List[str]) -> List[str]:\n        cells = [list(row) for row in board]\n        rows, cols = len(cells), len(cells[0])\n        queue = deque()\n\n        def mark(row: int, col: int) -> None:\n            if cells[row][col] != \"O\":\n                return\n            cells[row][col] = \"#\"\n            queue.append((row, col))\n\n        for row in range(rows):\n            mark(row, 0)\n            mark(row, cols - 1)\n        for col in range(cols):\n            mark(0, col)\n            mark(rows - 1, col)\n        while queue:\n            row, col = queue.popleft()\n            for row_step, col_step in ((1, 0), (-1, 0), (0, 1), (0, -1)):\n                next_row = row + row_step\n                next_col = col + col_step\n                if 0 <= next_row < rows and 0 <= next_col < cols:\n                    mark(next_row, next_col)\n\n        result = []\n        for row in cells:\n            result.append(\"\".join(\"O\" if cell == \"#\" else \"X\" for cell in row))\n        return result\n```\n", "starter": {"go": "package main\n\nfunc Solve(board []string) []string {\n    return []string{}\n}\n", "python": "from typing import List\n\nclass Solution:\n    def solve(self, board: List[str]) -> List[str]:\n        return []\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<string> solve(vector<string>& board) {\n        return {};\n    }\n};"}, "fn": "solve", "params": [{"name": "board", "type": "string_array", "visualizeType": "matrix"}], "outputType": "string_list", "tests": [["[\"X\"]"], ["[\"O\"]"], ["[\"XX\"]"], ["[\"OO\"]"], ["[\"XO\"]"], ["[\"OX\"]"], ["[\"XOX\"]"], ["[\"OOO\"]"], ["[\"XXX\"]"], ["[\"OXO\"]"], ["[\"X\",\"O\"]"], ["[\"O\",\"X\"]"], ["[\"O\",\"O\",\"X\"]"], ["[\"X\",\"O\",\"X\"]"], ["[\"XX\",\"XX\"]"], ["[\"OO\",\"OO\"]"], ["[\"XO\",\"OX\"]"], ["[\"OX\",\"XO\"]"], ["[\"XX\",\"XO\"]"], ["[\"XO\",\"XX\"]"], ["[\"XXX\",\"XOX\",\"XXX\"]"], ["[\"OOO\",\"OOO\",\"OOO\"]"], ["[\"XOX\",\"OOO\",\"XOX\"]"], ["[\"OXO\",\"XXX\",\"OXO\"]"], ["[\"XXX\",\"XOO\",\"XXX\"]"], ["[\"XXX\",\"OOX\",\"XXX\"]"], ["[\"OXX\",\"XOX\",\"XXO\"]"], ["[\"XXXX\",\"XOOX\",\"XXOX\",\"XOXX\"]"], ["[\"XXXX\",\"XOOX\",\"XOOX\",\"XXXX\"]"], ["[\"OOOO\",\"OXXO\",\"OXXO\",\"OOOO\"]"], ["[\"XOOX\",\"OXXO\",\"OXXO\",\"XOOX\"]"], ["[\"XXXX\",\"XOXO\",\"XOXX\",\"XXXX\"]"], ["[\"OXXX\",\"OXOX\",\"OOOX\",\"XXXX\"]"], ["[\"XXXX\",\"XOOX\",\"XOXO\",\"XXXX\"]"], ["[\"XXXXX\",\"XOOOX\",\"XOXXX\",\"XOOOX\",\"XXXXX\"]"], ["[\"OOOOO\",\"OXXXO\",\"OXOXO\",\"OXXXO\",\"OOOOO\"]"], ["[\"XXXXX\",\"XOXOX\",\"XXOXX\",\"XOXOX\",\"XXXXX\"]"], ["[\"OXXXX\",\"OOOXX\",\"XXOXX\",\"XXOOO\",\"XXXXO\"]"], ["[\"XXXXX\",\"XOOOX\",\"XXXXX\",\"XOOOX\",\"XXXXX\"]"], ["[\"OXOXO\",\"XOXOX\",\"OXOXO\",\"XOXOX\"]"], ["[\"XXXXXX\",\"XOOOOX\",\"XOXXOX\",\"XOOOOX\",\"XXXXXX\"]"], ["[\"OOOOOO\",\"OXXXXO\",\"OXOOXO\",\"OXXXXO\",\"OOOOOO\"]"], ["[\"XXXXXX\",\"XOXOOX\",\"XOXXOX\",\"XOOXOX\",\"XXXXXX\"]"], ["[\"OXXXXX\",\"OXOOOX\",\"OXOXOX\",\"OXOOOX\",\"OXXXXX\"]"], ["[\"XXXXXX\",\"XOOOOO\",\"XXXXXO\",\"XOOOOO\",\"XXXXXX\"]"], ["[\"XXXXXXX\",\"XOOOOOX\",\"XOXXXOX\",\"XOXOXOX\",\"XOXXXOX\",\"XOOOOOX\",\"XXXXXXX\"]"], ["[\"OOOOOOO\",\"OXXXXXO\",\"OXOOOXO\",\"OXOXOXO\",\"OXOOOXO\",\"OXXXXXO\",\"OOOOOOO\"]"], ["[\"XXXXXXX\",\"XOXOXOX\",\"XXOXOXX\",\"XOXOXOX\",\"XXXXXXX\"]"], ["[\"OXXXXXX\",\"OOOXXXX\",\"XXOXXXX\",\"XXOOOOX\",\"XXXXOOO\"]"], ["[\"XXXXXXXX\",\"XOOOOOOX\",\"XOXXXXOX\",\"XOXOOXOX\",\"XOXXXXOX\",\"XOOOOOOX\",\"XXXXXXXX\"]"], ["[\"OXOXOXOX\",\"XOXOXOXO\",\"OXOXOXOX\",\"XOXOXOXO\",\"OXOXOXOX\"]"], ["[\"XXXXXXXX\",\"XOOXXOOX\",\"XOXXXXOX\",\"XOOOOOOX\",\"XXXXXXXX\"]"], ["@javascript:JSON.stringify(Array.from({length:50},(_,r)=>r===0||r===49?'X'.repeat(200):'X'+'O'.repeat(198)+'X'))"]], "expected": [["X"], ["O"], ["XX"], ["OO"], ["XO"], ["OX"], ["XOX"], ["OOO"], ["XXX"], ["OXO"], ["X", "O"], ["O", "X"], ["O", "O", "X"], ["X", "O", "X"], ["XX", "XX"], ["OO", "OO"], ["XO", "OX"], ["OX", "XO"], ["XX", "XO"], ["XO", "XX"], ["XXX", "XXX", "XXX"], ["OOO", "OOO", "OOO"], ["XOX", "OOO", "XOX"], ["OXO", "XXX", "OXO"], ["XXX", "XOO", "XXX"], ["XXX", "OOX", "XXX"], ["OXX", "XXX", "XXO"], ["XXXX", "XXXX", "XXXX", "XOXX"], ["XXXX", "XXXX", "XXXX", "XXXX"], ["OOOO", "OXXO", "OXXO", "OOOO"], ["XOOX", "OXXO", "OXXO", "XOOX"], ["XXXX", "XXXO", "XXXX", "XXXX"], ["OXXX", "OXOX", "OOOX", "XXXX"], ["XXXX", "XXXX", "XXXO", "XXXX"], ["XXXXX", "XXXXX", "XXXXX", "XXXXX", "XXXXX"], ["OOOOO", "OXXXO", "OXXXO", "OXXXO", "OOOOO"], ["XXXXX", "XXXXX", "XXXXX", "XXXXX", "XXXXX"], ["OXXXX", "OOOXX", "XXOXX", "XXOOO", "XXXXO"], ["XXXXX", "XXXXX", "XXXXX", "XXXXX", "XXXXX"], ["OXOXO", "XXXXX", "OXXXO", "XOXOX"], ["XXXXXX", "XXXXXX", "XXXXXX", "XXXXXX", "XXXXXX"], ["OOOOOO", "OXXXXO", "OXXXXO", "OXXXXO", "OOOOOO"], ["XXXXXX", "XXXXXX", "XXXXXX", "XXXXXX", "XXXXXX"], ["OXXXXX", "OXXXXX", "OXXXXX", "OXXXXX", "OXXXXX"], ["XXXXXX", "XOOOOO", "XXXXXO", "XOOOOO", "XXXXXX"], ["XXXXXXX", "XXXXXXX", "XXXXXXX", "XXXXXXX", "XXXXXXX", "XXXXXXX", "XXXXXXX"], ["OOOOOOO", "OXXXXXO", "OXXXXXO", "OXXXXXO", "OXXXXXO", "OXXXXXO", "OOOOOOO"], ["XXXXXXX", "XXXXXXX", "XXXXXXX", "XXXXXXX", "XXXXXXX"], ["OXXXXXX", "OOOXXXX", "XXOXXXX", "XXOOOOX", "XXXXOOO"], ["XXXXXXXX", "XXXXXXXX", "XXXXXXXX", "XXXXXXXX", "XXXXXXXX", "XXXXXXXX", "XXXXXXXX"], ["OXOXOXOX", "XXXXXXXO", "OXXXXXXX", "XXXXXXXO", "OXOXOXOX"], ["XXXXXXXX", "XXXXXXXX", "XXXXXXXX", "XXXXXXXX", "XXXXXXXX"], ["XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX", "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"]], "loose": false}

package/data/problems/swap-adjacent-in-lr-string.json

@@ -0,0 +1 @@
+{"basic": false, "label": "777", "slug": "swap-adjacent-in-lr-string", "id": 777, "title": "Swap Adjacent in LR String", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/swap-adjacent-in-lr-string/", "examples": [{"input": "start = \"RXXLRXRXL\", end = \"XRLXXRRLX\"", "output": "true", "explanation": "A sequence of allowed slides reshapes the first row into the second one."}, {"input": "start = \"X\", end = \"L\"", "output": "false", "explanation": "An empty slot cannot become a token."}, {"input": "start = \"XL\", end = \"LX\"", "output": "true", "explanation": "The L steps one slot left into the empty cell."}], "hints": ["Ignore the empty slots first: after deleting every X, the remaining L/R order must match exactly.", "Track positions of the remaining tokens: each L in the start must not sit to the right of its counterpart in the target, and each R must not sit to the left.", "Scan both strings with two pointers that skip over X characters and compare token by token."], "statement": "In a row of slots, each slot holds one of three symbols: `L`, `R`, or `X`.\nAn `X` means the slot is empty. The other two symbols behave like tokens\nthat slide into neighboring empty slots, but only in one direction each.\n\nIn a single step you may pick one of these patterns and flip it:\n\n- `XL` may become `LX` (the `L` token steps one slot to the left).\n- `RX` may become `XR` (the `R` token steps one slot to the right).\n\nNo other change is allowed. In particular an `L` never steps right, an `R`\nnever steps left, and two non-empty tokens never jump over each other.\n\nYou are given two strings `start` and `end` of equal length that describe\nthe starting row and a desired target row. Decide whether `start` can be\nturned into `end` by applying any number of the steps above.\n\n**Constraints:**\n- `1 <= start.length <= 10^4`\n- `start.length == end.length`\n- `start` and `end` contain only characters `L`, `R`, and `X`.\n", "solution": "## Approach\n\nDrop every `X` from both rows and require the remaining token sequences to\nagree. Tokens keep their relative order because an `L` only drifts left\nthrough empty cells and an `R` only drifts right, so they can never overtake\neach other. While scanning past the empty cells, also enforce the direction\nrule: an `L` in the start must begin at or to the right of its target slot,\nand an `R` must begin at or to the left of its target slot.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the row length. Each pointer advances once.\n- **Space Complexity:** O(1) besides the inputs.\n\n## Implementation\n\n```python\nclass Solution:\n    def canTransform(self, start: str, end: str) -> bool:\n        n = len(start)\n        if len(end) != n:\n            return False\n        i = j = 0\n        while i < n and j < n:\n            while i < n and start[i] == 'X':\n                i += 1\n            while j < n and end[j] == 'X':\n                j += 1\n            if i == n and j == n:\n                return True\n            if i == n or j == n:\n                return False\n            if start[i] != end[j]:\n                return False\n            if start[i] == 'L' and i < j:\n                return False\n            if start[i] == 'R' and i > j:\n                return False\n            i += 1\n            j += 1\n        while i < n:\n            if start[i] != 'X':\n                return False\n            i += 1\n        while j < n:\n            if end[j] != 'X':\n                return False\n            j += 1\n        return True\n```\n", "starter": {"go": "package main\n\nfunc CanTransform(start string, end string) bool {\n    return false\n}", "python": "class Solution:\n    def canTransform(self, start: str, end: str) -> bool:\n        return False\n", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    bool canTransform(string start, string end) {\n        return false;\n    }\n};"}, "fn": "canTransform", "params": [{"name": "start", "type": "string"}, {"name": "end", "type": "string"}], "outputType": "boolean", "tests": [["RXXLRXRXL", "XRLXXRRLX"], ["X", "L"], ["XL", "LX"], ["RX", "XR"], ["LX", "XL"], ["XR", "RX"], ["RXX", "XXR"], ["XXL", "LXX"], ["XXR", "RXX"], ["LXX", "XXL"], ["XXX", "XXX"], ["RRR", "RRR"], ["LLL", "LLL"], ["RLX", "RLX"], ["RXXL", "XRXL"], ["RXXL", "XRLX"], ["RLX", "XRL"], ["XRL", "RLX"], ["RXLX", "XRXL"], ["XLXR", "LXXR"], ["RXLXRX", "XRLXXR"], ["LLRXXR", "LLXRXR"], ["RXL", "LRX"], ["XXRXXLXX", "XXRXXLXX"], ["RXLXLX", "LRXXXL"], ["XLXXRXXL", "LXXXRXLX"], ["RXRXRXLXLX", "XXRRRXLXLX"], ["XXXXXXXXXX", "XXXXXXXXXX"]], "expected": [true, false, true, true, false, false, true, true, false, false, true, true, true, true, true, true, false, false, false, true, true, true, false, true, false, true, true, true], "loose": false}

package/data/problems/swap-nodes-in-pairs.json

@@ -0,0 +1 @@
+{"basic": false, "label": "256", "slug": "swap-nodes-in-pairs", "id": 256, "title": "Swap Nodes in Pairs", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/swap-nodes-in-pairs/", "examples": [{"input": "head = [1,2,3,4]", "output": "[2,1,4,3]", "explanation": "Nodes 1 and 2 trade places, and nodes 3 and 4 trade places."}, {"input": "head = []", "output": "[]", "explanation": "An empty list has nothing to swap."}, {"input": "head = [1]", "output": "[1]", "explanation": "A single node has no partner, so the list is unchanged."}], "hints": ["Place a dummy node before the head so the first pair is handled exactly like every other pair.", "For each pair (a, b), point the previous node to b, b back to a, and a forward to the rest; then advance two steps."], "statement": "You are given the head of a singly linked list. Exchange every pair of neighboring nodes (positions 1-2, 3-4, and so on) and return the head of the rearranged list.\n\nWhen the list holds an odd number of nodes, the final node has no partner and stays where it is. You must relink the existing nodes themselves; just overwriting their values is not allowed.\n\n**Constraints:**\n- The number of nodes in the list is in the range `[0, 100]`.\n- `0 <= Node.val <= 100`\n", "solution": "## Approach\n\nAnchor a dummy node ahead of the head so every pair, including the first, has a predecessor to rewire. Repeatedly take the next two nodes `a` and `b`, splice them in as `prev -> b -> a`, reconnect `a` to the remainder, and step `prev` forward past the swapped pair. A leftover single node is simply never touched.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), one pass over the list.\n- **Space Complexity:** O(1) extra space besides a few pointers.\n\n## Implementation\n\n```python\nclass Solution:\n    def swapPairs(self, head):\n        dummy = ListNode(0, head)\n        prev = dummy\n        while prev.next and prev.next.next:\n            a = prev.next\n            b = a.next\n            a.next = b.next\n            b.next = a\n            prev.next = b\n            prev = a\n        return dummy.next\n```\n", "starter": {"go": "package main\n\n/*\nDefinition for singly-linked list.\ntype ListNode struct {\n    Val int\n    Next *ListNode\n}\n*/\n\nfunc SwapPairs(head *ListNode) *ListNode {\n    \n}", "python": "# Definition for singly-linked list.\n# class ListNode:\n#     def __init__(self, val=0, next=None):\n#         self.val = val\n#         self.next = next\n\nclass Solution:\n    def swapPairs(self, head):\n        pass\n", "cpp": "/*\nDefinition for singly-linked list.\nstruct ListNode {\n    int val;\n    ListNode *next;\n    ListNode(): val(0), next(nullptr) {}\n    ListNode(int x): val(x), next(nullptr) {}\n    ListNode(int x, ListNode* next): val(x), next(next) {}\n};\n*/\nclass Solution {\npublic:\n    ListNode* swapPairs(ListNode* head) {\n        return nullptr;\n    }\n};"}, "fn": "swapPairs", "params": [{"name": "head", "type": "list_node"}], "outputType": "list_node", "tests": [["[1,2,3,4]"], ["[]"], ["[1]"], ["[1,2]"], ["[1,2,3]"], ["[1,2,3,4,5]"], ["[5,4,3,2,1]"], ["[1,1,1,1]"], ["[0]"], ["[100]"], ["[1,2,3,4,5,6,7,8,9,10]"], ["[10,9,8,7,6,5,4,3,2,1]"], ["[2,2,1]"], ["[0,0,0,0,0]"], ["[7]"], ["[3,1]"], ["[99,100]"], ["[1,2,3,4,5,6]"], ["[6,5,4,3,2,1]"], ["[50,50,50]"], ["[1,3,5,7,9,11]"], ["[2,4,6,8]"], ["[100,0,100,0]"], ["[42]"], ["[1,2,3,4,5,6,7]"]], "expected": [[2, 1, 4, 3], null, [1], [2, 1], [2, 1, 3], [2, 1, 4, 3, 5], [4, 5, 2, 3, 1], [1, 1, 1, 1], [0], [100], [2, 1, 4, 3, 6, 5, 8, 7, 10, 9], [9, 10, 7, 8, 5, 6, 3, 4, 1, 2], [2, 2, 1], [0, 0, 0, 0, 0], [7], [1, 3], [100, 99], [2, 1, 4, 3, 6, 5], [5, 6, 3, 4, 1, 2], [50, 50, 50], [3, 1, 7, 5, 11, 9], [4, 2, 8, 6], [0, 100, 0, 100], [42], [2, 1, 4, 3, 6, 5, 7]], "loose": false}

package/data/problems/swim-in-rising-water.json

@@ -0,0 +1 @@
+{"basic": false, "label": "125", "slug": "swim-in-rising-water", "id": 125, "title": "Swim in Rising Water", "difficulty": "Hard", "category": "graph", "link": "https://leetcode.com/problems/swim-in-rising-water/", "examples": [{"input": "grid = [[0,2],[1,3]]", "output": "3", "explanation": "Both routes from (0,0) to (1,1) have a maximum elevation of 3, making 3 the minimum time needed."}, {"input": "grid = [[0,1,2,3,4],[24,23,22,21,5],[12,13,14,15,16],[11,17,18,19,20],[10,9,8,7,6]]", "output": "16", "explanation": "Every path from (0,0) to (4,4) must cross a cell with elevation at least 16, and there exists a path whose highest elevation is 16."}], "hints": ["A path's required time is the maximum elevation on that path; minimize that maximum.", "Use Dijkstra's algorithm where entering a neighbor changes the path cost to max(currentCost, neighborElevation).", "An alternative is binary search on time and a flood-fill reachability check."], "statement": "You are given an `n x n` grid where `grid[row][col]` is the elevation of a\ncell. At time `t`, you may enter cells whose elevation is at most `t`. From a\ncell, you may move up, down, left, or right.\n\nReturn the minimum time at which it is possible to travel from the top-left\ncell to the bottom-right cell.\n\n**Constraints:**\n\n- `1 <= n <= 50`\n- `grid.length == n`\n- `grid[i].length == n`\n- The grid contains every elevation from `0` through `n^2 - 1` exactly once.\n", "solution": "## Approach\n\nA path's required time is the maximum elevation visited along it. Run Dijkstra's algorithm where a state's cost is that maximum, and entering a neighbor changes the cost to `max(current_time, neighbor_elevation)`. The first time the bottom-right cell leaves the min-heap, its cost is the smallest possible path maximum.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(N^2 log(N^2)) for an `N x N` grid.\n- **Space Complexity:** O(N^2) for best costs and the heap.\n\n## Implementation\n\n```python\nimport heapq\nfrom typing import List\n\n\nclass Solution:\n    def swimInWater(self, grid: List[List[int]]) -> int:\n        n = len(grid)\n        best = [[float(\"inf\")] * n for _ in range(n)]\n        best[0][0] = grid[0][0]\n        queue = [(grid[0][0], 0, 0)]\n\n        while queue:\n            time, row, col = heapq.heappop(queue)\n            if time != best[row][col]:\n                continue\n            if row == n - 1 and col == n - 1:\n                return time\n\n            for row_step, col_step in ((1, 0), (-1, 0), (0, 1), (0, -1)):\n                next_row = row + row_step\n                next_col = col + col_step\n                if 0 <= next_row < n and 0 <= next_col < n:\n                    next_time = max(time, grid[next_row][next_col])\n                    if next_time < best[next_row][next_col]:\n                        best[next_row][next_col] = next_time\n                        heapq.heappush(queue, (next_time, next_row, next_col))\n\n        return -1\n```\n", "starter": {"go": "package main\n\nfunc SwimInWater(grid [][]int) int {\n    return 0\n}\n", "python": "from typing import List\n\nclass Solution:\n    def swimInWater(self, grid: List[List[int]]) -> int:\n        return 0\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    int swimInWater(vector<vector<int>>& grid) {\n        return 0;\n    }\n};"}, "fn": "swimInWater", "params": [{"name": "grid", "type": "int_array_2d", "visualizeType": "matrix"}], "outputType": "int", "tests": [["[[0]]"], ["[[0,1],[2,3]]"], ["[[0,1],[3,2]]"], ["[[0,2],[1,3]]"], ["[[0,2],[3,1]]"], ["[[0,3],[1,2]]"], ["[[0,3],[2,1]]"], ["[[1,0],[2,3]]"], ["[[1,0],[3,2]]"], ["[[1,2],[0,3]]"], ["[[1,2],[3,0]]"], ["[[1,3],[0,2]]"], ["[[1,3],[2,0]]"], ["[[2,0],[1,3]]"], ["[[2,0],[3,1]]"], ["[[2,1],[0,3]]"], ["[[2,1],[3,0]]"], ["[[2,3],[0,1]]"], ["[[2,3],[1,0]]"], ["[[3,0],[1,2]]"], ["[[3,0],[2,1]]"], ["[[3,1],[0,2]]"], ["[[3,1],[2,0]]"], ["[[3,2],[0,1]]"], ["[[3,2],[1,0]]"], ["[[0,1,2],[3,4,5],[6,7,8]]"], ["[[8,7,6],[5,4,3],[2,1,0]]"], ["[[0,3,6],[1,4,7],[2,5,8]]"], ["[[2,1,0],[5,4,3],[8,7,6]]"], ["[[0,1,2],[7,8,3],[6,5,4]]"], ["[[8,7,6],[1,0,5],[2,3,4]]"], ["[[0,2,4],[6,8,1],[3,5,7]]"], ["[[8,6,4],[2,0,7],[5,3,1]]"], ["[[1,2,3],[4,5,6],[7,8,0]]"], ["[[2,3,4],[5,6,7],[8,0,1]]"], ["[[3,4,5],[6,7,8],[0,1,2]]"], ["[[4,5,6],[7,8,0],[1,2,3]]"], ["[[5,6,7],[8,0,1],[2,3,4]]"], ["[[6,7,8],[0,1,2],[3,4,5]]"], ["[[7,8,0],[1,2,3],[4,5,6]]"], ["[[8,0,1],[2,3,4],[5,6,7]]"], ["[[0,8,1],[7,2,6],[3,5,4]]"], ["[[4,3,5],[2,0,6],[1,8,7]]"], ["[[8,1,6],[3,5,7],[4,0,2]]"], ["[[2,7,1],[6,0,5],[3,8,4]]"], ["[[0,1,2,3],[4,5,6,7],[8,9,10,11],[12,13,14,15]]"], ["[[15,14,13,12],[11,10,9,8],[7,6,5,4],[3,2,1,0]]"], ["[[0,4,8,12],[1,5,9,13],[2,6,10,14],[3,7,11,15]]"], ["[[3,2,1,0],[7,6,5,4],[11,10,9,8],[15,14,13,12]]"], ["[[0,1,2,3],[7,6,5,4],[8,9,10,11],[15,14,13,12]]"], ["[[0,1,2,3],[11,12,13,4],[10,15,14,5],[9,8,7,6]]"], ["[[5,6,7,8],[9,10,11,12],[13,14,15,0],[1,2,3,4]]"], ["[[0,2,4,6],[8,10,12,14],[1,3,5,7],[9,11,13,15]]"], ["@javascript:JSON.stringify(Array.from({length:50},(_,row)=>Array.from({length:50},(_,col)=>row*50+col)))"]], "expected": [0, 3, 2, 3, 2, 2, 2, 3, 2, 3, 2, 2, 2, 3, 2, 3, 2, 2, 2, 3, 3, 3, 3, 3, 3, 8, 8, 8, 6, 4, 8, 7, 8, 6, 6, 6, 6, 6, 6, 7, 8, 7, 7, 8, 6, 15, 15, 15, 12, 12, 6, 12, 15, 2499], "loose": false}

package/data/problems/symmetric-tree.json

@@ -0,0 +1 @@
+{"basic": false, "label": "283", "slug": "symmetric-tree", "id": 283, "title": "Symmetric Tree", "difficulty": "Easy", "category": "tree", "link": "https://leetcode.com/problems/symmetric-tree/", "examples": [{"input": "root = [1,2,2,3,4,4,3]", "output": "true", "explanation": "Left and right subtrees mirror each other at every level."}, {"input": "root = [1,2,2,null,3,null,3]", "output": "false", "explanation": "The right side has a 3 where the mirrored left side is empty, so the tree is not mirrored."}, {"input": "root = [1]", "output": "true", "explanation": "A single node is trivially symmetric."}], "hints": ["Compare the left and right subtrees as mirror images: left.left pairs with right.right and left.right pairs with right.left.", "A recursive helper on node pairs handles empty cases: two empties match, one empty does not.", "An iterative queue holding paired nodes works too and uses O(n) time."], "statement": "Decide whether a binary tree reads the same on both sides \u2014 that is, whether it is a mirror image of itself around its center.\n\nTwo trees are mirrors when their roots hold equal values and each left branch of one matches the corresponding right branch of the other, recursively. Check the root's left subtree against its right subtree in this mirrored fashion.\n\nReturn `true` when the whole structure is mirrored, otherwise `false`.\n\n**Constraints:**\n- `0 <= number of nodes <= 1000`\n- `-100 <= Node.val <= 100`\n", "solution": "## Approach\n\nMirror-check the two halves of the tree. A helper receives a pair of nodes that should be reflections of each other: both empty means success, exactly one empty means failure, and otherwise their values must match with cross-paired children (left-left against right-right and left-right against right-left). Starting the helper on the root's children determines symmetry.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), every node is visited once.\n- **Space Complexity:** O(h) recursion depth, O(n) in the worst skewed case.\n\n## Implementation\n\n```python\nclass Solution:\n    def isSymmetric(self, root) -> bool:\n        def mirror(a, b):\n            if not a and not b:\n                return True\n            if not a or not b:\n                return False\n            return a.val == b.val and mirror(a.left, b.right) and mirror(a.right, b.left)\n        if not root:\n            return True\n        return mirror(root.left, root.right)\n```\n", "starter": {"go": "// Definition for a binary tree node.\n// type TreeNode struct {\n//     Val int\n//     Left *TreeNode\n//     Right *TreeNode\n// }\npackage main\n\nfunc IsSymmetric(root *TreeNode) bool {\n    \n}", "python": "# Definition for a binary tree node.\n# class TreeNode:\n#     def __init__(self, val=0, left=None, right=None):\n#         self.val = val\n#         self.left = left\n#         self.right = right\n\nclass Solution:\n    def isSymmetric(self, root) -> bool:\n        pass\n", "cpp": "/*\nDefinition for a binary tree node.\nstruct TreeNode {\n    int val;\n    TreeNode *left;\n    TreeNode *right;\n    TreeNode(): val(0), left(nullptr), right(nullptr) {}\n    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}\n    TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}\n};\n*/\nclass Solution {\npublic:\n    bool isSymmetric(TreeNode* root) {\n        \n    }\n};"}, "fn": "isSymmetric", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}], "outputType": "boolean", "tests": [["[1,2,2,3,4,4,3]"], ["[1,2,2,null,3,null,3]"], ["[1]"], ["[]"], ["[1,2,2,3,null,null,3]"], ["[1,2,2,null,3,3,null]"], ["[1,2,3]"], ["[1,0]"], ["[1,2,2,3,4,4,3,5,6,7,8,8,7,6,5]"], ["[1,2,2,3,4,4,3,5,null,null,null,null,null,null,5]"], ["[2,3,3,4,5,5,4,null,null,8,9,9,8]"], ["[2,3,3,4,5,null,4]"], ["[1,2,2,3,4,4,3,null,null,null,null,null,null,null,null]"], ["[5,4,1,null,1,null,4,2,null,2]"], ["[1,2,2,null,null,2,2]"], ["[1,null,2]"], ["[1,2,null]"], ["[3,3,3]"], ["[0]"], ["[-100,100,100]"], ["[1,2,2,3,4,4,3,6,7,7,6,6,7,7,6]"], ["[1,2,2,3,4,4,3,6,null,7,null,null,7,null,6]"], ["[1,2,3,4,5,6,7]"], ["[7,7,7,7,7,7,7]"], ["[1,2,2,null,3,null,3,null,null,null,3]"], ["[9,25,25,null,-95,-95]"]], "expected": [true, false, true, true, true, true, false, false, true, true, true, false, true, false, false, false, false, true, true, true, true, true, false, true, false, true], "loose": false}

package/data/problems/tag-validator.json

@@ -0,0 +1 @@
+{"basic": false, "label": "633", "slug": "tag-validator", "id": 633, "title": "Tag Validator", "difficulty": "Hard", "category": "string", "link": "https://leetcode.com/problems/tag-validator/", "examples": [{"input": "code = \"<DIV>This is the first line <![CDATA[<div>]]></DIV>\"", "output": "true", "explanation": "One outer block wraps text plus a CDATA chunk."}, {"input": "code = \"<DIV>>>  ![cdata[]] <![CDATA[<div>]>]]>]]>>]</DIV>\"", "output": "true", "explanation": "Nested-looking symbols inside CDATA do not break parsing."}, {"input": "code = \"<A>  <B> </A>   </B>\"", "output": "false", "explanation": "Closing order does not match opening order."}], "hints": ["The whole string must be exactly one outer tag pair with nothing outside it.", "Track open tags on a stack; CDATA sections only count when the stack is non-empty.", "Tag names use 1-9 uppercase letters; CDATA opens with <![CDATA[ and closes with ]]> ."], "statement": "A snippet is valid when it consists of exactly one outer element with matched tags, optional text, and optional CDATA blocks. Tag names hold 1 to 9 uppercase letters. An opening tag looks like `<NAME>`, its closer like `</NAME>`, and a CDATA block looks like `<![CDATA[anything]]>` where the inside is taken literally.\n\nRules in plain terms: the snippet must start with an opening tag and end with its matching closer, with nothing before or after. Inside, plain text may appear only within some open tag, `<` must begin a valid tag or a well-formed CDATA, nested tags must close in reverse order, and every CDATA must terminate.\n\n**Constraints:**\n- `1 <= code.length <= 500`\n- Code uses printable ASCII plus `<`, `>`, `/`, `!`, `[`, `]`.\n", "solution": "## Approach\n\nScan left to right with a stack of open tag names. CDATA jumps to its terminator, closers must match the stack top, openers push, and plain text is legal only inside some tag. When the stack empties the scan must be exactly at the end, which enforces a single outer element.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2) worst case with naive search, O(n) with an index scan.\n- **Space Complexity:** O(n) for the stack.\n\n## Implementation\n\n```python\nclass Solution:\n    def isValid(self, code: str) -> bool:\n        n = len(code)\n        st = []\n        i = 0\n        def good(t):\n            return 1 <= len(t) <= 9 and all('A' <= c <= 'Z' for c in t)\n        while i < n:\n            if code.startswith('<![CDATA[', i):\n                j = code.find(']]>', i + 9)\n                if j < 0 or not st:\n                    return False\n                i = j + 3\n            elif code.startswith('</', i):\n                j = code.find('>', i)\n                if j < 0:\n                    return False\n                tag = code[i+2:j]\n                if not good(tag) or not st or st.pop() != tag:\n                    return False\n                i = j + 1\n                if not st and i != n:\n                    return False\n            elif code[i] == '<':\n                j = code.find('>', i)\n                if j < 0:\n                    return False\n                tag = code[i+1:j]\n                if not good(tag):\n                    return False\n                st.append(tag)\n                i = j + 1\n            else:\n                if not st:\n                    return False\n                i += 1\n        return not st\n```\n", "starter": {"go": "package main\n\nfunc IsValid(code string) bool {\n    return false\n}", "python": "class Solution:\n    def isValid(self, code: str) -> bool:\n        pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    bool isValid(string code) {\n        return false;\n    }\n};"}, "fn": "isValid", "params": [{"name": "code", "type": "string"}], "outputType": "boolean", "tests": [["<DIV>This is the first line <![CDATA[<div>]]></DIV>"], ["<DIV>>>  ![cdata[]] <![CDATA[<div>]>]]>]]>>]</DIV>"], ["<A>  <B> </A>   </B>"], ["<B><![CDATA[test]]></B>"], ["<A></A>"], ["<A>hello</A>"], ["<A><B></B></A>"], ["<A><B><C></C></B></A>"], ["<A><![CDATA[<>]]> </A>"], ["plain"], ["<A>"], ["</A>"], ["<A></B>"], ["<A></A><B></B>"], ["text<A></A>"], ["<A></A>text"], ["<a></a>"], ["<ABCDEFGHIJ></ABCDEFGHIJ>"], ["<A><![CDATA[x]]"], ["<A><![CDATA[x]]></A>"], ["<A><![CDATA[reserve]]></A>"], ["<A>  <B>hi<![CDATA[<br>]]></B>  </A>"], ["<X><Y></Y><Z></Z></X>"], ["<T><![CDATA[depth <><> ]]></T>"], ["<>"], ["<A>unclosed<B></A>"], ["<LONGTAGNAME></LONGTAGNAME>"], ["<A></A >"]], "expected": [true, true, false, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, true, true, true, true, true, false, false, false, false], "loose": false}

package/data/problems/tallest-billboard.json

@@ -0,0 +1 @@
+{"basic": false, "label": "942", "slug": "tallest-billboard", "id": 942, "title": "Tallest Billboard", "difficulty": "Hard", "category": "dp", "link": "https://leetcode.com/problems/tallest-billboard/", "examples": [{"input": "rods = [1,2,3,6]", "output": "6", "explanation": "Splitting into [1,2,3] and [6] gives two supports of height 6, which is the best achievable balance."}, {"input": "rods = [1,2,3,4,5,6]", "output": "10", "explanation": "Grouping [2,3,5] against [4,6] (or [1,4,5] against [2,3,... ]) reaches height 10; nothing taller balances."}, {"input": "rods = [1,2]", "output": "0", "explanation": "No two disjoint non-empty groups share a total, so the answer is 0."}], "hints": ["Track the height difference between the two supports instead of both heights.", "Let dp[d] be the tallest higher-support height reachable with difference d, and update it rod by rod.", "Adding a rod to the shorter support only raises the taller height when the rod overtakes the gap."], "statement": "You are given rods of various integer lengths and want to mount a billboard on two supports of exactly equal height. Each rod can be assigned to the left support, to the right support, or left unused, and the height of a support is the total length of the rods assigned to it.\n\nChoose the assignments so that both supports end up with the same height, and make that shared height as large as possible. Return the tallest balanced height you can build, or 0 when no balanced pair of supports exists.\n\n**Constraints:**\n- `1 <= rods.length <= 20`\n- `1 <= rods[i] <= 20`\n", "solution": "## Approach\n\nTrack the difference between the two supports. Let `dp[d]` be the tallest height of the higher support reachable with the two supports differing by `d`. Each new rod either joins the taller side (difference grows, height grows), joins the shorter side (difference shrinks or flips, height grows only if the rod overtakes), or is skipped. Copying the table per rod keeps every rod used at most once, and `dp[0]` at the end is the best balanced height.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * S), where n is the rod count and S the total length.\n- **Space Complexity:** O(S) for the difference table.\n\n## Implementation\n\n```python\nclass Solution:\n    def tallestBillboard(self, rods: list[int]) -> int:\n        s = sum(rods)\n        NEG = -10 ** 9\n        dp = [NEG] * (s + 1)\n        dp[0] = 0\n        for x in rods:\n            nxt = list(dp)\n            for d in range(s + 1):\n                if dp[d] < 0:\n                    continue\n                if d + x <= s:\n                    nxt[d + x] = max(nxt[d + x], dp[d] + x)\n                nd = abs(d - x)\n                nxt[nd] = max(nxt[nd], dp[d] + max(0, x - d))\n            dp = nxt\n        return dp[0]\n```\n", "starter": {"go": "package main\n\nfunc TallestBillboard(rods []int) int {\n    return 0\n}", "python": "from typing import List\nclass Solution:\n    def tallestBillboard(self, rods: List[int]) -> int:\n        return 0", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    int tallestBillboard(vector<int>& rods) {\n        return 0;\n    }\n};"}, "fn": "tallestBillboard", "params": [{"name": "rods", "type": "int_array"}], "outputType": "int", "tests": [["[1,2,3,6]"], ["[1,2,3,4,5,6]"], ["[1,2]"], ["[1,2,4,8,16]"], ["[3,3,3,3]"], ["[5,5,5,5,5]"], ["[2,4,5,9]"], ["[10,10]"], ["[7]"], ["[1,1,1,1,1,1]"], ["[20,20,20,20]"], ["[1,2,3,4,5]"], ["[8,3,5,2,7]"], ["[4,4,6,6,8]"], ["[11,12,13,14]"], ["[1,3,5,7,9]"], ["[2,2,3,5]"], ["[6,7,8,9,10]"], ["[1,4,6,8,10]"], ["[15,15,10,10,5,5]"], ["[9,9,9]"], ["[1,2,3,7]"], ["[5,3,2,8,8]"], ["[12,5,7,6,10]"], ["[1,1,2,3,5,8]"], ["[19,20,1,2,3]"], ["[4,8,15,16,19,20]"], ["[10,5,5,10]"]], "expected": [6, 10, 0, 0, 6, 10, 9, 10, 0, 3, 40, 7, 10, 14, 25, 12, 5, 17, 14, 30, 9, 3, 13, 17, 10, 22, 39, 15], "loose": false}

package/data/problems/target-sum.json

@@ -0,0 +1 @@
+{"basic": false, "label": "131", "slug": "target-sum", "id": 131, "title": "Target Sum", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/target-sum/", "examples": [{"input": "nums = [1,1,1,1,1], target = 3", "output": "5", "explanation": "Exactly five sign assignments evaluate to 3."}, {"input": "nums = [1], target = 1", "output": "1", "explanation": "There is 1 way to assign +/- to [1] such that the sum equals 1."}], "hints": ["After each number, track how many assignments reach every sum from -sum(nums) to sum(nums).", "A zero still has two sign choices, so both transitions must be counted."], "statement": "Take an integer list `nums` and an integer `target`. Imagine tagging every entry of\n`nums` with either `+` or `-`, leaving the entries in their original sequence,\nwhich yields a signed expression.\n\nCount how many distinct taggings make that expression come out to `target`.\nThe result is known to fit inside a signed 32-bit integer.\n\n**Constraints:**\n- `1 <= nums.length <= 20`\n- `0 <= nums[i] <= 1000`\n- `0 <= sum(nums) <= 1000`\n- `-1000 <= target <= 1000`\n", "solution": "## Approach\n\nSplit the numbers into a positive subset with sum `P` and a negative subset with sum\n`N`. Since `P + N` is the array sum and `P - N` is the target, `P` must equal\n`(sum(nums) + target) / 2`. Count subsets with that sum using backward one-dimensional\ndynamic programming. Zero values naturally double every existing count.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * S), where `S` is `sum(nums)`.\n- **Space Complexity:** O(S).\n\n## Implementation\n\n```python\nfrom typing import List\n\n\nclass Solution:\n    def findTargetSumWays(self, nums: List[int], target: int) -> int:\n        total = sum(nums)\n        if target < -total or target > total or (total + target) % 2:\n            return 0\n\n        subset = (total + target) // 2\n        ways = [0] * (subset + 1)\n        ways[0] = 1\n        for num in nums:\n            for value in range(subset, num - 1, -1):\n                ways[value] += ways[value - num]\n        return ways[subset]\n```\n", "starter": {"go": "package main\n\nfunc FindTargetSumWays(nums []int, target int) int {\n    return 0\n}", "python": "from typing import List\n\nclass Solution:\n    def findTargetSumWays(self, nums: List[int], target: int) -> int:\n        return 0\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    int findTargetSumWays(vector<int>& nums, int target) {\n        return 0;\n    }\n};"}, "fn": "findTargetSumWays", "params": [{"name": "nums", "type": "int_array"}, {"name": "target", "type": "int"}], "outputType": "int", "tests": [["[1,1,1,1,1]", "3"], ["[1]", "1"], ["[1]", "-1"], ["[1]", "0"], ["[1]", "2"], ["[0]", "0"], ["[0,0]", "0"], ["[0,0,1]", "1"], ["[0,0,1]", "-1"], ["[0,0,1]", "0"], ["[1,2]", "3"], ["[1,2]", "1"], ["[1,2]", "-1"], ["[1,2]", "0"], ["[1,2,3]", "0"], ["[1,2,3]", "2"], ["[1,2,3]", "7"], ["[2,2,2]", "2"], ["[2,2,2]", "0"], ["[5,5,5,5]", "0"], ["[5,5,5,5]", "10"], ["[1,1,1,1,1]", "-3"], ["[1,1,1,1,1]", "5"], ["[1,1,1,1,1]", "4"], ["[2,3,5,7]", "3"], ["[2,3,5,7]", "-3"], ["[2,3,5,7]", "17"], ["[2,3,5,7]", "16"], ["[10,20,30]", "0"], ["[10,20,30]", "20"], ["[10,20,30]", "60"], ["[1000]", "1000"], ["[1000]", "-1000"], ["[1000]", "999"], ["[100,200,300,400]", "0"], ["[100,200,300,400]", "200"], ["[100,200,300,400]", "-200"], ["[0,0,0,0,0,0,0,0,0,0]", "0"], ["[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]", "0"], ["[0,0,0,0,0,1,2,3]", "0"], ["[0,0,0,0,0,1,2,3]", "2"], ["[1,2,1]", "0"], ["[1,2,1]", "2"], ["[1,2,1]", "-2"], ["[7,1,3,9]", "4"], ["[7,1,3,9]", "-4"], ["[7,1,3,9]", "20"], ["[50,50,50,50,50,50]", "0"], ["[50,50,50,50,50,50]", "100"], ["[1,2,4,8,16,32]", "63"], ["[1,2,4,8,16,32]", "1"], ["[1,2,4,8,16,32]", "0"], ["[3,3,3,3,3,3,3,3]", "0"], ["[3,3,3,3,3,3,3,3]", "6"], ["[9,8,7,6,5,4,3,2,1]", "5"], ["[9,8,7,6,5,4,3,2,1]", "-5"], ["@javascript:JSON.stringify([1000,...Array(19).fill(0)])", "1000"]], "expected": [5, 1, 1, 0, 0, 2, 4, 4, 4, 0, 1, 1, 1, 0, 2, 1, 0, 3, 0, 6, 4, 5, 1, 0, 2, 2, 1, 0, 2, 1, 1, 1, 1, 0, 2, 2, 2, 1024, 1048576, 64, 32, 2, 2, 2, 1, 1, 1, 20, 15, 1, 1, 0, 70, 56, 22, 22, 524288], "loose": false}

package/data/problems/task-scheduler.json

@@ -0,0 +1 @@
+{"basic": false, "label": "105", "slug": "task-scheduler", "id": 105, "title": "Task Scheduler", "difficulty": "Medium", "category": "heap", "link": "https://leetcode.com/problems/task-scheduler/", "examples": [{"input": "tasks = \"AAABBB\", n = 2", "output": "8", "explanation": "A, B, idle, A, B, idle, A, B is optimal."}, {"input": "tasks = \"AAABBB\", n = 0", "output": "6", "explanation": "No idle time is required when the cooldown is zero."}], "hints": ["Count the frequency of each of the 26 task types.", "Arrange the most frequent task into blocks separated by n slots.", "If the maximum frequency is `f` and `m` task types have that frequency, compare `tasks.length` with `(f - 1) * (n + 1) + m`."], "statement": "You are given a string `tasks` whose uppercase letters represent CPU tasks and a nonnegative integer `n`. Each task takes one unit of time. Tasks may be executed in any order, but two executions of the same letter must be separated by at least `n` time units during which the CPU executes other tasks or is idle.\n\nReturn the minimum number of time units needed to execute every task.\n\nThis portable API adapts the original character-array input to a string. Each character of `tasks` is one task.\n\n**Constraints:**\n\n- `1 <= tasks.length <= 10^4`\n- Every character in `tasks` is an uppercase English letter from `A` through `Z`.\n- `0 <= n <= 100`\n", "solution": "## Approach\n\nCount the 26 task frequencies and let `maximum` be the largest frequency and `maximum_count` the number of task types with that frequency. Those tasks define a minimum block schedule of `(maximum - 1) * (n + 1) + maximum_count`; the answer is the larger of that value and the number of tasks.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(t), where `t` is `tasks.length`.\n- **Space Complexity:** O(1), because the frequency array always has 26 entries.\n\n## Implementation\n\n```python\nclass Solution:\n    def leastInterval(self, tasks: str, n: int) -> int:\n        frequencies = [0] * 26\n        for task in tasks:\n            frequencies[ord(task) - ord(\"A\")] += 1\n        maximum = max(frequencies)\n        maximum_count = sum(frequency == maximum for frequency in frequencies)\n        return max(len(tasks), (maximum - 1) * (n + 1) + maximum_count)\n```\n", "starter": {"go": "package main\n\nfunc LeastInterval(tasks string, n int) int {\n    panic(\"TODO\")\n}", "python": "class Solution:\n    def leastInterval(self, tasks: str, n: int) -> int:\n        raise NotImplementedError\n", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    int leastInterval(string tasks, int n) {\n        return 0;\n    }\n};"}, "fn": "leastInterval", "params": [{"name": "tasks", "type": "string"}, {"name": "n", "type": "int"}], "outputType": "int", "tests": [["AAABBB", "2"], ["AAABBB", "0"], ["AAAAAABCDEFG", "2"], ["A", "10"], ["ABCDE", "4"], ["AAAA", "3"], ["AAB", "2"], ["AABB", "2"], ["AAABBC", "2"], ["AAABC", "1"], ["ABCABC", "2"], ["ABCABC", "3"], ["AAAAABBBBB", "4"], ["AAAAABBBBBCCCCC", "2"], ["ZZZZ", "1"], ["AZAZAZ", "2"], ["ABCDEFGHIJKLMNOP", "100"], ["AABCDEF", "5"], ["AAAABCDEFGH", "3"], ["BBBBCCCCDD", "2"], ["AAABBBCCC", "2"], ["AAABBBCCC", "4"], ["ABACADA", "2"], ["ABCDEFGA", "6"], ["AAAAAAAAAA", "0"], ["AAAAAAAAAA", "100"], ["AABBCCDDEEFF", "1"], ["AABBCCDDEEFF", "5"], ["AAABBBC", "3"], ["AAAABCD", "2"], ["QQQWWWEEERRR", "3"], ["MNMNMNMN", "1"], ["MNMNMNMN", "3"], ["ABCDEABCDE", "4"], ["ABCDEABCDE", "6"], ["AAAZZZYYY", "2"], ["AAAAZZZYY", "2"], ["AABBC", "10"], ["ABCDABCDABCD", "3"], ["ABCDABCDABCD", "0"], ["XXXYZZ", "2"], ["PPPPQQR", "3"], ["AABBCCD", "2"], ["ABCDEFGHHA", "7"], ["CCCCBBBBAA", "1"], ["CCCCBBBBAA", "4"], ["ABCXYZABCXYZ", "5"], ["AAABBBBCCCCC", "2"], ["VVVVVWWWWWX", "5"], ["ABCDEFGHIJKLMNOPQRSTUVWXYZ", "25"], ["A", "0"], ["Z", "100"], ["@javascript:'A'.repeat(5000)+'Z'.repeat(5000)", "100"]], "expected": [8, 6, 16, 1, 5, 13, 4, 5, 7, 5, 6, 7, 22, 15, 7, 8, 16, 7, 13, 11, 9, 13, 10, 8, 10, 910, 12, 12, 10, 10, 12, 8, 14, 10, 12, 9, 10, 13, 12, 12, 7, 13, 7, 10, 10, 17, 12, 13, 26, 26, 1, 1, 504901], "loose": false}

package/data/problems/teemo-attacking.json

@@ -0,0 +1 @@
+{"basic": false, "label": "558", "slug": "teemo-attacking", "id": 558, "title": "Teemo Attacking", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/teemo-attacking/", "examples": [{"input": "timeSeries = [1,4], duration = 2", "output": "4", "explanation": "Spans [1,2] and [4,5] are disjoint, giving 2 + 2 seconds."}, {"input": "timeSeries = [1,2], duration = 2", "output": "3", "explanation": "Spans [1,2] and [2,3] overlap at second 2, giving 3 distinct seconds."}], "hints": ["Only neighboring attacks can overlap because the list is sorted.", "Each gap contributes min(duration, next - current); the final attack always adds a full duration.", "A duration of zero means no poisoned seconds at all."], "statement": "A hero poisons an enemy on each attack. An attack launched at second `t` keeps the enemy poisoned over the inclusive span from `t` through `t + duration - 1`. If a fresh attack lands while poison is still active, the clock restarts and the effect now lasts `duration` seconds beyond the new attack.\n\nYou are handed the non-decreasing attack moments in `timeSeries` and the fixed `duration`. Compute the total number of integer seconds during which the enemy suffers poison, merging all overlapping spans.\n\n**Constraints:**\n- `1 <= timeSeries.length <= 10^4`\n- `0 <= timeSeries[i], duration <= 10^7`\n- Attack times appear in non-decreasing order\n", "solution": "## Approach\n\nBecause attacks are ordered, poison intervals can only overlap with their immediate neighbor. Walking once through the list adds the overlap-capped gap `min(duration, next - current)` for every adjacent pair, plus a full `duration` for the last attack. A zero duration short-circuits to zero.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) for a single pass over the attacks.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n    def findPoisonedDuration(self, timeSeries: List[int], duration: int) -> int:\n        if not timeSeries or duration <= 0:\n            return 0\n        total = 0\n        for i in range(len(timeSeries) - 1):\n            total += min(duration, timeSeries[i + 1] - timeSeries[i])\n        return total + duration\n```\n", "starter": {"go": "package main\n\nfunc FindPoisonedDuration(timeSeries []int, duration int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def findPoisonedDuration(self, timeSeries: List[int], duration: int) -> int:\n        pass\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int findPoisonedDuration(vector<int>& timeSeries, int duration) {\n        return 0;\n    }\n};"}, "fn": "findPoisonedDuration", "params": [{"name": "timeSeries", "type": "int_array"}, {"name": "duration", "type": "int"}], "outputType": "int", "tests": [["[1,4]", "2"], ["[1,2]", "2"], ["[1]", "5"], ["[1]", "0"], ["[0]", "1"], ["[1,2,3,4,5]", "1"], ["[1,2,3,4,5]", "5"], ["[1,1,1]", "2"], ["[1,3,5,7]", "2"], ["[1,3,5,7]", "3"], ["[0,10000000]", "10000000"], ["[1,2]", "0"], ["[5,5,5,5]", "1"], ["[1,5,9]", "4"], ["[1,5,9]", "5"], ["[0,1,2,3]", "10"], ["[10,20,30]", "10"], ["[10,20,30]", "11"], ["[1,100,101,102]", "2"], ["[2,2]", "100"], ["[0,0]", "0"], ["[0,5,10]", "5"], ["[3,7,11]", "4"], ["[1,4,7,10]", "3"], ["[100]", "10000000"], ["[1,2,3]", "100"], ["[0,2,4,6,8]", "2"], ["[0,2,4,6,8]", "3"]], "expected": [4, 3, 5, 0, 1, 5, 9, 2, 8, 9, 20000000, 0, 1, 12, 13, 13, 30, 31, 6, 100, 0, 15, 12, 12, 10000000, 102, 10, 11], "loose": false}

package/data/problems/ternary-expression-parser.json

@@ -0,0 +1 @@
+{"basic": false, "label": "507", "slug": "ternary-expression-parser", "id": 507, "title": "Ternary Expression Parser", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/ternary-expression-parser/", "examples": [{"input": "expression = \"T?2:3\"", "output": "\"2\"", "explanation": "The condition is true, so the true branch 2 is picked."}, {"input": "expression = \"F?1:T?4:5\"", "output": "\"4\"", "explanation": "The outer condition is false, so the inner true choice T?4:5 gives 4."}, {"input": "expression = \"T?T?F:5:3\"", "output": "\"F\"", "explanation": "The inner T?F:5 is F, leaving T?F:3 which is F."}], "hints": ["Choices group from the right, so scanning from right to left turns nesting into a simple stack process.", "Push plain values and colons; when you meet '?', pop the true value, the colon, and the false value, then push back the picked one.", "The character just before '?' is the condition: 'T' keeps the first value, 'F' keeps the second."], "statement": "You are given a short program written with nested choices. The text `expression` uses `T` for true, `F` for false, single digits `0` to `9` as plain values, and the symbols `?` and `:` to form choices shaped like `condition ? valueIfTrue : valueIfFalse`.\n\nChoices can nest on either side, and nesting groups from the right. To find the answer, decide the rightmost choice first, replace it with its picked branch, then keep working leftward until one value remains.\n\nReturn that final value as a one-character string.\n\n**Constraints:**\n- `1 <= expression.length <= 10000`\n- `expression` contains only `T`, `F`, `0`-`9`, `?` and `:`.\n- `expression` is always a valid nested choice expression.\n- The answer is always a single character (`T`, `F`, or a digit).\n", "solution": "## Approach\n\nScan the choice text from right to left while keeping a stack. Plain values and colons are pushed. When a question mark is seen, pop the true branch, discard the colon, pop the false branch, and push back whichever branch the condition character selects. Because nesting groups from the right, this single pass collapses every level.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the length of `expression`. Each character is pushed and popped at most once.\n- **Space Complexity:** O(n) for the stack in the worst case.\n\n## Implementation\n\n```python\nclass Solution:\n    def parseTernary(self, expression: str) -> str:\n        st = []\n        i = len(expression) - 1\n        while i >= 0:\n            c = expression[i]\n            if c == '?':\n                cond = expression[i - 1]\n                i -= 1\n                t = st.pop()\n                st.pop()\n                f = st.pop()\n                st.append(t if cond == 'T' else f)\n            elif c == ':':\n                st.append(c)\n            else:\n                st.append(c)\n            i -= 1\n        return st.pop()\n```\n", "starter": {"go": "package main\n\nfunc ParseTernary(expression string) string {\n    return \"\"\n}", "python": "class Solution:\n    def parseTernary(self, expression: str) -> str:\n        pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    string parseTernary(string expression) {\n        return \"\";\n    }\n};"}, "fn": "parseTernary", "params": [{"name": "expression", "type": "string"}], "outputType": "string", "tests": [["T?2:3"], ["F?1:T?4:5"], ["T?T?F:5:3"], ["F"], ["T"], ["F?T:F"], ["T?F:T"], ["T?1:F?2:3"], ["F?1:F?2:3"], ["T?T?T?1:2:3:4"], ["F?T?1:2:F?3:4"], ["T?9:0"], ["F?9:0"], ["T?F?1:2:T?3:4"], ["F?F?1:2:T?3:4"], ["T?T?F?1:2:3:4"], ["5"], ["T?T:F"], ["F?T?F?1:2:3:4"], ["T?F?F?1:2:3:T?4:5"], ["T?T?1:2:3"], ["F?T?1:2:3"], ["T?F?1:2:F?3:4"], ["F?F?1:2:F?3:4"], ["T?0:1"], ["F?0:1"], ["T?T?T?T?1:2:3:4:5"], ["F?1:2"], ["T?1:2"], ["T?F:F"]], "expected": ["2", "4", "F", "F", "T", "F", "F", "1", "3", "1", "4", "9", "0", "2", "3", "2", "5", "T", "4", "3", "1", "3", "2", "4", "0", "1", "1", "2", "1", "F"], "loose": false}

package/data/problems/text-justification.json

@@ -0,0 +1 @@
+{"basic": false, "label": "271", "slug": "text-justification", "id": 271, "title": "Text Justification", "difficulty": "Hard", "category": "string", "link": "https://leetcode.com/problems/text-justification/", "examples": [{"input": "words = [\"This\",\"is\",\"an\",\"example\",\"of\",\"text\",\"justification.\"], maxWidth = 16", "output": "[\"This    is    an\",\"example  of text\",\"justification.  \"]", "explanation": "The first two lines spread extra blanks across gaps; the last line is left-aligned."}, {"input": "words = [\"What\",\"must\",\"be\",\"acknowledgment\",\"shall\",\"be\"], maxWidth = 16", "output": "[\"What   must   be\",\"acknowledgment  \",\"shall be        \"]", "explanation": "The long word fills its own line with trailing blanks."}], "hints": ["Greedily pack words: keep adding while the total letters plus minimum single spaces fits maxWidth.", "For justified lines, compute total blanks and share them as (blanks / gaps) with the first (blanks % gaps) gaps getting one extra.", "Left-align the last line and any single-word line: join with single spaces then pad the end."], "statement": "Spread a list of words across fully justified lines of exactly `maxWidth` characters. Pack as many words as possible into each line, then distribute blanks so the line reaches the required width.\n\nFor every line except the last, pad the gaps between words as evenly as possible, giving leftover single spaces to the leftmost gaps first. A line holding only one word is left-aligned with trailing blanks. The final line is left-aligned with single spaces between words and trailing blanks to fill the width.\n\n**Constraints:**\n- `1 <= words.length <= 300`\n- `1 <= words[i].length <= 20`\n- `1 <= maxWidth <= 100`\n- Each word contains letters and symbols without spaces.\n", "solution": "## Approach\n\nScan words greedily, extending each line while letters plus one blank per gap still fit. For middle lines with several words, divide the leftover blanks evenly among gaps and hand the remainder to the leftmost gaps. Single-word lines and the final line are left-aligned with single gaps and trailing padding.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(total characters), each word and blank written once.\n- **Space Complexity:** O(total characters) for the output lines.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def fullJustify(self, words: List[str], maxWidth: int) -> List[str]:\n        res = []\n        i = 0\n        while i < len(words):\n            j = i\n            line_len = 0\n            while j < len(words) and line_len + len(words[j]) + (j - i) <= maxWidth:\n                line_len += len(words[j])\n                j += 1\n            num = j - i\n            is_last = (j == len(words))\n            if num == 1 or is_last:\n                line = \" \".join(words[i:j])\n                line += \" \" * (maxWidth - len(line))\n                res.append(line)\n            else:\n                total = maxWidth - line_len\n                gaps = num - 1\n                base, extra = divmod(total, gaps)\n                parts = []\n                for k in range(i, j):\n                    parts.append(words[k])\n                    if k < j - 1:\n                        spaces = base + (1 if k - i < extra else 0)\n                        parts.append(\" \" * spaces)\n                res.append(\"\".join(parts))\n            i = j\n        return res\n```\n", "starter": {"go": "package main\n\nfunc FullJustify(words []string, maxWidth int) []string {\n    return []string{}\n}", "python": "from typing import List\nclass Solution:\n    def fullJustify(self, words: List[str], maxWidth: int) -> List[str]:\n        return []\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<string> fullJustify(vector<string>& words, int maxWidth) {\n        return {};\n    }\n};"}, "fn": "fullJustify", "params": [{"name": "words", "type": "string_array"}, {"name": "maxWidth", "type": "int"}], "outputType": "string_list", "tests": [["['This', 'is', 'an', 'example', 'of', 'text', 'justification.']", "16"], ["['What', 'must', 'be', 'acknowledgment', 'shall', 'be']", "16"], ["['Science', 'is', 'what', 'we', 'understand', 'well', 'enough', 'to', 'explain', 'to', 'a', 'computer.', 'Art', 'is', 'everything', 'else', 'we', 'do']", "20"], ["['a']", "1"], ["['a']", "5"], ["['ab', 'cd', 'ef']", "5"], ["['hello', 'world']", "11"], ["['hello', 'world']", "12"], ["['a', 'b', 'c', 'd', 'e']", "3"], ["['a', 'b', 'c', 'd', 'e']", "5"], ["['word']", "4"], ["['word', 'word', 'word']", "10"], ["['listen', 'to', 'many,', 'speak', 'to', 'a', 'few.']", "6"], ["['The', 'quick', 'brown', 'fox', 'jumps', 'over', 'the', 'lazy', 'dog']", "16"], ["['a', 'b']", "2"], ["['ab', 'cde', 'f']", "6"], ["['x']", "10"], ["['a', 'bb', 'ccc', 'dddd']", "7"], ["['hello']", "5"], ["['hi', 'there', 'everyone']", "10"], ["['one', 'two', 'three', 'four', 'five']", "8"], ["['a', 'b', 'c']", "1"], ["['longword', 'a', 'b', 'c']", "8"], ["['I', 'am', 'a', 'test']", "6"], ["['ab', 'cd']", "3"], ["['a', 'b', 'c', 'd']", "4"], ["['aa', 'bb', 'cc', 'dd']", "9"], ["['w1', 'w2', 'w3', 'w4', 'w5', 'w6']", "7"], ["['a!b', 'c?d', 'e.f']", "8"], ["['Ends', 'with', 'spaces', 'test']", "10"]], "expected": null, "loose": false}

package/data/problems/the-maze-ii.json

@@ -0,0 +1 @@
+{"basic": false, "label": "567", "slug": "the-maze-ii", "id": 567, "title": "The Maze II", "difficulty": "Medium", "category": "matrix", "link": "https://leetcode.com/problems/the-maze-ii/", "examples": [{"input": "maze = [[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]], start = [0,4], destination = [4,4]", "output": "12", "explanation": "One shortest rolling route covers 12 steps before stopping on the target."}, {"input": "maze = [[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]], start = [0,4], destination = [3,2]", "output": "-1", "explanation": "The ball can never come to rest on that cell, so the answer is -1."}, {"input": "maze = [[0,0,0],[0,0,0],[0,0,0]], start = [0,0], destination = [2,2]", "output": "4", "explanation": "Roll right across the top row (2 steps), then down the last column (2 steps)."}], "hints": ["Rolling turns stopping cells into graph nodes; edge weights are the roll lengths, so Dijkstra over stopping points gives the optimum.", "From each settled cell, simulate all four rolls to their stopping cells and relax longer known distances.", "Starting on the destination needs zero travel, and unreachable targets stay at -1."], "statement": "A ball rolls through a rectangular grid. Cells holding `0` are open floor and cells holding `1` are walls. From any open cell the ball can be launched in one of the four straight directions (up, down, left, right). Once moving it keeps rolling until a wall or the outer border stops it; it cannot halt partway. Each step onto a neighboring open cell adds one to the travelled length.\n\nGiven the grid `maze`, a `start` cell `[row, col]` and a `destination` cell `[row, col]`, compute the smallest total travel length that carries the ball from `start` to `destination` while obeying the rolling rule. The ball must come to rest exactly on `destination`. Return `-1` when the destination cannot be reached this way.\n\n**Constraints:**\n- `1 <= maze.length, maze[0].length <= 100`\n- `maze[i][j]` is `0` (open) or `1` (wall)\n- `start.length == 2` and `destination.length == 2`\n- `0 <= start[0], destination[0] < maze.length`\n- `0 <= start[1], destination[1] < maze[0].length`\n- Both `start` and `destination` are open cells\n", "solution": "## Approach\n\nTreat every cell where the ball can rest as a graph vertex. Rolling from one resting cell in a straight line until a wall yields an edge whose weight is the number of cells crossed. Because all weights are positive, Dijkstra's algorithm starting at `start` finds the cheapest travel length to every reachable resting cell. Simulate each of the four rolls directly, relax improved distances through a priority queue, and read off the destination distance (or `-1` when it stays unsettled).\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n * max(m, n) * log(m * n)) for rolling simulation plus heap operations.\n- **Space Complexity:** O(m * n) for the distance table and the queue.\n\n## Implementation\n\n```python\nfrom typing import List\nimport heapq\n\nclass Solution:\n    def shortestDistance(self, maze: List[List[int]], start: List[int], destination: List[int]) -> int:\n        m, n = len(maze), len(maze[0])\n        INF = 10 ** 9\n        dist = [[INF] * n for _ in range(m)]\n        dist[start[0]][start[1]] = 0\n        pq = [(0, start[0], start[1])]\n        dirs = [(-1, 0), (1, 0), (0, -1), (0, 1)]\n        while pq:\n            d, r, c = heapq.heappop(pq)\n            if d != dist[r][c]:\n                continue\n            if r == destination[0] and c == destination[1]:\n                return d\n            for dr, dc in dirs:\n                nr, nc, steps = r, c, 0\n                while 0 <= nr + dr < m and 0 <= nc + dc < n and maze[nr + dr][nc + dc] == 0:\n                    nr += dr\n                    nc += dc\n                    steps += 1\n                if dist[nr][nc] > d + steps:\n                    dist[nr][nc] = d + steps\n                    heapq.heappush(pq, (d + steps, nr, nc))\n        ans = dist[destination[0]][destination[1]]\n        return -1 if ans == INF else ans\n```\n", "starter": {"go": "package main\n\nfunc ShortestDistance(maze [][]int, start []int, destination []int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def shortestDistance(self, maze: List[List[int]], start: List[int], destination: List[int]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int shortestDistance(vector<vector<int>>& maze, vector<int>& start, vector<int>& destination) {\n        return -1;\n    }\n};"}, "fn": "shortestDistance", "params": [{"name": "maze", "type": "int_array_2d"}, {"name": "start", "type": "int_array"}, {"name": "destination", "type": "int_array"}], "outputType": "int", "tests": [["[[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]]", "[0,4]", "[4,4]"], ["[[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]]", "[0,4]", "[3,2]"], ["[[0,0,0],[0,0,0],[0,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,0],[0,0,0],[0,0,0]]", "[0,0]", "[0,0]"], ["[[0,1],[0,0]]", "[0,0]", "[1,1]"], ["[[0,1],[0,0]]", "[0,0]", "[0,0]"], ["[[0,0,0,0],[0,0,0,0],[0,0,0,0]]", "[0,0]", "[2,3]"], ["[[0,0,0,0],[0,1,1,0],[0,0,0,0]]", "[0,0]", "[2,3]"], ["[[1,0],[0,0]]", "[0,1]", "[1,1]"], ["[[0,0,0,0,0],[0,0,0,0,0],[0,0,1,0,0],[0,0,0,0,0]]", "[0,0]", "[3,4]"], ["[[0,0,0,0,0],[0,1,0,1,0],[0,0,0,0,0]]", "[0,0]", "[2,4]"], ["[[0,0],[0,0]]", "[0,0]", "[1,1]"], ["[[0,0],[0,0]]", "[0,0]", "[0,1]"], ["[[0,0,0],[0,1,0],[0,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,0],[0,1,0],[0,0,0]]", "[0,0]", "[1,1]"], ["[[0,0,0,1,0],[0,0,0,0,0],[0,1,0,1,0],[0,0,0,0,0]]", "[3,0]", "[0,4]"], ["[[0]]", "[0,0]", "[0,0]"], ["[[0,0,0,0,0,0],[0,0,0,0,0,0],[0,0,0,0,0,0]]", "[0,0]", "[2,5]"], ["[[0,0,1],[0,1,0],[0,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,0,0],[1,1,0,0],[0,0,0,1],[0,1,0,0]]", "[0,0]", "[3,3]"], ["[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]", "[1,1]", "[1,1]"], ["[[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]]", "[0,3]", "[3,0]"], ["[[0,1,0],[0,1,0],[0,0,0]]", "[0,0]", "[0,2]"], ["[[0,0,0,0,0],[1,1,1,1,0],[0,0,0,0,0]]", "[0,0]", "[2,4]"], ["[[0,0],[1,0]]", "[0,0]", "[1,1]"], ["[[0,0,0],[1,1,0],[0,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,0,0,0,0,0],[0,1,1,1,1,1,0],[0,0,0,0,0,0,0]]", "[0,0]", "[2,6]"], ["[[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]]", "[0,4]", "[1,2]"]], "expected": [12, -1, 4, 0, 2, 0, 5, 5, 1, 7, 6, 2, 1, 4, -1, 7, 0, 7, 4, 8, 0, 6, 6, 6, 2, 4, 8, 9], "loose": false}

package/data/problems/the-maze-iii.json

@@ -0,0 +1 @@
+{"basic": false, "label": "562", "slug": "the-maze-iii", "id": 562, "title": "The Maze III", "difficulty": "Hard", "category": "graph", "link": "https://leetcode.com/problems/the-maze-iii/", "examples": [{"input": "maze = [[0,0,0,0,0],[1,1,0,0,1],[0,0,0,0,0],[0,1,0,0,1],[0,1,0,0,0]], ball = [4,3], hole = [0,1]", "output": "\"lul\"", "explanation": "Rolling left, up and left in three segments reaches the hole with minimal distance."}, {"input": "maze = [[0,0,0,0,0],[1,1,0,0,1],[0,0,0,0,0],[0,1,0,0,1],[0,1,0,0,0]], ball = [4,3], hole = [3,0]", "output": "\"impossible\"", "explanation": "The hole sits in a pocket no rolling path can stop in."}], "hints": ["Treat stopping cells as nodes and rolling segments as weighted edges; Dijkstra over (distance, path) finds the optimum.", "Stop a roll early as soon as the hole is entered, counting only steps up to the hole.", "Order the priority queue by distance first and direction string second to get the lexicographically smallest shortest path."], "statement": "A ball rolls on a grid where `0` means open and `1` means wall. From a resting spot it may roll up (`u`), down (`d`), left (`l`) or right (`r`). It slides straight until the next step would hit a wall or leave the grid. There is one exception: if the rolling path crosses the hole cell, the ball drops in immediately and stops, even in open space.\n\nStarting from `ball`, find the shortest rolling route that ends in the hole. Distance is the number of open cells traveled. If several shortest routes exist, return the lexicographically smallest direction string (`d` < `l` < `r` < `u` in character order). When the hole cannot be reached, return the word `impossible`.\n\n**Constraints:**\n- `1 <= maze.length, maze[i].length <= 100`\n- Entries are `0` or `1`; ball and hole lie on open cells\n- Ball and hole positions differ\n", "solution": "## Approach\n\nModel each resting cell as a node and each maximal roll as a weighted edge, with the special rule that a roll halts early upon entering the hole. Dijkstra's algorithm over states ordered by (distance, path string) yields the shortest route, breaking ties toward the lexicographically smallest direction sequence. Distances and best paths are relaxed whenever a strictly shorter or equally short but smaller string is found.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n * (m + n) log(m * n)) for rolling from each cell with a heap.\n- **Space Complexity:** O(m * n) for distance, path and heap storage.\n\n## Implementation\n\n```python\nimport heapq\nfrom typing import List\n\nclass Solution:\n    def findShortestWay(self, maze: List[List[int]], ball: List[int], hole: List[int]) -> str:\n        m, n = len(maze), len(maze[0])\n        INF = 10 ** 9\n        dist = [[INF] * n for _ in range(m)]\n        best = [[None] * n for _ in range(m)]\n        dr = [1, 0, 0, -1]\n        dc = [0, -1, 1, 0]\n        ds = ['d', 'l', 'r', 'u']\n        dist[ball[0]][ball[1]] = 0\n        best[ball[0]][ball[1]] = \"\"\n        pq = [(0, \"\", ball[0], ball[1])]\n        while pq:\n            d, p, r, c = heapq.heappop(pq)\n            if d != dist[r][c] or p != best[r][c]:\n                continue\n            if r == hole[0] and c == hole[1]:\n                return p\n            for k in range(4):\n                nr, nc, steps = r, c, d\n                np = p + ds[k]\n                while True:\n                    tr, tc = nr + dr[k], nc + dc[k]\n                    if not (0 <= tr < m and 0 <= tc < n and maze[tr][tc] == 0):\n                        break\n                    nr, nc = tr, tc\n                    steps += 1\n                    if nr == hole[0] and nc == hole[1]:\n                        break\n                if nr == r and nc == c:\n                    continue\n                if steps < dist[nr][nc] or (steps == dist[nr][nc] and (best[nr][nc] is None or np < best[nr][nc])):\n                    dist[nr][nc] = steps\n                    best[nr][nc] = np\n                    heapq.heappush(pq, (steps, np, nr, nc))\n        return \"impossible\"\n```\n", "starter": {"go": "package main\n\nfunc FindShortestWay(maze [][]int, ball []int, hole []int) string {\n    \n}", "python": "from typing import List\nclass Solution:\n    def findShortestWay(self, maze: List[List[int]], ball: List[int], hole: List[int]) -> str:\n        pass\n", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    string findShortestWay(vector<vector<int>>& maze, vector<int>& ball, vector<int>& hole) {\n        return \"\";\n    }\n};"}, "fn": "findShortestWay", "params": [{"name": "maze", "type": "int_array_2d"}, {"name": "ball", "type": "int_array"}, {"name": "hole", "type": "int_array"}], "outputType": "string", "tests": [["[[0,0,0,0,0],[1,1,0,0,1],[0,0,0,0,0],[0,1,0,0,1],[0,1,0,0,0]]", "[4,3]", "[0,1]"], ["[[0,0,0,0,0],[1,1,0,0,1],[0,0,0,0,0],[0,1,0,0,1],[0,1,0,0,0]]", "[4,3]", "[3,0]"], ["[[0,0,0,0,0],[1,1,0,0,1],[0,0,0,0,0],[0,1,0,0,1],[0,1,0,0,0]]", "[0,0]", "[4,4]"], ["[[0,0,0],[0,0,0],[0,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,0],[0,0,0],[0,0,0]]", "[2,2]", "[0,0]"], ["[[0,0,0],[0,1,0],[0,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,0],[0,1,0],[0,0,0]]", "[0,0]", "[1,1]"], ["[[0,1,0],[0,1,0],[0,0,0]]", "[0,0]", "[0,2]"], ["[[0,0,0,0],[0,0,0,0],[0,0,0,0]]", "[0,0]", "[0,3]"], ["[[0,0,0,0],[0,0,0,0],[0,0,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,1],[0,0,0],[1,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,0,0,0],[0,0,0,0,0]]", "[0,0]", "[1,4]"], ["[[0,0],[0,0]]", "[0,0]", "[1,1]"], ["[[0,0],[0,0]]", "[0,0]", "[0,1]"], ["[[0,1],[0,0]]", "[0,0]", "[1,1]"], ["[[0,0,0],[1,1,0],[0,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,0,0,0,0,0],[0,0,1,0,0,1,0],[0,0,0,0,1,0,0],[0,0,0,0,0,0,1]]", "[0,4]", "[3,5]"], ["[[0,0,0],[0,0,0]]", "[0,0]", "[0,2]"], ["[[0,0,0],[0,0,0]]", "[0,2]", "[0,0]"], ["[[0,0,0,1],[0,1,0,0],[0,1,0,0]]", "[0,0]", "[1,3]"], ["[[0,0,0],[0,0,1],[0,1,0]]", "[0,0]", "[0,2]"], ["[[0,0,0,0],[1,1,1,0],[0,0,0,0]]", "[0,0]", "[2,3]"], ["[[0,0,1,0],[0,0,0,0],[0,0,0,0]]", "[2,0]", "[0,3]"], ["[[0,0,0,0,0],[0,1,1,1,0],[0,0,0,0,0]]", "[0,0]", "[2,4]"], ["[[0,0,0],[0,0,0],[1,1,0]]", "[2,2]", "[0,0]"], ["[[0,1,0,0],[0,1,0,1],[0,0,0,1],[1,1,0,0]]", "[0,0]", "[3,3]"], ["[[0,0,0,1,0],[0,0,0,1,0],[0,0,0,0,0]]", "[0,0]", "[0,4]"], ["[[0,0,0],[1,0,1],[0,0,0]]", "[0,1]", "[2,1]"]], "expected": ["lul", "impossible", "impossible", "dr", "lu", "dr", "impossible", "dru", "r", "dr", "drd", "dr", "dr", "r", "dr", "rd", "dldr", "r", "l", "rdru", "r", "rd", "ru", "dr", "ul", "drdr", "dru", "d"], "loose": false}

package/data/problems/the-maze.json

@@ -0,0 +1 @@
+{"basic": false, "label": "554", "slug": "the-maze", "id": 554, "title": "The Maze", "difficulty": "Medium", "category": "graph", "link": "https://leetcode.com/problems/the-maze/", "examples": [{"input": "maze = [[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]], start = [0,4], destination = [4,4]", "output": "true", "explanation": "Rolling left, down and around the walls lets the ball halt on the target cell."}, {"input": "maze = [[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]], start = [0,4], destination = [3,2]", "output": "false", "explanation": "Every rolling path stops on cells other than the requested destination."}], "hints": ["Model stopping positions as graph nodes; rolling to the wall in each direction gives the edges.", "Breadth-first or depth-first search over stopping positions avoids revisiting the same halt.", "Simulate each roll step by step until the cell before a wall, then enqueue that halt if unseen."], "statement": "A ball rests on an empty cell of a grid maze. Cells holding `0` are open; cells holding `1` are walls. From any stopping position the ball may roll in one of the four straight directions. Once moving it keeps sliding through open cells and only halts when the next step would hit a wall or leave the grid. At each halt it may pick a new direction.\n\nGiven the maze plus a start coordinate and a destination coordinate, decide whether the ball can come to rest exactly on the destination. Passing over the destination without stopping does not count.\n\nReturn `true` when such a rolling route exists and `false` otherwise.\n\n**Constraints:**\n- `1 <= maze.length, maze[i].length <= 100`\n- Entries are `0` (open) or `1` (wall)\n- Start and destination lie on open cells and differ\n- At least two open cells exist\n", "solution": "## Approach\n\nSearch only over cells where the ball can halt. From each halted cell simulate rolling in the four directions until the step before a wall or border, and treat that stopping cell as a neighbor. Breadth-first search marks halts visited so each is expanded once; reaching the destination halt means success.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n * (m + n)) in the worst case, since each of the m*n halts rolls up to m+n steps.\n- **Space Complexity:** O(m * n) for the visited table and queue.\n\n## Implementation\n\n```python\nfrom collections import deque\nfrom typing import List\n\nclass Solution:\n    def hasPath(self, maze: List[List[int]], start: List[int], destination: List[int]) -> bool:\n        m, n = len(maze), len(maze[0])\n        vis = [[False] * n for _ in range(m)]\n        q = deque([(start[0], start[1])])\n        vis[start[0]][start[1]] = True\n        while q:\n            x, y = q.popleft()\n            if x == destination[0] and y == destination[1]:\n                return True\n            for dx, dy in ((-1, 0), (1, 0), (0, -1), (0, 1)):\n                nx, ny = x, y\n                while 0 <= nx + dx < m and 0 <= ny + dy < n and maze[nx + dx][ny + dy] == 0:\n                    nx += dx\n                    ny += dy\n                if not vis[nx][ny]:\n                    vis[nx][ny] = True\n                    q.append((nx, ny))\n        return False\n```\n", "starter": {"go": "package main\n\nfunc HasPath(maze [][]int, start []int, destination []int) bool {\n    \n}", "python": "from typing import List\nclass Solution:\n    def hasPath(self, maze: List[List[int]], start: List[int], destination: List[int]) -> bool:\n        pass\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    bool hasPath(vector<vector<int>>& maze, vector<int>& start, vector<int>& destination) {\n        return false;\n    }\n};"}, "fn": "hasPath", "params": [{"name": "maze", "type": "int_array_2d"}, {"name": "start", "type": "int_array"}, {"name": "destination", "type": "int_array"}], "outputType": "boolean", "tests": [["[[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]]", "[0,4]", "[4,4]"], ["[[0,0,1,0,0],[0,0,0,0,0],[0,0,0,1,0],[1,1,0,1,1],[0,0,0,0,0]]", "[0,4]", "[3,2]"], ["[[0,0,0,0,0],[1,1,0,0,1],[0,0,0,0,0],[0,1,0,0,1],[0,1,0,0,0]]", "[4,3]", "[0,1]"], ["[[0,0],[0,0]]", "[0,0]", "[1,1]"], ["[[0,1],[0,0]]", "[0,0]", "[1,1]"], ["[[0,0,0],[0,1,0],[0,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,0],[1,1,0],[0,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,1],[0,0,1],[1,0,0]]", "[0,0]", "[2,2]"], ["[[0,0,0,0],[0,0,0,0],[0,0,0,0]]", "[0,0]", "[0,3]"], ["[[0,0,0,0],[0,0,0,0],[0,0,0,0]]", "[0,0]", "[2,2]"], ["[[0,1,0],[0,1,0],[0,0,0]]", "[0,0]", "[0,2]"], ["[[0,0,0],[0,0,0],[1,1,0]]", "[2,2]", "[0,0]"], ["[[0,0,0,1,0],[0,0,0,1,0],[0,0,0,0,0]]", "[0,0]", "[0,4]"], ["[[0]]", "[0,0]", "[0,0]"], ["[[0,0,0],[0,0,0]]", "[0,0]", "[1,2]"], ["[[1,1,0],[0,0,0],[0,0,0]]", "[0,2]", "[2,0]"], ["[[0,0,0],[0,1,1],[0,0,0]]", "[0,0]", "[2,0]"], ["[[0,0,1,0],[0,0,0,0],[0,0,0,0]]", "[2,0]", "[0,3]"], ["[[0,0,0,0,0],[0,1,1,1,0],[0,0,0,0,0]]", "[0,0]", "[2,4]"], ["[[0,1,0,0],[0,1,0,1],[0,0,0,1],[1,1,0,0]]", "[0,0]", "[3,3]"], ["[[0,0],[1,0]]", "[0,0]", "[1,1]"], ["[[0,0,0],[1,0,1],[0,0,0]]", "[0,1]", "[2,1]"], ["[[0,0,0,0,0],[1,1,1,1,0],[0,0,0,0,0]]", "[0,0]", "[2,4]"], ["[[0,0,1],[1,0,0],[0,0,0]]", "[0,0]", "[1,1]"], ["[[0,0,0,0],[0,1,0,0],[0,1,0,0],[0,0,0,0]]", "[0,0]", "[3,3]"], ["[[0,1],[0,1],[0,0]]", "[0,0]", "[2,1]"], ["[[0,0,0,1],[0,1,0,0],[0,1,0,0]]", "[0,0]", "[1,3]"], ["[[0,0,0],[0,0,1],[0,1,0]]", "[0,0]", "[0,2]"]], "expected": [true, false, false, true, true, true, true, true, true, false, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true, true], "loose": false}