offcode 0.0.0-stage → 0.1.0

package/data/problems/01-matrix.json

@@ -0,0 +1 @@
+{"basic": false, "label": "600", "slug": "01-matrix", "id": 600, "title": "01 Matrix", "difficulty": "Medium", "category": "matrix", "link": "https://leetcode.com/problems/01-matrix/", "examples": [{"input": "mat = [[0,0,0],[0,1,0],[0,0,0]]", "output": "[[0,0,0],[0,1,0],[0,0,0]]", "explanation": "Centre cell is one step from zero."}, {"input": "mat = [[0,0,0],[0,1,0],[1,1,1]]", "output": "[[0,0,0],[0,1,0],[1,2,1]]", "explanation": "Bottom row distances grow with depth."}, {"input": "mat = [[0]]", "output": "[[0]]"}], "hints": ["Start a breadth-first search from all zero cells at once; the first visit to a cell gives its nearest distance.", "Initialise ones as unvisited (-1) and expand level by level in the four directions."], "statement": "You are given a rectangular binary grid `mat` containing only zeros and ones. At least one cell holds zero.\n\nFor every cell, compute how many steps it takes to reach the closest zero when you may move up, down, left, or right to a neighbouring cell. Each move costs one.\n\nReturn a grid of the same shape where each entry holds that distance.\n\n**Constraints:**\n- `m == mat.length`, `n == mat[i].length`\n- `1 <= m, n <= 100`\n- `1 <= m * n <= 10^4`\n- `mat[i][j]` is `0` or `1`\n- At least one `0` exists\n", "solution": "## Approach\n\nSeed a queue with every zero cell at distance zero and mark all ones as unseen. Repeatedly pop a cell and relax its four neighbours: the first time a neighbour is reached its distance is final because the search expands in increasing distance order.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n), each cell enqueued once.\n- **Space Complexity:** O(m * n) for distances and the queue.\n\n## Implementation\n\n```python\nfrom typing import List\nfrom collections import deque\nclass Solution:\n    def updateMatrix(self, mat: List[List[int]]) -> List[List[int]]:\n        m, n = len(mat), len(mat[0])\n        dist = [[-1] * n for _ in range(m)]\n        q = deque()\n        for i in range(m):\n            for j in range(n):\n                if mat[i][j] == 0:\n                    dist[i][j] = 0\n                    q.append((i, j))\n        while q:\n            i, j = q.popleft()\n            for di, dj in ((1,0),(-1,0),(0,1),(0,-1)):\n                ni, nj = i + di, j + dj\n                if 0 <= ni < m and 0 <= nj < n and dist[ni][nj] == -1:\n                    dist[ni][nj] = dist[i][j] + 1\n                    q.append((ni, nj))\n        return dist\n```\n", "starter": {"go": "package main\n\nfunc UpdateMatrix(mat [][]int) [][]int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def updateMatrix(self, mat: List[List[int]]) -> List[List[int]]:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<vector<int>> updateMatrix(vector<vector<int>>& mat) {\n        return {};\n    }\n};"}, "fn": "updateMatrix", "params": [{"name": "mat", "type": "int_array_2d"}], "outputType": "int_array_2d", "tests": [["[[0,0,0],[0,1,0],[0,0,0]]"], ["[[0,0,0],[0,1,0],[1,1,1]]"], ["[[0]]"], ["[[1,1,1],[1,1,1],[1,1,0]]"], ["[[0,1],[1,1]]"], ["[[1,0],[0,1]]"], ["[[1,1],[1,0]]"], ["[[0,1,1],[1,1,1],[1,1,1]]"], ["[[1,0]]"], ["[[0,1,0],[1,1,1],[0,1,0]]"], ["[[1,1,0],[1,1,1],[0,0,0]]"], ["[[0,0],[0,0]]"], ["[[1,1],[1,1],[1,0]]"], ["[[0,1,1,1],[1,1,1,1],[1,1,1,0]]"], ["[[1,0,1],[0,0,0],[1,0,1]]"], ["[[0,0,0,0],[0,1,1,0],[0,1,1,0],[0,0,0,0]]"], ["[[1,1,1,1],[1,1,1,1],[1,1,1,0]]"], ["[[0,1,1],[1,1,0],[0,0,0]]"], ["[[1,1],[0,0]]"], ["[[0,0],[1,1]]"], ["[[1,0,0],[0,0,0],[0,0,1]]"], ["[[1,1,1],[1,0,1],[1,1,1]]"], ["[[0,1],[1,0],[1,1]]"], ["[[1,1,0,0],[0,1,1,0],[0,0,0,1]]"], ["[[0,0,1],[0,1,1],[1,1,1]]"], ["[[1,1,1,0],[0,0,0,0]]"], ["[[0,1,0,1,0]]"], ["[[0],[1],[1],[0]]"]], "expected": [[[0, 0, 0], [0, 1, 0], [0, 0, 0]], [[0, 0, 0], [0, 1, 0], [1, 2, 1]], [[0]], [[4, 3, 2], [3, 2, 1], [2, 1, 0]], [[0, 1], [1, 2]], [[1, 0], [0, 1]], [[2, 1], [1, 0]], [[0, 1, 2], [1, 2, 3], [2, 3, 4]], [[1, 0]], [[0, 1, 0], [1, 2, 1], [0, 1, 0]], [[2, 1, 0], [1, 1, 1], [0, 0, 0]], [[0, 0], [0, 0]], [[3, 2], [2, 1], [1, 0]], [[0, 1, 2, 2], [1, 2, 2, 1], [2, 2, 1, 0]], [[1, 0, 1], [0, 0, 0], [1, 0, 1]], [[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]], [[5, 4, 3, 2], [4, 3, 2, 1], [3, 2, 1, 0]], [[0, 1, 1], [1, 1, 0], [0, 0, 0]], [[1, 1], [0, 0]], [[0, 0], [1, 1]], [[1, 0, 0], [0, 0, 0], [0, 0, 1]], [[2, 1, 2], [1, 0, 1], [2, 1, 2]], [[0, 1], [1, 0], [2, 1]], [[1, 1, 0, 0], [0, 1, 1, 0], [0, 0, 0, 1]], [[0, 0, 1], [0, 1, 2], [1, 2, 3]], [[1, 1, 1, 0], [0, 0, 0, 0]], [[0, 1, 0, 1, 0]], [[0], [1], [1], [0]]], "loose": false}

package/data/problems/1-bit-and-2-bit-characters.json

@@ -0,0 +1 @@
+{"basic": false, "label": "725", "slug": "1-bit-and-2-bit-characters", "id": 725, "title": "1-bit and 2-bit Characters", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/1-bit-and-2-bit-characters/", "examples": [{"input": "bits = [1,0,0]", "output": "true", "explanation": "The encoding splits as 10 then 0, so the final symbol uses one bit."}, {"input": "bits = [1,1,1,0]", "output": "false", "explanation": "The only split is 11 then 10, leaving a two-bit tail."}, {"input": "bits = [0]", "output": "true", "explanation": "A lone zero is a one-bit symbol."}], "hints": ["A 1 always starts a two-bit symbol and consumes the next bit; a 0 stands alone.", "Walk from the front jumping 1 or 2 steps and see where you land relative to the last index.", "The answer is true exactly when the walk ends on the final position, not before it."], "statement": "An encoded message uses two symbol widths: `0` alone means a one-bit symbol, while `10` and `11` each mean a two-bit symbol. The given array `bits` is a valid encoding of at least one symbol.\n\nDecide whether the very last symbol occupies a single bit. In other words, walk the encoding greedily from the start \u2014 a `1` always consumes its follower, a `0` consumes only itself \u2014 and check whether the final `0` is read alone.\n\nReturn `true` when the tail symbol is one bit long, else `false`.\n\n**Constraints:**\n- `1 <= bits.length <= 1000`\n- Each entry is `0` or `1`, and the last entry is `0`.\n", "solution": "## Approach\n\nStep through the array with an index. A `1` jumps two places because it must pair with its follower; a `0` advances one place. Stop before the last cell: landing exactly on it means it was read alone.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the array length.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def isOneBitCharacter(self, bits: List[int]) -> bool:\n        i = 0\n        n = len(bits)\n        while i < n - 1:\n            i += 2 if bits[i] == 1 else 1\n        return i == n - 1\n```\n", "starter": {"go": "package main\n\nfunc IsOneBitCharacter(bits []int) bool {\n    return false\n}", "python": "from typing import List\nclass Solution:\n    def isOneBitCharacter(self, bits: List[int]) -> bool:\n        return False", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    bool isOneBitCharacter(vector<int>& bits) {\n        return false;\n    }\n};"}, "fn": "isOneBitCharacter", "params": [{"name": "bits", "type": "int_array"}], "outputType": "boolean", "tests": [["[1,0,0]"], ["[1,1,1,0]"], ["[0]"], ["[1,0]"], ["[0,0]"], ["[1,1,0]"], ["[1,0,1,0]"], ["[0,1,0]"], ["[1,1,1,1,0]"], ["[0,0,0]"], ["[1,0,0,0]"], ["[1,1,0,0]"], ["[0,1,1,0]"], ["[1,0,1,1,0]"], ["[1,1,1,1,1,0]"], ["[0,0,0,0]"], ["[1,0,0,1,0]"], ["[1,1,0,1,0]"], ["[0,1,0,0]"], ["[1,0,1,0,0]"], ["[1,1,1,0,0]"], ["[0,0,1,0]"], ["[1,1,0,0,0]"], ["[1,0,0,0,0]"], ["[0,1,1,1,0]"], ["[1,1,1,1,0,0]"], ["[0,0,0,0,0]"], ["[1,0,1,1,1,0]"]], "expected": [true, false, true, false, true, true, false, false, true, true, true, true, true, true, false, true, false, false, true, true, true, false, true, true, false, true, true, false], "loose": false}

package/data/problems/132-pattern.json

@@ -0,0 +1 @@
+{"basic": false, "label": "523", "slug": "132-pattern", "id": 523, "title": "132 Pattern", "difficulty": "Medium", "category": "stack", "link": "https://leetcode.com/problems/132-pattern/", "examples": [{"input": "nums = [1,2,3,4]", "output": "false", "explanation": "Every triple is increasing, so no middle value sits strictly between a smaller earlier value and a larger middle value."}, {"input": "nums = [3,1,4,2]", "output": "true", "explanation": "Indices 1, 2, 3 hold values 1, 4, 2, and 1 < 2 < 4."}, {"input": "nums = [-1,3,2,0]", "output": "true", "explanation": "The values -1, 3, 2 at indices 0, 1, 2 satisfy -1 < 2 < 3."}], "hints": ["Scan from right to left while keeping candidates for the middle value on a decreasing stack.", "Track the largest value popped so far as the best achievable `nums[k]`; any earlier smaller value completes the pattern."], "statement": "You are given an array `nums`. A `132 pattern` is a triple of positions `i < j < k` whose values sit in small-large-middle order:\n\n```\nnums[i] < nums[k] < nums[j]\n```\n\nReturn `true` if such a triple exists, and `false` otherwise.\n\n**Constraints:**\n- `1 <= nums.length <= 2 * 10^5`\n- `-10^9 <= nums[i] <= 10^9`\n", "solution": "## Approach\n\nWalk the array from right to left while maintaining a decreasing stack of candidates for the large middle position `nums[j]`. Whenever the current value exceeds the stack top, pop it and remember the biggest popped value as the best achievable `nums[k]` seen so far. If the current value is smaller than that remembered `nums[k]`, the three positions form the required small-large-middle ordering.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), since each element 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 find132pattern(self, nums: list) -> bool:\n        st = []\n        third = float(\"-inf\")\n        for v in reversed(nums):\n            if v < third:\n                return True\n            while st and v > st[-1]:\n                third = st.pop()\n            st.append(v)\n        return False\n```\n", "starter": {"go": "package main\n\nfunc Find132pattern(nums []int) bool {\n    \n}", "python": "from typing import List\nclass Solution:\n    def find132pattern(self, nums: List[int]) -> bool:\n        pass", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    bool find132pattern(vector<int>& nums) {\n        return false;\n    }\n};"}, "fn": "find132pattern", "params": [{"name": "nums", "type": "int_array"}], "outputType": "boolean", "tests": [["[1,2,3,4]"], ["[3,1,4,2]"], ["[-1,3,2,0]"], ["[3,5,0,3,4]"], ["[1,2,3,2,1]"], ["[1]"], ["[1,2]"], ["[2,1]"], ["[1,1,1]"], ["[1,3,2]"], ["[3,1,2]"], ["[2,4,3,1]"], ["[4,3,2,1]"], ["[1,0,1,-4,-3]"], ["[6,7,1,2,3,4,5]"], ["[-1,-2,-3,1,2]"], ["@javascript:JSON.stringify(Array.from({length:20000},(_,i)=>20000-i))"], ["[1,3,2,4]"], ["[3,2,1,0]"], ["[1,4,2,3]"], ["[5,4,3,2,1,0]"], ["[-5,-4,-3,-2,-1]"], ["[2,1,5,0,4,6]"], ["[0,1000000000,-1000000000,500000000]"], ["[1,0,1,0,1]"], ["[3,3,3,2,2,1]"], ["[1,5,2,4,3]"], ["[-2,-1,0,-3,-4,2]"]], "expected": [false, true, true, true, true, false, false, false, false, true, false, true, false, false, false, false, false, true, false, true, false, false, true, true, false, false, true, false], "loose": false}

package/data/problems/2-keys-keyboard.json

@@ -0,0 +1 @@
+{"basic": false, "label": "670", "slug": "2-keys-keyboard", "id": 670, "title": "2 Keys Keyboard", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/2-keys-keyboard/", "examples": [{"input": "n = 3", "output": "3", "explanation": "Copy (1) then paste twice: 1 -> 2 -> 3."}, {"input": "n = 1", "output": "0", "explanation": "The single A is already there."}, {"input": "n = 6", "output": "5", "explanation": "Copy, paste to 2, copy, paste to 4, paste to 6."}], "hints": ["A paste run from size a to a multiple m*a costs one copy plus (m - 1) pastes, i.e. m steps for the factor m.", "Hence the optimum equals the sum of the prime factors of n with multiplicity.", "Peel off the smallest divisor repeatedly; whatever prime remains counts itself."], "statement": "You start with one `A` on screen and two operations: copy everything currently shown, and paste the clipboard's contents to the end. The clipboard starts empty; a copy overwrites it, and a paste does not change it.\n\nImplement `minSteps(n)` returning the fewest operations that leave exactly `n` characters on screen.\n\n**Constraints:**\n- `1 <= n <= 1000`\n", "solution": "## Approach\n\nGrowing from length 1, each copy-plus-pastes block multiplies the current size by some factor m at a cost of m steps (one copy, m-1 pastes). Building n therefore costs the sum of the multiplied factors, which is minimized by splitting n into primes. Factoring n and adding the prime factors with multiplicity gives the optimum.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(sqrt(n)) for trial division.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nclass Solution:\n    def minSteps(self, n: int) -> int:\n        if n <= 1:\n            return 0\n        ans, x, d = 0, n, 2\n        while d * d <= x:\n            while x % d == 0:\n                ans += d\n                x //= d\n            d += 1\n        if x > 1:\n            ans += x\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc MinSteps(n int) int {\n    return 0\n}", "python": "from typing import List\nclass Solution:\n    def minSteps(self, n: int) -> int:\n        pass", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    int minSteps(int n) {\n        return 0;\n    }\n};"}, "fn": "minSteps", "params": [{"name": "n", "type": "int"}], "outputType": "int", "tests": [["3"], ["1"], ["6"], ["2"], ["4"], ["5"], ["7"], ["8"], ["9"], ["10"], ["12"], ["15"], ["18"], ["20"], ["25"], ["27"], ["30"], ["36"], ["48"], ["50"], ["64"], ["72"], ["81"], ["100"], ["128"], ["256"], ["512"], ["1000"]], "expected": [3, 0, 5, 2, 4, 5, 7, 6, 6, 7, 7, 8, 8, 9, 10, 9, 10, 10, 11, 12, 12, 12, 12, 14, 14, 16, 18, 21], "loose": false}

package/data/problems/24-game.json

@@ -0,0 +1 @@
+{"basic": false, "label": "697", "slug": "24-game", "id": 697, "title": "24 Game", "difficulty": "Hard", "category": "backtracking", "link": "https://leetcode.com/problems/24-game/", "examples": [{"input": "cards = [4,1,8,7]", "output": "true", "explanation": "(8 - 4) * (7 - 1) equals 24."}, {"input": "cards = [1,2,1,2]", "output": "false", "explanation": "No arrangement of the four values reaches 24."}, {"input": "cards = [3,3,8,8]", "output": "true", "explanation": "8 divided by (3 - 8/3) equals 24."}], "hints": ["Try every order of combining pairs with +, -, *, / in a depth-first search.", "Floating comparisons need a small tolerance (1e-6); document that divisions use doubles.", "Prune symmetric branches but keep both subtraction and division orders."], "statement": "You receive four cards, each showing an integer. Using the four arithmetic operators `+`, `-`, `*`, `/` and any placement of parentheses, decide whether an expression using every card exactly once can evaluate to 24.\n\nDivision is real division (not integer division). Two values that differ by less than `1e-6` are treated as equal when checking for 24; this tolerance rule is part of the task because intermediate results are doubles.\n\nReturn `true` when such an expression exists, otherwise `false`.\n\n**Constraints:**\n- `cards.length == 4`\n- `1 <= cards[i] <= 9`\n", "solution": "## Approach\n\nTreat the cards as doubles and repeatedly pick an ordered pair, replace it by one of its possible results (+, -, *, / when legal), and recurse. With one value left, succeed when it is within 1e-6 of 24. Trying all pairs and orders covers every parenthesization.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1) \u2014 only four numbers, bounded search tree.\n- **Space Complexity:** O(1) recursion depth.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def judgePoint24(self, cards: List[int]) -> bool:\n        vals = [float(c) for c in cards]\n        def dfs(arr):\n            if len(arr) == 1:\n                return abs(arr[0] - 24.0) < 1e-6\n            for i in range(len(arr)):\n                for j in range(len(arr)):\n                    if i == j:\n                        continue\n                    rest = [arr[k] for k in range(len(arr)) if k != i and k != j]\n                    a, b = arr[i], arr[j]\n                    cands = [a + b, a - b, a * b]\n                    if abs(b) > 1e-9:\n                        cands.append(a / b)\n                    for v in cands:\n                        if dfs(rest + [v]):\n                            return True\n            return False\n        return dfs(vals)\n```\n", "starter": {"go": "package main\n\nfunc JudgePoint24(cards []int) bool {\n    return false\n}", "python": "from typing import List\nclass Solution:\n    def judgePoint24(self, cards: List[int]) -> bool:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    bool judgePoint24(vector<int>& cards) {\n        return false;\n    }\n};"}, "fn": "judgePoint24", "params": [{"name": "cards", "type": "int_array"}], "outputType": "boolean", "tests": [["[4,1,8,7]"], ["[1,2,1,2]"], ["[3,3,8,8]"], ["[1,1,1,1]"], ["[6,6,6,6]"], ["[1,5,5,5]"], ["[2,2,2,2]"], ["[3,3,3,3]"], ["[4,4,4,4]"], ["[5,5,5,5]"], ["[6,1,2,3]"], ["[1,1,2,6]"], ["[1,3,4,6]"], ["[2,3,4,6]"], ["[7,7,7,7]"], ["[8,8,8,8]"], ["[9,9,9,9]"], ["[1,9,9,9]"], ["[2,7,8,9]"], ["[3,4,5,6]"], ["[4,5,6,7]"], ["[1,2,3,4]"], ["[2,5,5,10]"], ["[1,4,5,6]"], ["[3,5,7,9]"], ["[6,7,8,9]"], ["[1,1,1,2]"], ["[4,4,10,10]"]], "expected": [true, false, true, false, true, true, false, true, true, true, true, true, true, true, false, false, false, false, true, true, true, true, true, true, true, true, false, true], "loose": false}

package/data/problems/3sum-closest.json

@@ -0,0 +1 @@
+{"basic": false, "label": "255", "slug": "3sum-closest", "id": 255, "title": "3Sum Closest", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/3sum-closest/", "examples": [{"input": "nums = [-1,2,1,-4], target = 1", "output": "2", "explanation": "The triple (-1, 2, 1) sums to 2, the closest achievable total to 1."}, {"input": "nums = [0,0,0], target = 1", "output": "0", "explanation": "The only triple sums to 0."}], "hints": ["Sort the array first; then for each fixed first element, sweep the other two with inward-moving pointers.", "Track the best total seen so far and move the left pointer up when the sum is below target, else move the right pointer down."], "statement": "You are given an array `nums` of `n` integers and a target value `target`. Pick three entries at pairwise different positions so that their total is as near as possible to `target`, then return that total.\n\nEvery test case is constructed so that exactly one such closest total exists.\n\n**Constraints:**\n- `3 <= nums.length <= 500`\n- `-1000 <= nums[i] <= 1000`\n- `-10^4 <= target <= 10^4`\n", "solution": "## Approach\n\nSort a copy of the array so the two-pointer sweep applies. Fix each index in turn as the first element of the triple and move two pointers inward, keeping whichever total lands nearest the target. Whenever the current sum falls short of the target the left pointer advances, otherwise the right pointer retreats; an exact hit ends the search immediately.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2) from sorting plus one linear sweep per fixed index.\n- **Space Complexity:** O(n) for the sorted copy (O(1) besides input storage with in-place sort).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def threeSumClosest(self, nums: List[int], target: int) -> int:\n        a = sorted(nums)\n        best = a[0] + a[1] + a[2]\n        for i in range(len(a) - 2):\n            l, r = i + 1, len(a) - 1\n            while l < r:\n                s = a[i] + a[l] + a[r]\n                if abs(s - target) < abs(best - target):\n                    best = s\n                if s < target:\n                    l += 1\n                elif s > target:\n                    r -= 1\n                else:\n                    return target\n        return best\n```\n", "starter": {"go": "package main\n\nfunc ThreeSumClosest(nums []int, target int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def threeSumClosest(self, nums: List[int], target: int) -> int:\n        ", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    int threeSumClosest(vector<int>& nums, int target) {\n        return 0;\n    }\n};"}, "fn": "threeSumClosest", "params": [{"name": "nums", "type": "int_array"}, {"name": "target", "type": "int"}], "outputType": "int", "tests": [["[-1,2,1,-4]", "1"], ["[0,0,0]", "1"], ["[1,1,1,0]", "-100"], ["[1,2,3,4,5]", "10"], ["[-5,-4,-3,-2,-1]", "-8"], ["[0,1,2]", "3"], ["[0,1,2]", "0"], ["[1,1,-1,-1,3]", "-1"], ["[1000,1000,1000]", "0"], ["[-1000,-1000,-1000]", "1000"], ["[4,0,5,-5,3,3,0,0,-5]", "-2"], ["[1,2,4,8,16,32,64,128]", "82"], ["[-1,0,1,0]", "100"], ["[5,5,5,5,5]", "14"], ["[5,5,5,5,5]", "16"], ["[-2,0,1,3]", "2"], ["[0,0,0,0,1]", "1"], ["[1,-1,2,-2,3,-3]", "0"], ["[999,998,997]", "2994"], ["[1,2,4]", "5"], ["[10,20,30]", "65"], ["[-10,-20,15,25,-5]", "12"], ["[3,7,1,9,2,8]", "20"], ["[-4,-1,1,2,5,8]", "0"], ["[6,-6,6,-6,0]", "1"], ["[100,-100,50,-50,25]", "30"], ["[1,1,1,1,1,1,1]", "3"]], "expected": [2, 0, 2, 10, -8, 3, 3, -1, 3000, -3000, -2, 82, 1, 15, 15, 2, 1, 0, 2994, 7, 60, 10, 20, 0, 0, 25, 3], "loose": false}

package/data/problems/3sum-smaller.json

@@ -0,0 +1 @@
+{"basic": false, "label": "363", "slug": "3sum-smaller", "id": 363, "title": "3Sum Smaller", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/3sum-smaller/", "examples": [{"input": "nums = [-2,0,1,3], target = 2", "output": "2", "explanation": "The triples ([-2,0,1]) and ([-2,0,3]) sum to -1 and 1, both below 2."}, {"input": "nums = [], target = 0", "output": "0", "explanation": "Fewer than three values means no triple exists."}, {"input": "nums = [3,1,0,-2], target = 4", "output": "3", "explanation": "Three of the four possible triples fall below 4."}], "hints": ["Sort the array so the two-pointer technique applies to each fixed first index.", "When the current triple is below target, every index between the pointers pairs with the fixed index, adding that many triples at once."], "statement": "Given an integer array `nums` and an integer `target`, count the index triples `(i, j, k)` with `i < j < k` whose values sum to less than `target`.\n\n**Constraints:**\n- `0 <= nums.length <= 10^4`\n- `-10^4 <= nums[i] <= 10^4`\n- `-10^4 <= target <= 10^4`\n", "solution": "## Approach\n\nSort the array and fix each first index in turn. With two pointers on the remaining suffix, a triple below the target means every index between the pointers also works with the fixed index, so add that whole block at once and move the left pointer forward. Otherwise move the right pointer inward. Each index is processed once as the fixed choice.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2), where n is the length of `nums`, for sorting plus the nested two-pointer scan.\n- **Space Complexity:** O(1) besides sorting.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n    def threeSumSmaller(self, nums: List[int], target: int) -> int:\n        a = sorted(nums)\n        count = 0\n        for i in range(len(a) - 2):\n            lo, hi = i + 1, len(a) - 1\n            while lo < hi:\n                if a[i] + a[lo] + a[hi] < target:\n                    count += hi - lo\n                    lo += 1\n                else:\n                    hi -= 1\n        return count\n```\n", "starter": {"go": "package main\n\nfunc ThreeSumSmaller(nums []int, target int) int {\n    return 0\n}", "python": "from typing import List\n\nclass Solution:\n    def threeSumSmaller(self, nums: List[int], target: int) -> int:\n        return 0\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    int threeSumSmaller(vector<int>& nums, int target) {\n        return 0;\n    }\n};"}, "fn": "threeSumSmaller", "params": [{"name": "nums", "type": "int_array"}, {"name": "target", "type": "int"}], "outputType": "int", "tests": [["[-2,0,1,3]", "2"], ["[]", "0"], ["[0]", "0"], ["[3,1,0,-2]", "4"], ["[1,1,1]", "4"], ["[1,1,1]", "3"], ["[0,0,0]", "1"], ["[5,1,3,4,7]", "12"], ["[-2,0,-1,3]", "2"], ["[3,2,-2,6,2,-2,6,-2,-4,2,3,0,4,4,1]", "3"], ["[1,2,3,4,5]", "8"], ["[1,2,3,4,5]", "100"], ["[-4,-3,-2,-1,0]", "-5"], ["[0,0,0,0]", "1"], ["[10,-10,10,-10]", "0"], ["[1,0,-1]", "1"], ["[2,2,2,2]", "7"], ["[2,2,2,2]", "6"], ["[-1,1,-1,1]", "1"], ["[100,200,300]", "50"], ["[7,7,7,7,7,7]", "22"], ["[-100,100,-50,50,0]", "10"], ["[1,2]", "10"], ["[4,0,5,-5,3,3,0,-4,-5]", "-2"], ["[0,1,2,3,4,5,6,7,8,9]", "10"], ["[-2,-2,-2,-2]", "-5"]], "expected": [2, 0, 0, 3, 1, 0, 1, 4, 3, 151, 2, 10, 6, 4, 2, 1, 4, 0, 2, 0, 20, 6, 0, 22, 23, 4], "loose": false}

package/data/problems/3sum-with-multiplicity.json

@@ -0,0 +1 @@
+{"basic": false, "label": "910", "slug": "3sum-with-multiplicity", "id": 910, "title": "3Sum With Multiplicity", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/3sum-with-multiplicity/", "examples": [{"input": "arr = [1,1,2,2,3,3,4,4,5,5], target = 8", "output": "20", "explanation": "Twenty index triplets (i < j < k) have values summing to 8."}, {"input": "arr = [1,1,2,2,2,2], target = 5", "output": "12", "explanation": "Each choice of one of the two 1s, one of the four 2s... triplets of values (1,2,2) give 2 * 6 = 12."}, {"input": "arr = [2,1,3], target = 6", "output": "1", "explanation": "Only the triplet using all three positions sums to 6."}], "hints": ["Values are bounded (0 to 100), so counting frequencies beats enumerating triplets.", "For each value combination i <= j <= k with i + j + k == target, multiply the available choices (using nC2 / nC3 when values repeat).", "Accumulate the total modulo 1,000,000,007."], "statement": "You are given an integer array `arr` and an integer `target`. Count the triplets of positions `(i, j, k)` with `i < j < k` whose values add up to `target`.\n\nReturn that count modulo `10^9 + 7`.\n\n**Constraints:**\n- `3 <= arr.length <= 3000`\n- `0 <= arr[i] <= 100`\n- `0 <= target <= 300`\n", "solution": "## Approach\n\nBecause values are confined to 0..100, tally frequencies once and iterate over value triples `i <= j <= k` summing to the target. Each triple contributes the product of available picks, using combinations (nC2, nC3) when values coincide, all reduced modulo 1,000,000,007.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + V^2) with V = 101 distinct values.\n- **Space Complexity:** O(V) for the frequency table.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def threeSumMulti(self, arr: List[int], target: int) -> int:\n        mod = 10 ** 9 + 7\n        c = [0] * 101\n        for v in arr:\n            c[v] += 1\n        ans = 0\n        for i in range(101):\n            if c[i] == 0:\n                continue\n            for j in range(i, 101):\n                if c[j] == 0:\n                    continue\n                k = target - i - j\n                if k < j or k > 100 or c[k] == 0:\n                    continue\n                if i == j == k:\n                    ans += c[i] * (c[i] - 1) * (c[i] - 2) // 6\n                elif i == j:\n                    ans += c[i] * (c[i] - 1) // 2 * c[k]\n                elif j == k:\n                    ans += c[i] * c[j] * (c[j] - 1) // 2\n                else:\n                    ans += c[i] * c[j] * c[k]\n        return ans % mod\n```\n", "starter": {"go": "package main\n\nfunc ThreeSumMulti(arr []int, target int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def threeSumMulti(self, arr: List[int], target: int) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int threeSumMulti(vector<int>& arr, int target) {\n        return 0;\n    }\n};"}, "fn": "threeSumMulti", "params": [{"name": "arr", "type": "int_array"}, {"name": "target", "type": "int"}], "outputType": "int", "tests": [["[1,1,2,2,3,3,4,4,5,5]", "8"], ["[1,1,2,2,2,2]", "5"], ["[2,1,3]", "6"], ["[0,0,0]", "0"], ["[4, 2, 4, 5, 4, 5, 0, 5, 3, 0, 0, 5, 3, 3, 1, 3, 5, 1, 4, 0]", "12"], ["[14, 1, 16, 0, 2, 17, 18, 6, 2, 14, 20, 1, 18, 4, 4, 9, 1, 9, 14, 5]", "28"], ["[2, 1, 0, 0, 1, 2, 2, 2]", "6"], ["[23, 6, 42, 3, 21, 1, 49, 42, 3, 22, 22, 29, 47, 49, 35, 39, 32, 2, 25, 4, 6, 4, 38, 18, 10, 34, 6, 5, 28, 40, 35, 30, 18, 18, 28, 37, 46, 30, 16, 15, 3, 45, 16, 20, 3, 34, 35, 29, 23, 4, 40, 8, 4, 49, 22, 5, 7, 23, 43, 29, 39, 29, 24, 36, 47, 5, 33, 10, 32, 35, 10, 43, 11, 46, 47, 12, 0, 3, 21, 9]", "136"], ["[9, 2, 7, 10]", "9"], ["[36, 47, 8, 44]", "11"], ["[3, 3, 7]", "4"], ["[2, 3, 2]", "3"], ["[24, 41, 29, 1, 3, 37, 35, 50, 43, 9]", "130"], ["[3, 18, 18, 10, 10, 19, 10, 13, 0, 17, 20, 3, 17, 13, 9, 3, 6, 17, 16, 17, 15, 14, 12, 2, 9, 4, 17, 4, 8, 19, 7, 3, 12, 6, 11, 10, 6, 5, 10, 8]", "9"], ["[2, 8, 11, 15, 10, 12, 20, 13, 9, 3, 0, 3, 18, 19, 17, 0, 0, 20, 15, 7, 5, 16, 11, 12, 6, 18, 6, 2, 20, 0, 19, 18, 4, 15, 4, 18, 17, 3, 20, 2, 3, 13, 12, 15, 5, 2, 1, 19, 13, 11, 14, 14, 9, 11, 12, 12, 18, 8, 5, 18, 11, 3, 10, 3, 1, 16, 8, 7, 19, 16, 18, 5, 1, 4, 12, 4, 10, 20, 19, 12]", "31"], ["[1, 0, 4, 0, 3, 3, 0, 0, 0, 4, 3, 2, 1, 2, 3, 0, 4, 1, 1, 4, 1, 5, 2, 5, 3, 2, 5, 4, 5, 2, 1, 1, 5, 0, 4, 1, 0, 2, 1, 2, 4, 2, 2, 0, 4, 2, 1, 2, 2, 5, 0, 4, 1, 3, 4, 1, 5, 0, 1, 4, 3, 1, 0, 2, 2, 5, 2, 2, 4, 5, 0, 4, 1, 1, 5, 4, 0, 2, 5, 3]", "14"], ["[17, 2, 18, 20]", "26"], ["[49, 5, 28, 21, 38, 8, 39, 6, 38, 23, 9, 40, 44, 40, 14, 36, 20, 10, 17, 41]", "92"], ["[10, 8, 6, 4, 3, 10, 8, 1, 1, 1]", "20"], ["[82, 46, 16]", "162"], ["[20, 83, 92, 85, 82, 66, 15, 100, 49, 23, 50, 0, 44, 61, 78]", "116"], ["[17, 18, 16, 11, 2, 16, 7, 16, 12, 14, 5, 0, 16, 10, 1, 20, 20, 15, 8, 11, 12, 20, 18, 3, 17, 9, 20, 2, 6, 16, 8, 4, 11, 6, 1, 11, 7, 2, 1, 14, 18, 5, 7, 20, 19, 18, 15, 2, 1, 4, 2, 10, 4, 9, 20, 9, 5, 19, 0, 11, 1, 10, 20, 1, 9, 9, 12, 12, 2, 8, 11, 15, 4, 9, 16, 19, 6, 11, 16, 2]", "56"], ["[2, 3, 8, 6]", "8"], ["[42, 25, 45, 37, 43, 42]", "144"], ["[5, 5, 2, 4, 3, 1, 1, 3, 1, 2, 4, 1, 1, 1, 2, 4, 1, 3, 4, 4]", "1"], ["[6, 5, 7, 4, 7]", "20"], ["[31, 38, 33, 26]", "141"], ["[6, 4, 4, 0, 2, 17, 18, 11, 14, 13, 13, 8, 16, 4, 10]", "50"]], "expected": [20, 12, 1, 1, 94, 33, 4, 45, 0, 0, 0, 0, 1, 27, 2852, 770, 0, 15, 3, 0, 3, 243, 0, 0, 0, 1, 0, 0], "loose": false}

package/data/problems/3sum.json

@@ -0,0 +1 @@
+{"basic": false, "label": "9", "slug": "3sum", "id": 9, "title": "3Sum", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/3sum/", "examples": [{"input": "nums = [-1,0,1,2,-1,-4]", "output": "[[-1,-1,2],[-1,0,1]]", "explanation": "The triplets [-1,-1,2] and [-1,0,1] each sum to 0."}, {"input": "nums = [0,1,1]", "output": "[]", "explanation": "No three numbers sum to 0. The only possible triplets are (0,1,1) which sums to 2."}, {"input": "nums = [0,0,0]", "output": "[[0,0,0]]", "explanation": "All three zeros sum to 0: [[0,0,0]]."}], "hints": ["Sort the array and use a two-pointer sweep for each fixed i, skipping duplicates to avoid repeated triplets. Output can be in any order; duplicates are not allowed."], "statement": "Your input is an integer array `nums`. Collect every triple of entries sitting at three pairwise-different positions `i`, `j`, `k` whose values cancel out, i.e. `nums[i] + nums[j] + nums[k] == 0`, and return each hit as the value triple `[nums[i], nums[j], nums[k]]`.\n\n**Constraints:**\n\n- 3 \u2264 nums.length \u2264 3000\n- -10^5 \u2264 nums[i] \u2264 10^5\n", "solution": "## Approach\n\nSort the array and use a fixed pointer i with two pointers l and r to find triplets that sum to zero. Skip duplicates to avoid duplicate triplets.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n\u00b2)\n- **Space Complexity:** O(1)\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def threeSum(self, nums: List[int]) -> List[List[int]]:\n        nums.sort()\n        n = len(nums)\n        res = []\n        for i in range(n - 2):\n            if i > 0 and nums[i] == nums[i - 1]:\n                continue\n            l, r = i + 1, n - 1\n            while l < r:\n                s = nums[i] + nums[l] + nums[r]\n                if s < 0:\n                    l += 1\n                elif s > 0:\n                    r -= 1\n                else:\n                    res.append([nums[i], nums[l], nums[r]])\n                    l += 1\n                    r -= 1\n                    while l < r and nums[l] == nums[l - 1]:\n                        l += 1\n                    while l < r and nums[r] == nums[r + 1]:\n                        r -= 1\n        return res\n```\n", "starter": {"go": "package main\n\nfunc ThreeSum(nums []int) [][]int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def threeSum(self, nums: List[int]) -> List[List[int]]:\n        ", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<vector<int>> threeSum(vector<int>& nums) {\n        return {};\n    }\n};"}, "fn": "threeSum", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int_array_2d", "tests": [["[-1,0,1,2,-1,-4]"], ["[0,1,1]"], ["[0,0,0]"], ["[1,-1,-1,0]"], ["[3,-2,1,0,-1,2,-1,-4]"], ["[-2,0,1,1,2]"], ["[4, -2, -2, -2, 0, 2, 2]"], ["[0,0,0,0]"], ["[0,1,2]"], ["[-100000,0,100000]"], ["[1,1,1]"], ["[-1,0,1]"], ["[-1,-1,2]"], ["[0,0,0,0,0]"], ["[1,2,3]"], ["[-3,-2,-1]"], ["[-3,1,2]"], ["[-2,-1,0,1,2,3]"], ["[-1,0,0,1]"], ["[-5,0,5]"], ["[-4,1,3]"], ["[-2,-1,3]"], ["[-10,0,10]"], ["[-1,-1,-1,2,2]"], ["[-3,0,1,2]"], ["[2,1,0,-1,-2]"], ["[-10,0,0,5,5]"], ["[-100,50,50]"], ["[-2,0,1,1]"], ["[-2,0,0,2,2]"]], "expected": [[[-1, -1, 2], [-1, 0, 1]], [], [[0, 0, 0]], [[-1, 0, 1]], [[-4, 1, 3], [-2, -1, 3], [-2, 0, 2], [-1, -1, 2], [-1, 0, 1]], [[-2, 0, 2], [-2, 1, 1]], [[-2, -2, 4], [-2, 0, 2]], [[0, 0, 0]], [], [[-100000, 0, 100000]], [], [[-1, 0, 1]], [[-1, -1, 2]], [[0, 0, 0]], [], [], [[-3, 1, 2]], [[-2, -1, 3], [-2, 0, 2], [-1, 0, 1]], [[-1, 0, 1]], [[-5, 0, 5]], [[-4, 1, 3]], [[-2, -1, 3]], [[-10, 0, 10]], [[-1, -1, 2]], [[-3, 1, 2]], [[-2, 0, 2], [-1, 0, 1]], [[-10, 5, 5]], [[-100, 50, 50]], [[-2, 1, 1]], [[-2, 0, 2]]], "loose": true}

package/data/problems/4-keys-keyboard.json

@@ -0,0 +1 @@
+{"basic": false, "label": "671", "slug": "4-keys-keyboard", "id": 671, "title": "4 Keys Keyboard", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/4-keys-keyboard/", "examples": [{"input": "n = 3", "output": "3", "explanation": "Type three times."}, {"input": "n = 7", "output": "9", "explanation": "Type, type, type, select, copy, paste, paste: 3 -> 6 -> 9."}, {"input": "n = 1", "output": "1"}], "hints": ["Let dp[i] be the best screen size with i presses; typing once more always gives dp[i-1] + 1.", "Alternatively stop typing at some j, spend 2 presses on select+copy, then paste (i - j - 2) times to reach dp[j] * (i - j - 1).", "Take the best j with at least one paste (j <= i - 3)."], "statement": "You start with one `A` on screen and four operations: type one more `A`, copy everything shown, paste the clipboard, or select everything (select must precede a useful copy). With exactly `n` key presses, how many `A` characters can be on screen at most?\n\nImplement `maxA(n)` returning that maximum.\n\n**Constraints:**\n- `1 <= n <= 50`\n", "solution": "## Approach\n\nDefine dp[i] as the most characters reachable in i presses. Pressing plain A extends the previous best by one. Otherwise pick a breakpoint j where typing stops: two presses select and copy dp[j], and the remaining i-j-2 presses paste, multiplying to dp[j]*(i-j-1). Maximizing over valid breakpoints fills the table bottom-up.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2) for n up to 50.\n- **Space Complexity:** O(n) for the table.\n\n## Implementation\n\n```python\nclass Solution:\n    def maxA(self, n: int) -> int:\n        dp = [0] * (n + 1)\n        for i in range(1, n + 1):\n            dp[i] = dp[i - 1] + 1\n            for j in range(1, i - 2):\n                dp[i] = max(dp[i], dp[j] * (i - j - 1))\n        return dp[n]\n```\n", "starter": {"go": "package main\n\nfunc MaxA(n int) int {\n    return 0\n}", "python": "from typing import List\nclass Solution:\n    def maxA(self, n: int) -> int:\n        pass", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    int maxA(int n) {\n        return 0;\n    }\n};"}, "fn": "maxA", "params": [{"name": "n", "type": "int"}], "outputType": "int", "tests": [["3"], ["7"], ["1"], ["2"], ["4"], ["5"], ["6"], ["8"], ["9"], ["10"], ["11"], ["12"], ["13"], ["14"], ["15"], ["16"], ["17"], ["18"], ["19"], ["20"], ["21"], ["25"], ["30"], ["35"], ["40"], ["45"], ["49"], ["50"]], "expected": [3, 9, 1, 2, 4, 5, 6, 12, 16, 20, 27, 36, 48, 64, 81, 108, 144, 192, 256, 324, 432, 1296, 5184, 20736, 82944, 331776, 1048576, 1327104], "loose": false}

package/data/problems/4sum-ii.json

@@ -0,0 +1 @@
+{"basic": false, "label": "521", "slug": "4sum-ii", "id": 521, "title": "4Sum II", "difficulty": "Medium", "category": "hash-table", "link": "https://leetcode.com/problems/4sum-ii/", "examples": [{"input": "nums1 = [1,2], nums2 = [-2,-1], nums3 = [-1,2], nums4 = [0,2]", "output": "2", "explanation": "Two index tuples sum to zero."}, {"input": "nums1 = [0], nums2 = [0], nums3 = [0], nums4 = [0]", "output": "1", "explanation": "The only tuple sums to zero."}], "hints": ["Split into two pair sums: every nums1+nums2 and every nums3+nums4.", "Store frequencies of the first half in a hash map.", "For each second-half sum, look up its negation in the map."], "statement": "You are given four integer lists `nums1`, `nums2`, `nums3` and `nums4`, each of length `n`. Count the tuples `(i, j, k, l)` with one index from each list such that `nums1[i] + nums2[j] + nums3[k] + nums4[l]` equals zero.\n\nIndices may repeat across lists but each tuple position comes from its own list.\n\n**Constraints:**\n- `1 <= n <= 500`\n- `-2^28 <= nums1[i], nums2[i], nums3[i], nums4[i] <= 2^28`\n", "solution": "## Approach\n\nPair the first two lists and record how often each pair sum occurs in a hash map. Then pair the last two lists; for each sum `s`, the needed complement `-s` in the map tells how many first-half pairs complete a zero total. Summing over all second-half pairs counts every tuple.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2), one step per pair in each half.\n- **Space Complexity:** O(n^2) for the pair-sum frequencies.\n\n## Implementation\n\n```python\nfrom typing import List\nfrom collections import defaultdict\nclass Solution:\n    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:\n        freq = defaultdict(int)\n        for a in nums1:\n            for b in nums2:\n                freq[a + b] += 1\n        ans = 0\n        for c in nums3:\n            for d in nums4:\n                ans += freq.get(-(c + d), 0)\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc FourSumCount(nums1 []int, nums2 []int, nums3 []int, nums4 []int) int {\n    return 0\n}", "python": "from typing import List\nclass Solution:\n    def fourSumCount(self, nums1: List[int], nums2: List[int], nums3: List[int], nums4: List[int]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int fourSumCount(vector<int>& nums1, vector<int>& nums2, vector<int>& nums3, vector<int>& nums4) {\n        return 0;\n    }\n};"}, "fn": "fourSumCount", "params": [{"name": "nums1", "type": "int_array"}, {"name": "nums2", "type": "int_array"}, {"name": "nums3", "type": "int_array"}, {"name": "nums4", "type": "int_array"}], "outputType": "int", "tests": [["[1,2]", "[-2,-1]", "[-1,2]", "[0,2]"], ["[0]", "[0]", "[0]", "[0]"], ["[1,1]", "[1,1]", "[-1,-1]", "[-1,-1]"], ["[0,1]", "[0,-1]", "[0,1]", "[0,-1]"], ["[-1,-1]", "[-1,1]", "[-1,1]", "[1,-1]"], ["[1,2,3]", "[4,5,6]", "[-7,-8,-9]", "[0,0,0]"], ["[0,0,0]", "[0,0,0]", "[0,0,0]", "[0,0,0]"], ["[1]", "[1]", "[-1]", "[-1]"], ["[1,2]", "[-1,-2]", "[0,0]", "[0,0]"], ["[2,2]", "[2,2]", "[-2,-2]", "[-2,-2]"], ["[0,0]", "[1,-1]", "[0,0]", "[0,0]"], ["[-1,0,1]", "[-1,0,1]", "[-1,0,1]", "[-1,0,1]"], ["[5]", "[-5]", "[5]", "[-5]"], ["[10,20]", "[-10,-20]", "[0,0]", "[0,0]"], ["[1,2,3,4]", "[-4,-3,-2,-1]", "[0,0,0,0]", "[0,0,0,0]"], ["[0,0,0,0]", "[0,0,0,0]", "[0,0,0,0]", "[0,0,0,0]"], ["[100,200]", "[-100,-200]", "[50,-50]", "[-50,50]"], ["[-5,-4,-3]", "[-1,-2,-3]", "[1,2,3]", "[5,4,3]"], ["[7]", "[3]", "[-5]", "[-5]"], ["[1,1,1]", "[-1,-1,-1]", "[0,0,0]", "[0,0,0]"], ["[2]", "[-2]", "[1]", "[-1]"], ["[0,1,2]", "[-2,-1,0]", "[1,1,1]", "[-1,-1,-1]"], ["[3,3,3]", "[3,3,3]", "[-3,-3,-3]", "[-3,-3,-3]"], ["[1000000]", "[-1000000]", "[0]", "[0]"], ["[-100,100]", "[-100,100]", "[100,-100]", "[100,-100]"], ["[1,2]", "[3,4]", "[-3,-4]", "[-1,-2]"], ["[0]", "[1]", "[-1]", "[0]"], ["[5,5,5,5]", "[-5,-5,-5,-5]", "[5,5,5,5]", "[-5,-5,-5,-5]"]], "expected": [2, 1, 16, 6, 6, 18, 81, 1, 8, 16, 0, 19, 1, 8, 64, 256, 6, 19, 1, 81, 1, 27, 81, 1, 6, 6, 1, 256], "loose": false}

package/data/problems/4sum.json

@@ -0,0 +1 @@
+{"basic": false, "label": "170", "slug": "4sum", "id": 170, "title": "4Sum", "difficulty": "Medium", "category": "two-pointer", "link": "https://leetcode.com/problems/4sum/", "examples": [{"input": "nums = [1,0,-1,0,-2,2], target = 0", "output": "[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]", "explanation": "The quadruplets [-2,-1,1,2], [-2,0,0,2] and [-1,0,0,1] each sum to 0."}, {"input": "nums = [2,2,2,2,2], target = 8", "output": "[[2,2,2,2]]", "explanation": "The only quadruplet [2,2,2,2] sums to 8."}], "hints": ["Sort the array and fix two indices, then use two pointers for the remaining pair.", "Skip duplicates at every level to avoid repeated quadruplets. Output order does not matter."], "statement": "You receive an array `nums` of `n` integers plus an integer `target`. Gather every quadruplet of values `[nums[a], nums[b], nums[c], nums[d]]` picked from four pairwise-distinct positions:\n\n- each index satisfies 0 \u2264 a, b, c, d < n\n- the four indices are all different from one another\n- the four chosen elements add up to exactly `target`: nums[a] + nums[b] + nums[c] + nums[d] == target\n\nThe collected quadruplets may come back in any order.\n\n**Constraints:**\n\n- 1 \u2264 nums.length \u2264 200\n- -10^9 \u2264 nums[i] \u2264 10^9\n- -10^9 \u2264 target \u2264 10^9\n", "solution": "## Approach\n\nSort the array, then fix two indices `i` and `j` and use two pointers `l` and `r` for the remaining pair. When the four sum equals the target, record the quadruplet and skip duplicates. Skipping duplicates at every level guarantees unique quadruplets, and the output order does not matter.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n\u00b3), where n is the length of the array. Sorting is O(n log n) and the triple nested sweep dominates.\n- **Space Complexity:** O(1) extra besides the output (O(n) for sorting depending on the implementation).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:\n        nums.sort()\n        n = len(nums)\n        res = []\n        for i in range(n - 3):\n            if i > 0 and nums[i] == nums[i - 1]:\n                continue\n            for j in range(i + 1, n - 2):\n                if j > i + 1 and nums[j] == nums[j - 1]:\n                    continue\n                l, r = j + 1, n - 1\n                while l < r:\n                    s = nums[i] + nums[j] + nums[l] + nums[r]\n                    if s == target:\n                        res.append([nums[i], nums[j], nums[l], nums[r]])\n                        lv, rv = nums[l], nums[r]\n                        while l < r and nums[l] == lv:\n                            l += 1\n                        while l < r and nums[r] == rv:\n                            r -= 1\n                    elif s < target:\n                        l += 1\n                    else:\n                        r -= 1\n        return res\n```\n", "starter": {"go": "package main\n\nfunc FourSum(nums []int, target int) [][]int {\n    return [][]int{}\n}", "python": "from typing import List\nclass Solution:\n    def fourSum(self, nums: List[int], target: int) -> List[List[int]]:\n        return []\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<vector<int>> fourSum(vector<int>& nums, int target) {\n        return {};\n    }\n};"}, "fn": "fourSum", "params": [{"name": "nums", "type": "int_array"}, {"name": "target", "type": "int"}], "outputType": "int_array_2d", "tests": [["[1,0,-1,0,-2,2]", "0"], ["[2,2,2,2,2]", "8"], ["[0,0,0,0]", "0"], ["[1,-2,-5,-4,-3,3,3,5]", "-11"], ["[-3,-2,-1,0,0,1,2,3]", "0"], ["[0,0,0,1000000000,1000000000,1000000000,1000000000]", "1000000000"], ["[-2,-1,-1,1,1,2,2]", "0"], ["[1,0,-1]", "0"], ["[1000000000,1000000000,1000000000,1000000000]", "-294967296"], ["[-1,0,1,2,-1,-4]", "-1"], ["[2,2,2,2,2,2,2]", "8"], ["[-5,5,4,-3,0,0,4,-2]", "4"], ["[0,1]", "0"], ["[0]", "0"], ["[1,2,3]", "5"], ["[1,2,3,4]", "10"], ["[1,2,3,4]", "100"], ["[0,0,0,0,0]", "0"], ["[-1,0,1,0]", "0"], ["[-3,-1,0,2,4,5]", "6"], ["[5,5,5,5,5]", "20"], ["[-5,-4,-3,-2,-1]", "-14"], ["[10,20,30,40,50]", "100"], ["[1,1,1,1]", "4"], ["[-2,-1,0,1]", "-2"], ["[0,1,2,3,4,5]", "6"], ["[-1,-1,-1,-1,2,2]", "0"], ["[100,200,-100,-200,0,50]", "50"], ["[-1000000000,-1000000000,1000000000,1000000000,0]", "0"], ["[5,4,3,2,1]", "10"]], "expected": [[[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]], [[2, 2, 2, 2]], [[0, 0, 0, 0]], [[-5, -4, -3, 1]], [[-3, -2, 2, 3], [-3, -1, 1, 3], [-3, 0, 0, 3], [-3, 0, 1, 2], [-2, -1, 0, 3], [-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]], [[0, 0, 0, 1000000000]], [[-2, -1, 1, 2], [-1, -1, 1, 1]], [], [], [[-4, 0, 1, 2], [-1, -1, 0, 1]], [[2, 2, 2, 2]], [[-5, 0, 4, 5], [-3, -2, 4, 5]], [], [], [], [[1, 2, 3, 4]], [], [[0, 0, 0, 0]], [[-1, 0, 0, 1]], [[-3, 0, 4, 5], [-1, 0, 2, 5]], [[5, 5, 5, 5]], [[-5, -4, -3, -2]], [[10, 20, 30, 40]], [[1, 1, 1, 1]], [[-2, -1, 0, 1]], [[0, 1, 2, 3]], [], [[-200, 0, 50, 200], [-100, 0, 50, 100]], [[-1000000000, -1000000000, 1000000000, 1000000000]], [[1, 2, 3, 4]]], "loose": true}

package/data/problems/accounts-merge.json

@@ -0,0 +1 @@
+{"basic": false, "label": "220", "slug": "accounts-merge", "id": 220, "title": "Accounts Merge", "difficulty": "Medium", "category": "graph", "link": "https://leetcode.com/problems/accounts-merge/", "examples": [{"input": "accounts = [[\"John\",\"johnsmith@mail.com\",\"john_newyork@mail.com\"],[\"John\",\"johnsmith@mail.com\",\"john00@mail.com\"],[\"Mary\",\"mary@mail.com\"],[\"John\",\"johnnybravo@mail.com\"]]", "output": "[[\"John\",\"john00@mail.com\",\"john_newyork@mail.com\",\"johnsmith@mail.com\"],[\"Mary\",\"mary@mail.com\"],[\"John\",\"johnnybravo@mail.com\"]]"}], "hints": ["Union emails that share an account. Then group by root and sort emails."], "statement": "Each entry `accounts[i]` opens with a holder name in `accounts[i][0]`, followed by one or more email addresses attached to that entry.\n\nEntries that share at least one email address must be fused, since that overlap proves they describe the same individual. People may happen to share a name while remaining different individuals, so a matching name alone never justifies a fusion. One person may start out with arbitrarily many entries, but every entry of theirs carries an identical name.\n\nOnce fusing is finished, emit each merged person as a single list: the shared name first, then all of their distinct emails arranged in sorted order. The merged people themselves may appear in any order.\n\n**Constraints:**\n- `1 <= accounts.length <= 1000`\n- `2 <= accounts[i].length <= 10`\n- `1 <= accounts[i][j].length <= 30`\n- `accounts[i][0]` consists of English letters\n- `accounts[i][j] (j > 0)` is a valid email\n", "solution": "## Approach\n\nUnion-find over emails. Emails in the same account are united. Group by root, sort emails, attach the name.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(A log A) where A is total emails\n- **Space Complexity:** O(A)\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def accountsMerge(self, accounts: List[List[str]]) -> List[List[str]]:\n        parent = {}\n        email_name = {}\n        def find(x):\n            parent.setdefault(x, x)\n            if parent[x] != x:\n                parent[x] = find(parent[x])\n            return parent[x]\n        def union(a, b):\n            parent[find(a)] = find(b)\n        for acc in accounts:\n            name = acc[0]\n            for email in acc[1:]:\n                email_name[email] = name\n                union(acc[1], email)\n        groups = {}\n        for email in email_name:\n            root = find(email)\n            groups.setdefault(root, []).append(email)\n        res = []\n        for root, emails in groups.items():\n            res.append([email_name[root]] + sorted(emails))\n        return res\n```\n", "starter": {"go": "package main\n\nfunc AccountsMerge(accounts [][]string) [][]string {\n    return nil\n}", "python": "from typing import List\nclass Solution:\n    def accountsMerge(self, accounts: List[List[str]]) -> List[List[str]]:\n        ", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {\n        return {};\n    }\n};"}, "fn": "accountsMerge", "params": [{"name": "accounts", "type": "string_list_2d"}], "outputType": "string_list_2d", "tests": [["[[\"John\",\"johnsmith@mail.com\",\"john_newyork@mail.com\"],[\"John\",\"johnsmith@mail.com\",\"john00@mail.com\"],[\"Mary\",\"mary@mail.com\"],[\"John\",\"johnnybravo@mail.com\"]]"], ["[[\"Gabe\",\"Gabe0@m.co\",\"Gabe3@m.co\",\"Gabe1@m.co\"],[\"Kevin\",\"Kevin3@m.co\",\"Kevin5@m.co\",\"Kevin0@m.co\"],[\"Ethan\",\"Ethan5@m.co\",\"Ethan4@m.co\",\"Ethan0@m.co\"],[\"Hanzo\",\"Hanzo3@m.co\",\"Hanzo1@m.co\",\"Hanzo0@m.co\"],[\"Fern\",\"Fern5@m.co\",\"Fern1@m.co\",\"Fern0@m.co\"]]"], ["[[\"Alex\",\"Alex5@m.co\",\"Alex4@m.co\",\"Alex0@m.co\"],[\"Ethan\",\"Ethan3@m.co\",\"Ethan3@m.co\",\"Ethan0@m.co\"],[\"Kevin\",\"Kevin4@m.co\",\"Kevin2@m.co\",\"Kevin2@m.co\"],[\"Gabe\",\"Gabe0@m.co\",\"Gabe3@m.co\",\"Gabe2@m.co\"],[\"Gabe\",\"Gabe3@m.co\",\"Gabe4@m.co\",\"Gabe2@m.co\"]]"], ["[[\"David\",\"David0@m.co\",\"David1@m.co\"],[\"David\",\"David3@m.co\",\"David4@m.co\"],[\"David\",\"David4@m.co\",\"David5@m.co\"],[\"David\",\"David2@m.co\",\"David3@m.co\"],[\"David\",\"David1@m.co\",\"David2@m.co\"]]"], ["[[\"A\",\"a@x.com\"],[\"B\",\"b@x.com\"]]"], ["[[\"Solo\",\"solo@mail.com\"]]"], ["[[\"Zoe\",\"z3@mail.com\",\"z1@mail.com\",\"z2@mail.com\"]]"], ["[[\"John\",\"a@mail.com\",\"b@mail.com\"],[\"John\",\"b@mail.com\",\"c@mail.com\"]]"], ["[[\"John\",\"a@mail.com\"],[\"John\",\"b@mail.com\"]]"], ["[[\"Alice\",\"shared@mail.com\"],[\"Alice\",\"shared@mail.com\"]]"], ["[[\"A\",\"a1@x.com\",\"a2@x.com\"],[\"A\",\"a2@x.com\",\"a3@x.com\"],[\"A\",\"a3@x.com\",\"a4@x.com\"]]"], ["[[\"Dup\",\"x@mail.com\",\"x@mail.com\",\"y@mail.com\"]]"], ["[[\"A\",\"a@x.com\"],[\"B\",\"b@x.com\"],[\"C\",\"c@x.com\"],[\"D\",\"d@x.com\"]]"], ["[[\"Star\",\"center@mail.com\",\"s1@mail.com\"],[\"Star\",\"center@mail.com\",\"s2@mail.com\"],[\"Star\",\"center@mail.com\",\"s3@mail.com\"]]"], ["[[\"Bob\",\"bob@mail.com\"],[\"Bob\",\"bob@mail.com\"]]"], ["[[\"Ann\",\"ann2@mail.com\",\"ann1@mail.com\"],[\"Ann\",\"ann3@mail.com\"],[\"Ann\",\"bob@mail.com\",\"ann1@mail.com\"]]"], ["[[\"Mike\",\"m1@mail.com\",\"m2@mail.com\",\"m3@mail.com\",\"m4@mail.com\",\"m5@mail.com\"]]"], ["[[\"K\",\"k1@mail.com\"],[\"K\",\"k1@mail.com\",\"k2@mail.com\"],[\"K\",\"k2@mail.com\",\"k3@mail.com\"],[\"L\",\"l1@mail.com\"]]"], ["[[\"Eve\",\"e1@mail.com\",\"e2@mail.com\"],[\"Adam\",\"a1@mail.com\"],[\"Eve\",\"e2@mail.com\",\"e3@mail.com\"],[\"Adam\",\"a1@mail.com\",\"a2@mail.com\"]]"], ["[[\"Tom\",\"t2@mail.com\",\"t1@mail.com\"],[\"Tom\",\"t1@mail.com\",\"t0@mail.com\"],[\"Jerry\",\"j@mail.com\"]]"], ["[[\"A\",\"a@mail.com\",\"b@mail.com\",\"c@mail.com\"],[\"A\",\"d@mail.com\",\"e@mail.com\"],[\"A\",\"c@mail.com\",\"d@mail.com\"]]"], ["[[\"X\",\"x@mail.com\"],[\"X\",\"y@mail.com\"],[\"Z\",\"z@mail.com\"],[\"X\",\"x@mail.com\",\"y@mail.com\"]]"], ["[[\"Paul\",\"p@mail.com\"],[\"Paul\",\"p@mail.com\"],[\"Paul\",\"p@mail.com\"],[\"Paige\",\"q@mail.com\"]]"], ["[[\"LongName\",\"a1@mail.com\",\"a2@mail.com\"],[\"LongName\",\"a3@mail.com\"],[\"LongName\",\"a2@mail.com\",\"a3@mail.com\"]]"], ["[[\"A\",\"m@mail.com\",\"a@mail.com\",\"z@mail.com\"]]"], ["[[\"Ben\",\"b@mail.com\"],[\"Ben\",\"c@mail.com\"],[\"Ben\",\"d@mail.com\"],[\"Ben\",\"b@mail.com\",\"c@mail.com\",\"d@mail.com\"]]"], ["[[\"Cara\",\"c1@mail.com\",\"c2@mail.com\"],[\"Cara\",\"c3@mail.com\",\"c4@mail.com\"],[\"Cara\",\"c2@mail.com\",\"c3@mail.com\"]]"], ["[[\"Nina\",\"n@mail.com\"],[\"Noah\",\"m@mail.com\"],[\"Nina\",\"n2@mail.com\"],[\"Nina\",\"n@mail.com\",\"n2@mail.com\"]]"], ["[[\"Q\",\"q1@mail.com\",\"q2@mail.com\"],[\"Q\",\"q3@mail.com\",\"q4@mail.com\"],[\"Q\",\"q5@mail.com\"]]"], ["[[\"W\",\"w1@mail.com\",\"w2@mail.com\"],[\"W\",\"w2@mail.com\",\"w1@mail.com\"]]"]], "expected": [[["John", "john00@mail.com", "john_newyork@mail.com", "johnsmith@mail.com"], ["John", "johnnybravo@mail.com"], ["Mary", "mary@mail.com"]], [["Ethan", "Ethan0@m.co", "Ethan4@m.co", "Ethan5@m.co"], ["Fern", "Fern0@m.co", "Fern1@m.co", "Fern5@m.co"], ["Gabe", "Gabe0@m.co", "Gabe1@m.co", "Gabe3@m.co"], ["Hanzo", "Hanzo0@m.co", "Hanzo1@m.co", "Hanzo3@m.co"], ["Kevin", "Kevin0@m.co", "Kevin3@m.co", "Kevin5@m.co"]], [["Alex", "Alex0@m.co", "Alex4@m.co", "Alex5@m.co"], ["Ethan", "Ethan0@m.co", "Ethan3@m.co"], ["Gabe", "Gabe0@m.co", "Gabe2@m.co", "Gabe3@m.co", "Gabe4@m.co"], ["Kevin", "Kevin2@m.co", "Kevin4@m.co"]], [["David", "David0@m.co", "David1@m.co", "David2@m.co", "David3@m.co", "David4@m.co", "David5@m.co"]], [["A", "a@x.com"], ["B", "b@x.com"]], [["Solo", "solo@mail.com"]], [["Zoe", "z1@mail.com", "z2@mail.com", "z3@mail.com"]], [["John", "a@mail.com", "b@mail.com", "c@mail.com"]], [["John", "a@mail.com"], ["John", "b@mail.com"]], [["Alice", "shared@mail.com"]], [["A", "a1@x.com", "a2@x.com", "a3@x.com", "a4@x.com"]], [["Dup", "x@mail.com", "y@mail.com"]], [["A", "a@x.com"], ["B", "b@x.com"], ["C", "c@x.com"], ["D", "d@x.com"]], [["Star", "center@mail.com", "s1@mail.com", "s2@mail.com", "s3@mail.com"]], [["Bob", "bob@mail.com"]], [["Ann", "ann1@mail.com", "ann2@mail.com", "bob@mail.com"], ["Ann", "ann3@mail.com"]], [["Mike", "m1@mail.com", "m2@mail.com", "m3@mail.com", "m4@mail.com", "m5@mail.com"]], [["K", "k1@mail.com", "k2@mail.com", "k3@mail.com"], ["L", "l1@mail.com"]], [["Adam", "a1@mail.com", "a2@mail.com"], ["Eve", "e1@mail.com", "e2@mail.com", "e3@mail.com"]], [["Jerry", "j@mail.com"], ["Tom", "t0@mail.com", "t1@mail.com", "t2@mail.com"]], [["A", "a@mail.com", "b@mail.com", "c@mail.com", "d@mail.com", "e@mail.com"]], [["X", "x@mail.com", "y@mail.com"], ["Z", "z@mail.com"]], [["Paige", "q@mail.com"], ["Paul", "p@mail.com"]], [["LongName", "a1@mail.com", "a2@mail.com", "a3@mail.com"]], [["A", "a@mail.com", "m@mail.com", "z@mail.com"]], [["Ben", "b@mail.com", "c@mail.com", "d@mail.com"]], [["Cara", "c1@mail.com", "c2@mail.com", "c3@mail.com", "c4@mail.com"]], [["Nina", "n2@mail.com", "n@mail.com"], ["Noah", "m@mail.com"]], [["Q", "q1@mail.com", "q2@mail.com"], ["Q", "q3@mail.com", "q4@mail.com"], ["Q", "q5@mail.com"]], [["W", "w1@mail.com", "w2@mail.com"]]], "loose": true}

package/data/problems/add-binary.json

@@ -0,0 +1 @@
+{"basic": false, "label": "248", "slug": "add-binary", "id": 248, "title": "Add Binary", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/add-binary/", "examples": [{"input": "a = \"11\", b = \"1\"", "output": "\"100\""}, {"input": "a = \"1010\", b = \"1011\"", "output": "\"10101\""}], "hints": ["Add the two strings bit by bit from the least significant digit (rightmost), carrying a 1 into the next position when a column sums to 2.", "Pad the shorter string with leading zeros, or stop once both are consumed and the carry is zero."], "statement": "Two binary numerals arrive as strings `a` and `b`. Add them together arithmetically and emit the total, again written as a binary string.\n\n**Constraints:**\n\n- `1 <= a.length, b.length <= 10^4`\n- `a` and `b` consist only of `'0'` or `'1'` characters.\n- Each string does not contain leading zeros except for the zero itself.\n", "solution": "## Approach\n\nProcess the two strings from the least significant (rightmost) digit toward the most significant, column by column. At each step add the two bits and the incoming carry: the resulting bit is `sum % 2` and the new carry is `sum / 2`. Keep going until both strings are exhausted and the carry is cleared, then reverse the accumulated result.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(max(a.length, b.length)).\n- **Space Complexity:** O(max(a.length, b.length)) for the output string.\n\n## Implementation\n\n```python\nclass Solution:\n    def addBinary(self, a: str, b: str) -> str:\n        i, j = len(a) - 1, len(b) - 1\n        carry = 0\n        result = []\n        while i >= 0 or j >= 0 or carry:\n            total = carry\n            if i >= 0:\n                total += int(a[i])\n                i -= 1\n            if j >= 0:\n                total += int(b[j])\n                j -= 1\n            result.append(str(total % 2))\n            carry = total // 2\n        return ''.join(reversed(result))\n```", "starter": {"go": "package main\n\nfunc AddBinary(a string, b string) string {\n    return \"\"\n}", "python": "class Solution:\n    def addBinary(self, a: str, b: str) -> str:\n        return \"\"\n", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    string addBinary(string a, string b) {\n        return \"\";\n    }\n};"}, "fn": "addBinary", "params": [{"name": "a", "type": "string"}, {"name": "b", "type": "string"}], "outputType": "string", "tests": [["11", "1"], ["1010", "1011"], ["0", "0"], ["1", "1"], ["101", "0"], ["0", "101"], ["111", "111"], ["1001", "111"], ["11111111", "1"], ["1", "11111111"], ["1010101010101010", "101010101010101"], ["111111111111111111111111111111111111111111111111111111111111", "1"], ["0", "1"], ["1", "0"], ["1", "10"], ["10", "10"], ["100", "1"], ["1111", "1"], ["1111", "1111"], ["1000", "1000"], ["1110", "1"], ["10101", "10101"], ["1100", "1010"], ["10000000", "1"], ["11110000", "1111"], ["10101010", "1010101"], ["110110", "101"], ["1001", "1001"], ["11101011", "11010"], ["1000000000000000000000000000000", "111"]], "expected": ["100", "10101", "0", "10", "101", "101", "1110", "10000", "100000000", "100000000", "1111111111111111", "1000000000000000000000000000000000000000000000000000000000000", "1", "1", "11", "100", "101", "10000", "11110", "10000", "1111", "101010", "10110", "10000001", "11111111", "11111111", "111011", "10010", "100000101", "1000000000000000000000000000111"], "loose": false}

package/data/problems/add-bold-tag-in-string.json

@@ -0,0 +1 @@
+{"basic": false, "label": "645", "slug": "add-bold-tag-in-string", "id": 645, "title": "Add Bold Tag in String", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/add-bold-tag-in-string/", "examples": [{"input": "s = \"abcxyz123\", dict = [\"abc\",\"123\"]", "output": "\"<b>abc</b>xyz<b>123</b>\"", "explanation": "The two words cover disjoint spans, so each gets its own tag pair."}, {"input": "s = \"aaabbcc\", dict = [\"aaa\",\"aab\",\"bc\"]", "output": "\"<b>aaabbc</b>c\"", "explanation": "Matches overlap and touch, merging into one bold run from 0 to 5."}, {"input": "s = \"abc\", dict = [\"xyz\"]", "output": "\"abc\"", "explanation": "With no hit, the string is unchanged."}], "hints": ["Mark a boolean array: for every dictionary word, flag all characters of each occurrence in s.", "Find occurrences with repeated substring search from each next start so overlaps are not skipped.", "Emit <b> when entering a flagged run and </b> when leaving one; touching runs merge automatically.", "Adaptation: the word list maps to string_array in this judge."], "statement": "You are given a text `s` and a list of keywords `dict`. Every slice of `s` that equals one of the keywords must appear bold in the answer.\n\nMarking works character by character: a character is bold when it belongs to at least one keyword occurrence (overlapping occurrences all count, and searching continues from each next index so overlaps are found). Neighboring or overlapping bold characters fuse into a single run. Wrap each maximal bold run with an opening `<b>` and a closing `</b>` tag, leaving other characters untouched.\n\nReturn the tagged string. If no keyword occurs, return `s` unchanged.\n\n**Constraints:**\n- `s` and each keyword hold lowercase letters (and digits in tests here).\n- Lengths are small enough for direct scanning.\n\n*Adaptation: the keyword list maps to `string_array` in this judge.*\n", "solution": "## Approach\n\nFlag each character covered by any keyword hit. For every word, repeatedly search forward from the previous hit plus one so overlapping copies are caught, marking the whole span. Then walk the text once, opening a tag at the start of each flagged run and closing it at the run end; adjacent flagged cells naturally join into one pair.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n), where m is total keyword characters scanned against text length n with naive search.\n- **Space Complexity:** O(n) for the flag array and output.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def addBoldTag(self, s: str, dict: List[str]) -> str:\n        n = len(s)\n        bold = [False] * n\n        for w in dict:\n            if not w:\n                continue\n            start = s.find(w, 0)\n            while start != -1:\n                for k in range(start, start + len(w)):\n                    bold[k] = True\n                start = s.find(w, start + 1)\n        out = []\n        for i, ch in enumerate(s):\n            if bold[i] and (i == 0 or not bold[i - 1]):\n                out.append(\"<b>\")\n            out.append(ch)\n            if bold[i] and (i == n - 1 or not bold[i + 1]):\n                out.append(\"</b>\")\n        return \"\".join(out)\n```\n", "starter": {"go": "package main\n\nfunc AddBoldTag(s string, dict []string) string {\n    \n}", "python": "from typing import List\nclass Solution:\n    def addBoldTag(self, s: str, dict: List[str]) -> str:\n        pass", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    string addBoldTag(string s, vector<string>& dict) {\n        return \"\";\n    }\n};"}, "fn": "addBoldTag", "params": [{"name": "s", "type": "string"}, {"name": "dict", "type": "string_array"}], "outputType": "string", "tests": [["abcxyz123", "['abc', '123']"], ["aaabbcc", "['aaa', 'aab', 'bc']"], ["abc", "['xyz']"], ["a", "['a']"], ["aa", "['a']"], ["aa", "['aa']"], ["abc", "['abc']"], ["abcdef", "['bcd']"], ["abcdef", "['ab', 'cd', 'ef']"], ["abcdef", "['ab', 'bc', 'cd']"], ["aaaa", "['aa']"], ["abcabc", "['abc']"], ["xyz", "['x', 'y', 'z']"], ["hello", "['hell', 'ello']"], ["mississippi", "['is', 'si']"], ["abc", "['a', 'b', 'c']"], ["abcde", "['cde', 'abc']"], ["qwerty", "['qw', 'erty']"], ["ababa", "['aba']"], ["testtest", "['test']"], ["a", "['b']"], ["abc", "['abcd']"], ["aaabbb", "['aa', 'bb']"], ["abcd", "['ab', 'cd']"], ["abcd", "['bc']"], ["zzzz", "['zz', 'zzz']"], ["helloworld", "['low', 'owo']"], ["abcxyz", "['abcxyz']"]], "expected": null, "loose": false}

package/data/problems/add-digits.json

@@ -0,0 +1 @@
+{"basic": false, "label": "362", "slug": "add-digits", "id": 362, "title": "Add Digits", "difficulty": "Easy", "category": "math", "link": "https://leetcode.com/problems/add-digits/", "examples": [{"input": "num = 38", "output": "2", "explanation": "3 + 8 = 11, then 1 + 1 = 2."}, {"input": "num = 0", "output": "0", "explanation": "0 already has one digit."}, {"input": "num = 123", "output": "6", "explanation": "1 + 2 + 3 = 6, which is a single digit."}], "hints": ["Add the digits in a loop until the value is below 10.", "Alternatively use the digit-root pattern: 0 stays 0, otherwise the answer is 1 plus the remainder of num - 1 divided by 9."], "statement": "Given a non-negative integer `num`, repeatedly replace it by the sum of its decimal digits until only one digit remains. Return that final digit.\n\n**Constraints:**\n- `0 <= num <= 2^31 - 1`\n", "solution": "## Approach\n\nRepeated digit sums settle into a cycle of length 9. Zero stays zero, and every positive number reduces to 1 plus the remainder of the number minus 1 divided by 9. This computes the digit root directly without simulating each round.\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 addDigits(self, num: int) -> int:\n        if num == 0:\n            return 0\n        return 1 + (num - 1) % 9\n```\n", "starter": {"go": "package main\n\nfunc AddDigits(num int) int {\n    return 0\n}", "python": "class Solution:\n    def addDigits(self, num: int) -> int:\n        return 0\n", "cpp": "class Solution {\npublic:\n    int addDigits(int num) {\n        return 0;\n    }\n};"}, "fn": "addDigits", "params": [{"name": "num", "type": "int"}], "outputType": "int", "tests": [["38"], ["0"], ["123"], ["9"], ["10"], ["19"], ["99"], ["100"], ["199"], ["1000"], ["9999"], ["12345"], ["18"], ["27"], ["36"], ["777"], ["1000000"], ["2147483647"], ["11"], ["101"], ["999"], ["1000000000"], ["5"], ["999999999"], ["123456789"], ["987654321"]], "expected": [2, 0, 6, 9, 1, 1, 9, 1, 1, 1, 9, 6, 9, 9, 9, 3, 1, 1, 2, 2, 9, 1, 5, 9, 9, 9], "loose": false}

package/data/problems/add-one-row-to-tree.json

@@ -0,0 +1 @@
+{"basic": false, "label": "647", "slug": "add-one-row-to-tree", "id": 647, "title": "Add One Row to Tree", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/add-one-row-to-tree/", "examples": [{"input": "root = [4,2,6,3,1,5], val = 1, depth = 2", "output": "[4,1,1,2,null,null,6,3,1,5,null]", "explanation": "Every depth-1 node gains a new val-1 child on each side; old subtrees hang below the new row."}, {"input": "root = [4,2,null,3,1], val = 1, depth = 3", "output": "[4,2,null,1,1,3,null,null,1]", "explanation": "Nodes at depth 2 each receive the new row; node 2 keeps 3 under its new left child and 1 under its new right child."}, {"input": "root = [1], val = 5, depth = 1", "output": "[5,1]", "explanation": "Depth 1 replaces the root with a new node holding 5."}], "hints": ["Depth 1 is special: build a new root holding val with the old tree as its left child.", "Otherwise walk to depth-1 (breadth-first or recursion) and splice a new left and right node under each host.", "The old left subtree becomes the left child of the new left node; the old right subtree becomes the right child of the new right node."], "statement": "You are given a binary tree root, an integer `val`, and a 1-based target `depth`. Insert a full row of new nodes holding `val` at that depth.\n\n- When `depth` is 1, create a fresh root with value `val`; the previous tree becomes its left subtree.\n- Otherwise, every node currently at depth `depth-1` receives two fresh children both holding `val`. The node's former left subtree is reattached as the left child of the new left node, and its former right subtree as the right child of the new right node. Nodes already deeper simply shift one level down.\n\nReturn the (possibly new) root.\n\n**Constraints:**\n- Tree size is between 0 and 10000 nodes.\n- Depth is at least 1 and at most one past the current height plus one.\n- Values fit in 32-bit signed integers.\n", "solution": "## Approach\n\nTreat depth 1 as a special case that wraps the old tree. For deeper targets, walk down to the parents at depth-1 with a queue, then splice two fresh nodes under each parent while preserving the displaced subtrees (old left under new left, old right under new right). Every host is handled independently, so one level-order pass suffices.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), visiting each node at most once.\n- **Space Complexity:** O(w) for the queue, where w is the widest level, plus O(n) for the added row.\n\n## Implementation\n\n```python\nfrom collections import deque\nclass Solution:\n    def addOneRow(self, root, val: int, depth: int):\n        if depth == 1:\n            node = TreeNode(val)\n            node.left = root\n            return node\n        q = deque([root] if root else [])\n        cur = 1\n        while q and cur < depth - 1:\n            for _ in range(len(q)):\n                n = q.popleft()\n                if n.left:\n                    q.append(n.left)\n                if n.right:\n                    q.append(n.right)\n            cur += 1\n        while q:\n            n = q.popleft()\n            old_l, old_r = n.left, n.right\n            nl = type(n)(val)\n            nr = type(n)(val)\n            nl.left = old_l\n            nr.right = old_r\n            n.left, n.right = nl, nr\n        return root\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 AddOneRow(root *TreeNode, val int, depth int) *TreeNode {\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 addOneRow(self, root, val: int, depth: int):\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    TreeNode* addOneRow(TreeNode* root, int val, int depth) {\n        \n    }\n};"}, "fn": "addOneRow", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}, {"name": "val", "type": "int"}, {"name": "depth", "type": "int"}], "outputType": "tree_node", "tests": [["[4,2,6,3,1,5]", "1", "2"], ["[4,2,null,3,1]", "1", "3"], ["[1]", "5", "1"], ["[1,2,3]", "9", "2"], ["[1,2,3]", "9", "3"], ["[1,2,3]", "9", "4"], ["[]", "1", "1"], ["[1,null,2]", "3", "2"], ["[1,2,null,3]", "7", "3"], ["[5,4,9,1,10]", "6", "2"], ["[1,2,3,4,5,6,7]", "0", "3"], ["[1]", "2", "2"], ["[2,1,3]", "4", "2"], ["[1,2,null,null,3]", "8", "3"], ["[10,5,15]", "12", "2"], ["[1,2,3,4]", "5", "4"], ["[3,1,4,null,2]", "9", "2"], ["[1,2]", "3", "2"], ["[1,null,3]", "2", "3"], ["[7]", "7", "2"], ["[1,2,3,null,4]", "6", "3"], ["[4,2,6,3,1,5]", "1", "3"], ["[4,2,6,3,1,5]", "1", "4"], ["[1,2,3,4,5]", "11", "2"], ["[100,50]", "25", "2"], ["[1,null,2,null,3]", "9", "2"], ["[8,3,10,1,6]", "2", "3"], ["[1,2,3]", "5", "1"]], "expected": null, "loose": false}

package/data/problems/add-strings.json

@@ -0,0 +1 @@
+{"basic": false, "label": "488", "slug": "add-strings", "id": 488, "title": "Add Strings", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/add-strings/", "examples": [{"input": "num1 = \"11\", num2 = \"123\"", "output": "\"134\"", "explanation": "11 plus 123 is 134."}, {"input": "num1 = \"456\", num2 = \"77\"", "output": "\"533\"", "explanation": "Column addition with carries gives 533."}, {"input": "num1 = \"0\", num2 = \"0\"", "output": "\"0\""}], "hints": ["Add from the least significant digit toward the front, keeping a carry.", "Each column sums two digits plus the carry; the digit is the remainder mod 10.", "A leftover carry after the front-most column becomes a new leading digit."], "statement": "Two non-negative integers arrive as decimal strings `num1` and `num2`. They may be long, so converting the whole strings to integers (or relying on big-integer helpers) is not allowed.\n\nAdd them digit by digit and return the total, also as a decimal string without extra leading zeros (except `\"0\"` itself).\n\n**Constraints:**\n- `1 <= num1.length, num2.length <= 10^4`\n- Strings hold only digits `0-9` with no leading zeros except for `\"0\"` itself.\n", "solution": "## Approach\n\nAlign the strings at their right ends and add column by column with a carry. Each step combines the two current digits plus the incoming carry, emits the units digit, and forwards the tens digit. When both strings and the carry are exhausted, reversing the collected digits gives the sum.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(max(n, m)), where n and m are the input lengths.\n- **Space Complexity:** O(max(n, m)) for the output.\n\n## Implementation\n\n```python\nclass Solution:\n    def addStrings(self, num1: str, num2: str) -> str:\n        i, j = len(num1) - 1, len(num2) - 1\n        carry = 0\n        out = []\n        while i >= 0 or j >= 0 or carry:\n            a = ord(num1[i]) - 48 if i >= 0 else 0\n            b = ord(num2[j]) - 48 if j >= 0 else 0\n            s = a + b + carry\n            out.append(chr(48 + s % 10))\n            carry = s // 10\n            i -= 1\n            j -= 1\n        return \"\".join(reversed(out))\n```\n", "starter": {"go": "package main\n\nfunc AddStrings(num1 string, num2 string) string {\n    return \"\"\n}", "python": "class Solution:\n    def addStrings(self, num1: str, num2: str) -> str:\n        return \"\"", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    string addStrings(string num1, string num2) {\n        return \"\";\n    }\n};"}, "fn": "addStrings", "params": [{"name": "num1", "type": "string"}, {"name": "num2", "type": "string"}], "outputType": "string", "tests": [["11", "123"], ["456", "77"], ["0", "0"], ["9", "9"], ["1", "999"], ["999", "1"], ["100", "900"], ["123456789", "987654321"], ["9999999999", "1"], ["1", "1"], ["10", "10"], ["99", "1"], ["500", "500"], ["123", "877"], ["0", "12345"], ["12345", "0"], ["99999", "99999"], ["19", "19"], ["12345678901234567890", "98765432109876543210"], ["5", "5"], ["1000000", "1"], ["888", "222"], ["1010", "1011"], ["999", "999"], ["1234", "8766"], ["7", "13"], ["29", "71"], ["1009", "991"], ["55", "55"], ["123456789123456789", "111111111111111111"]], "expected": ["134", "533", "0", "18", "1000", "1000", "1000", "1111111110", "10000000000", "2", "20", "100", "1000", "1000", "12345", "12345", "199998", "38", "111111111011111111100", "10", "1000001", "1110", "2021", "1998", "10000", "20", "100", "2000", "110", "234567900234567900"], "loose": false}

package/data/problems/add-to-array-form-of-integer.json

@@ -0,0 +1 @@
+{"basic": false, "label": "972", "slug": "add-to-array-form-of-integer", "id": 972, "title": "Add to Array-Form of Integer", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/add-to-array-form-of-integer/", "examples": [{"input": "num = [1,2,0,0], k = 34", "output": "[1,2,3,4]", "explanation": "1200 + 34 = 1234."}, {"input": "num = [2,7,4], k = 181", "output": "[4,5,5]", "explanation": "274 + 181 = 455."}, {"input": "num = [2,1,5], k = 806", "output": "[1,0,2,1]", "explanation": "215 + 806 = 1021."}], "hints": ["Add from the least significant digit, carrying the value of k along as you move left.", "Keep emitting digits while digits of num or a nonzero carry remain; a leftover carry may add a new leading digit.", "Collect the digits backwards and reverse them at the end."], "statement": "The array form of a non-negative integer lists its decimal digits from the most\nsignificant digit to the least significant digit. For example, the array form\nof `1200` is `[1,2,0,0]`.\n\nYou are given the array form `num` of an integer together with a non-negative\ninteger `k`. Add the two values and return the array form of the result.\n\n**Constraints:**\n- `1 <= num.length <= 10^4`\n- `0 <= num[i] <= 9`\n- `0 <= k <= 10^4`\n", "solution": "## Approach\n\nWalk the digits from right to left while folding `k` into a running carry.\nAt each position add the current digit to the carry, record `carry % 10`, and\nkeep `carry / 10` for the next step. The loop continues while digits or a\nnonzero carry remain, so an overflowing carry naturally produces an extra\nleading digit. Digits are collected backwards and reversed once at the end.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(max(n, log k)), where n is the length of `num`. Each digit is visited once.\n- **Space Complexity:** O(n) for the answer list.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def addToArrayForm(self, num: List[int], k: int) -> List[int]:\n        ans = []\n        i = len(num) - 1\n        carry = k\n        while i >= 0 or carry > 0:\n            if i >= 0:\n                carry += num[i]\n                i -= 1\n            ans.append(carry % 10)\n            carry //= 10\n        ans.reverse()\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc AddToArrayForm(num []int, k int) []int {\n    return []int{}\n}", "python": "from typing import List\nclass Solution:\n    def addToArrayForm(self, num: List[int], k: int) -> List[int]:\n        return []", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<int> addToArrayForm(vector<int>& num, int k) {\n        return {};\n    }\n};"}, "fn": "addToArrayForm", "params": [{"name": "num", "type": "int_array"}, {"name": "k", "type": "int"}], "outputType": "int_list", "tests": [["[1,2,0,0]", "34"], ["[2,7,4]", "181"], ["[2,1,5]", "806"], ["[9,9,9,9,9,9,9,9,9,9]", "1"], ["[0]", "0"], ["[0]", "10000"], ["[1]", "9999"], ["[9]", "9"], ["[1,0]", "0"], ["[5]", "5"], ["[1,2,3]", "999"], ["[9,8,7,6,5]", "2345"], ["[1,9,9]", "1"], ["[9,9]", "11"], ["[1,1,1,1]", "8888"], ["[7]", "0"], ["[1,2,3,4,5,6,7,8,9]", "8765"], ["[4,5,6]", "44"], ["[2,4,9]", "2001"], ["[9,9,9]", "9991"], ["[1,0,0,0,0]", "1"], ["[3]", "10000"], ["[6,5,4,3,2,1]", "10000"], ["[8,8]", "88"], ["[1,2]", "9000"], ["[9,0,9,0]", "1010"], ["[5,5,5,5,5]", "5555"], ["[1,0,0,0,0,0,0,0,0,0]", "9999"]], "expected": [[1, 2, 3, 4], [4, 5, 5], [1, 0, 2, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [0], [1, 0, 0, 0, 0], [1, 0, 0, 0, 0], [1, 8], [1, 0], [1, 0], [1, 1, 2, 2], [1, 0, 1, 1, 1, 0], [2, 0, 0], [1, 1, 0], [9, 9, 9, 9], [7], [1, 2, 3, 4, 6, 5, 5, 5, 4], [5, 0, 0], [2, 2, 5, 0], [1, 0, 9, 9, 0], [1, 0, 0, 0, 1], [1, 0, 0, 0, 3], [6, 6, 4, 3, 2, 1], [1, 7, 6], [9, 0, 1, 2], [1, 0, 1, 0, 0], [6, 1, 1, 1, 0], [1, 0, 0, 0, 0, 0, 9, 9, 9, 9]], "loose": false}

package/data/problems/add-two-numbers-ii.json

@@ -0,0 +1 @@
+{"basic": false, "label": "513", "slug": "add-two-numbers-ii", "id": 513, "title": "Add Two Numbers II", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/add-two-numbers-ii/", "examples": [{"input": "l1 = [7,2,4,3], l2 = [5,6,4]", "output": "[7,8,0,7]", "explanation": "7243 + 564 = 7807."}, {"input": "l1 = [2,4,3], l2 = [5,6,4]", "output": "[8,0,7]", "explanation": "243 + 564 = 807."}, {"input": "l1 = [0], l2 = [0]", "output": "[0]", "explanation": "0 + 0 = 0."}], "hints": ["Forward order means the least significant digits are at the tails; stacks expose them in addition order.", "Push both lists, then pop pairs with a carry, prepending each new digit.", "A leftover carry becomes a new leading node."], "statement": "Two non-negative numbers are stored as linked lists with the most significant digit first. Each node holds one digit, and there are no leading zeros except for the number zero itself.\n\nGiven the heads `l1` and `l2`, add the two numbers and return the sum in the same forward layout, again without leading zeros.\n\n**Constraints:**\n- Each list has `1` to `100` nodes.\n- Each node value lies in `0..9`.\n", "solution": "## Approach\n\nBecause the heads hold the most significant digits, push both lists onto stacks to reach the ones place first. Repeatedly pop one digit from each stack plus the carry, create the result digit, and prepend it to the answer. Continue until both stacks and the carry are empty.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m + n), where m and n are the two list lengths.\n- **Space Complexity:** O(m + n) for the two stacks.\n\n## Implementation\n\n```python\nclass Solution:\n    def addTwoNumbers(self, l1, l2):\n        s1, s2 = [], []\n        p = l1\n        while p:\n            s1.append(p.val)\n            p = p.next\n        p = l2\n        while p:\n            s2.append(p.val)\n            p = p.next\n        carry = 0\n        head = None\n        while s1 or s2 or carry:\n            total = carry\n            if s1:\n                total += s1.pop()\n            if s2:\n                total += s2.pop()\n            node = ListNode(total % 10)\n            node.next = head\n            head = node\n            carry = total // 10\n        return head\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 AddTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {\n    return nil\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 addTwoNumbers(self, l1, l2):\n        pass\n", "cpp": "/*\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* addTwoNumbers(ListNode* l1, ListNode* l2) {\n        return nullptr;\n    }\n};"}, "fn": "addTwoNumbers", "params": [{"name": "l1", "type": "list_node"}, {"name": "l2", "type": "list_node"}], "outputType": "list_node", "tests": [["[7,2,4,3]", "[5,6,4]"], ["[2,4,3]", "[5,6,4]"], ["[0]", "[0]"], ["[1]", "[9,9,9]"], ["[9,9,9]", "[1]"], ["[5]", "[5]"], ["[9,9]", "[9,9]"], ["[1,0,0]", "[9,9]"], ["[9,9,9,9]", "[9,9,9,9]"], ["[3,9,9]", "[7]"], ["[8,9]", "[2]"], ["[1,2,3,4]", "[5,6,7,8]"], ["[9]", "[9]"], ["[1,0]", "[9,9]"], ["[4,5,6]", "[7,8,9]"], ["[1,0,0,0]", "[1]"], ["[9,9,9,9,9]", "[1]"], ["[1,2,3]", "[9,9,9]"], ["[9,8,7]", "[1,2,3]"], ["[1,0,1]", "[9,9,9]"], ["[5,0,0]", "[5,0,0]"], ["[9,0,9]", "[1,1,1]"], ["[2,0,0,0,0]", "[8,0,0,0,0]"], ["[4]", "[6]"], ["[7,7,7]", "[3,3,3]"], ["[1,9,9]", "[8,0,1]"], ["[6,2,8]", "[3,7,2]"], ["[9,9,0]", "[1,0]"]], "expected": [[7, 8, 0, 7], [8, 0, 7], [0], [1, 0, 0, 0], [1, 0, 0, 0], [1, 0], [1, 9, 8], [1, 9, 9], [1, 9, 9, 9, 8], [4, 0, 6], [9, 1], [6, 9, 1, 2], [1, 8], [1, 0, 9], [1, 2, 4, 5], [1, 0, 0, 1], [1, 0, 0, 0, 0, 0], [1, 1, 2, 2], [1, 1, 1, 0], [1, 1, 0, 0], [1, 0, 0, 0], [1, 0, 2, 0], [1, 0, 0, 0, 0, 0], [1, 0], [1, 1, 1, 0], [1, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0]], "loose": false}

package/data/problems/add-two-numbers.json

@@ -0,0 +1 @@
+{"basic": false, "label": "93", "slug": "add-two-numbers", "id": 93, "title": "Add Two Numbers", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/add-two-numbers/", "examples": [{"input": "l1 = [2,4,3], l2 = [5,6,4]", "output": "[7,0,8]", "explanation": "342 + 465 = 807."}, {"input": "l1 = [0], l2 = [0]", "output": "[0]", "explanation": "0 + 0 = 0. Stored in reversed order as [0]."}, {"input": "l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]", "output": "[8,9,9,9,0,0,0,1]", "explanation": "9999999 + 9999 = 10009998. Stored in reversed order as [8, 9, 9, 9, 0, 0, 0, 1]."}], "hints": ["Walk through both lists together and add corresponding digits plus a carry.", "Create a result node for `sum % 10` and carry `sum / 10` into the next position.", "After both lists end, append one more node if a carry remains."], "statement": "Two non-negative integers are handed to you, each encoded as a non-empty linked list with the least significant digit first: every node stores a single decimal digit, so the head holds the ones place, the next node the tens place, and so on. Compute the arithmetic total of the two encoded integers and hand it back encoded the same way, least significant digit first.\n\nWritten out normally, neither input carries a leading zero, apart from the value zero itself, which is written as the lone digit zero.\n\n**Constraints:**\n\n- Each list contains between `1` and `100` nodes.\n- `0 <= node.val <= 9`\n- Each list represents a number without leading zeros, except the single-node\n  list `[0]`.\n", "solution": "## Approach\n\nWalk through both reverse-order digit lists together. Add the available digits and the carry, append a node containing the ones digit, and carry the tens digit into the next position. Continue until both inputs and the final carry are exhausted.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(max(m, n)), where `m` and `n` are the input lengths.\n- **Space Complexity:** O(max(m, n)) for the returned list; the auxiliary pointer state is O(1).\n\n## Implementation\n\n```python\nclass Solution:\n    def addTwoNumbers(self, l1, l2):\n        dummy = ListNode(0)\n        tail = dummy\n        carry = 0\n\n        while l1 is not None or l2 is not None or carry:\n            total = carry\n            if l1 is not None:\n                total += l1.val\n                l1 = l1.next\n            if l2 is not None:\n                total += l2.val\n                l2 = l2.next\n\n            tail.next = ListNode(total % 10)\n            tail = tail.next\n            carry = total // 10\n\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 AddTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {\n    return nil\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 addTwoNumbers(self, l1, l2):\n        pass\n", "cpp": "/*\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* addTwoNumbers(ListNode* l1, ListNode* l2) {\n        return nullptr;\n    }\n};"}, "fn": "addTwoNumbers", "params": [{"name": "l1", "type": "list_node"}, {"name": "l2", "type": "list_node"}], "outputType": "list_node", "tests": [["[2,4,3]", "[5,6,4]"], ["[0]", "[0]"], ["[9,9,9,9,9,9,9]", "[9,9,9,9]"], ["[1]", "[9]"], ["[9]", "[1]"], ["[5]", "[5]"], ["[1]", "[0]"], ["[0]", "[7]"], ["[3,2]", "[4,5]"], ["[9,9]", "[1]"], ["[1]", "[9,9]"], ["[5,4]", "[5,5]"], ["[8,1]", "[1,8]"], ["[0,1]", "[0,9]"], ["[7,3]", "[8,6]"], ["[1,2,3]", "[4,5,6]"], ["[9,8,7]", "[1,1,2]"], ["[9,9,9]", "[1]"], ["[1]", "[9,9,9]"], ["[5,5,5]", "[5,5,5]"], ["[6,7,8]", "[4,2,1]"], ["[0,0,1]", "[0,0,9]"], ["[4,6,5]", "[6,3,4]"], ["[2,4,3]", "[5]"], ["[5]", "[2,4,3]"], ["[9,0,1]", "[1,9]"], ["[1,9]", "[9,0,1]"], ["[8,9,9,9]", "[2]"], ["[2]", "[8,9,9,9]"], ["[3,1,4,1]", "[5,9,2,6]"], ["[7,7,7,7]", "[2,2,2,2]"], ["[9,9,9,9]", "[9,9,9,9]"], ["[0,0,0,1]", "[9,9,9]"], ["[4,3,2,1]", "[6,6,7,8]"], ["[1,0,0,0,1]", "[9,9,9,9]"], ["[9,9,9,9]", "[1,0,0,0,1]"], ["[2,7,1,8,2]", "[8,2,8,1,7]"], ["[9,0,9,0,9]", "[1,9,0,9,1]"], ["[5,0,0,0,5]", "[5,9,9,9,4]"], ["[1,2,3,4,5]", "[5,4,3,2,1]"], ["[9,9,9,9,9]", "[1]"], ["[1]", "[9,9,9,9,9]"], ["[9,8,7,6,5,4]", "[1,2,3]"], ["[1,2,3]", "[9,8,7,6,5,4]"], ["[6,5,4,3,2,1]", "[4,4,5,6,7,8]"], ["[0,0,0,0,0,1]", "[0,0,0,0,0,9]"], ["[9,9,0,0,9,9]", "[1,0,9,9,0,1]"], ["[3,1,4,1,5,9]", "[2,6,5,3,5,8]"], ["[8,8,8,8,8,8,8]", "[1,1,1,1,1,1,1]"], ["[9,9,9,9,9,9,9,9]", "[9,9,9,9,9,9,9,9]"], ["[1,0,1,0,1,0,1,0,1]", "[9,9,8,9,8,9,8,9,8]"], ["[7,6,5,4,3,2,1,9,8,7]", "[3,3,4,5,6,7,8,0,1,2]"], ["@javascript:JSON.stringify([...Array(98).fill(0),1])", "@javascript:JSON.stringify([...Array(98).fill(9),8])"], ["@javascript:JSON.stringify(Array(100).fill(9))", "@javascript:JSON.stringify(Array(100).fill(9))"]], "expected": [[7, 0, 8], [0], [8, 9, 9, 9, 0, 0, 0, 1], [0, 1], [0, 1], [0, 1], [1], [7], [7, 7], [0, 0, 1], [0, 0, 1], [0, 0, 1], [9, 9], [0, 0, 1], [5, 0, 1], [5, 7, 9], [0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1], [0, 1, 1, 1], [0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 0, 1], [7, 4, 3], [7, 4, 3], [0, 0, 2], [0, 0, 2], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [8, 0, 7, 7], [9, 9, 9, 9], [8, 9, 9, 9, 1], [9, 9, 9, 1], [0, 0, 0, 0, 1], [0, 0, 0, 0, 2], [0, 0, 0, 0, 2], [0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 1, 1], [0, 0, 0, 0, 0, 1], [6, 6, 6, 6, 6], [0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1], [0, 1, 1, 7, 5, 4], [0, 1, 1, 7, 5, 4], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 1, 1], [5, 7, 9, 4, 0, 8, 1], [9, 9, 9, 9, 9, 9, 9], [8, 9, 9, 9, 9, 9, 9, 9, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9], [8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1]], "loose": false}

package/data/problems/additive-number.json

@@ -0,0 +1 @@
+{"basic": false, "label": "398", "slug": "additive-number", "id": 398, "title": "Additive Number", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/additive-number/", "examples": [{"input": "num = \"112358\"", "output": "true", "explanation": "Splits as 1, 1, 2, 3, 5."}, {"input": "num = \"199100199\"", "output": "true", "explanation": "Splits as 1, 99, 100, 199."}, {"input": "num = \"1023\"", "output": "false", "explanation": "No valid additive split exists."}], "hints": ["Only the first two numbers are free choices; everything after is forced by the sum rule.", "Reject any candidate first or second number with a leading zero and length above one.", "Add with digit strings (or big integers) since values can outgrow fixed-size types."], "statement": "A string of digits is additive when it can be split into at least three numbers where every\nnumber from the third on equals the sum of the previous two (like 1, 1, 2, 3, 5). Numbers\nmay not carry leading zeros unless the number itself is exactly `\"0\"`. Decide whether the\ngiven digit string `num` is additive.\n\n**Constraints:**\n- `1 <= num.length <= 35`\n- `num` contains only digits.\n", "solution": "## Approach\n\nEnumerate the lengths of the first two numbers (respecting the no-leading-zero rule), then verify the forced sums match the rest of the string using string addition.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^3)\n- **Space Complexity:** O(n)\n\n## Implementation\n\n```python\nclass Solution:\n    def isAdditiveNumber(self, num: str) -> bool:\n        n = len(num)\n        def add_str(x: str, y: str) -> str:\n            i, j, carry, out = len(x) - 1, len(y) - 1, 0, []\n            while i >= 0 or j >= 0 or carry:\n                s = carry\n                if i >= 0:\n                    s += ord(x[i]) - 48\n                    i -= 1\n                if j >= 0:\n                    s += ord(y[j]) - 48\n                    j -= 1\n                out.append(chr(48 + s % 10))\n                carry = s // 10\n            return ''.join(reversed(out))\n        for i in range(1, n):\n            if i > 1 and num[0] == '0':\n                break\n            for j in range(1, n - i):\n                if j > 1 and num[i] == '0':\n                    break\n                x, y, k = num[:i], num[i:i + j], i + j\n                while k < n:\n                    z = add_str(x, y)\n                    if not num.startswith(z, k):\n                        break\n                    k += len(z)\n                    x, y = y, z\n                else:\n                    return True\n        return False\n```\n", "starter": {"go": "package main\n\nfunc IsAdditiveNumber(num string) bool {\n    return false\n}", "python": "class Solution:\n    def isAdditiveNumber(self, num: str) -> bool:\n        ", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    bool isAdditiveNumber(string num) {\n        return false;\n    }\n};"}, "fn": "isAdditiveNumber", "params": [{"name": "num", "type": "string"}], "outputType": "boolean", "tests": [["112358"], ["199100199"], ["1023"], ["123"], ["000"], ["101"], ["011235813"], ["112"], ["111"], ["1235"], ["121224"], ["11235813"], ["199100200"], ["0000"], ["1010"], ["123456789"], ["9999999999"], ["1357924680"], ["11235813213455"], ["100100200"], ["123581321"], ["10101"], ["999"], ["1000"], ["1000000000000000"], ["144233377610987"], ["1235813"], ["1020305"]], "expected": [true, true, false, true, true, true, true, true, false, true, true, true, false, true, false, false, false, false, true, true, true, false, false, false, false, true, true, false], "loose": false}

package/data/problems/advantage-shuffle.json

@@ -0,0 +1 @@
+{"basic": false, "label": "864", "slug": "advantage-shuffle", "id": 864, "title": "Advantage Shuffle", "difficulty": "Medium", "category": "greedy", "link": "https://leetcode.com/problems/advantage-shuffle/", "examples": [{"input": "nums1 = [2,7,11,15], nums2 = [1,10,4,11]", "output": "[2,11,7,15]", "explanation": "All four positions beat the opponent."}, {"input": "nums1 = [12,24,8,32], nums2 = [13,25,32,11]", "output": "[24,32,8,12]", "explanation": "Three positions beat the opponent, optimal."}, {"input": "nums1 = [1,1], nums2 = [1,1]", "output": "[1,1]", "explanation": "No position can beat."}], "hints": ["Sort one copy of `nums1` and pair each `nums2` value with its original index, then handle the opponent's values from smallest to largest.", "For each opponent value in order, play the smallest remaining card that beats it; if none beats it, sacrifice the smallest remaining card.", "A balanced multiset with lower-bound search, or two pointers over sorted arrays with a deque assignment, implements this greedy choice."], "statement": "You are given two arrays `nums1` and `nums2` of equal length `n`. You may reorder `nums1` arbitrarily; call the reordered version `ans`.\n\nThe advantage of `ans` over `nums2` is the count of positions `i` where `ans[i] > nums2[i]`. Arrange `ans` to make this count as large as possible.\n\nReturn any rearrangement of `nums1` achieving the maximum advantage. The checker verifies that your output uses exactly the same multiset as `nums1` and reaches the best achievable count, not that it matches one particular ordering.\n\n**Constraints:**\n- `1 <= nums1.length == nums2.length <= 10^5`\n- `0 <= nums1[i], nums2[i] <= 10^9`\n", "solution": "## Approach\n\nSort the opponent's positions from weakest to strongest while keeping the cards in a counted multiset. For the strongest remaining opponent, spend the smallest card that still beats it; if no such card exists, sacrifice the weakest card. Working from large to small guarantees every winnable slot is won with minimal waste, which maximizes the total count.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n log n) for sorting and multiset operations.\n- **Space Complexity:** O(n) for the ordering and answer.\n\n## Implementation\n\n```python\nfrom typing import List\nfrom bisect import bisect_right\n\nclass Solution:\n    def advantageCount(self, nums1: List[int], nums2: List[int]) -> List[int]:\n        import bisect\n        n = len(nums1)\n        order = sorted(range(n), key=lambda i: nums2[i])\n        pool = sorted(nums1)\n        ans = [0] * n\n        # two-pointer assignment using sorted pool\n        for idx in reversed(order):\n            opp = nums2[idx]\n            pos = bisect.bisect_right(pool, opp)\n            if pos < len(pool):\n                ans[idx] = pool.pop(pos)\n            else:\n                ans[idx] = pool.pop(0)\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc AdvantageCount(nums1 []int, nums2 []int) []int {\n    return []int{}\n}", "python": "from typing import List\nclass Solution:\n    def advantageCount(self, nums1: List[int], nums2: List[int]) -> List[int]:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<int> advantageCount(vector<int>& nums1, vector<int>& nums2) {\n        return {};\n    }\n};"}, "fn": "advantageCount", "params": [{"name": "nums1", "type": "int_array"}, {"name": "nums2", "type": "int_array"}], "outputType": "int_array", "tests": [["[2,7,11,15]", "[1,10,4,11]"], ["[12,24,8,32]", "[13,25,32,11]"], ["[1,1]", "[1,1]"], ["[2,0,4,1,2]", "[1,3,0,0,2]"], ["[0]", "[0]"], ["[5]", "[3]"], ["[3]", "[5]"], ["[1,2,3,4,5]", "[1,2,3,4,5]"], ["[5,4,3,2,1]", "[1,2,3,4,5]"], ["[10,10,10]", "[9,9,9]"], ["[1,10,4,2]", "[5,6,7,8]"], ["[8,2,4,4,5,6,6,7]", "[0,1,2,3,4,5,6,7]"], ["[100,200,300]", "[150,150,150]"], ["[7,7,7,7]", "[7,7,7,7]"], ["[1,3,5,7,9]", "[2,4,6,8,10]"], ["[2,4,6,8,10]", "[1,3,5,7,9]"], ["[0,0,10,10]", "[5,5,5,5]"], ["[6,5,4,3,2,1]", "[1,1,1,1,1,1]"], ["[1,2]", "[3,4]"], ["[4,3]", "[1,2]"], ["[9,8,7,6,5,4]", "[0,0,0,9,9,9]"], ["[11,22,33]", "[33,22,11]"], ["[5,15,20,25]", "[10,10,10,30]"], ["[1000,0,1000,0]", "[500,500,500,500]"], ["[1,2,3]", "[2,3,1]"], ["[7,1,5,3]", "[6,2,4,8]"], ["[13,25,32,11]", "[12,24,8,32]"], ["[0,1,2,3,4,5,6,7,8,9]", "[9,8,7,6,5,4,3,2,1,0]"]], "expected": [[2, 11, 7, 15], [24, 32, 8, 12], [1, 1], [2, 4, 2, 1, 0], [0], [5], [3], [2, 3, 4, 5, 1], [2, 3, 4, 5, 1], [10, 10, 10], [4, 2, 1, 10], [6, 2, 4, 4, 5, 6, 7, 8], [100, 300, 200], [7, 7, 7, 7], [3, 5, 7, 9, 1], [2, 4, 6, 8, 10], [0, 0, 10, 10], [1, 6, 5, 4, 3, 2], [2, 1], [4, 3], [9, 8, 7, 6, 5, 4], [11, 33, 22], [25, 20, 15, 5], [0, 0, 1000, 1000], [3, 1, 2], [7, 3, 5, 1], [13, 25, 32, 11], [0, 9, 8, 7, 6, 5, 4, 3, 2, 1]], "loose": false}

package/data/problems/alien-dictionary.json

@@ -0,0 +1 @@
+{"basic": false, "label": "32", "slug": "alien-dictionary", "id": 32, "title": "Alien Dictionary", "difficulty": "Hard", "category": "graph", "link": "https://leetcode.com/problems/alien-dictionary/", "examples": [{"input": "words = [\"wrt\",\"wrf\",\"er\",\"ett\",\"rftt\"]", "output": "\"wertf\" (one valid order)", "explanation": "The valid character order derived from the given words is \"wertf\"."}, {"input": "words = [\"z\",\"x\"]", "output": "\"zx\"", "explanation": "The valid character order derived from the given words is \"zx\"."}], "hints": ["Build a graph of precedence constraints from adjacent words and perform topological sort. If a cycle exists or an invalid prefix condition occurs, return an empty string."], "statement": "There is a new alien language that uses the English alphabet (lowercase letters a-z). However, the order of the letters is unknown to you.\n\nYou are given a list of strings `words` from the alien language's dictionary, where the strings are **sorted lexicographically** by the rules of this new language.\n\nDerive the order of characters in this alien language and return it as a string. If the given arrangement of words cannot correspond to any valid order of letters (e.g., due to a cycle in the character dependencies, or a longer word appearing before its prefix), return `\"\"`. If there are multiple valid orders, return **any** of them.\n\n**Constraints:**\n\n- 1 <= words.length <= 100\n- 1 <= words[i].length <= 100\n- words[i] consists of only lowercase English letters.\n", "solution": "## Approach\n\nBuild a directed graph containing every character in the input. For each adjacent pair of words, the first differing characters give an ordering constraint. Store each edge only once so that indegrees count distinct dependencies. If no characters differ and the first word is longer, the dictionary is invalid because a word cannot precede its own prefix.\n\nPerform topological sort using Kahn's algorithm: repeatedly remove a character with zero indegree and release its outgoing dependencies. If not all characters are processed, the graph contains a cycle, so return `\"\"`.\n\n## Complexity Analysis\n\n- **Time Complexity:** **O(N \u00d7 L)**, where N = `words.length` and L is the maximum length of a word in `words`. Initializing the graph scans at most N \u00d7 L characters. Each of the N \u2212 1 adjacent-word comparisons examines at most L characters. The topological sort takes constant time relative to the input size because the input contains only 26 possible lowercase English letters and each directed edge is stored only once.\n- **Auxiliary Space Complexity:** **O(1)**. The graph has at most 26 characters and 26\u00b2 distinct directed edges. The indegrees, queue, and result each hold at most 26 characters. The prefix check does not create string slices.\n\n## Implementation\n\n```python\nfrom collections import deque\nfrom typing import List\n\n\nclass Solution:\n    def alienOrder(self, words: List[str]) -> str:\n        adj = {c: set() for w in words for c in w}\n        indeg = {c: 0 for c in adj}\n        for i in range(len(words) - 1):\n            w1, w2 = words[i], words[i + 1]\n            for j in range(min(len(w1), len(w2))):\n                if w1[j] != w2[j]:\n                    if w2[j] not in adj[w1[j]]:\n                        adj[w1[j]].add(w2[j])\n                        indeg[w2[j]] += 1\n                    break\n            else:\n                if len(w1) > len(w2):\n                    return \"\"\n\n        q = deque(c for c in indeg if indeg[c] == 0)\n        res = []\n        while q:\n            c = q.popleft()\n            res.append(c)\n            for nb in adj[c]:\n                indeg[nb] -= 1\n                if indeg[nb] == 0:\n                    q.append(nb)\n        return \"\".join(res) if len(res) == len(adj) else \"\"\n```\n", "starter": {"go": "package main\n\nfunc AlienOrder(words []string) string {\n    \n}", "python": "from typing import List\nclass Solution:\n    def alienOrder(self, words: List[str]) -> str:\n        pass\n", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    string alienOrder(vector<string>& words) {\n        return \"\";\n    }\n};"}, "fn": "alienOrder", "params": [{"name": "words", "type": "string_array"}], "outputType": "string", "tests": [["[\"wrt\",\"wrf\",\"er\",\"ett\",\"rftt\"]"], ["[\"z\",\"x\"]"], ["[\"z\",\"x\",\"z\"]"], ["[\"abc\",\"ab\"]"], ["[\"a\"]"], ["[\"abcdefghijklmnopqrstuvwxyz\"]"], ["[\"abc\",\"abc\",\"abc\"]"], ["[\"a\",\"aa\",\"aaa\",\"aaaa\"]"], ["[\"aaa\",\"aab\",\"aba\",\"abb\",\"baa\",\"bab\",\"bba\",\"bbb\"]"], ["[\"za\",\"zb\",\"ca\",\"cb\"]"], ["[\"za\",\"zb\"]"], ["[\"aa\",\"ab\",\"ba\",\"bc\",\"ca\",\"cb\"]"], ["[\"aa\",\"ab\",\"ac\",\"ba\",\"bd\"]"], ["[\"a\",\"b\",\"c\",\"a\"]"], ["[\"za\",\"zb\",\"zc\",\"za\"]"], ["[\"a\",\"abc\",\"ab\"]"], ["[\"ab\",\"abc\",\"b\"]"], ["[\"ab\",\"ba\",\"bb\"]"], ["[\"z\",\"y\",\"x\",\"w\",\"v\",\"u\",\"t\",\"s\",\"r\",\"q\",\"p\",\"o\",\"n\",\"m\",\"l\",\"k\",\"j\",\"i\",\"h\",\"g\",\"f\",\"e\",\"d\",\"c\",\"b\",\"a\"]"], ["[\"aaaaaaaaaaaaaaaaaaaaaaaaab\",\"aaaaaaaaaaaaaaaaaaaaaaaaac\"]"], ["[\"b\",\"a\"]"], ["[\"a\",\"b\",\"c\"]"], ["[\"c\",\"b\",\"a\"]"], ["[\"ab\",\"bc\",\"cd\",\"de\"]"], ["[\"aaa\",\"aa\"]"], ["[\"aa\",\"aaa\"]"], ["[\"abc\",\"abd\",\"bcd\"]"], ["[\"x\",\"z\"]"], ["[\"ac\",\"ab\",\"bc\"]"], ["[\"ab\",\"adc\"]"]], "expected": ["wertf", "zx", "", "", "a", "abcdefghijklmnopqrstuvwxyz", "abc", "a", "ab", "azbc", "azb", "abc", "abdc", "", "", "", "acb", "ab", "zyxwvutsrqponmlkjihgfedcba", "abc", "ba", "abc", "cba", "aebcd", "", "a", "acbd", "xz", "acb", "abcd"], "loose": false}

package/data/problems/all-nodes-distance-k-in-binary-tree.json

@@ -0,0 +1 @@
+{"basic": false, "label": "858", "slug": "all-nodes-distance-k-in-binary-tree", "id": 858, "title": "All Nodes Distance K in Binary Tree", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/all-nodes-distance-k-in-binary-tree/", "examples": [{"input": "root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, k = 2", "output": "[1,4,7]", "explanation": "Nodes 7, 4 and 1 are two steps from 5."}, {"input": "root = [3,5,1,6,2,0,8,null,null,7,4], target = 5, k = 0", "output": "[5]", "explanation": "Distance zero means the target itself."}, {"input": "root = [1], target = 1, k = 3", "output": "[]", "explanation": "No node is three steps away."}], "hints": ["Record each node's parent with a traversal so the tree can be walked upward as well as downward.", "Run a breadth-first search outward from the target node, tracking visited nodes to avoid going back.", "Collect nodes seen at depth `k` and sort them before returning."], "statement": "You are given the root of a binary tree in level-order form, an integer `target` identifying a node by its value, and an integer `k`. All node values in the tree are unique.\n\nTreat the tree as an undirected graph where each parent-child link can be walked in either direction. The distance between two nodes is the number of edges on the shortest such walk.\n\nReturn the values of all nodes that sit exactly `k` edges away from the node holding `target`, sorted in ascending order.\n\nAdaptation note: the original task passes a node reference and accepts any order; here the target is given by value (values are unique) and the answer is required sorted so every language can be checked deterministically.\n\n**Constraints:**\n- The tree holds `1 <= n <= 500` nodes.\n- `0 <= node.val <= 500`\n- All values are unique.\n- `0 <= k <= 1000`\n- `target` appears exactly once in the tree.\n", "solution": "## Approach\n\nFirst walk the tree to remember each node's parent, turning it into a graph that can be climbed upward. Locate the node whose value equals the target. Then run a breadth-first search from there across child and parent edges, level by level, until depth `k` is reached. Sorting the collected values gives a stable order.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of nodes. Each node is visited a constant number of times.\n- **Space Complexity:** O(n) for the parent map and search queue.\n\n## Implementation\n\n```python\nfrom collections import deque\nfrom typing import List\n\nclass Solution:\n    def distanceK(self, root, target: int, k: int) -> List[int]:\n        pmap = {}\n        tgt = None\n        stack = [(root, None)]\n        while stack:\n            n, p = stack.pop()\n            if not n:\n                continue\n            pmap[id(n)] = p\n            if n.val == target:\n                tgt = n\n            stack.append((n.left, n))\n            stack.append((n.right, n))\n        if tgt is None:\n            return []\n        q = deque([tgt])\n        seen = {id(tgt)}\n        d = 0\n        while q:\n            if d == k:\n                return sorted([n.val for n in q])\n            for _ in range(len(q)):\n                cur = q.popleft()\n                for nb in (cur.left, cur.right, pmap.get(id(cur))):\n                    if nb is not None and id(nb) not in seen:\n                        seen.add(id(nb))\n                        q.append(nb)\n            d += 1\n        return []\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 DistanceK(root *TreeNode, target int, k int) []int {\n    return []int{}\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\nfrom typing import List\nclass Solution:\n    def distanceK(self, root, target: int, k: int) -> List[int]:\n        pass", "cpp": "/**\n * Definition for a binary tree node.\n * struct 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 */\n#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<int> distanceK(TreeNode* root, int target, int k) {\n        return {};\n    }\n};"}, "fn": "distanceK", "params": [{"name": "root", "type": "tree_node"}, {"name": "target", "type": "int"}, {"name": "k", "type": "int"}], "outputType": "int_list", "tests": [["[3,5,1,6,2,0,8,null,null,7,4]", "5", "2"], ["[3,5,1,6,2,0,8,null,null,7,4]", "5", "0"], ["[1]", "1", "3"], ["[3,5,1,6,2,0,8,null,null,7,4]", "5", "1"], ["[3,5,1,6,2,0,8,null,null,7,4]", "3", "1"], ["[3,5,1,6,2,0,8,null,null,7,4]", "2", "1"], ["[0,1,null,3,4]", "3", "2"], ["[1,2,3,4,5,6,7]", "4", "2"], ["[1,2,3,null,4]", "2", "1"], ["[1,null,2,null,3]", "3", "2"], ["[1,2,null,3]", "3", "1"], ["[0]", "0", "0"], ["[0]", "0", "1"], ["[1,2,3]", "1", "1"], ["[1,2,3]", "2", "2"], ["[5,1,2,3,4]", "1", "2"], ["[10,5,15,3,7,12,20]", "5", "2"], ["[10,5,15,3,7,12,20]", "10", "2"], ["[1,2,3,4,null,null,5]", "4", "3"], ["[0,2,1,null,null,3]", "3", "3"], ["[1,2,3,4,5]", "1", "2"], ["[1,2,3,4,5]", "2", "0"], ["[7,3,9,1,5]", "3", "1"], ["[7,3,9,1,5]", "9", "2"], ["[1,2,null,3,null,4]", "4", "3"], ["[2,1,3]", "3", "1"], ["[0,1,2,3,4,5,6]", "0", "2"], ["[100,50,150,25,75]", "75", "2"]], "expected": [[1, 4, 7], [5], [], [2, 3, 6], [1, 5], [4, 5, 7], [0, 4], [1, 5], [1, 4], [1], [2], [0], [], [2, 3], [3], [2], [15], [3, 7, 12, 20], [3], [2], [4, 5], [2], [1, 5, 7], [3], [1], [2], [3, 4, 5, 6], [25, 100]], "loose": true}

package/data/problems/all-oone-data-structure.json

@@ -0,0 +1 @@
+{"basic": false, "label": "501", "slug": "all-oone-data-structure", "id": 501, "title": "All Oone Data Structure", "difficulty": "Hard", "category": "design", "link": "https://leetcode.com/problems/all-oone-data-structure/", "examples": [{"input": "operations = [\"AllOne\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\",\"inc\",\"getMaxKey\",\"getMinKey\"]\nvalues = [\"\",\"hello\",\"hello\",\"\",\"\",\"leet\",\"\",\"\"]", "output": "[\"null\",\"null\",\"null\",\"hello\",\"hello\",\"null\",\"hello\",\"hello\"]", "explanation": "hello reaches 2, then leet joins at 1; extremes are tie-checked."}, {"input": "operations = [\"AllOne\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\",\"dec\",\"getMaxKey\",\"getMinKey\"]\nvalues = [\"\",\"a\",\"b\",\"b\",\"\",\"\",\"b\",\"\",\"\"]", "output": "[\"null\",\"null\",\"null\",\"null\",\"b\",\"a\",\"null\",\"b\",\"a\"]", "explanation": "Counts a:1, b:2 give max b and min a; after decrement both tie."}], "hints": ["Keep a map from key to count plus a map from count to the set of keys at that count.", "Track the current min and max counts incrementally, or derive them from the ordered count map.", "Ties may return any key at the extreme count; empty structures answer with an empty string."], "statement": "Maintain counts for a dynamic set of lowercase keys. You receive two parallel arrays describing a script: `operations` names the action at each step and `values` carries its argument (an empty string when the action takes none).\n\nThe script always starts with `\"AllOne\"` (create the structure, answer `\"null\"`). Later steps use:\n- `\"inc\"` with a key: raise that key's count by one, inserting at 1 when new; answer `\"null\"`.\n- `\"dec\"` with a key: lower that key's count by one, removing keys that reach zero; the key is guaranteed present; answer `\"null\"`.\n- `\"getMaxKey\"`: return any key currently holding the largest count, or `\"\"` when empty.\n- `\"getMinKey\"`: return any key currently holding the smallest count, or `\"\"` when empty.\n\nWrite `runAllOne`, which replays the whole script and returns the per-step answers (`\"null\"` for mutating or constructing steps, the requested key otherwise). When several keys tie for max or min, any tied key is accepted by the checker.\n\n**Constraints:**\n- Key length lies in `[1, 10]`, lowercase letters only.\n- At most `5 * 10^4` calls in one script.\n- Every `dec` targets an existing key.\n\nAdaptation: the source is a stateful `AllOne` class; here it is modeled as the `runAllOne(operations, values)` replay function with `string_array` inputs and `string_list` output so all runners can drive it. Average O(1) per action is intended but only answer correctness is checked.\n", "solution": "## Approach\n\nReplay the script against a count table plus buckets from count to key set. Insertion and removal update both structures; extremes come from the smallest and largest occupied buckets. Because any tied extreme is valid, the checker compares counts rather than exact keys.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n log m) with an ordered bucket map, where n is the step count and m the distinct counts (O(1) average with a doubly-linked bucket list).\n- **Space Complexity:** O(k) for k distinct keys.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def runAllOne(self, operations: List[str], values: List[str]) -> List[str]:\n        from collections import defaultdict\n        cnt = {}\n        buckets = defaultdict(set)\n        res = []\n        for op, v in zip(operations, values):\n            if op == 'AllOne':\n                cnt.clear()\n                buckets.clear()\n                res.append('null')\n            elif op == 'inc':\n                c = cnt.get(v, 0)\n                if c:\n                    buckets[c].discard(v)\n                cnt[v] = c + 1\n                buckets[c + 1].add(v)\n                res.append('null')\n            elif op == 'dec':\n                c = cnt[v]\n                buckets[c].discard(v)\n                if c == 1:\n                    del cnt[v]\n                else:\n                    cnt[v] = c - 1\n                    buckets[c - 1].add(v)\n                res.append('null')\n            elif op == 'getMaxKey':\n                if not cnt:\n                    res.append('')\n                else:\n                    mx = max(cnt.values())\n                    res.append(next(k for k, c in cnt.items() if c == mx))\n            elif op == 'getMinKey':\n                if not cnt:\n                    res.append('')\n                else:\n                    mn = min(cnt.values())\n                    res.append(next(k for k, c in cnt.items() if c == mn))\n        return res\n```\n", "starter": {"go": "package main\n\nfunc RunAllOne(operations []string, values []string) []string {\n    \n}", "python": "from typing import List\nclass Solution:\n    def runAllOne(self, operations: List[str], values: List[str]) -> List[str]:\n        pass", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    vector<string> runAllOne(vector<string>& operations, vector<string>& values) {\n        return {};\n    }\n};"}, "fn": "runAllOne", "params": [{"name": "operations", "type": "string_array"}, {"name": "values", "type": "string_array"}], "outputType": "string_list", "tests": [["[\"AllOne\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\",\"inc\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"hello\",\"hello\",\"\",\"\",\"leet\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"a\",\"b\",\"b\",\"\",\"\",\"b\",\"\",\"\"]"], ["[\"AllOne\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"getMaxKey\",\"getMinKey\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"x\",\"\",\"\",\"x\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\",\"dec\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"a\",\"a\",\"b\",\"c\",\"\",\"\",\"b\",\"c\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"hello\",\"world\",\"hello\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"getMinKey\",\"dec\",\"getMinKey\"]", "[\"\",\"a\",\"b\",\"c\",\"\",\"a\",\"\"]"], ["[\"AllOne\",\"inc\",\"getMaxKey\",\"inc\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"k\",\"\",\"k\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"p\",\"q\",\"p\",\"q\",\"p\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"solo\",\"solo\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"a\",\"a\",\"\",\"\",\"a\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\",\"dec\",\"getMaxKey\"]", "[\"\",\"x\",\"y\",\"y\",\"z\",\"\",\"\",\"y\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\",\"dec\",\"dec\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"a\",\"b\",\"c\",\"\",\"\",\"a\",\"b\",\"c\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"inc\",\"getMinKey\",\"dec\",\"getMaxKey\"]", "[\"\",\"k\",\"k\",\"k\",\"\",\"m\",\"\",\"k\",\"\"]"], ["[\"AllOne\",\"inc\",\"getMaxKey\",\"dec\",\"getMaxKey\",\"inc\",\"getMinKey\"]", "[\"\",\"a\",\"\",\"a\",\"\",\"b\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"aa\",\"bb\",\"aa\",\"bb\",\"cc\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"foo\",\"bar\",\"foo\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\",\"dec\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"a\",\"a\",\"a\",\"b\",\"\",\"\",\"a\",\"a\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"getMinKey\",\"getMaxKey\",\"inc\",\"getMaxKey\",\"dec\",\"getMinKey\"]", "[\"\",\"z\",\"\",\"\",\"z\",\"\",\"z\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"m\",\"n\",\"o\",\"m\",\"n\",\"m\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"dec\",\"inc\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"a\",\"b\",\"b\",\"c\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"a\",\"a\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"dec\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"ab\",\"ab\",\"ab\",\"cd\",\"cd\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"dec\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"x\",\"y\",\"z\",\"x\",\"y\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"key\",\"key\",\"other\",\"other\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\",\"dec\",\"getMaxKey\"]", "[\"\",\"a\",\"b\",\"b\",\"c\",\"c\",\"c\",\"\",\"\",\"c\",\"\"]"], ["[\"AllOne\",\"inc\",\"inc\",\"inc\",\"inc\",\"getMaxKey\",\"getMinKey\",\"dec\",\"dec\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"q\",\"w\",\"e\",\"r\",\"\",\"\",\"q\",\"w\",\"\",\"\"]"], ["[\"AllOne\",\"inc\",\"dec\",\"inc\",\"dec\",\"inc\",\"getMaxKey\",\"getMinKey\"]", "[\"\",\"a\",\"a\",\"b\",\"b\",\"c\",\"\",\"\"]"]], "expected": [["null", "null", "null", "hello", "hello", "null", "hello", "leet"], ["null", "null", "null", "null", "b", "a", "null", "a", "a"], ["null", "", ""], ["null", "null", "x", "x", "null", "", ""], ["null", "null", "null", "null", "null", "a", "b", "null", "null", "a", "a"], ["null", "null", "null", "null", "world", "world"], ["null", "null", "null", "null", "a", "null", "b"], ["null", "null", "k", "null", "k", "k"], ["null", "null", "null", "null", "null", "null", "p", "q"], ["null", "null", "null", "", ""], ["null", "null", "null", "a", "a", "null", "a", "a"], ["null", "null", "null", "null", "null", "y", "x", "null", "x"], ["null", "null", "null", "null", "a", "a", "null", "null", "null", "", ""], ["null", "null", "null", "null", "k", "null", "m", "null", "k"], ["null", "null", "a", "null", "", "null", "b"], ["null", "null", "null", "null", "null", "null", "aa", "cc"], ["null", "null", "null", "null", "bar", "bar"], ["null", "null", "null", "null", "null", "a", "b", "null", "null", "b", "b"], ["null", "null", "z", "z", "null", "z", "null", "z"], ["null", "null", "null", "null", "null", "null", "null", "m", "o"], ["null", "null", "null", "null", "null", "a", "a"], ["null", "null", "null", "", ""], ["null", "null", "null", "null", "null", "null", "cd", "ab"], ["null", "null", "null", "null", "null", "null", "z", "z"], ["null", "null", "null", "null", "null", "key", "key"], ["null", "null", "null", "null", "null", "null", "null", "c", "a", "null", "b"], ["null", "null", "null", "null", "null", "q", "q", "null", "null", "e", "e"], ["null", "null", "null", "null", "null", "null", "c", "c"]], "loose": false}

package/data/problems/all-paths-from-source-to-target.json

@@ -0,0 +1 @@
+{"basic": false, "label": "795", "slug": "all-paths-from-source-to-target", "id": 795, "title": "All Paths From Source to Target", "difficulty": "Medium", "category": "graph", "link": "https://leetcode.com/problems/all-paths-from-source-to-target/", "examples": [{"input": "graph = [[1,2],[3],[3],[]]", "output": "[[0,1,3],[0,2,3]]", "explanation": "Two ways reach the final vertex."}, {"input": "graph = [[4,3,1],[3,2,4],[3],[4],[]]", "output": "[[0,4],[0,3,4],[0,1,3,4],[0,1,2,3,4],[0,1,4]]", "explanation": "Five routes connect start to finish."}, {"input": "graph = [[1],[]]", "output": "[[0,1]]", "explanation": "The lone edge is the answer."}], "hints": ["Depth-first search from 0 carrying the current path naturally enumerates every route.", "Append a copy of the path once the final vertex is reached, then backtrack.", "Adaptation: the nested input maps to int_array_2d and the nested output maps to int_list_2d in this judge."], "statement": "You receive a directed acyclic graph with `n` vertices numbered `0` through `n - 1`. It is stored as an adjacency list `graph`, where `graph[i]` lists every vertex reachable by one directed edge from `i`. Every edge points from a smaller index to a larger one, so no cycles exist.\n\nList every directed route that starts at vertex `0` and finishes at vertex `n - 1`. The order of the routes in your answer does not matter, but each individual route must list vertices from start to finish.\n\n**Constraints:**\n- `2 <= n <= 15`\n- `graph[i]` contains distinct vertices larger than `i`\n- At least the structure is acyclic; the target may be unreachable\n- Adaptation: the nested input maps to int_array_2d and the nested output maps to int_list_2d in this judge.\n", "solution": "## Approach\n\nRun a depth-first search that carries the path from the start vertex. Each time the final vertex is reached, store a copy of the current path; otherwise extend the path with each outgoing neighbour and backtrack after the recursive call.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(2^n * n) in the worst case, proportional to the number of paths times path length.\n- **Space Complexity:** O(n) for the recursion stack plus the output storage.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def allPathsSourceTarget(self, graph: List[List[int]]) -> List[List[int]]:\n        res = []\n        path = [0]\n        def dfs(u: int):\n            if u == len(graph) - 1:\n                res.append(list(path))\n                return\n            for v in graph[u]:\n                path.append(v)\n                dfs(v)\n                path.pop()\n        dfs(0)\n        return res\n```\n", "starter": {"go": "package main\n\nfunc AllPathsSourceTarget(graph [][]int) [][]int {\n    return nil\n}", "python": "from typing import List\nclass Solution:\n    def allPathsSourceTarget(self, graph: List[List[int]]) -> List[List[int]]:\n        return []", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<vector<int>> allPathsSourceTarget(vector<vector<int>>& graph) {\n        return {};\n    }\n};"}, "fn": "allPathsSourceTarget", "params": [{"name": "graph", "type": "int_array_2d"}], "outputType": "int_list_2d", "tests": [["[[1, 2], [3], [3], []]"], ["[[4, 3, 1], [3, 2, 4], [3], [4], []]"], ["[[1], []]"], ["[[1, 2, 3], [], [], []]"], ["[[1], [2], [3], []]"], ["[[1, 2], [3], [3], [4], []]"], ["[[1], [3], [3], []]"], ["[[2], [2], [3], []]"], ["[[1, 2], [2, 3], [3], []]"], ["[[1, 2], [3], [], []]"], ["[[1], [2], []]"], ["[[1, 2], [2], []]"], ["[[1, 2, 3], [3], [3], [4], []]"], ["[[1], [2], [3], [4], []]"], ["[[1, 2], [3, 4], [4], [4], []]"], ["[[], []]"], ["[[1, 2], [3], [4], [5], [], []]"], ["[[1], [2], [3], [4], [5], []]"], ["[[2, 3], [4], [4], [4], []]"], ["[[1, 3], [2], [3], []]"], ["[[1, 2, 3, 4], [5], [5], [5], [5], []]"], ["[[2], [3], [4], [4], []]"], ["[[1, 2], [4], [3], [4], []]"], ["[[3], [3], [3], []]"], ["[[1, 2], [3], [3], [4, 5], [6], [6], []]"], ["[[1], [2], [3], [4], [5], [6], []]"], ["[[1, 2], [3], [4], [], []]"], ["[[1, 2], [3], [3], [4], [5], []]"]], "expected": [[[0, 1, 3], [0, 2, 3]], [[0, 4], [0, 3, 4], [0, 1, 3, 4], [0, 1, 2, 3, 4], [0, 1, 4]], [[0, 1]], [[0, 3]], [[0, 1, 2, 3]], [[0, 1, 3, 4], [0, 2, 3, 4]], [[0, 1, 3]], [[0, 2, 3]], [[0, 1, 2, 3], [0, 1, 3], [0, 2, 3]], [[0, 1, 3]], [[0, 1, 2]], [[0, 1, 2], [0, 2]], [[0, 1, 3, 4], [0, 2, 3, 4], [0, 3, 4]], [[0, 1, 2, 3, 4]], [[0, 1, 3, 4], [0, 1, 4], [0, 2, 4]], [], [[0, 1, 3, 5]], [[0, 1, 2, 3, 4, 5]], [[0, 2, 4], [0, 3, 4]], [[0, 1, 2, 3], [0, 3]], [[0, 1, 5], [0, 2, 5], [0, 3, 5], [0, 4, 5]], [[0, 2, 4]], [[0, 1, 4], [0, 2, 3, 4]], [[0, 3]], [[0, 1, 3, 4, 6], [0, 1, 3, 5, 6], [0, 2, 3, 4, 6], [0, 2, 3, 5, 6]], [[0, 1, 2, 3, 4, 5, 6]], [[0, 2, 4]], [[0, 1, 3, 4, 5], [0, 2, 3, 4, 5]]], "loose": true}