npm - offcode - Versions diffs - 0.0.0-stage → 0.1.0 - Mend

offcode 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1038) hide show

package/data/problems/pascals-triangle.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "295", "slug": "pascals-triangle", "id": 295, "title": "Pascal's Triangle", "difficulty": "Easy", "category": "dp", "link": "https://leetcode.com/problems/pascals-triangle/", "examples": [{"input": "numRows = 5", "output": "[[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]", "explanation": "Each interior entry is the sum of the two entries above it."}, {"input": "numRows = 1", "output": "[[1]]", "explanation": "The apex alone forms row 1."}], "hints": ["Start with [[1]] and grow one row at a time.", "Each interior entry equals the sum of the two entries diagonally above it; row edges are always 1.", "Adaptation: the nested list maps to int_list_2d in this judge."], "statement": "Produce the first `numRows` rows of Pascal's triangle.\n\nBegin with a single `1` at the top. Every later row starts and ends with `1`, and each interior position holds the sum of the two numbers directly above it from the previous row. Collect all rows from top to bottom and return them.\n\n**Constraints:**\n- `1 <= numRows <= 30`\n\n**Adaptation note:** The nested value list is represented as `int_list_2d` in this judge.\n", "solution": "## Approach\n\nBuild rows iteratively. The first row is [1]; each following row has one more entry, with 1s on both ends and interior sums taken from adjacent pairs of the previous row. Repeating this `numRows` times yields the triangle top-down with no extra bookkeeping.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(numRows^2), proportional to the total entries produced.\n- **Space Complexity:** O(numRows^2) for the stored triangle.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def generate(self, numRows: int) -> List[List[int]]:\n ans = []\n for r in range(numRows):\n row = [1] * (r + 1)\n for c in range(1, r):\n row[c] = ans[r - 1][c - 1] + ans[r - 1][c]\n ans.append(row)\n return ans\n```\n", "starter": {"go": "package main\n\nfunc Generate(numRows int) [][]int {\n \n}", "python": "from typing import List\nclass Solution:\n def generate(self, numRows: int) -> List[List[int]]:\n pass\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<vector<int>> generate(int numRows) {\n \n }\n};"}, "fn": "generate", "params": [{"name": "numRows", "type": "int"}], "outputType": "int_list_2d", "tests": [["1"], ["2"], ["3"], ["4"], ["5"], ["6"], ["7"], ["8"], ["9"], ["10"], ["11"], ["12"], ["13"], ["14"], ["15"], ["16"], ["17"], ["18"], ["19"], ["20"], ["21"], ["22"], ["23"], ["24"], ["25"], ["26"], ["27"], ["28"], ["29"], ["30"]], "expected": [[[1]], [[1], [1, 1]], [[1], [1, 1], [1, 2, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1], [1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1], [1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1], [1, 20, 190, 1140, 4845, 15504, 38760, 77520, 125970, 167960, 184756, 167960, 125970, 77520, 38760, 15504, 4845, 1140, 190, 20, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1], [1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1], [1, 20, 190, 1140, 4845, 15504, 38760, 77520, 125970, 167960, 184756, 167960, 125970, 77520, 38760, 15504, 4845, 1140, 190, 20, 1], [1, 21, 210, 1330, 5985, 20349, 54264, 116280, 203490, 293930, 352716, 352716, 293930, 203490, 116280, 54264, 20349, 5985, 1330, 210, 21, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1], [1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1], [1, 20, 190, 1140, 4845, 15504, 38760, 77520, 125970, 167960, 184756, 167960, 125970, 77520, 38760, 15504, 4845, 1140, 190, 20, 1], [1, 21, 210, 1330, 5985, 20349, 54264, 116280, 203490, 293930, 352716, 352716, 293930, 203490, 116280, 54264, 20349, 5985, 1330, 210, 21, 1], [1, 22, 231, 1540, 7315, 26334, 74613, 170544, 319770, 497420, 646646, 705432, 646646, 497420, 319770, 170544, 74613, 26334, 7315, 1540, 231, 22, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1], [1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1], [1, 20, 190, 1140, 4845, 15504, 38760, 77520, 125970, 167960, 184756, 167960, 125970, 77520, 38760, 15504, 4845, 1140, 190, 20, 1], [1, 21, 210, 1330, 5985, 20349, 54264, 116280, 203490, 293930, 352716, 352716, 293930, 203490, 116280, 54264, 20349, 5985, 1330, 210, 21, 1], [1, 22, 231, 1540, 7315, 26334, 74613, 170544, 319770, 497420, 646646, 705432, 646646, 497420, 319770, 170544, 74613, 26334, 7315, 1540, 231, 22, 1], [1, 23, 253, 1771, 8855, 33649, 100947, 245157, 490314, 817190, 1144066, 1352078, 1352078, 1144066, 817190, 490314, 245157, 100947, 33649, 8855, 1771, 253, 23, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1], [1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1], [1, 20, 190, 1140, 4845, 15504, 38760, 77520, 125970, 167960, 184756, 167960, 125970, 77520, 38760, 15504, 4845, 1140, 190, 20, 1], [1, 21, 210, 1330, 5985, 20349, 54264, 116280, 203490, 293930, 352716, 352716, 293930, 203490, 116280, 54264, 20349, 5985, 1330, 210, 21, 1], [1, 22, 231, 1540, 7315, 26334, 74613, 170544, 319770, 497420, 646646, 705432, 646646, 497420, 319770, 170544, 74613, 26334, 7315, 1540, 231, 22, 1], [1, 23, 253, 1771, 8855, 33649, 100947, 245157, 490314, 817190, 1144066, 1352078, 1352078, 1144066, 817190, 490314, 245157, 100947, 33649, 8855, 1771, 253, 23, 1], [1, 24, 276, 2024, 10626, 42504, 134596, 346104, 735471, 1307504, 1961256, 2496144, 2704156, 2496144, 1961256, 1307504, 735471, 346104, 134596, 42504, 10626, 2024, 276, 24, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1], [1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1], [1, 20, 190, 1140, 4845, 15504, 38760, 77520, 125970, 167960, 184756, 167960, 125970, 77520, 38760, 15504, 4845, 1140, 190, 20, 1], [1, 21, 210, 1330, 5985, 20349, 54264, 116280, 203490, 293930, 352716, 352716, 293930, 203490, 116280, 54264, 20349, 5985, 1330, 210, 21, 1], [1, 22, 231, 1540, 7315, 26334, 74613, 170544, 319770, 497420, 646646, 705432, 646646, 497420, 319770, 170544, 74613, 26334, 7315, 1540, 231, 22, 1], [1, 23, 253, 1771, 8855, 33649, 100947, 245157, 490314, 817190, 1144066, 1352078, 1352078, 1144066, 817190, 490314, 245157, 100947, 33649, 8855, 1771, 253, 23, 1], [1, 24, 276, 2024, 10626, 42504, 134596, 346104, 735471, 1307504, 1961256, 2496144, 2704156, 2496144, 1961256, 1307504, 735471, 346104, 134596, 42504, 10626, 2024, 276, 24, 1], [1, 25, 300, 2300, 12650, 53130, 177100, 480700, 1081575, 2042975, 3268760, 4457400, 5200300, 5200300, 4457400, 3268760, 2042975, 1081575, 480700, 177100, 53130, 12650, 2300, 300, 25, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1], [1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1], [1, 20, 190, 1140, 4845, 15504, 38760, 77520, 125970, 167960, 184756, 167960, 125970, 77520, 38760, 15504, 4845, 1140, 190, 20, 1], [1, 21, 210, 1330, 5985, 20349, 54264, 116280, 203490, 293930, 352716, 352716, 293930, 203490, 116280, 54264, 20349, 5985, 1330, 210, 21, 1], [1, 22, 231, 1540, 7315, 26334, 74613, 170544, 319770, 497420, 646646, 705432, 646646, 497420, 319770, 170544, 74613, 26334, 7315, 1540, 231, 22, 1], [1, 23, 253, 1771, 8855, 33649, 100947, 245157, 490314, 817190, 1144066, 1352078, 1352078, 1144066, 817190, 490314, 245157, 100947, 33649, 8855, 1771, 253, 23, 1], [1, 24, 276, 2024, 10626, 42504, 134596, 346104, 735471, 1307504, 1961256, 2496144, 2704156, 2496144, 1961256, 1307504, 735471, 346104, 134596, 42504, 10626, 2024, 276, 24, 1], [1, 25, 300, 2300, 12650, 53130, 177100, 480700, 1081575, 2042975, 3268760, 4457400, 5200300, 5200300, 4457400, 3268760, 2042975, 1081575, 480700, 177100, 53130, 12650, 2300, 300, 25, 1], [1, 26, 325, 2600, 14950, 65780, 230230, 657800, 1562275, 3124550, 5311735, 7726160, 9657700, 10400600, 9657700, 7726160, 5311735, 3124550, 1562275, 657800, 230230, 65780, 14950, 2600, 325, 26, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1], [1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1], [1, 20, 190, 1140, 4845, 15504, 38760, 77520, 125970, 167960, 184756, 167960, 125970, 77520, 38760, 15504, 4845, 1140, 190, 20, 1], [1, 21, 210, 1330, 5985, 20349, 54264, 116280, 203490, 293930, 352716, 352716, 293930, 203490, 116280, 54264, 20349, 5985, 1330, 210, 21, 1], [1, 22, 231, 1540, 7315, 26334, 74613, 170544, 319770, 497420, 646646, 705432, 646646, 497420, 319770, 170544, 74613, 26334, 7315, 1540, 231, 22, 1], [1, 23, 253, 1771, 8855, 33649, 100947, 245157, 490314, 817190, 1144066, 1352078, 1352078, 1144066, 817190, 490314, 245157, 100947, 33649, 8855, 1771, 253, 23, 1], [1, 24, 276, 2024, 10626, 42504, 134596, 346104, 735471, 1307504, 1961256, 2496144, 2704156, 2496144, 1961256, 1307504, 735471, 346104, 134596, 42504, 10626, 2024, 276, 24, 1], [1, 25, 300, 2300, 12650, 53130, 177100, 480700, 1081575, 2042975, 3268760, 4457400, 5200300, 5200300, 4457400, 3268760, 2042975, 1081575, 480700, 177100, 53130, 12650, 2300, 300, 25, 1], [1, 26, 325, 2600, 14950, 65780, 230230, 657800, 1562275, 3124550, 5311735, 7726160, 9657700, 10400600, 9657700, 7726160, 5311735, 3124550, 1562275, 657800, 230230, 65780, 14950, 2600, 325, 26, 1], [1, 27, 351, 2925, 17550, 80730, 296010, 888030, 2220075, 4686825, 8436285, 13037895, 17383860, 20058300, 20058300, 17383860, 13037895, 8436285, 4686825, 2220075, 888030, 296010, 80730, 17550, 2925, 351, 27, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1], [1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1], [1, 20, 190, 1140, 4845, 15504, 38760, 77520, 125970, 167960, 184756, 167960, 125970, 77520, 38760, 15504, 4845, 1140, 190, 20, 1], [1, 21, 210, 1330, 5985, 20349, 54264, 116280, 203490, 293930, 352716, 352716, 293930, 203490, 116280, 54264, 20349, 5985, 1330, 210, 21, 1], [1, 22, 231, 1540, 7315, 26334, 74613, 170544, 319770, 497420, 646646, 705432, 646646, 497420, 319770, 170544, 74613, 26334, 7315, 1540, 231, 22, 1], [1, 23, 253, 1771, 8855, 33649, 100947, 245157, 490314, 817190, 1144066, 1352078, 1352078, 1144066, 817190, 490314, 245157, 100947, 33649, 8855, 1771, 253, 23, 1], [1, 24, 276, 2024, 10626, 42504, 134596, 346104, 735471, 1307504, 1961256, 2496144, 2704156, 2496144, 1961256, 1307504, 735471, 346104, 134596, 42504, 10626, 2024, 276, 24, 1], [1, 25, 300, 2300, 12650, 53130, 177100, 480700, 1081575, 2042975, 3268760, 4457400, 5200300, 5200300, 4457400, 3268760, 2042975, 1081575, 480700, 177100, 53130, 12650, 2300, 300, 25, 1], [1, 26, 325, 2600, 14950, 65780, 230230, 657800, 1562275, 3124550, 5311735, 7726160, 9657700, 10400600, 9657700, 7726160, 5311735, 3124550, 1562275, 657800, 230230, 65780, 14950, 2600, 325, 26, 1], [1, 27, 351, 2925, 17550, 80730, 296010, 888030, 2220075, 4686825, 8436285, 13037895, 17383860, 20058300, 20058300, 17383860, 13037895, 8436285, 4686825, 2220075, 888030, 296010, 80730, 17550, 2925, 351, 27, 1], [1, 28, 378, 3276, 20475, 98280, 376740, 1184040, 3108105, 6906900, 13123110, 21474180, 30421755, 37442160, 40116600, 37442160, 30421755, 21474180, 13123110, 6906900, 3108105, 1184040, 376740, 98280, 20475, 3276, 378, 28, 1]], [[1], [1, 1], [1, 2, 1], [1, 3, 3, 1], [1, 4, 6, 4, 1], [1, 5, 10, 10, 5, 1], [1, 6, 15, 20, 15, 6, 1], [1, 7, 21, 35, 35, 21, 7, 1], [1, 8, 28, 56, 70, 56, 28, 8, 1], [1, 9, 36, 84, 126, 126, 84, 36, 9, 1], [1, 10, 45, 120, 210, 252, 210, 120, 45, 10, 1], [1, 11, 55, 165, 330, 462, 462, 330, 165, 55, 11, 1], [1, 12, 66, 220, 495, 792, 924, 792, 495, 220, 66, 12, 1], [1, 13, 78, 286, 715, 1287, 1716, 1716, 1287, 715, 286, 78, 13, 1], [1, 14, 91, 364, 1001, 2002, 3003, 3432, 3003, 2002, 1001, 364, 91, 14, 1], [1, 15, 105, 455, 1365, 3003, 5005, 6435, 6435, 5005, 3003, 1365, 455, 105, 15, 1], [1, 16, 120, 560, 1820, 4368, 8008, 11440, 12870, 11440, 8008, 4368, 1820, 560, 120, 16, 1], [1, 17, 136, 680, 2380, 6188, 12376, 19448, 24310, 24310, 19448, 12376, 6188, 2380, 680, 136, 17, 1], [1, 18, 153, 816, 3060, 8568, 18564, 31824, 43758, 48620, 43758, 31824, 18564, 8568, 3060, 816, 153, 18, 1], [1, 19, 171, 969, 3876, 11628, 27132, 50388, 75582, 92378, 92378, 75582, 50388, 27132, 11628, 3876, 969, 171, 19, 1], [1, 20, 190, 1140, 4845, 15504, 38760, 77520, 125970, 167960, 184756, 167960, 125970, 77520, 38760, 15504, 4845, 1140, 190, 20, 1], [1, 21, 210, 1330, 5985, 20349, 54264, 116280, 203490, 293930, 352716, 352716, 293930, 203490, 116280, 54264, 20349, 5985, 1330, 210, 21, 1], [1, 22, 231, 1540, 7315, 26334, 74613, 170544, 319770, 497420, 646646, 705432, 646646, 497420, 319770, 170544, 74613, 26334, 7315, 1540, 231, 22, 1], [1, 23, 253, 1771, 8855, 33649, 100947, 245157, 490314, 817190, 1144066, 1352078, 1352078, 1144066, 817190, 490314, 245157, 100947, 33649, 8855, 1771, 253, 23, 1], [1, 24, 276, 2024, 10626, 42504, 134596, 346104, 735471, 1307504, 1961256, 2496144, 2704156, 2496144, 1961256, 1307504, 735471, 346104, 134596, 42504, 10626, 2024, 276, 24, 1], [1, 25, 300, 2300, 12650, 53130, 177100, 480700, 1081575, 2042975, 3268760, 4457400, 5200300, 5200300, 4457400, 3268760, 2042975, 1081575, 480700, 177100, 53130, 12650, 2300, 300, 25, 1], [1, 26, 325, 2600, 14950, 65780, 230230, 657800, 1562275, 3124550, 5311735, 7726160, 9657700, 10400600, 9657700, 7726160, 5311735, 3124550, 1562275, 657800, 230230, 65780, 14950, 2600, 325, 26, 1], [1, 27, 351, 2925, 17550, 80730, 296010, 888030, 2220075, 4686825, 8436285, 13037895, 17383860, 20058300, 20058300, 17383860, 13037895, 8436285, 4686825, 2220075, 888030, 296010, 80730, 17550, 2925, 351, 27, 1], [1, 28, 378, 3276, 20475, 98280, 376740, 1184040, 3108105, 6906900, 13123110, 21474180, 30421755, 37442160, 40116600, 37442160, 30421755, 21474180, 13123110, 6906900, 3108105, 1184040, 376740, 98280, 20475, 3276, 378, 28, 1], [1, 29, 406, 3654, 23751, 118755, 475020, 1560780, 4292145, 10015005, 20030010, 34597290, 51895935, 67863915, 77558760, 77558760, 67863915, 51895935, 34597290, 20030010, 10015005, 4292145, 1560780, 475020, 118755, 23751, 3654, 406, 29, 1]]], "loose": false}

package/data/problems/patching-array.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "416", "slug": "patching-array", "id": 416, "title": "Patching Array", "difficulty": "Hard", "category": "array", "link": "https://leetcode.com/problems/patching-array/", "examples": [{"explanation": "Subset sums of [1,3] cover 1, 3 and 4. Patching in 2 extends coverage to every value 1..6.", "input": "nums = [1,3], n = 6", "output": "1"}, {"explanation": "Patching 2 and then 4 (one workable choice) fills the gaps so that 1..20 all become reachable.", "input": "nums = [1,5,10], n = 20", "output": "2"}, {"explanation": "Sums of [1,2,2] already produce 1, 2, 3, 4 and 5.", "input": "nums = [1,2,2], n = 5", "output": "0"}], "hints": ["Track `miss`, the smallest value not yet known to be formable; initially everything below `miss` is covered.", "If the next array element is at most `miss`, absorb it (coverage grows to miss + nums[i]); otherwise patch `miss` itself, doubling coverage.", "Count patches until `miss` exceeds n; use 64-bit integers since coverage can pass 2^31."], "statement": "You start with a sorted array `nums` of positive integers and a target reach `n`. Using any subset of the array's elements (each at most once), you can assemble various totals. If every integer from `1` through `n` can already be formed this way, nothing needs to change. Otherwise you may insert extra numbers (\"patches\") anywhere in the array. Return the smallest number of patches that makes all values in `[1, n]` representable as subset sums.\n\n**Constraints:**\n- `1 <= nums.length <= 1000`\n- `1 <= nums[i] <= 10^4`\n- `nums` is sorted in non-decreasing order.\n- `1 <= n <= 2^31 - 1`\n", "solution": "## Approach\n\nMaintain `miss`, the smallest total not yet achievable; every value below it is already covered. If the next array entry is at most `miss`, include it and stretch coverage by its value; otherwise insert `miss` itself as a patch, which doubles the covered range. Repeat until coverage passes `n`, counting the patches used.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m + log n), where m is the length of `nums`.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def minPatches(self, nums: List[int], n: int) -> int:\n miss = 1\n patches = 0\n i = 0\n while miss <= n:\n if i < len(nums) and nums[i] <= miss:\n miss += nums[i]\n i += 1\n else:\n miss += miss\n patches += 1\n return patches\n```\n", "starter": {"go": "package main\n\nfunc MinPatches(nums []int, n int) int {\n \n}", "python": "from typing import List\nclass Solution:\n def minPatches(self, nums: List[int], n: int) -> int:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int minPatches(vector<int>& nums, int n) {\n return 0;\n }\n};"}, "fn": "minPatches", "params": [{"name": "nums", "type": "int_array"}, {"name": "n", "type": "int"}], "outputType": "int", "tests": [["[1,3]", "6"], ["[1,5,10]", "20"], ["[1,2,2]", "5"], ["[1]", "1"], ["[1]", "2"], ["[2]", "1"], ["[2]", "3"], ["[1,2,4,8]", "15"], ["[1,2,4,8]", "16"], ["[1,2,4]", "8"], ["[1,3,5]", "10"], ["[1,4,9]", "20"], ["[1,2,3]", "6"], ["[1,2,3]", "7"], ["[5]", "5"], ["[1,2,7]", "14"], ["[1,2,7]", "15"], ["[1,10,100]", "1000"], ["[1,2,4,13,43]", "100"], ["[3]", "6"], ["[1,2,2,6,9]", "20"], ["[1,5,10,100]", "1000"], ["[2,4,8,16]", "31"], ["[1,2,4,8,16]", "100"], ["[7]", "7"], ["[1,10000]", "1000000"], ["[1,2,32]", "2147483647"], ["[1,3,6,10,15]", "30"], ["[4,9]", "20"], ["[1,1,1,1]", "4"]], "expected": [1, 2, 0, 0, 1, 1, 1, 0, 1, 1, 1, 2, 0, 1, 3, 1, 2, 8, 2, 2, 0, 7, 1, 2, 3, 19, 28, 1, 3, 0], "loose": false}

package/data/problems/path-sum-ii.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "291", "slug": "path-sum-ii", "id": 291, "title": "Path Sum II", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/path-sum-ii/", "examples": [{"input": "root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22", "output": "[[5,4,11,2],[5,8,4,5]]", "explanation": "Two leaf-ending chains sum to 22: 5-4-11-2 and 5-8-4-5."}, {"input": "root = [1,2,3], targetSum = 5", "output": "[]", "explanation": "No leaf chain reaches 5."}, {"input": "root = [1,2], targetSum = 0", "output": "[]", "explanation": "No leaf chain reaches 0."}], "hints": ["Depth-first search with backtracking maintains the current root-to-node chain.", "Copy the chain into the answer only at leaves whose values sum to the target.", "Adaptation: the nested list maps to int_list_2d; order of paths is normalized by the checker."], "statement": "Collect every root-to-leaf chain whose values add up to a target total.\n\nExplore the tree depth-first while keeping the current path. At each node, extend the path and reduce the remaining sum. When a leaf is reached, keep a snapshot of the path if its sum matches the target; otherwise discard it. Then backtrack and try the next branch.\n\nReturn all matching paths as value lists ordered from root to leaf. The checker treats path order as insignificant but each individual path must run root-first.\n\n**Constraints:**\n- `0 <= number of nodes <= 5000`\n- `-1000 <= Node.val <= 1000`\n- `-1000 <= targetSum <= 1000`\n\n**Adaptation note:** The nested value list is represented as `int_list_2d` in this judge.\n", "solution": "## Approach\n\nBacktracking depth-first search keeps one mutable path from the root to the current node. Each step appends the node value; at a leaf the accumulated path is copied to the answer when its sum equals the target. Removing the value on the way back up restores the path for sibling branches. Copying only at leaves keeps memory proportional to depth plus output size.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * h) in the worst case \u2014 each root-to-leaf path of length h may be copied.\n- **Space Complexity:** O(h) recursion depth excluding the answer.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def pathSum(self, root, targetSum: int) -> List[List[int]]:\n ans = []\n path = []\n def dfs(n, rest):\n if not n:\n return\n path.append(n.val)\n if not n.left and not n.right:\n if n.val == rest:\n ans.append(list(path))\n else:\n dfs(n.left, rest - n.val)\n dfs(n.right, rest - n.val)\n path.pop()\n dfs(root, targetSum)\n return ans\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 PathSum(root *TreeNode, TargetSum int) [][]int {\n \n}", "python": "# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\nfrom typing import List\nclass Solution:\n def pathSum(self, root, targetSum: int) -> List[List[int]]:\n pass\n", "cpp": "/*\nDefinition for a binary tree node.\nstruct TreeNode {\n int val;\n TreeNode *left;\n TreeNode *right;\n TreeNode(): val(0), left(nullptr), right(nullptr) {}\n TreeNode(int x): val(x), left(nullptr), right(nullptr) {}\n TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}\n};\n*/\n#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<vector<int>> pathSum(TreeNode* root, int targetSum) {\n \n }\n};"}, "fn": "pathSum", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}, {"name": "targetSum", "type": "int"}], "outputType": "int_list_2d", "tests": [["[5,4,8,11,null,13,4,7,2,null,null,5,1]", "22"], ["[1,2,3]", "5"], ["[1,2]", "0"], ["[]", "0"], ["[1,2,3,4,5]", "7"], ["[5,4,8,11,null,13,4,7,2,null,null,null,1]", "22"], ["[1]", "1"], ["[1]", "2"], ["[1,-2,-3,1,3,-2,null,-1]", "-1"], ["[1,2,3,4,null,null,5]", "7"], ["[-2,null,-3]", "-5"], ["[0]", "0"], ["[1,2,null,3,null,4]", "10"], ["[3,9,20,null,null,15,7]", "12"], ["[1,2,3,4,5,6,7]", "10"], ["[10,5,-3,3,2,null,11,3,-2,null,1]", "18"], ["[5,4,8,11,null,13,4,7,2,null,null,5,1]", "26"], ["[2,1,3]", "3"], ["[4,2,6,1,3,5,7]", "7"], ["[1,null,2,null,3]", "6"], ["[7,3,10,2,5,null,12]", "22"], ["[1,2,3,null,4,5,6]", "8"], ["[5,3,6,2,4,null,7]", "10"], ["[-1,-2,-3]", "-3"], ["[0,1,1]", "1"], ["[1,2,3,4,5,6,7,8]", "15"]], "expected": [[[5, 4, 11, 2], [5, 8, 4, 5]], [], [], [], [[1, 2, 4]], [[5, 4, 11, 2]], [[1]], [], [[1, -2, 1, -1]], [[1, 2, 4]], [[-2, -3]], [[0]], [[1, 2, 3, 4]], [[3, 9]], [[1, 3, 6]], [[10, 5, 2, 1], [10, -3, 11]], [[5, 8, 13]], [[2, 1]], [[4, 2, 1]], [[1, 2, 3]], [], [], [[5, 3, 2]], [[-1, -2]], [[0, 1], [0, 1]], [[1, 2, 4, 8]]], "loose": true}

package/data/problems/path-sum-iii.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "505", "slug": "path-sum-iii", "id": 505, "title": "Path Sum III", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/path-sum-iii/", "examples": [{"input": "root = [10,5,-3,3,2,null,11,3,-2,null,1], targetSum = 8", "output": "3", "explanation": "Three downward routes total 8."}, {"input": "root = [5,4,8,11,null,13,4,7,2,null,null,5,1], targetSum = 22", "output": "3", "explanation": "Three routes hit 22."}, {"input": "root = [], targetSum = 0", "output": "0", "explanation": "No nodes means no paths."}], "hints": ["Carry prefix sums from the root: paths ending at the current node match earlier prefixes offset by targetSum.", "A hash map of prefix frequencies updated on entry and removed on exit keeps the walk linear.", "Use 64-bit sums to avoid overflow on deep paths."], "statement": "You are given a binary tree `root` and a number `targetSum`. Count the downward paths whose node values add up to `targetSum`. A path may begin at any node and finish at any descendant of that start (the start and end may coincide); it must follow parent-to-child links only.\n\n**Constraints:**\n- Node count lies in `[0, 1000]`.\n- Node values and `targetSum` fit the stated ranges; sums may exceed 32-bit during accumulation, so use 64-bit counters internally.\n", "solution": "## Approach\n\nDo a depth-first walk carrying the running sum from the root. A hash map counts how often each prefix sum has appeared on the current path; any earlier prefix equal to `current - targetSum` closes a qualifying downward path ending here. Add that count, recurse into both children, then decrement the current prefix before backtracking.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the node count. Each node is visited once with O(1) map work.\n- **Space Complexity:** O(h) for recursion depth plus the prefix table, where h is the tree height.\n\n## Implementation\n\n```python\nfrom collections import defaultdict\nclass Solution:\n def pathSum(self, root, targetSum: int) -> int:\n freq = defaultdict(int)\n freq[0] = 1\n def dfs(n, cur):\n if not n:\n return 0\n cur += n.val\n res = freq[cur - targetSum]\n freq[cur] += 1\n res += dfs(n.left, cur)\n res += dfs(n.right, cur)\n freq[cur] -= 1\n return res\n return dfs(root, 0)\n```\n", "starter": {"go": "// Definition for a binary tree node.\n// type TreeNode struct {\n// Val int\n// Left *TreeNode\n// Right *TreeNode\n// }\npackage main\n\nfunc PathSum(root *TreeNode, targetSum int) int {\n \n}", "python": "# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\nclass Solution:\n def pathSum(self, root, targetSum: int) -> int:\n pass\n", "cpp": "/*\nDefinition for a binary tree node.\nstruct TreeNode {\n int val;\n TreeNode *left;\n TreeNode *right;\n TreeNode(): val(0), left(nullptr), right(nullptr) {}\n TreeNode(int x): val(x), left(nullptr), right(nullptr) {}\n TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}\n};\n*/\nclass Solution {\npublic:\n int pathSum(TreeNode* root, int targetSum) {\n \n }\n};"}, "fn": "pathSum", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}, {"name": "targetSum", "type": "int"}], "outputType": "int", "tests": [["[10,5,-3,3,2,null,11,3,-2,null,1]", "8"], ["[5,4,8,11,null,13,4,7,2,null,null,5,1]", "22"], ["[]", "0"], ["[1]", "1"], ["[1]", "2"], ["[1,2,3]", "3"], ["[0,0,0]", "0"], ["[1,null,2,null,3]", "3"], ["[-1,-2,-3]", "-3"], ["[5]", "5"], ["[3,3,3]", "3"], ["[1,-2,-3,1,3,-2,null,-1]", "-1"], ["[1,2,3,4,5]", "5"], ["[0]", "0"], ["[1,2,null,3]", "3"], ["[5,4,8,11,null,13,4,7,2,null,null,5,1]", "5"], ["[10,5,-3,3,2,null,11,3,-2,null,1]", "3"], ["[1,null,2,null,3,null,4]", "6"], ["[2,2,2]", "2"], ["[0,1,1]", "1"], ["[-2,null,-3]", "-5"], ["[1,-1,1]", "0"], ["[3,5,1,6,2,0,8,null,null,7,4]", "8"], ["[1,2,3,4,null,null,5]", "8"], ["[1000000,1000000,1000000]", "1000000"], ["[1,1,1,1,1]", "2"], ["[0,0,null,0]", "0"], ["[5,3,6,2,4,null,null,1]", "8"]], "expected": [3, 3, 0, 1, 0, 2, 5, 2, 2, 1, 3, 4, 1, 1, 2, 3, 3, 1, 3, 4, 1, 1, 2, 1, 3, 4, 6, 1], "loose": false}

package/data/problems/path-sum-iv.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "685", "slug": "path-sum-iv", "id": 685, "title": "Path Sum IV", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/path-sum-iv/", "examples": [{"input": "nums = [113,215,221]", "output": "12", "explanation": "Paths 3->5 (=8) and 3->1 (=4) total 12."}, {"input": "nums = [113,221]", "output": "4", "explanation": "Single path 3 -> 1 totals 4."}, {"input": "nums = [111,222,333]", "output": "6", "explanation": "Chain 1->2->3 sums to 6."}], "hints": ["Decode each entry: hundreds are depth, tens are position, ones are the node value.", "Store the values in a map keyed by (depth, position); children of (d, p) sit at (d+1, 2p-1) and (d+1, 2p).", "Depth-first walk from (1, 1), adding the running total whenever a node has no children in the map."], "statement": "You are given an array `nums` encoding a binary tree. Each entry is a three-digit number:\n\n- hundreds digit: depth `d` (root is depth 1),\n- tens digit: position `p` within that depth (counting from 1),\n- ones digit: node value `v` (0..9).\n\nThe tree is consistent: every code except the root has its parent present, and positions follow heap rules where children of `(d, p)` are `(d+1, 2p-1)` and `(d+1, 2p)`.\n\nAdd up the sums of all root-to-leaf paths and return the total.\n\n**Adaptation:** the encoded entries map to an int array in this judge.\n\n**Constraints:**\n- `1 <= nums.length <= 50`\n- Each code is between 111 and 459 with value digit 0..9 and forms a valid tree.\n", "solution": "## Approach\n\nDecode each triple into a `(depth, position) -> value` table. From the root `(1, 1)`, recurse to children `(d+1, 2p-1)` and `(d+1, 2p)` carrying the running sum. When neither child exists in the table, the accumulated sum is one complete path; add it to the answer.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) for n codes.\n- **Space Complexity:** O(n) for the table plus recursion depth.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def pathSum(self, nums: List[int]) -> int:\n val = {}\n for x in nums:\n d, p, v = x // 100, (x // 10) % 10, x % 10\n val[(d, p)] = v\n def dfs(d, p, cur):\n if (d, p) not in val:\n return 0\n cur += val[(d, p)]\n has_l = (d + 1, 2 * p - 1) in val\n has_r = (d + 1, 2 * p) in val\n if not has_l and not has_r:\n return cur\n return dfs(d + 1, 2 * p - 1, cur) + dfs(d + 1, 2 * p, cur)\n return dfs(1, 1, 0)\n```\n", "starter": {"go": "package main\n\nfunc PathSum(nums []int) int {\n \n}", "python": "from typing import List\nclass Solution:\n def pathSum(self, nums: List[int]) -> int:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int pathSum(vector<int>& nums) {\n return 0;\n }\n};"}, "fn": "pathSum", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[113,215,221]"], ["[113,221]"], ["[111,222,333]"], ["[113]"], ["[113,215,221,342,324]"], ["[111]"], ["[115,215,225,335,345]"], ["[119,219,229,339,349]"], ["[110,210,220]"], ["[113,214,221,334]"], ["[121,222,223]"], ["[111,212,223,414,425]"], ["[115]"], ["[112,213,214,314,325]"], ["[119,229,339,449]"], ["[111,222,333,444]"], ["[113,215,216,315,326]"], ["[114,214,224,314,324,334,344]"], ["[110,210]"], ["[117,217,227,317,327,337,347]"], ["[111,211,221,311,322]"], ["[119,219,229]"], ["[113,215,221,345]"], ["[116,216,226]"], ["[111,212,213,314]"], ["[118,218,228,318,328]"], ["[115,225,335,445]"], ["[112,212,222,312,323]"]], "expected": [12, 4, 6, 3, 18, 1, 40, 72, 0, 15, 0, 7, 5, 21, 27, 6, 29, 48, 0, 84, 9, 36, 17, 24, 8, 64, 15, 17], "loose": false}

package/data/problems/path-sum.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "290", "slug": "path-sum", "id": 290, "title": "Path Sum", "difficulty": "Easy", "category": "tree", "link": "https://leetcode.com/problems/path-sum/", "examples": [{"input": "root = [5,4,8,11,null,13,4,7,2,null,null,null,1], targetSum = 22", "output": "true", "explanation": "Route 5 -> 4 -> 11 -> 2 adds to 22 and ends at a leaf."}, {"input": "root = [1,2,3], targetSum = 5", "output": "false", "explanation": "Routes 1 -> 2 (=3) and 1 -> 3 (=4) both miss 5."}, {"input": "root = [], targetSum = 0", "output": "false", "explanation": "With no nodes there is no root-to-leaf route."}], "hints": ["Subtract the current node value from the remaining sum as you descend.", "Only return true at a leaf whose remaining sum is exactly zero.", "An empty tree never satisfies the condition, even when the target is zero."], "statement": "Determine whether any root-to-leaf chain in a binary tree adds up to a given total.\n\nStart at the root with the full target. At each step, subtract the current node's value and continue to its children. When a leaf (a node with no children) is reached, success means the leftover amount is zero. Interior nodes never count, even if the partial sum matches early.\n\nReturn `true` if at least one qualifying leaf route exists, otherwise `false`.\n\n**Constraints:**\n- `0 <= number of nodes <= 5000`\n- `-1000 <= Node.val <= 1000`\n- `-1000 <= targetSum <= 1000`\n", "solution": "## Approach\n\nDepth-first search carries the remaining sum downward. Each call subtracts the current value; at a leaf the call succeeds exactly when nothing remains. Non-leaf nodes combine their children's answers with logical OR, and a null tree immediately fails. Negative values are handled naturally since no early pruning is used.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), each node visited once.\n- **Space Complexity:** O(h) recursion depth.\n\n## Implementation\n\n```python\nclass Solution:\n def hasPathSum(self, root, targetSum: int) -> bool:\n if not root:\n return False\n if not root.left and not root.right:\n return root.val == targetSum\n rest = targetSum - root.val\n return self.hasPathSum(root.left, rest) or self.hasPathSum(root.right, rest)\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 HasPathSum(root *TreeNode, TargetSum int) bool {\n \n}", "python": "# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\n\nclass Solution:\n def hasPathSum(self, root, targetSum: int) -> bool:\n pass\n", "cpp": "/*\nDefinition for a binary tree node.\nstruct TreeNode {\n int val;\n TreeNode *left;\n TreeNode *right;\n TreeNode(): val(0), left(nullptr), right(nullptr) {}\n TreeNode(int x): val(x), left(nullptr), right(nullptr) {}\n TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}\n};\n*/\nclass Solution {\npublic:\n bool hasPathSum(TreeNode* root, int targetSum) {\n \n }\n};"}, "fn": "hasPathSum", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}, {"name": "targetSum", "type": "int"}], "outputType": "boolean", "tests": [["[5,4,8,11,null,13,4,7,2,null,null,null,1]", "22"], ["[1,2,3]", "5"], ["[]", "0"], ["[1,2]", "1"], ["[1,-2,-3,1,3,-2,null,-1]", "-1"], ["[1,2,3,4,5]", "7"], ["[1]", "1"], ["[1]", "2"], ["[]", "5"], ["[5,4,8,11,null,13,4,7,2,null,null,5,1]", "22"], ["[1,2,3,4,null,null,5]", "7"], ["[-2,null,-3]", "-5"], ["[1,-2,3]", "-1"], ["[3,9,20,null,null,15,7]", "12"], ["[3,9,20,null,null,15,7]", "30"], ["[5,4,8,11,null,13,4,7,2,null,null,null,1]", "26"], ["[1,2,null,3,null,4]", "10"], ["[0]", "0"], ["[0]", "1"], ["[1,2,3,4,5,6,7]", "10"], ["[10,5,15,2,7,12,20]", "17"], ["[-5,-10,0]", "-15"], ["[2,1,3]", "3"], ["[4,2,6,1,3,5,7]", "7"], ["[1,null,2,null,3]", "6"], ["[7,3,10,2,5,null,12]", "12"]], "expected": [true, false, false, false, true, true, true, false, false, true, true, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true], "loose": false}

package/data/problems/path-with-minimum-effort.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "223", "slug": "path-with-minimum-effort", "id": 223, "title": "Path With Minimum Effort", "difficulty": "Medium", "category": "graph", "link": "https://leetcode.com/problems/path-with-minimum-effort/", "examples": [{"input": "heights = [[1,2,2],[3,8,2],[5,3,5]]", "output": "2", "explanation": "The route of [1,3,5,3,5] has a maximum absolute difference of 2 in consecutive cells. This is better than the route of [1,2,2,2,5], where the maximum absolute difference is 3."}, {"input": "heights = [[1,2,3],[3,8,4],[5,3,5]]", "output": "1", "explanation": "The route of [1,2,3,4,5] has a maximum absolute difference of 1 in consecutive cells, which is better than route [1,3,5,3,5]."}, {"input": "heights = [[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]", "output": "0", "explanation": "This route does not require any effort."}], "hints": ["Consider the grid as a graph, where adjacent cells have an edge with cost of the difference between the cells.", "If you are given threshold k, check if it is possible to go from (0, 0) to (n-1, m-1) using only edges of cost at most k.", "Binary search the k value."], "statement": "You are planning a walk over a terrain map `heights` with `rows` rows and `columns` columns, where `heights[row][col]` is the altitude of that square. The walk begins at the upper-left corner `(0, 0)` and must finish at the lower-right corner `(rows-1, columns-1)`, moving only to the four directly neighboring squares.\n\nFor any chosen walk, look at the absolute altitude change between each pair of successive squares and take the largest of those changes; that maximum is the walk's effort. Among all possible walks, return the smallest achievable effort.\n\n**Constraints:**\n- `rows == heights.length`\n- `columns == heights[i].length`\n- `1 <= rows, columns <= 100`\n- `1 <= heights[i][j] <= 10^6`\n", "solution": "## Approach\n\nTreat each cell as a graph node with edges to its four neighbors weighted by the absolute height difference. The effort of a path is the maximum edge weight along it, so run Dijkstra where the path cost is the max edge seen so far instead of a sum. A min-heap ordered by effort expands the cheapest frontier first, and the first time the target is popped its effort is optimal.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(mn log(mn)), where m and n are the grid dimensions. Each cell is processed with heap operations.\n- **Space Complexity:** O(mn) for the distance array and the heap.\n\n## Implementation\n\n```python\nimport heapq\nclass Solution:\n def minimumEffortPath(self, heights: list[list[int]]) -> int:\n rows, cols = len(heights), len(heights[0])\n dist = [[10**18] * cols for _ in range(rows)]\n dist[0][0] = 0\n pq = [(0, 0, 0)]\n while pq:\n effort, r, c = heapq.heappop(pq)\n if r == rows - 1 and c == cols - 1:\n return effort\n if effort > dist[r][c]:\n continue\n for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):\n nr, nc = r + dr, c + dc\n if 0 <= nr < rows and 0 <= nc < cols:\n nxt = max(effort, abs(heights[r][c] - heights[nr][nc]))\n if nxt < dist[nr][nc]:\n dist[nr][nc] = nxt\n heapq.heappush(pq, (nxt, nr, nc))\n return dist[rows - 1][cols - 1]\n```\n", "starter": {"go": "package main\n\nfunc MinimumEffortPath(heights [][]int) int {\n \n}", "python": "from typing import List\nclass Solution:\n def minimumEffortPath(self, heights: List[List[int]]) -> int:\n ", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n int minimumEffortPath(vector<vector<int>>& heights) {\n return 0;\n }\n};"}, "fn": "minimumEffortPath", "params": [{"name": "heights", "type": "int_array_2d"}], "outputType": "int", "tests": [["[[1,2,2],[3,8,2],[5,3,5]]"], ["[[1,2,3],[3,8,4],[5,3,5]]"], ["[[1,2,1,1,1],[1,2,1,2,1],[1,2,1,2,1],[1,2,1,2,1],[1,1,1,2,1]]"], ["[[1]]"], ["[[1,10],[10,1]]"], ["[[1,2],[3,4]]"], ["[[3]]"], ["[[1,2,3],[4,5,6],[7,8,9]]"], ["[[1,1000000],[1,1]]"], ["[[4,3,4,10,5,5,9,2],[10,8,2,10,9,7,5,6],[5,8,10,10,10,7,4,2],[5,1,3,1,1,3,1,9],[6,4,10,6,10,9,4,6]]"], ["[[5]]"], ["[[1,2]]"], ["[[1],[2]]"], ["[[2,2],[2,2]]"], ["[[5,1],[1,5]]"], ["[[1,2,3,4]]"], ["[[1],[2],[3],[4]]"], ["[[1,3],[2,5],[4,6]]"], ["[[1,2,3],[1,2,3],[1,2,3]]"], ["[[10,10,10],[10,1,10],[10,10,10]]"], ["[[1,100],[100,100]]"], ["[[2,1],[1,2]]"], ["[[1,5,1],[5,1,5],[1,5,1]]"], ["[[7,7,7,7],[7,7,7,7]]"], ["[[3,2,1],[6,5,4]]"], ["[[100,1,100],[1,100,1],[100,1,100]]"], ["[[1,4],[2,3],[5,6],[7,8]]"], ["[[9,9],[9,9],[9,1]]"], ["[[6,5,4,3],[1,2,7,8]]"], ["[[2,3,1],[4,6,5]]"]], "expected": [2, 1, 0, 0, 9, 2, 0, 3, 0, 5, 0, 1, 1, 0, 4, 1, 1, 2, 1, 0, 99, 1, 4, 0, 3, 99, 3, 8, 3, 2], "loose": false}

package/data/problems/peak-index-in-a-mountain-array.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "849", "slug": "peak-index-in-a-mountain-array", "id": 849, "title": "Peak Index in a Mountain Array", "difficulty": "Medium", "category": "binary-search", "link": "https://leetcode.com/problems/peak-index-in-a-mountain-array/", "examples": [{"input": "arr = [0,1,0]", "output": "1", "explanation": "Peak at index 1."}, {"input": "arr = [0,2,1,0]", "output": "1", "explanation": "Maximum at index 1."}, {"input": "arr = [0,10,5,2]", "output": "1", "explanation": "Summit at index 1."}], "hints": ["The slope tells the side: when arr[mid] < arr[mid+1] the peak lies to the right, otherwise to the left.", "Binary-search that slope test for O(log n); a linear max scan also works but is slower.", "Keep the loop invariant lo < hi and return lo when they meet."], "statement": "Locate the summit of a mountain array.\n\nAn array `arr` is a mountain when its length is at least three and there is a single peak index `p` such that values rise strictly from the start to `p` and then fall strictly after `p`. Given such an array, return the peak index.\n\n**Constraints:**\n- `3 <= arr.length <= 10^4`\n- `0 <= arr[i] <= 10^6`\n- `arr` is guaranteed to be a mountain array.\n", "solution": "## Approach\n\nCompare each middle index with its right neighbour: an upward slope means the summit is further right, a downward slope means it is at or left of centre. Halving the interval on this test homes in on the unique peak.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(log n), where n is the array length.\n- **Space Complexity:** O(1) extra.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def peakIndexInMountainArray(self, arr: List[int]) -> int:\n lo, hi = 0, len(arr) - 1\n while lo < hi:\n mid = (lo + hi) // 2\n if arr[mid] < arr[mid + 1]:\n lo = mid + 1\n else:\n hi = mid\n return lo\n```\n", "starter": {"go": "package main\n\nfunc PeakIndexInMountainArray(arr []int) int {\n return 0\n}", "python": "from typing import List\nclass Solution:\n def peakIndexInMountainArray(self, arr: List[int]) -> int:\n return 0\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int peakIndexInMountainArray(vector<int>& arr) {\n return 0;\n }\n};"}, "fn": "peakIndexInMountainArray", "params": [{"name": "arr", "type": "int_array"}], "outputType": "int", "tests": [["[0,1,0]"], ["[0,2,1,0]"], ["[0,10,5,2]"], ["[3,4,5,1]"], ["[1,3,5,4,2]"], ["[0,1,2,3,2,1,0]"], ["[1,2,3,4,5,4,3,2,1]"], ["[10,20,30,20,10]"], ["[0,5,4,3,2,1]"], ["[1,5,4]"], ["[2,5,3]"], ["[0,2,4,3,1]"], ["[1,2,10,9,8,7]"], ["[3,5,3,2,0]"], ["[24,69,100,99,79,78,67,36,26,19]"], ["[1,2,3,5,4]"], ["[5,10,3]"], ["[0,3,2]"], ["[1,4,3,2,1,0]"], ["[0,1,3,5,4,2]"], ["[2,3,4,5,1]"], ["[1,2,3,4,3]"], ["[40,50,60,30,20,10]"], ["[0,10,20,15,10,5]"], ["[1,3,2]"], ["[0,1,2,1]"], ["[18,29,38,59,98,100,99,90,80,70]"], ["[3,9,8,6,4]"]], "expected": [1, 1, 1, 2, 2, 3, 4, 2, 1, 1, 1, 2, 2, 1, 2, 3, 1, 1, 1, 3, 3, 3, 2, 2, 1, 2, 5, 1], "loose": false}

package/data/problems/peeking-iterator.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "382", "slug": "peeking-iterator", "id": 382, "title": "Peeking Iterator", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/peeking-iterator/", "examples": [{"input": "nums = [1,2,3], operations = [\"next\",\"peek\",\"next\",\"next\",\"hasNext\"]", "output": "[1,2,2,3,0]", "explanation": "next gives 1, peek previews 2, next gives 2, next gives 3, then nothing remains (0)."}, {"input": "nums = [1], operations = [\"hasNext\",\"next\",\"hasNext\"]", "output": "[1,1,0]", "explanation": "One value present (1), next returns it, then empty (0)."}, {"input": "nums = [1,2], operations = [\"peek\",\"peek\",\"next\",\"hasNext\"]", "output": "[1,1,1,1]", "explanation": "Repeated peeks return 1 without advancing; next returns 1; one value remains."}], "hints": ["Adaptation: instead of a PeekingIterator class, implement runPeek(nums, operations) simulating the calls.", "Keep an index: next returns nums[i++], peek returns nums[i], hasNext returns 1/0.", "Cache nothing extra; peek never advances."], "statement": "Simulate an iterator with lookahead over an integer array.\n\n**Adaptation:** the original design asks for a `PeekingIterator` class with\n`next`, `peek`, and `hasNext`; here implement `runPeek(nums, operations)`\nwhere `operations` lists the calls to run in order. Return one integer per\noperation: the value for `next`/`peek`, and `1`/`0` for `hasNext`\ntrue/false. Calls are guaranteed valid (peek/next only when data remains).\n\n**Constraints:**\n- `1 <= nums.length <= 1000`\n- At most `1000` operations.\n", "solution": "## Approach\n\nKeep an index into nums. For each requested operation emit nums[idx] for peek, nums[idx++] for next, or 1/0 for hasNext depending on whether the index is still inside the array.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(q) for q operations.\n- **Space Complexity:** O(q) for the output.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def runPeek(self, nums: List[int], operations: List[str]) -> List[int]:\n out, idx = [], 0\n for op in operations:\n if op == \"next\":\n out.append(nums[idx]); idx += 1\n elif op == \"peek\":\n out.append(nums[idx])\n elif op == \"hasNext\":\n out.append(1 if idx < len(nums) else 0)\n return out\n```\n", "starter": {"go": "package main\n\nfunc RunPeek(nums []int, operations []string) []int {\n return []int{}\n}", "python": "from typing import List\nclass Solution:\n def runPeek(self, nums: List[int], operations: List[str]) -> List[int]:\n return []", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<int> runPeek(vector<int>& nums, vector<string>& operations) {\n return {};\n }\n};"}, "fn": "runPeek", "params": [{"name": "nums", "type": "int_array"}, {"name": "operations", "type": "string_array"}], "outputType": "int_array", "tests": [["[1,2,3]", "[\"next\",\"peek\",\"next\",\"next\",\"hasNext\"]"], ["[1]", "[\"hasNext\",\"next\",\"hasNext\"]"], ["[1,2]", "[\"peek\",\"peek\",\"next\",\"hasNext\"]"], ["[5,6,7,8]", "[\"next\",\"hasNext\",\"peek\",\"next\",\"hasNext\",\"next\",\"hasNext\"]"], ["[1,2]", "[\"next\",\"next\",\"hasNext\"]"], ["[1,2,3,4]", "[\"peek\",\"next\",\"peek\",\"next\",\"peek\",\"next\",\"hasNext\"]"], ["[10]", "[\"peek\",\"hasNext\",\"next\",\"hasNext\"]"], ["[1,2,3]", "[\"hasNext\",\"hasNext\",\"next\",\"hasNext\"]"], ["[4,5]", "[\"next\",\"hasNext\",\"hasNext\"]"], ["[1,2,3,4,5]", "[\"next\",\"next\",\"peek\",\"hasNext\",\"next\",\"hasNext\"]"], ["[7]", "[\"hasNext\"]"], ["[7]", "[\"peek\"]"], ["[7]", "[\"next\"]"], ["[1,2]", "[\"peek\",\"next\",\"peek\",\"next\",\"hasNext\"]"], ["[3,1,2]", "[\"next\",\"peek\",\"hasNext\",\"next\",\"hasNext\"]"], ["[2,4,6]", "[\"peek\",\"next\",\"hasNext\",\"next\",\"hasNext\",\"next\",\"hasNext\"]"], ["[9,8,7]", "[\"hasNext\",\"peek\",\"peek\",\"next\",\"next\",\"peek\",\"next\",\"hasNext\"]"], ["[1,2,3,4,5,6]", "[\"next\",\"next\",\"next\",\"hasNext\",\"peek\",\"next\",\"hasNext\"]"], ["[5]", "[\"hasNext\",\"peek\",\"next\",\"hasNext\",\"hasNext\"]"], ["[1,1,1]", "[\"peek\",\"next\",\"peek\",\"next\",\"peek\",\"next\",\"hasNext\"]"], ["[10,20]", "[\"next\",\"peek\",\"hasNext\",\"next\",\"hasNext\"]"], ["[3,3,3,3]", "[\"hasNext\",\"next\",\"hasNext\",\"next\",\"hasNext\",\"next\",\"peek\",\"next\",\"hasNext\"]"], ["[100,200,300]", "[\"next\",\"hasNext\",\"hasNext\",\"next\",\"next\",\"hasNext\"]"], ["[1,2,3]", "[\"peek\",\"hasNext\",\"next\",\"hasNext\",\"peek\",\"next\",\"peek\",\"next\",\"hasNext\"]"], ["[8,9]", "[\"hasNext\",\"hasNext\",\"hasNext\",\"next\",\"peek\",\"next\",\"hasNext\"]"], ["[4]", "[\"peek\",\"peek\",\"peek\",\"next\",\"hasNext\"]"], ["[6,7,8,9,10]", "[\"peek\",\"next\",\"peek\",\"next\",\"peek\",\"next\",\"peek\",\"next\",\"peek\",\"next\",\"hasNext\"]"], ["[11,22]", "[\"next\",\"next\",\"hasNext\",\"hasNext\"]"], ["[0,1]", "[\"peek\",\"next\",\"hasNext\",\"next\",\"hasNext\"]"]], "expected": [[1, 2, 2, 3, 0], [1, 1, 0], [1, 1, 1, 1], [5, 1, 6, 6, 1, 7, 1], [1, 2, 0], [1, 1, 2, 2, 3, 3, 1], [10, 1, 10, 0], [1, 1, 1, 1], [4, 1, 1], [1, 2, 3, 1, 3, 1], [1], [7], [7], [1, 1, 2, 2, 0], [3, 1, 1, 1, 1], [2, 2, 1, 4, 1, 6, 0], [1, 9, 9, 9, 8, 7, 7, 0], [1, 2, 3, 1, 4, 4, 1], [1, 5, 5, 0, 0], [1, 1, 1, 1, 1, 1, 0], [10, 20, 1, 20, 0], [1, 3, 1, 3, 1, 3, 3, 3, 0], [100, 1, 1, 200, 300, 0], [1, 1, 1, 1, 2, 2, 3, 3, 0], [1, 1, 1, 8, 9, 9, 0], [4, 4, 4, 4, 0], [6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 0], [11, 22, 0, 0], [0, 0, 1, 1, 0]], "loose": false}

package/data/problems/perfect-number.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "569", "slug": "perfect-number", "id": 569, "title": "Perfect Number", "difficulty": "Easy", "category": "math", "link": "https://leetcode.com/problems/perfect-number/", "examples": [{"input": "num = 28", "output": "true", "explanation": "Its proper divisors 1, 2, 4, 7 and 14 add up to 28."}, {"input": "num = 8", "output": "false", "explanation": "The proper divisors 1, 2 and 4 sum to 7, not 8."}, {"input": "num = 1", "output": "false", "explanation": "1 has no proper divisors, so the empty sum 0 differs from 1."}], "hints": ["Only trial divisors up to the square root are needed; each divisor d pairs with num / d.", "Start the total at 1 for num > 1 and take care not to double-count a square root."], "statement": "A positive whole number is called perfect when it equals the sum of all its proper divisors, meaning every divisor except the number itself. For instance, 6 qualifies because 1 + 2 + 3 = 6, while 8 does not because 1 + 2 + 4 = 7.\n\nGiven `num`, decide whether it is perfect.\n\n**Constraints:**\n- `1 <= num <= 10^8`\n", "solution": "## Approach\n\nScan possible divisors only up to the square root of `num`. Whenever `d` divides `num`, add both `d` and its partner `num / d` to a running total (adding the square root just once). Starting from 1 covers the universal divisor for `num > 1`. The number is perfect exactly when the accumulated total equals `num`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(sqrt(num)) trial divisions.\n- **Space Complexity:** O(1) extra memory.\n\n## Implementation\n\n```python\nclass Solution:\n def checkPerfectNumber(self, num: int) -> bool:\n if num <= 1:\n return False\n total = 1\n d = 2\n while d * d <= num:\n if num % d == 0:\n total += d\n other = num // d\n if other != d:\n total += other\n if total > num:\n return False\n d += 1\n return total == num\n```\n", "starter": {"go": "package main\n\nfunc CheckPerfectNumber(num int) bool {\n \n}", "python": "class Solution:\n def checkPerfectNumber(self, num: int) -> bool:\n pass", "cpp": "class Solution {\npublic:\n bool checkPerfectNumber(int num) {\n return false;\n }\n};"}, "fn": "checkPerfectNumber", "params": [{"name": "num", "type": "int"}], "outputType": "boolean", "tests": [["28"], ["8"], ["1"], ["6"], ["496"], ["8128"], ["33550336"], ["2"], ["3"], ["4"], ["5"], ["7"], ["12"], ["27"], ["100"], ["1000"], ["99999999"], ["100000000"], ["33550335"], ["33550337"], ["8127"], ["8129"], ["495"], ["497"], ["29"], ["16"], ["36"], ["49"]], "expected": [true, false, false, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false], "loose": false}

package/data/problems/perfect-rectangle.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "467", "slug": "perfect-rectangle", "id": 467, "title": "Perfect Rectangle", "difficulty": "Hard", "category": "array", "link": "https://leetcode.com/problems/perfect-rectangle/", "examples": [{"explanation": "The five small blocks tile the square from (1,1) to (4,4) without overlap.", "input": "rectangles = [[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]", "output": "true"}, {"explanation": "A hole sits where [2,1,3,4] would go, so the union is not solid.", "input": "rectangles = [[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]", "output": "false"}, {"explanation": "The last two blocks overlap on [2,2,3,3].", "input": "rectangles = [[1,1,3,3],[3,1,4,2],[1,3,2,4],[2,2,4,4]]", "output": "false"}], "hints": ["Add up all small areas and compare with the area of the min/max bounding box.", "Toggle each block corner in a set; interior corners appear an even number of times and cancel.", "At the end exactly the four extreme corners must remain."], "statement": "Each entry of `rectangles` describes one axis-aligned block by its lower-left corner `(xi, yi)` and its upper-right corner `(ai, bi)`, with `xi < ai` and `yi < bi`. Decide whether the blocks fit together perfectly: jointly they must fill some larger rectangle exactly, with no overlaps and no gaps.\n\nThat means two things must hold at once: the total covered area must equal the area of the bounding box, and the block corners must cancel out everywhere except at the four extreme corners.\n\n**Constraints:**\n- `1 <= rectangles.length <= 2 * 10^4`\n- `rectangles[i].length == 4`\n- `-10^5 <= xi < ai <= 10^5`\n- `-10^5 <= yi < bi <= 10^5`\n", "solution": "## Approach\n\nSum the areas of all small blocks and track the extreme coordinates of their union. Insert each block corner into a set, removing it when seen again, so shared interior corners cancel and only unmatched corners survive. A perfect tiling leaves exactly the four bounding-box corners and has total area equal to the bounding-box area; any gap, overlap, or stray corner breaks one of those checks.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m), where m is the number of rectangles.\n- **Space Complexity:** O(m) for the corner set.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def isRectangleCover(self, rectangles: List[List[int]]) -> bool:\n area = 0\n min_x = min_y = 10 ** 9\n max_x = max_y = -10 ** 9\n corners = set()\n for x1, y1, x2, y2 in rectangles:\n area += (x2 - x1) * (y2 - y1)\n min_x = min(min_x, x1); min_y = min(min_y, y1)\n max_x = max(max_x, x2); max_y = max(max_y, y2)\n for p in ((x1, y1), (x1, y2), (x2, y1), (x2, y2)):\n if p in corners:\n corners.remove(p)\n else:\n corners.add(p)\n if len(corners) != 4:\n return False\n if {(min_x, min_y), (min_x, max_y), (max_x, min_y), (max_x, max_y)} != corners:\n return False\n return area == (max_x - min_x) * (max_y - min_y)\n```\n", "starter": {"go": "package main\n\nfunc IsRectangleCover(rectangles [][]int) bool {\n return false\n}", "python": "from typing import List\nclass Solution:\n def isRectangleCover(self, rectangles: List[List[int]]) -> bool:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n bool isRectangleCover(vector<vector<int>>& rectangles) {\n return false;\n }\n};"}, "fn": "isRectangleCover", "params": [{"name": "rectangles", "type": "int_array_2d"}], "outputType": "boolean", "tests": [["[[1,1,3,3],[3,1,4,2],[3,2,4,4],[1,3,2,4],[2,3,3,4]]"], ["[[1,1,2,3],[1,3,2,4],[3,1,4,2],[3,2,4,4]]"], ["[[1,1,3,3],[3,1,4,2],[1,3,2,4],[2,2,4,4]]"], ["[[0,0,1,1]]"], ["[[0,0,1,1],[1,0,2,1]]"], ["[[0,0,1,1],[0,1,1,2]]"], ["[[0,0,2,2],[1,1,3,3]]"], ["[[0,0,1,1],[1,1,2,2]]"], ["[[0,0,3,1],[0,1,3,2],[0,2,3,3]]"], ["[[-1,-1,0,0],[0,-1,1,0],[-1,0,0,1],[0,0,1,1]]"], ["[[0,0,1,1],[0,0,1,1]]"], ["[[0,0,4,4],[1,1,2,2]]"], ["[[0,0,2,1],[2,0,4,1],[0,1,4,2]]"], ["[[0,0,1,2],[1,0,2,2],[0,2,2,3]]"], ["[[0,0,5,5],[1,1,4,4],[1,1,2,2]]"], ["[[-100000,-100000,100000,100000]]"], ["[[0,0,2,2],[2,0,4,2],[0,2,2,4],[2,2,4,4]]"], ["[[0,0,2,2],[1,0,3,2],[0,2,3,4]]"], ["[[1,1,2,2],[2,1,3,2],[3,1,4,2],[1,2,4,4]]"], ["[[0,0,1,1],[2,2,3,3]]"], ["[[0,0,10,1],[0,1,1,10],[1,1,10,10]]"], ["[[0,0,1,1],[1,0,2,1],[0,1,1,2],[1,1,2,2]]"], ["[[0,0,3,3],[1,1,2,2]]"], ["[[0,0,2,2],[0,2,2,3],[2,0,3,3]]"], ["[[-2,-2,2,2],[-1,-1,1,1]]"], ["[[0,0,1,3],[1,0,2,1],[1,1,2,3]]"], ["[[0,0,2,1],[0,1,1,2],[1,1,2,2]]"], ["[[5,5,8,8],[5,8,8,10],[8,5,10,10]]"], ["[[0,0,1,1],[0,1,2,2],[1,0,2,1]]"], ["[[0,0,4,1],[0,1,4,2],[0,2,4,3],[0,3,4,4]]"]], "expected": [true, false, false, true, true, true, false, false, true, true, false, false, true, true, false, true, true, false, true, false, true, true, false, true, false, true, true, true, true, true], "loose": false}

package/data/problems/perfect-squares.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "228", "slug": "perfect-squares", "id": 228, "title": "Perfect Squares", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/perfect-squares/", "examples": [{"input": "n = 12", "output": "3", "explanation": "12 = 4 + 4 + 4."}, {"input": "n = 13", "output": "2", "explanation": "13 = 4 + 9."}], "hints": ["Use dynamic programming. dp[i] = minimum number of perfect squares that sum to i.", "dp[0] = 0. For each i, try all perfect squares j*j <= i and update dp[i] = min(dp[i], dp[i - j*j] + 1)."], "statement": "You receive an integer `n`. Split it into a sum of perfect-square addends using as few addends as possible, and report that smallest achievable count.\n\nA perfect square is what you get when a whole number is multiplied by itself \u2014 the square of an integer. That makes `1`, `4`, `9`, and `16` perfect squares, whereas `3` and `11` fall outside that family.\n\n**Constraints:**\n- 1 \u2264 n \u2264 10<sup>4</sup>\n", "solution": "## Approach\n\nUse 1D dynamic programming. Let `dp[i]` be the minimum number of perfect squares that sum to `i`. Base case: `dp[0] = 0`. For each `i` from 1 to `n`, try every perfect square `j*j <= i` and update `dp[i] = min(dp[i], dp[i - j*j] + 1)`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * sqrt(n)), as for each of the n values we try up to sqrt(n) perfect squares.\n- **Space Complexity:** O(n) for the dp array.\n\n## Implementation\n\n```python\nclass Solution:\n def numSquares(self, n: int) -> int:\n dp = [n + 1] * (n + 1)\n dp[0] = 0\n for i in range(1, n + 1):\n j = 1\n while j * j <= i:\n dp[i] = min(dp[i], dp[i - j * j] + 1)\n j += 1\n return dp[n]\n```\n", "starter": {"go": "package main\n\nfunc NumSquares(n int) int {\n \n}", "python": "class Solution:\n def numSquares(self, n: int) -> int:\n ", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n int numSquares(int n) {\n \n }\n};"}, "fn": "numSquares", "params": [{"name": "n", "type": "int"}], "outputType": "int", "tests": [["12"], ["13"], ["1"], ["2"], ["3"], ["4"], ["7"], ["9"], ["10"], ["16"], ["100"], ["1000"], ["9999"], ["10000"], ["43"], ["5"], ["6"], ["8"], ["11"], ["14"], ["15"], ["17"], ["18"], ["19"], ["20"], ["24"], ["25"], ["26"], ["27"], ["28"]], "expected": [3, 2, 1, 2, 3, 1, 4, 1, 2, 1, 1, 2, 4, 1, 3, 2, 3, 2, 3, 3, 4, 2, 2, 3, 2, 3, 1, 2, 3, 4], "loose": false}

package/data/problems/permutation-in-string.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "85", "slug": "permutation-in-string", "id": 85, "title": "Permutation in String", "difficulty": "Medium", "category": "sliding-window", "link": "https://leetcode.com/problems/permutation-in-string/", "examples": [{"input": "s1 = \"ab\", s2 = \"eidbaooo\"", "output": "true", "explanation": "The substring \"ba\" is a permutation of \"ab\"."}, {"input": "s1 = \"ab\", s2 = \"eidboaoo\"", "output": "false", "explanation": "No permutation of \"ab\" appears as a contiguous substring in \"eidboaoo\"."}, {"input": "s1 = \"adc\", s2 = \"dcda\"", "output": "true", "explanation": "The substring \"cda\" is a permutation of \"adc\"."}], "hints": ["A permutation is determined by character frequencies, not character order.", "Maintain a window in s2 whose length is exactly s1.length.", "Update only the counts for the character entering and leaving the window."], "statement": "Given two nonempty lowercase strings `s1` and `s2`, return `true` if `s2` contains a contiguous substring that is a permutation of `s1`. Otherwise, return `false`.\n\nA permutation uses every character of `s1` exactly once, including duplicate characters.\n\n**Constraints:**\n\n- `1 <= s1.length, s2.length <= 10^4`\n- `s1` and `s2` contain only lowercase English letters.\n\n**Portable interface:** Implement `checkInclusion(s1, s2)` directly. The judge supplies both strings and expects a boolean result; no input parsing is required.\n", "solution": "## Approach\n\nCount how many of each lowercase letter `s1` requires, then scan `s2` with a fixed-size sliding window. When a character enters or leaves the window, update its deficit and the number of required characters still missing. A window is a permutation exactly when its length is `s1.length` and no required characters remain.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m + n), where `m` is the length of `s1` and `n` is the length of `s2`.\n- **Space Complexity:** O(1), because the frequency array always has 26 entries.\n\n## Implementation\n\n```python\nclass Solution:\n def checkInclusion(self, s1: str, s2: str) -> bool:\n if len(s1) > len(s2):\n return False\n\n needed = [0] * 26\n for char in s1:\n needed[ord(char) - ord(\"a\")] += 1\n\n remaining = len(s1)\n for right, char in enumerate(s2):\n entering = ord(char) - ord(\"a\")\n if needed[entering] > 0:\n remaining -= 1\n needed[entering] -= 1\n\n if right >= len(s1):\n leaving = ord(s2[right - len(s1)]) - ord(\"a\")\n needed[leaving] += 1\n if needed[leaving] > 0:\n remaining += 1\n\n if right + 1 >= len(s1) and remaining == 0:\n return True\n return False\n```\n", "starter": {"go": "package main\n\nfunc CheckInclusion(s1 string, s2 string) bool {\n return false\n}", "python": "class Solution:\n def checkInclusion(self, s1: str, s2: str) -> bool:\n return False\n", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n bool checkInclusion(string s1, string s2) {\n return false;\n }\n};"}, "fn": "checkInclusion", "params": [{"name": "s1", "type": "string"}, {"name": "s2", "type": "string"}], "outputType": "boolean", "tests": [["ab", "eidbaooo"], ["ab", "eidboaoo"], ["adc", "dcda"], ["a", "a"], ["a", "bbbb"], ["z", "zzzzz"], ["abc", "bbbca"], ["abc", "defgh"], ["abc", "ccccbbbbaaaa"], ["abc", "ccccbbbbaaaacba"], ["aa", "baa"], ["aa", "abab"], ["aab", "eidbaaoo"], ["aab", "aaab"], ["aab", "aba"], ["abcd", "dcba"], ["abcd", "abc"], ["abcd", "zzabdczz"], ["hello", "ooolleoooleh"], ["xyz", "afdgzyxksldfm"], ["xyz", "xy"], ["zz", "zz"], ["zz", "azbz"], ["aaa", "aaaaa"], ["aaa", "aa"], ["abb", "baba"], ["abb", "abca"], ["abcdxabcde", "abcdeabcdx"], ["abcdxabcde", "abcdeabcd"], ["qwerty", "ytrewq"], ["qwerty", "qwertx"], ["mnop", "aaaaponmaaa"], ["mnop", "mmnnoopp"], ["abcdefghijklmnopqrstuvwxyz", "zyxwvutsrqponmlkjihgfedcba"], ["abcdefghijklmnopqrstuvwxyz", "abcdefghijklmnopqrstuvwxy"], ["abcabc", "cbacba"], ["abcabc", "abcabxabc"], ["abab", "baba"], ["abab", "abba"], ["abab", "aaaaabbbbb"], ["aabbcc", "ccbbaa"], ["aabbcc", "abcabc"], ["aabbcc", "aaabbbccc"], ["leetcode", "edocteel"], ["leetcode", "leetcodx"], ["silent", "listen"], ["silent", "enlistxx"], ["aaaaab", "baaaaa"], ["aaaaab", "aaaaaaaaab"], ["abcde", "edcbaedcba"], ["@javascript:'a'.repeat(10000)", "@javascript:'a'.repeat(10000)"], ["@javascript:'a'.repeat(9998) + 'b'", "@javascript:'z' + 'a'.repeat(9998) + 'b'"]], "expected": [true, false, true, true, false, true, true, false, false, true, true, false, true, true, true, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, false, true, true, true, true, true, false, true, false, true, true, true, true, true, true, true], "loose": false}

package/data/problems/permutation-sequence.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "268", "slug": "permutation-sequence", "id": 268, "title": "Permutation Sequence", "difficulty": "Hard", "category": "math", "link": "https://leetcode.com/problems/permutation-sequence/", "examples": [{"input": "n = 3, k = 3", "output": "\"213\"", "explanation": "The orderings are 123, 132, 213, 231, 312, 321; the 3rd is 213."}, {"input": "n = 4, k = 9", "output": "\"2314\"", "explanation": "Among the 24 orderings of 1..4, the 9th in sorted order is 2314."}, {"input": "n = 3, k = 1", "output": "\"123\"", "explanation": "The first ordering is the digits in increasing order."}], "hints": ["There are (n-1)! orderings starting with each choice for the first digit, so divide (k-1) by (n-1)! to pick it.", "Convert k to 0-based, then repeatedly select index k / fact and update k = k % fact with shrinking factorials.", "Keep the remaining digits in a list and remove the chosen digit at each step."], "statement": "Consider the digits `1` through `n` arranged in increasing order. All `n!` orderings of these digits can be listed from smallest to largest in dictionary order. Given `n` and a 1-based position `k`, return the ordering that appears at that position.\n\nFor example, with `n = 3` the ordered list is `123`, `132`, `213`, `231`, `312`, `321`, so asking for `k = 3` yields `213`.\n\nDo not generate every ordering; instead decide the result one place at a time by counting how many orderings start with each remaining digit.\n\n**Constraints:**\n- `1 <= n <= 9`\n- `1 <= k <= n!`\n", "solution": "## Approach\n\nThere are (n-1)! orderings for each choice of leading digit, so the first digit is determined by dividing the 0-based rank by (n-1)!. Remove that digit, then repeat with the remainder and the next smaller factorial until all positions are fixed.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2) due to list removals, with n at most 9.\n- **Space Complexity:** O(n) for the remaining digits and factorials.\n\n## Implementation\n\n```python\nclass Solution:\n def getPermutation(self, n: int, k: int) -> str:\n digits = list(range(1, n + 1))\n fact = [1] * (n + 1)\n for i in range(1, n + 1):\n fact[i] = fact[i - 1] * i\n k -= 1\n res = []\n for i in range(n, 0, -1):\n idx = k // fact[i - 1]\n k %= fact[i - 1]\n res.append(str(digits.pop(idx)))\n return \"\".join(res)\n```\n", "starter": {"go": "package main\n\nfunc GetPermutation(n int, k int) string {\n return \"\"\n}", "python": "class Solution:\n def getPermutation(self, n: int, k: int) -> str:\n return \"\"\n", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n string getPermutation(int n, int k) {\n return \"\";\n }\n};"}, "fn": "getPermutation", "params": [{"name": "n", "type": "int"}, {"name": "k", "type": "int"}], "outputType": "string", "tests": [["3", "3"], ["4", "9"], ["3", "1"], ["1", "1"], ["2", "1"], ["2", "2"], ["3", "2"], ["3", "4"], ["3", "5"], ["3", "6"], ["4", "1"], ["4", "24"], ["4", "12"], ["4", "13"], ["5", "1"], ["5", "120"], ["5", "60"], ["5", "61"], ["5", "38"], ["6", "1"], ["6", "720"], ["6", "360"], ["7", "1"], ["7", "5040"], ["7", "2500"], ["8", "1"], ["8", "40320"], ["8", "20000"], ["9", "1"], ["9", "362880"], ["9", "100000"], ["9", "362879"]], "expected": ["213", "2314", "123", "1", "12", "21", "132", "231", "312", "321", "1234", "4321", "2431", "3124", "12345", "54321", "32541", "34125", "24153", "123456", "654321", "365421", "1234567", "7654321", "4371562", "12345678", "87654321", "48652173", "123456789", "987654321", "358926471", "987654312"], "loose": false}

package/data/problems/permutations-ii.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "209", "slug": "permutations-ii", "id": 209, "title": "Permutations II", "difficulty": "Medium", "category": "backtracking", "link": "https://leetcode.com/problems/permutations-ii/", "examples": [{"input": "nums = [1,1,2]", "output": "[[1,1,2],[1,2,1],[2,1,1]]", "explanation": "The three output arrays do not include duplicate permutations: [1,1,2] appears only once."}, {"input": "nums = [1,2,3]", "output": "[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]", "explanation": "There are six ways to order three distinct values."}], "hints": ["Sort `nums` so equal values are adjacent.", "Build the permutation one position at a time, and skip placing `nums[i]` when it equals a value already placed at that same depth in a previous branch."], "statement": "You are handed an array `nums` whose entries may repeat. List every distinct ordering of its elements, each ordering exactly once, and return the collection in whatever sequence you prefer.\n\n**Constraints:**\n\n- `1 <= nums.length <= 8`\n- `-10 <= nums[i] <= 10`\n", "solution": "## Approach\n\nSort the array first so that equal values are adjacent. Perform standard permutation backtracking, but skip a value at a given recursion depth when it equals the previous value and that previous value has not been used yet in the current branch. This rule ensures that duplicate elements are not placed at the same position across branches, so each unique permutation is produced exactly once.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * P) where P is the number of unique permutations of length n; each permutation is copied at a cost of O(n).\n- **Space Complexity:** O(n) for the recursion stack and helper data, excluding the O(n * P) output.\n\n## Implementation\n\n```python\nfrom typing import List\n\n\nclass Solution:\n def permuteUnique(self, nums: List[int]) -> List[List[int]]:\n nums.sort()\n n = len(nums)\n result: List[List[int]] = []\n used = [False] * n\n current: List[int] = []\n\n def backtrack() -> None:\n if len(current) == n:\n result.append(current.copy())\n return\n for i in range(n):\n if used[i]:\n continue\n if i > 0 and nums[i] == nums[i - 1] and not used[i - 1]:\n continue\n used[i] = True\n current.append(nums[i])\n backtrack()\n current.pop()\n used[i] = False\n\n backtrack()\n return result\n```", "starter": {"go": "package main\n\nfunc PermuteUnique(nums []int) [][]int {\n \n}", "python": "from typing import List\nclass Solution:\n def permuteUnique(self, nums: List[int]) -> List[List[int]]:\n ", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n vector<vector<int>> permuteUnique(vector<int>& nums) {\n \n }\n};"}, "fn": "permuteUnique", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int_list_2d", "tests": [["[1]"], ["[1,1,2]"], ["[1,2,3]"], ["[2,2,2]"], ["[1,2]"], ["[-1,-1]"], ["[1,1,1,1]"], ["[1,1,2,2]"], ["[-10,-5,0,5]"], ["[3,3,0,3]"], ["[1,2,2,3]"], ["[10,9,8,7]"], ["[0]"], ["[1,1]"], ["[1,2,2]"], ["[2,1,1]"], ["[1,1,1]"], ["[0,0,1]"], ["[1,1,2,3]"], ["[0,0,0]"], ["[5,5]"], ["[-10,10]"], ["[0,1,1]"], ["[2,2,3,3]"], ["[1,1,1,2]"], ["[0,0,0,1]"], ["[-1,0,1]"], ["[3,2,1,1]"], ["[10,10,10]"], ["[-5,-5,5]"]], "expected": [[[1]], [[1, 1, 2], [1, 2, 1], [2, 1, 1]], [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 1, 2], [3, 2, 1]], [[2, 2, 2]], [[1, 2], [2, 1]], [[-1, -1]], [[1, 1, 1, 1]], [[1, 1, 2, 2], [1, 2, 1, 2], [1, 2, 2, 1], [2, 1, 1, 2], [2, 1, 2, 1], [2, 2, 1, 1]], [[-10, -5, 0, 5], [-10, -5, 5, 0], [-10, 0, -5, 5], [-10, 0, 5, -5], [-10, 5, -5, 0], [-10, 5, 0, -5], [-5, -10, 0, 5], [-5, -10, 5, 0], [-5, 0, -10, 5], [-5, 0, 5, -10], [-5, 5, -10, 0], [-5, 5, 0, -10], [0, -10, -5, 5], [0, -10, 5, -5], [0, -5, -10, 5], [0, -5, 5, -10], [0, 5, -10, -5], [0, 5, -5, -10], [5, -10, -5, 0], [5, -10, 0, -5], [5, -5, -10, 0], [5, -5, 0, -10], [5, 0, -10, -5], [5, 0, -5, -10]], [[0, 3, 3, 3], [3, 0, 3, 3], [3, 3, 0, 3], [3, 3, 3, 0]], [[1, 2, 2, 3], [1, 2, 3, 2], [1, 3, 2, 2], [2, 1, 2, 3], [2, 1, 3, 2], [2, 2, 1, 3], [2, 2, 3, 1], [2, 3, 1, 2], [2, 3, 2, 1], [3, 1, 2, 2], [3, 2, 1, 2], [3, 2, 2, 1]], [[7, 8, 9, 10], [7, 8, 10, 9], [7, 9, 8, 10], [7, 9, 10, 8], [7, 10, 8, 9], [7, 10, 9, 8], [8, 7, 9, 10], [8, 7, 10, 9], [8, 9, 7, 10], [8, 9, 10, 7], [8, 10, 7, 9], [8, 10, 9, 7], [9, 7, 8, 10], [9, 7, 10, 8], [9, 8, 7, 10], [9, 8, 10, 7], [9, 10, 7, 8], [9, 10, 8, 7], [10, 7, 8, 9], [10, 7, 9, 8], [10, 8, 7, 9], [10, 8, 9, 7], [10, 9, 7, 8], [10, 9, 8, 7]], [[0]], [[1, 1]], [[1, 2, 2], [2, 1, 2], [2, 2, 1]], [[1, 1, 2], [1, 2, 1], [2, 1, 1]], [[1, 1, 1]], [[0, 0, 1], [0, 1, 0], [1, 0, 0]], [[1, 1, 2, 3], [1, 1, 3, 2], [1, 2, 1, 3], [1, 2, 3, 1], [1, 3, 1, 2], [1, 3, 2, 1], [2, 1, 1, 3], [2, 1, 3, 1], [2, 3, 1, 1], [3, 1, 1, 2], [3, 1, 2, 1], [3, 2, 1, 1]], [[0, 0, 0]], [[5, 5]], [[-10, 10], [10, -10]], [[0, 1, 1], [1, 0, 1], [1, 1, 0]], [[2, 2, 3, 3], [2, 3, 2, 3], [2, 3, 3, 2], [3, 2, 2, 3], [3, 2, 3, 2], [3, 3, 2, 2]], [[1, 1, 1, 2], [1, 1, 2, 1], [1, 2, 1, 1], [2, 1, 1, 1]], [[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]], [[-1, 0, 1], [-1, 1, 0], [0, -1, 1], [0, 1, -1], [1, -1, 0], [1, 0, -1]], [[1, 1, 2, 3], [1, 1, 3, 2], [1, 2, 1, 3], [1, 2, 3, 1], [1, 3, 1, 2], [1, 3, 2, 1], [2, 1, 1, 3], [2, 1, 3, 1], [2, 3, 1, 1], [3, 1, 1, 2], [3, 1, 2, 1], [3, 2, 1, 1]], [[10, 10, 10]], [[-5, -5, 5], [-5, 5, -5], [5, -5, -5]]], "loose": true}