offcode 0.0.0-stage → 0.1.1

package/data/problems/implement-rand10-using-rand7.json

@@ -0,0 +1 @@
+{"basic": false, "label": "535", "slug": "implement-rand10-using-rand7", "id": 535, "title": "Implement Rand10() Using Rand7()", "difficulty": "Medium", "category": "math", "link": "https://leetcode.com/problems/implement-rand10-using-rand7/", "examples": [{"input": "calls = 1", "output": "[4]", "explanation": "Any single value from 1 to 10 is acceptable; the judge only checks the range."}, {"input": "calls = 3", "output": "[7,2,9]", "explanation": "Return one independent uniform draw per requested call."}], "hints": ["Two rand7 draws combine into 49 equally likely pairs; map them to the numbers 1-40 and retry on 41-49.", "Each accepted value `r` in 1..40 converts with `(r - 1) % 10 + 1`."], "statement": "In the original form of this task you are given a uniform generator `rand7()` producing integers 1 through 7, and you must build a uniform `rand10()` producing integers 1 through 10 from it.\n\n**Offline adaptation used here:** implement `runRand10(calls)`, which returns an array of length `calls` where each entry is an integer from 1 to 10. Inside your solution you may write your own `rand7` helper (a uniform 1..7 source) and derive each draw with rejection sampling: combine two `rand7` results into a uniform value `r` in 1..49 via `r = (rand7() - 1) * 7 + rand7()`, keep it when `r <= 40` as `(r - 1) % 10 + 1`, and retry otherwise. The reference judge simulates `rand7` with a fixed seed internally.\n\nGrading checks that the returned array has exactly `calls` entries and that every entry lies in 1..10. On longer runs (`calls >= 100`) every face 1..10 must also appear at least once \u2014 a constant array passes the range check but fails coverage, so the draws must genuinely vary (distribution uniformity beyond coverage is not measured).\n\n**Constraints:**\n- `1 <= calls <= 1000`\n", "solution": "## Approach\n\nSimulate the classic rejection sampler: a private `rand7` helper draws uniform values 1..7 from a fixed-seed generator, and each `rand10` draw combines two of them into a uniform 1..49 number. Values 1..40 map evenly onto 1..10 with `(r - 1) % 10 + 1`, while 41..49 are discarded and retried, which keeps every output uniform. Repeat once per requested call.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(calls) expected time, since each draw succeeds with probability 40/49.\n- **Space Complexity:** O(calls) for the output array.\n\n## Implementation\n\n```python\nimport random\nfrom typing import List\n\nclass Solution:\n    def runRand10(self, calls: int) -> List[int]:\n        rng = random.Random(42)\n\n        def rand7() -> int:\n            return rng.randint(1, 7)\n\n        out = []\n        for _ in range(calls):\n            while True:\n                r = (rand7() - 1) * 7 + rand7()\n                if r <= 40:\n                    out.append((r - 1) % 10 + 1)\n                    break\n        return out\n```\n", "starter": {"go": "package main\n\nfunc RunRand10(calls int) []int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def runRand10(self, calls: int) -> List[int]:\n        pass", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<int> runRand10(int calls) {\n        return {};\n    }\n};"}, "fn": "runRand10", "params": [{"name": "calls", "type": "int"}], "outputType": "int_array", "tests": [["1"], ["2"], ["10"], ["50"], ["200"], ["3"], ["4"], ["5"], ["6"], ["7"], ["8"], ["9"], ["11"], ["12"], ["15"], ["20"], ["25"], ["30"], ["40"], ["60"], ["75"], ["100"], ["150"], ["300"], ["500"], ["1000"], ["13"], ["17"], ["22"], ["33"]], "expected": [[3], [10, 1], [6, 1, 1, 6, 3, 7, 10, 3, 4, 4], [8, 6, 7, 1, 2, 6, 6, 5, 1, 1, 6, 1, 10, 3, 9, 3, 6, 2, 6, 5, 9, 1, 6, 6, 7, 3, 10, 1, 9, 3, 6, 9, 10, 4, 3, 4, 10, 5, 1, 8, 4, 7, 2, 9, 5, 3, 1, 4, 1, 9], [9, 4, 1, 5, 3, 4, 6, 7, 9, 8, 8, 10, 5, 8, 2, 7, 5, 1, 7, 8, 3, 5, 9, 8, 2, 4, 1, 6, 7, 8, 10, 6, 3, 7, 2, 6, 9, 5, 2, 5, 10, 4, 6, 6, 9, 3, 8, 3, 2, 10, 7, 5, 8, 5, 3, 3, 10, 3, 9, 5, 1, 4, 3, 7, 4, 2, 4, 6, 4, 6, 5, 8, 1, 2, 5, 5, 7, 9, 9, 9, 4, 3, 10, 2, 8, 7, 2, 4, 4, 9, 8, 6, 7, 8, 9, 2, 4, 4, 7, 10, 8, 3, 10, 9, 6, 2, 5, 10, 6, 10, 3, 5, 1, 7, 1, 9, 4, 3, 9, 9, 1, 10, 8, 6, 1, 4, 5, 8, 6, 5, 6, 9, 7, 5, 9, 5, 7, 1, 1, 6, 2, 3, 1, 8, 1, 2, 10, 8, 9, 5, 1, 6, 9, 3, 1, 7, 1, 4, 3, 2, 3, 10, 9, 5, 10, 5, 1, 3, 9, 4, 5, 1, 9, 1, 9, 6, 5, 1, 6, 3, 3, 8, 1, 9, 2, 1, 6, 8, 3, 8, 6, 2, 7, 10, 7, 3, 9, 8, 1, 4], [8, 9, 2], [7, 8, 1, 2], [3, 8, 4, 3, 2], [1, 4, 8, 9, 6, 9], [6, 10, 3, 2, 7, 7, 1], [3, 8, 7, 9, 10, 3, 2, 2], [5, 3, 2, 3, 10, 2, 8, 6, 2], [2, 8, 8, 9, 6, 10, 10, 5, 4, 6, 1], [7, 2, 4, 3, 4, 6, 10, 7, 3, 1, 5, 2], [6, 9, 7, 5, 10, 6, 4, 1, 2, 1, 5, 8, 4, 4, 2], [8, 1, 1, 3, 10, 2, 10, 4, 8, 3, 5, 10, 7, 6, 1, 3, 9, 4, 10, 8], [8, 4, 1, 9, 8, 10, 9, 10, 5, 3, 1, 5, 9, 9, 2, 10, 6, 8, 10, 3, 9, 6, 9, 10, 10], [5, 9, 8, 2, 5, 7, 4, 4, 2, 6, 10, 4, 2, 8, 8, 9, 9, 7, 9, 5, 1, 6, 5, 1, 9, 6, 7, 4, 10, 9], [9, 5, 10, 4, 8, 5, 4, 3, 9, 9, 7, 7, 4, 9, 10, 8, 7, 2, 1, 8, 3, 8, 10, 4, 10, 4, 1, 5, 7, 7, 3, 9, 8, 8, 8, 5, 8, 10, 1, 7], [7, 8, 1, 2, 1, 2, 5, 9, 2, 10, 6, 9, 7, 2, 9, 5, 6, 10, 6, 6, 1, 10, 3, 1, 3, 1, 9, 2, 5, 5, 3, 7, 9, 1, 1, 5, 3, 3, 6, 1, 4, 9, 3, 1, 10, 2, 2, 10, 5, 10, 10, 2, 7, 4, 9, 5, 7, 6, 1, 3], [7, 2, 6, 10, 2, 6, 1, 2, 1, 2, 6, 10, 8, 4, 6, 2, 8, 5, 9, 2, 7, 3, 4, 6, 4, 3, 5, 3, 1, 5, 1, 7, 5, 2, 10, 7, 8, 10, 3, 10, 10, 8, 4, 6, 8, 3, 1, 7, 9, 5, 7, 10, 7, 9, 10, 6, 9, 6, 1, 2, 4, 2, 2, 10, 3, 7, 5, 9, 8, 5, 10, 3, 8, 4, 5], [8, 8, 3, 9, 4, 7, 4, 1, 10, 9, 9, 8, 5, 4, 10, 5, 5, 4, 7, 1, 9, 2, 2, 4, 9, 9, 5, 7, 5, 4, 8, 8, 8, 3, 3, 7, 8, 5, 4, 6, 8, 1, 7, 7, 4, 2, 3, 4, 6, 3, 4, 8, 2, 10, 3, 5, 10, 10, 1, 9, 10, 3, 8, 4, 7, 8, 2, 5, 2, 6, 4, 5, 8, 1, 10, 7, 5, 6, 1, 8, 10, 1, 7, 2, 3, 6, 7, 1, 1, 3, 10, 2, 8, 1, 5, 9, 10, 10, 6, 7], [9, 10, 9, 9, 7, 3, 2, 7, 6, 1, 5, 8, 4, 4, 3, 10, 3, 5, 8, 2, 8, 9, 5, 9, 6, 3, 2, 4, 1, 6, 9, 4, 4, 7, 9, 3, 1, 1, 2, 6, 6, 4, 10, 10, 5, 5, 1, 10, 3, 10, 5, 1, 10, 3, 6, 10, 9, 2, 5, 4, 7, 2, 7, 8, 9, 4, 3, 1, 7, 6, 1, 10, 8, 2, 7, 1, 5, 5, 3, 4, 8, 3, 5, 7, 6, 6, 1, 1, 9, 6, 9, 5, 5, 4, 7, 4, 1, 2, 6, 9, 9, 5, 1, 6, 1, 5, 4, 10, 5, 10, 5, 3, 2, 1, 5, 4, 9, 9, 8, 9, 2, 8, 6, 6, 7, 5, 2, 10, 2, 7, 1, 10, 9, 7, 6, 4, 10, 10, 5, 6, 10, 5, 5, 4, 4, 6, 2, 7, 4, 9], [6, 5, 7, 3, 2, 5, 1, 10, 8, 2, 2, 4, 8, 6, 6, 10, 2, 10, 4, 1, 9, 3, 8, 7, 10, 3, 6, 10, 1, 10, 9, 6, 3, 10, 3, 3, 2, 4, 6, 7, 4, 8, 3, 9, 4, 1, 6, 10, 2, 6, 2, 3, 7, 10, 4, 2, 3, 9, 4, 1, 6, 2, 7, 1, 5, 9, 1, 8, 10, 9, 6, 4, 10, 10, 9, 3, 5, 2, 7, 5, 9, 8, 5, 10, 5, 10, 10, 2, 3, 5, 9, 1, 6, 2, 2, 5, 9, 7, 9, 4, 5, 10, 3, 9, 3, 6, 9, 6, 2, 1, 9, 8, 2, 1, 3, 1, 7, 5, 9, 3, 2, 1, 3, 7, 8, 10, 5, 3, 3, 5, 3, 8, 3, 4, 6, 2, 8, 10, 5, 10, 5, 1, 9, 6, 2, 3, 10, 10, 7, 7, 10, 4, 8, 5, 10, 6, 6, 5, 4, 3, 10, 10, 7, 5, 9, 1, 10, 4, 1, 5, 9, 9, 9, 5, 10, 1, 10, 9, 9, 10, 4, 7, 6, 7, 6, 10, 10, 4, 4, 8, 6, 5, 9, 2, 9, 9, 1, 2, 10, 7, 2, 10, 6, 9, 5, 6, 3, 3, 5, 6, 4, 5, 4, 5, 10, 8, 2, 1, 10, 1, 9, 3, 10, 5, 5, 6, 3, 3, 3, 10, 10, 2, 6, 2, 1, 7, 8, 1, 5, 8, 3, 3, 2, 9, 2, 10, 7, 5, 6, 4, 7, 7, 8, 7, 5, 5, 4, 7, 2, 5, 1, 8, 10, 4, 4, 4, 9, 3, 9, 3, 5, 4, 1, 9, 7, 3, 7, 7, 7, 4, 8, 9, 1, 9, 7, 6, 5, 8, 10, 8, 5, 10, 2, 1, 6, 5, 3, 4, 1, 7], [2, 8, 7, 1, 3, 3, 2, 4, 2, 5, 1, 10, 5, 9, 5, 2, 2, 3, 6, 4, 2, 3, 2, 4, 6, 2, 2, 2, 5, 2, 4, 9, 9, 3, 10, 8, 6, 6, 2, 5, 5, 8, 10, 4, 4, 9, 1, 7, 9, 8, 4, 4, 2, 3, 1, 6, 4, 3, 6, 8, 6, 6, 3, 2, 4, 10, 3, 2, 3, 5, 9, 7, 1, 1, 7, 1, 1, 1, 2, 2, 2, 8, 4, 5, 7, 1, 10, 7, 8, 2, 7, 1, 4, 5, 9, 5, 5, 5, 7, 1, 7, 7, 10, 2, 8, 10, 9, 8, 6, 10, 8, 10, 7, 7, 3, 2, 3, 2, 8, 10, 5, 7, 6, 9, 3, 7, 8, 1, 4, 2, 8, 10, 7, 3, 9, 3, 2, 3, 10, 5, 10, 4, 9, 6, 4, 9, 3, 6, 1, 1, 4, 10, 3, 8, 7, 5, 10, 2, 9, 4, 6, 1, 9, 4, 1, 9, 10, 9, 5, 7, 8, 6, 8, 2, 7, 1, 3, 4, 3, 1, 9, 6, 5, 5, 6, 9, 1, 3, 4, 8, 7, 7, 9, 4, 9, 5, 2, 8, 7, 6, 6, 8, 9, 1, 2, 2, 5, 7, 8, 3, 5, 5, 7, 2, 1, 6, 2, 8, 7, 7, 9, 7, 10, 2, 5, 5, 5, 4, 1, 6, 10, 2, 10, 8, 3, 1, 5, 10, 1, 6, 1, 1, 9, 6, 7, 6, 5, 8, 4, 2, 4, 10, 2, 5, 3, 7, 8, 3, 9, 2, 1, 8, 4, 10, 1, 4, 8, 1, 3, 3, 1, 10, 1, 3, 2, 2, 1, 4, 4, 3, 7, 1, 9, 7, 10, 3, 8, 9, 3, 1, 10, 4, 8, 10, 4, 8, 10, 1, 5, 3, 4, 2, 4, 6, 8, 6, 10, 2, 6, 10, 8, 10, 2, 7, 10, 4, 6, 8, 2, 6, 8, 7, 3, 10, 5, 8, 6, 10, 9, 6, 2, 10, 5, 5, 1, 4, 1, 1, 8, 2, 2, 10, 9, 8, 9, 2, 6, 5, 10, 3, 7, 3, 5, 7, 2, 9, 3, 6, 5, 5, 5, 6, 1, 4, 8, 5, 8, 4, 7, 10, 3, 8, 3, 9, 8, 9, 10, 6, 2, 7, 3, 5, 9, 3, 2, 6, 10, 1, 9, 6, 7, 4, 10, 2, 2, 10, 2, 7, 7, 9, 9, 5, 6, 7, 3, 8, 1, 3, 3, 6, 6, 6, 10, 5, 1, 2, 3, 9, 1, 4, 6, 2, 3, 8, 5, 1, 10, 8, 6, 1, 4, 2, 3, 3, 5, 10, 9, 4, 7, 6, 10, 5, 8, 10, 8, 5, 2, 9, 6, 6, 6, 6, 7, 2, 3, 4, 8, 2, 8, 6, 5, 4, 9, 5, 1, 5, 2, 9, 6, 10, 10, 7, 7, 7, 7, 9, 9, 1, 7, 7, 3, 1, 1, 1, 4, 2, 10, 6, 8, 10, 4, 10, 7, 8, 2, 7, 10, 1, 3, 5], [6, 7, 6, 6, 10, 3, 7, 9, 10, 8, 6, 7, 10, 7, 8, 1, 2, 8, 8, 4, 1, 5, 9, 5, 2, 7, 2, 3, 6, 2, 8, 8, 3, 10, 10, 5, 8, 2, 2, 6, 3, 1, 10, 4, 4, 4, 6, 2, 4, 4, 4, 1, 4, 3, 1, 7, 7, 5, 7, 9, 2, 10, 2, 9, 2, 5, 3, 5, 7, 7, 4, 4, 2, 5, 8, 1, 6, 7, 8, 4, 2, 1, 5, 4, 8, 8, 1, 3, 9, 8, 9, 10, 1, 10, 4, 8, 10, 10, 3, 3, 4, 8, 6, 8, 2, 7, 2, 9, 5, 7, 7, 1, 2, 6, 4, 6, 7, 9, 10, 7, 5, 7, 5, 7, 3, 10, 2, 3, 9, 3, 5, 5, 4, 2, 7, 2, 3, 5, 1, 5, 2, 1, 2, 3, 10, 7, 10, 6, 3, 5, 10, 2, 3, 9, 6, 6, 1, 7, 8, 6, 7, 2, 1, 3, 1, 4, 3, 1, 7, 1, 1, 10, 5, 2, 10, 7, 5, 6, 10, 4, 7, 5, 7, 7, 4, 7, 7, 5, 1, 4, 1, 8, 6, 1, 5, 9, 7, 2, 9, 7, 5, 2, 6, 5, 5, 4, 8, 9, 4, 3, 4, 1, 1, 2, 6, 8, 2, 1, 5, 5, 4, 6, 6, 3, 7, 7, 4, 6, 7, 8, 10, 2, 2, 1, 2, 5, 5, 1, 5, 2, 4, 9, 2, 9, 7, 1, 5, 1, 4, 10, 1, 6, 3, 1, 6, 5, 3, 8, 8, 6, 1, 2, 3, 5, 8, 2, 5, 9, 6, 4, 6, 2, 10, 4, 5, 6, 9, 6, 8, 6, 9, 3, 3, 6, 7, 9, 6, 9, 1, 2, 3, 6, 6, 1, 7, 3, 4, 5, 1, 1, 3, 6, 8, 4, 2, 1, 10, 9, 6, 1, 6, 7, 7, 3, 10, 1, 1, 7, 10, 1, 2, 7, 6, 8, 5, 6, 3, 7, 8, 8, 7, 10, 4, 1, 6, 7, 5, 6, 5, 9, 3, 8, 6, 8, 1, 3, 8, 5, 3, 6, 10, 3, 10, 7, 7, 10, 10, 10, 5, 7, 7, 10, 9, 3, 7, 2, 8, 4, 6, 10, 6, 6, 7, 1, 8, 10, 6, 7, 9, 5, 1, 4, 7, 9, 8, 7, 4, 2, 2, 10, 1, 6, 8, 6, 3, 5, 1, 7, 6, 4, 2, 4, 4, 2, 5, 9, 8, 6, 9, 10, 9, 9, 6, 3, 3, 6, 10, 4, 3, 8, 2, 4, 3, 3, 1, 1, 1, 4, 9, 6, 6, 10, 6, 6, 9, 7, 1, 2, 2, 5, 2, 4, 5, 1, 2, 8, 2, 9, 4, 9, 3, 3, 10, 1, 9, 9, 4, 4, 6, 4, 5, 6, 6, 5, 8, 4, 4, 7, 6, 7, 1, 10, 3, 6, 10, 3, 8, 3, 9, 6, 9, 3, 6, 4, 2, 4, 4, 3, 10, 3, 10, 9, 7, 7, 5, 6, 1, 1, 2, 10, 2, 3, 4, 9, 3, 6, 6, 3, 10, 6, 1, 4, 2, 2, 3, 1, 2, 8, 6, 10, 5, 7, 7, 2, 8, 8, 4, 6, 8, 1, 8, 5, 7, 7, 2, 6, 6, 4, 4, 10, 9, 4, 9, 8, 2, 3, 9, 5, 10, 10, 9, 3, 10, 8, 8, 7, 7, 4, 6, 9, 7, 8, 8, 4, 6, 5, 1, 4, 4, 3, 1, 1, 9, 7, 2, 10, 7, 4, 3, 8, 7, 6, 5, 5, 6, 3, 2, 6, 1, 9, 2, 5, 1, 4, 8, 2, 5, 8, 9, 8, 7, 6, 4, 7, 1, 6, 1, 10, 2, 6, 4, 8, 5, 5, 7, 2, 7, 3, 10, 1, 2, 4, 10, 10, 5, 4, 4, 4, 6, 3, 4, 5, 2, 6, 5, 2, 5, 9, 2, 5, 4, 4, 2, 1, 7, 5, 9, 4, 10, 4, 2, 3, 5, 8, 3, 6, 10, 6, 5, 3, 4, 6, 1, 1, 10, 9, 5, 1, 9, 7, 9, 8, 7, 4, 6, 10, 4, 9, 6, 2, 10, 4, 6, 9, 7, 4, 4, 3, 4, 2, 6, 10, 5, 7, 10, 5, 3, 2, 6, 3, 3, 6, 6, 9, 3, 4, 8, 4, 5, 2, 9, 8, 8, 4, 6, 2, 8, 8, 10, 4, 4, 3, 3, 7, 10, 2, 5, 2, 6, 10, 9, 4, 3, 6, 5, 6, 2, 9, 7, 6, 9, 6, 9, 5, 10, 10, 2, 4, 3, 6, 2, 8, 9, 3, 9, 10, 3, 2, 8, 5, 6, 2, 5, 2, 3, 1, 4, 8, 7, 5, 6, 5, 1, 2, 7, 6, 8, 4, 5, 1, 10, 2, 5, 10, 1, 7, 10, 1, 10, 4, 2, 4, 6, 3, 4, 4, 7, 7, 10, 4, 6, 4, 1, 1, 9, 10, 3, 7, 8, 9, 1, 10, 1, 1, 10, 5, 2, 9, 9, 7, 7, 10, 4, 9, 3, 10, 10, 2, 3, 3, 8, 10, 6, 4, 5, 5, 4, 10, 6, 8, 6, 2, 9, 1, 6, 3, 10, 9, 7, 8, 2, 5, 9, 8, 10, 4, 1, 10, 9, 5, 9, 3, 3, 8, 1, 5, 3, 10, 3, 6, 2, 3, 10, 2, 4, 2, 6, 4, 7, 10, 6, 1, 2, 7, 4, 7, 5, 7, 8, 7, 7, 4, 2, 10, 9, 6, 6, 1, 7, 10, 8, 1, 2, 4, 3, 10, 8, 6, 4, 10, 8, 2, 3, 3, 2, 10, 3, 2, 10, 8, 6, 3, 10, 7, 1, 4, 9, 5, 8, 8, 4, 6, 4, 8, 5, 1, 4, 4, 7, 1, 9, 3, 10, 8, 6, 4, 7, 8, 7, 5, 3, 5, 2, 4, 5, 9, 3, 4, 6, 8, 1, 3, 5, 6, 9, 2, 10, 5, 7, 5, 6, 4, 8, 9, 3, 5, 8, 8, 7, 6, 5, 10, 6, 10, 5, 8, 3, 3, 6, 3, 1, 3, 1, 1, 4, 5, 2, 8, 4, 6], [1, 8, 4, 8, 8, 2, 4, 3, 9, 8, 6, 4, 2], [4, 9, 7, 3, 6, 9, 4, 10, 10, 4, 7, 3, 6, 8, 7, 1, 7], [2, 4, 7, 3, 2, 9, 9, 6, 7, 1, 4, 4, 9, 8, 9, 9, 9, 4, 7, 2, 8, 10], [9, 7, 3, 2, 1, 3, 5, 3, 2, 2, 3, 4, 9, 1, 1, 3, 10, 5, 6, 3, 9, 5, 8, 10, 4, 10, 8, 6, 8, 7, 9, 5, 4]], "loose": true}

package/data/problems/implement-stack-using-queues.json

@@ -0,0 +1 @@
+{"basic": false, "label": "177", "slug": "implement-stack-using-queues", "id": 177, "title": "Implement Stack using Queues", "difficulty": "Easy", "category": "stack", "link": "https://leetcode.com/problems/implement-stack-using-queues/", "examples": [{"input": "operations = [\"push\",\"push\",\"top\",\"pop\",\"empty\"], values = [1,2,0,0,0]", "output": "[2,2,0]", "explanation": "Push 1 then push 2. Top returns 2, pop removes and returns 2, then empty returns false (encoded as 0)."}, {"input": "operations = [\"push\",\"top\",\"pop\",\"empty\"], values = [1,0,0,0]", "output": "[1,1,1]", "explanation": "Push 1. Top returns 1, pop returns 1, then the stack is empty so empty returns true (encoded as 1)."}, {"input": "operations = [\"push\",\"push\",\"push\",\"pop\",\"pop\",\"top\",\"empty\"], values = [1,2,3,0,0,0,0]", "output": "[3,2,1,0]", "explanation": "Push 1, 2, 3. Pop returns 3, pop returns 2, top returns 1, and empty returns false (0) because 1 remains."}], "hints": ["Simulate a stack with two queues: on push, move all elements so the newest element is always at the front.", "Pop and top read from the front of the primary queue; empty checks whether it has no elements. Encode empty as 1 for true and 0 for false."], "statement": "Implement a last-in-first-out (LIFO) stack using only standard queue operations.\n\n`operations[i]` is one of `push`, `pop`, `top`, or `empty`. The aligned value\n`values[i]` is used only by `push`; it is ignored for every other operation.\nReturn an array containing the result of each `pop`, `top`, and `empty`\noperation, in the order those queries occur. `push` does not add anything to\nthe returned array. Encode `empty` as `1` for true and `0` for false.\n\nEvery trace is valid: `pop` and `top` are never called on an empty stack.\n\n**Constraints:**\n\n- `1 <= operations.length == values.length <= 100`\n- `operations[i]` is `push`, `pop`, `top`, or `empty`.\n- `1 <= values[i] <= 9` when `operations[i]` is `push`.\n- At most 100 calls are made in one trace.\n", "solution": "## Approach\n\nSimulate a LIFO stack with two FIFO queues. Keep all elements in `q1` with the\nmost recently pushed element at the front. To push `x`, offer `x` to the empty\n`q2`, drain every element of `q1` into `q2`, then swap the two queues. `pop`\npolls the front, `top` peeks at the front, and `empty` checks whether `q1` is\nempty (encoded as `1`/`0`). Collect outputs only for `pop`, `top`, and\n`empty`.\n\n## Complexity Analysis\n\n- **Time Complexity:** `O(m)` amortized per trace with `O(n)` work for each `push` where `n` is the current size, `O(1)` for `pop`/`top`/`empty`.\n- **Space Complexity:** `O(m)` for the two queues in the worst case.\n\n## Implementation\n\n```python\nfrom collections import deque\nfrom typing import List\n\n\nclass Solution:\n    def runStackUsingQueues(self, operations: List[str], values: List[int]) -> List[int]:\n        q1: deque[int] = deque()\n        q2: deque[int] = deque()\n        answers: List[int] = []\n        for operation, value in zip(operations, values):\n            if operation == \"push\":\n                q2.append(value)\n                while q1:\n                    q2.append(q1.popleft())\n                q1, q2 = q2, q1\n            elif operation == \"pop\":\n                answers.append(q1.popleft())\n            elif operation == \"top\":\n                answers.append(q1[0])\n            else:\n                answers.append(1 if not q1 else 0)\n        return answers\n```\n", "starter": {"go": "package main\n\nfunc RunStackUsingQueues(operations []string, values []int) []int {\n    return []int{}\n}", "python": "from typing import List\n\nclass Solution:\n    def runStackUsingQueues(self, operations: List[str], values: List[int]) -> List[int]:\n        return []\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<int> runStackUsingQueues(vector<string>& operations, vector<int>& values) {\n        return {};\n    }\n};"}, "fn": "runStackUsingQueues", "params": [{"name": "operations", "type": "string_array"}, {"name": "values", "type": "int_array"}], "outputType": "int_array", "tests": [["[\"push\",\"push\",\"top\",\"pop\",\"empty\"]", "[1,2,0,0,0]"], ["[\"push\",\"top\",\"pop\",\"empty\"]", "[1,0,0,0]"], ["[\"push\",\"push\",\"push\",\"pop\",\"pop\",\"top\",\"empty\"]", "[1,2,3,0,0,0,0]"], ["[\"push\",\"empty\",\"top\",\"pop\",\"empty\"]", "[5,0,0,0,0]"], ["[\"push\",\"pop\",\"empty\"]", "[9,0,0]"], ["[\"push\",\"push\",\"pop\",\"top\",\"pop\",\"empty\"]", "[3,7,0,0,0,0]"], ["[\"push\",\"push\",\"push\",\"push\",\"top\",\"pop\",\"top\",\"pop\",\"empty\"]", "[1,2,3,4,0,0,0,0,0]"], ["[\"push\",\"push\",\"empty\",\"pop\",\"empty\",\"push\",\"top\",\"empty\"]", "[4,5,0,0,0,6,0,0]"], ["[\"push\",\"push\",\"push\",\"push\",\"push\",\"pop\",\"pop\",\"pop\",\"pop\",\"pop\",\"empty\"]", "[9,8,7,6,5,0,0,0,0,0,0]"], ["[\"push\",\"top\",\"top\",\"pop\",\"empty\",\"push\",\"top\",\"empty\"]", "[2,0,0,0,0,8,0,0]"], ["[\"push\",\"push\",\"pop\",\"push\",\"pop\",\"pop\",\"empty\"]", "[1,9,0,2,0,0,0]"], ["[\"push\",\"push\",\"push\",\"top\",\"top\",\"pop\",\"empty\",\"pop\",\"top\",\"empty\"]", "[5,1,9,0,0,0,0,0,0,0]"], ["@javascript:JSON.stringify(Array(50).fill('push').flatMap((_,i)=>i%5===4?['push','top','pop']:['push']))", "@javascript:JSON.stringify(Array.from({length:50},(_,i)=>(i%9)+1).flatMap((v,i)=>i%5===4?[v,0,0]:[v]))"], ["@javascript:JSON.stringify([...Array(60).fill('push'),...Array(30).fill('pop'),'top','empty'])", "@javascript:JSON.stringify([...Array.from({length:60},(_,i)=>(i%9)+1),...Array(32).fill(0)])"], ["[\"push\",\"push\",\"push\",\"pop\",\"pop\",\"pop\",\"empty\"]", "[1,2,3,0,0,0,0]"], ["[\"push\",\"empty\",\"empty\",\"pop\",\"empty\"]", "[7,0,0,0,0]"], ["[\"push\",\"push\",\"top\",\"top\",\"pop\",\"top\",\"empty\"]", "[4,6,0,0,0,0,0]"], ["[\"push\",\"pop\",\"push\",\"pop\",\"empty\"]", "[3,0,5,0,0]"], ["[\"push\",\"push\",\"pop\",\"push\",\"top\",\"pop\",\"pop\",\"empty\"]", "[8,1,0,9,0,0,0,0]"], ["[\"empty\",\"push\",\"top\",\"empty\"]", "[0,2,0,0]"], ["[\"push\",\"push\",\"push\",\"empty\",\"top\",\"pop\",\"empty\"]", "[2,4,6,0,0,0,0]"], ["[\"push\",\"top\",\"push\",\"top\",\"pop\",\"pop\",\"empty\"]", "[1,0,2,0,0,0,0]"], ["[\"push\",\"push\",\"pop\",\"pop\",\"push\",\"top\",\"empty\"]", "[5,5,0,0,5,0,0]"], ["[\"push\",\"push\",\"push\",\"push\",\"pop\",\"empty\",\"pop\",\"top\",\"empty\"]", "[3,3,3,3,0,0,0,0,0]"], ["[\"push\",\"empty\",\"push\",\"empty\",\"pop\",\"top\",\"empty\"]", "[1,0,2,0,0,0,0]"], ["[\"push\",\"pop\",\"push\",\"top\",\"pop\",\"empty\",\"push\",\"empty\"]", "[6,0,4,0,0,0,7,0]"], ["[\"push\",\"push\",\"top\",\"pop\",\"push\",\"top\",\"pop\",\"pop\",\"empty\"]", "[9,1,0,0,2,0,0,0,0]"], ["[\"push\",\"push\",\"push\",\"pop\",\"push\",\"pop\",\"pop\",\"pop\",\"empty\"]", "[4,4,4,0,4,0,0,0,0]"], ["[\"empty\",\"empty\",\"push\",\"pop\",\"empty\"]", "[0,0,9,0,0]"], ["[\"push\",\"top\",\"empty\",\"pop\",\"empty\"]", "[8,0,0,0,0]"], ["[\"push\",\"push\",\"empty\",\"top\",\"pop\",\"push\",\"empty\"]", "[7,3,0,0,0,8,0]"], ["[\"push\",\"push\",\"pop\",\"empty\",\"push\",\"pop\",\"top\",\"empty\"]", "[2,8,0,0,5,0,0,0]"]], "expected": [[2, 2, 0], [1, 1, 1], [3, 2, 1, 0], [0, 5, 5, 1], [9, 1], [7, 3, 3, 1], [4, 4, 3, 3, 0], [0, 5, 0, 6, 0], [5, 6, 7, 8, 9, 1], [2, 2, 2, 1, 8, 0], [9, 2, 1, 1], [9, 9, 9, 0, 1, 5, 0], [5, 5, 1, 1, 6, 6, 2, 2, 7, 7, 3, 3, 8, 8, 4, 4, 9, 9, 5, 5], [6, 5, 4, 3, 2, 1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 9, 8, 7, 6, 5, 4, 3, 2, 1, 9, 8, 7, 6, 5, 4, 3, 0], [3, 2, 1, 1], [0, 0, 7, 1], [6, 6, 6, 4, 0], [3, 5, 1], [1, 9, 9, 8, 1], [1, 2, 0], [0, 6, 6, 0], [1, 2, 2, 1, 1], [5, 5, 5, 0], [3, 0, 3, 3, 0], [0, 0, 2, 1, 0], [6, 4, 4, 1, 0], [1, 1, 2, 2, 9, 1], [4, 4, 4, 4, 1], [1, 1, 9, 1], [8, 0, 8, 1], [0, 3, 3, 0], [8, 0, 5, 2, 0]], "loose": false}

package/data/problems/implement-trie-prefix-tree.json

@@ -0,0 +1 @@
+{"basic": false, "label": "65", "slug": "implement-trie-prefix-tree", "id": 65, "title": "Implement Trie (Prefix Tree)", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/implement-trie-prefix-tree/", "examples": [{"input": "operations = [\"Trie\",\"insert\",\"search\",\"search\",\"startsWith\",\"insert\",\"search\"]\nvalues = [\"\",\"apple\",\"apple\",\"app\",\"app\",\"app\",\"app\"]", "output": "[null,null,true,false,true,null,true]", "explanation": "After inserting 'apple', searching 'apple' returns true, searching 'app' returns false, startsWith('app') returns true. After inserting 'app', searching 'app' returns true."}, {"input": "operations = [\"Trie\",\"insert\",\"search\",\"startsWith\"]\nvalues = [\"\",\"hello\",\"hello\",\"hell\"]", "output": "[null,null,true,true]", "explanation": "After inserting 'hello', both search('hello') and startsWith('hell') return true."}], "hints": ["A Trie (prefix tree) is a tree data structure used for efficient retrieval of keys in a dataset of strings.", "Each node contains an array of child pointers (one for each character) and a boolean flag indicating whether the node marks the end of a word.", "For insert: traverse character by character, creating nodes as needed, and mark the final node as end of word.", "For search: traverse character by character; if a character is missing, return false; check the end-of-word flag at the final node.", "For startsWith: same as search but return true if the path exists, regardless of the end-of-word flag."], "statement": "A prefix tree, spoken like \"try\" and often called a trie, organizes a collection of strings so that entries sharing a beginning share structure. Typical uses include predictive text and spelling assistance.\n\nBuild a class named `Trie` supporting:\n\n- `Trie()` Creates a fresh empty structure.\n- `void insert(String word)` Adds the string `word` to the stored collection.\n- `boolean search(String word)` Reports `true` when `word` was added earlier as a complete entry, and `false` otherwise.\n- `boolean startsWith(String prefix)` Reports `true` when some previously added `word` begins with `prefix`, and `false` otherwise.\n\n**Constraints:**\n\n- `1 <= word.length, prefix.length <= 2000`\n- Both `word` and `prefix` use only lowercase English letters.\n- No more than `3 * 10^4` invocations of `insert`, `search`, and `startsWith` occur in total.\n", "solution": "## Approach\n\nA trie (prefix tree) where each node holds a map of child characters and a boolean end-of-word flag. Insert traverses character by character, creating nodes as needed. Search and startsWith traverse similarly, checking existence.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) per operation, where n is the word length.\n- **Space Complexity:** O(total number of characters inserted across all words).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Trie:\n    def __init__(self):\n        self.children = {}\n        self.is_end = False\n    def insert(self, word: str) -> None:\n        node = self\n        for c in word:\n            if c not in node.children:\n                node.children[c] = Trie()\n            node = node.children[c]\n        node.is_end = True\n    def search(self, word: str) -> bool:\n        node = self\n        for c in word:\n            if c not in node.children:\n                return False\n            node = node.children[c]\n        return node.is_end\n    def startsWith(self, prefix: str) -> bool:\n        node = self\n        for c in prefix:\n            if c not in node.children:\n                return False\n            node = node.children[c]\n        return True\nclass Solution:\n    def solve(self, operations: List[str], values: List[str]) -> List[str]:\n        result = []\n        obj = None\n        for i, op in enumerate(operations):\n            if op == \"Trie\":\n                obj = Trie()\n                result.append(\"null\")\n            elif op == \"insert\":\n                obj.insert(values[i])\n                result.append(\"null\")\n            elif op == \"search\":\n                result.append(str(obj.search(values[i])).lower())\n            elif op == \"startsWith\":\n                result.append(str(obj.startsWith(values[i])).lower())\n        return result\n```\n", "starter": {"go": "package main\n\ntype Trie struct {\n    \n}\n\nfunc Constructor() Trie {\n    return Trie{}\n}\n\nfunc (this *Trie) Insert(word string) {\n    \n}\n\nfunc (this *Trie) Search(word string) bool {\n    return false\n}\n\nfunc (this *Trie) StartsWith(prefix string) bool {\n    return false\n}", "python": "class Trie:\n    def __init__(self):\n        \n    def insert(self, word: str) -> None:\n        \n    def search(self, word: str) -> bool:\n        return False\n    def startsWith(self, prefix: str) -> bool:\n        return False", "cpp": "#include <string>\nusing namespace std;\n\nclass Trie {\npublic:\n    Trie() {\n        \n    }\n    \n    void insert(string word) {\n        \n    }\n    \n    bool search(string word) {\n        return false;\n    }\n    \n    bool startsWith(string prefix) {\n        return false;\n    }\n};"}, "fn": "solve", "params": [{"name": "operations", "type": "string_array"}, {"name": "values", "type": "string_array"}], "outputType": "string_list", "tests": [["[\"Trie\",\"insert\",\"search\",\"search\",\"startsWith\",\"insert\",\"search\"]", "[\"\",\"apple\",\"apple\",\"app\",\"app\",\"app\",\"app\"]"], ["[\"Trie\",\"insert\",\"search\",\"startsWith\"]", "[\"\",\"hello\",\"hello\",\"hell\"]"], ["[\"Trie\",\"insert\",\"search\",\"search\",\"startsWith\",\"startsWith\"]", "[\"\",\"abc\",\"abc\",\"ab\",\"a\",\"abc\"]"], ["[\"Trie\",\"search\",\"startsWith\",\"insert\",\"search\"]", "[\"\",\"key\",\"ke\",\"key\",\"key\"]"], ["[\"Trie\",\"insert\",\"search\",\"search\",\"search\",\"startsWith\"]", "[\"\",\"a\",\"a\",\"aa\",\"aaa\",\"a\"]"], ["[\"Trie\",\"insert\",\"insert\",\"insert\",\"search\",\"search\",\"search\",\"startsWith\",\"startsWith\",\"startsWith\"]", "[\"\",\"cat\",\"car\",\"card\",\"cat\",\"car\",\"card\",\"ca\",\"car\",\"dog\"]"], ["[\"Trie\",\"insert\",\"startsWith\",\"startsWith\"]", "[\"\",\"leet\",\"lee\",\"leetc\"]"], ["[\"Trie\",\"insert\",\"insert\",\"search\",\"search\",\"startsWith\"]", "[\"\",\"code\",\"cojudge\",\"code\",\"cojudge\",\"coj\"]"], ["[\"Trie\",\"insert\",\"search\"]", "[\"\",\"zebra\",\"zebra\"]"], ["[\"Trie\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"dog\", \"dog\", \"do\", \"do\", \"doggy\"]"], ["[\"Trie\", \"insert\", \"insert\", \"insert\", \"search\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"a\", \"ab\", \"abc\", \"a\", \"ab\", \"abc\", \"ab\", \"abcd\"]"], ["[\"Trie\", \"search\", \"startsWith\", \"insert\", \"search\"]", "[\"\", \"nothing\", \"pre\", \"pre\", \"pre\"]"], ["[\"Trie\", \"insert\", \"insert\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"banana\", \"band\", \"bandana\", \"band\", \"banda\", \"band\", \"banana\"]"], ["[\"Trie\", \"insert\", \"insert\", \"search\", \"startsWith\"]", "[\"\", \"test\", \"test\", \"test\", \"tes\"]"], ["[\"Trie\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\", \"startsWith\"]", "[\"\", \"xyz\", \"xy\", \"xyz\", \"x\", \"xyz\", \"xyzz\"]"], ["[\"Trie\", \"insert\", \"insert\", \"insert\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"up\", \"down\", \"left\", \"right\", \"up\", \"down\", \"l\", \"r\"]"], ["[\"Trie\", \"insert\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"algorithm\", \"algo\", \"algorithm\", \"algo\", \"algo\", \"algorithmx\"]"], ["[\"Trie\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"m\", \"m\", \"n\", \"m\", \"n\"]"], ["[\"Trie\", \"insert\", \"insert\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"s\", \"str\", \"string\", \"st\", \"str\", \"stri\", \"stringy\"]"], ["[\"Trie\", \"insert\", \"insert\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"foo\", \"bar\", \"baz\", \"foo\", \"ba\", \"ba\", \"baz\"]"], ["[\"Trie\", \"insert\", \"insert\", \"insert\", \"search\", \"search\", \"startsWith\"]", "[\"\", \"trie\", \"tried\", \"tries\", \"trie\", \"tried\", \"tri\"]"], ["[\"Trie\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"aaabbb\", \"aaabbb\", \"aaab\", \"aaa\", \"bbb\"]"], ["[\"Trie\", \"insert\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"qwerty\", \"qwert\", \"qwerty\", \"qwert\", \"qwer\", \"qwertyuiop\"]"], ["[\"Trie\", \"insert\", \"insert\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"data\", \"database\", \"datum\", \"data\", \"dat\", \"dat\", \"data\"]"], ["[\"Trie\", \"insert\", \"insert\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\", \"startsWith\"]", "[\"\", \"sun\", \"moon\", \"star\", \"sun\", \"moo\", \"s\", \"mo\", \"star\"]"], ["[\"Trie\", \"insert\", \"search\", \"startsWith\", \"search\"]", "[\"\", \"supercalifragilistic\", \"supercalifragilistic\", \"super\", \"supercali\"]"], ["[\"Trie\", \"insert\", \"search\", \"startsWith\", \"search\", \"startsWith\"]", "[\"\", \"abcdef\", \"abc\", \"abc\", \"abcdef\", \"abcdefg\"]"], ["[\"Trie\", \"insert\", \"insert\", \"search\", \"startsWith\", \"search\"]", "[\"\", \"applepie\", \"applet\", \"apple\", \"apple\", \"applepie\"]"], ["[\"Trie\", \"insert\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"go\", \"golang\", \"go\", \"golan\", \"gol\", \"golangx\"]"], ["[\"Trie\", \"insert\", \"insert\", \"insert\", \"search\", \"search\", \"startsWith\", \"startsWith\"]", "[\"\", \"alpha\", \"beta\", \"gamma\", \"alpha\", \"alph\", \"gam\", \"bet\"]"]], "expected": null, "loose": false}

package/data/problems/increasing-order-search-tree.json

@@ -0,0 +1 @@
+{"basic": false, "label": "887", "slug": "increasing-order-search-tree", "id": 887, "title": "Increasing Order Search Tree", "difficulty": "Easy", "category": "tree", "link": "https://leetcode.com/problems/increasing-order-search-tree/", "examples": [{"input": "root = [5,3,6,2,4,null,8,1,null,null,null,7,9]", "output": "[1,null,2,null,3,null,4,null,5,null,6,null,7,null,8,null,9]", "explanation": "Sorted values 1..9 relinked right-only."}, {"input": "root = [5,1,7]", "output": "[1,null,5,null,7]", "explanation": "Chain of [1,5,7]."}, {"input": "root = [1]", "output": "[1]", "explanation": "Single node unchanged."}], "hints": ["Collect values with an in-order walk, which visits a search tree in sorted order.", "Then create fresh nodes in that order, linking each as the right child of the previous one with no left children."], "statement": "Start from the root of a binary search tree. Gather its values from smallest to largest and rebuild them as a spine that leans only to the right: the tiniest value becomes the new root, each node keeps an empty left hand and points rightward to the next larger value.\n\nReturn the head of that right-leaning chain.\n\n**Constraints:**\n- `1 <= nodes in tree <= 100`\n- `0 <= Node.val <= 1000`\n", "solution": "## Approach\n\nAn in-order traversal of a search tree yields its keys from smallest to largest. Storing that order and then stitching brand-new nodes together so each node has only a right link produces exactly the requested spine. Building fresh nodes keeps the original tree untouched for the checker.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) to visit each node once and O(n) to relink.\n- **Space Complexity:** O(n) for the value list and the new chain (plus recursion depth).\n\n## Implementation\n\n```python\nclass Solution:\n    def increasingBST(self, root):\n        vals = []\n        def dfs(nd):\n            if not nd:\n                return\n            dfs(nd.left)\n            vals.append(nd.val)\n            dfs(nd.right)\n        dfs(root)\n        dummy = TreeNode(0)\n        cur = dummy\n        for v in vals:\n            cur.right = TreeNode(v)\n            cur = cur.right\n        return dummy.right\n```\n", "starter": {"go": "// Definition for a binary tree node.\n// type TreeNode struct {\n//     Val int\n//     Left *TreeNode\n//     Right *TreeNode\n// }\npackage main\n\nfunc IncreasingBST(root *TreeNode) *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 increasingBST(self, root):\n        pass", "cpp": "/*\nDefinition for a binary tree node.\nstruct TreeNode {\n    int val;\n    TreeNode *left;\n    TreeNode *right;\n    TreeNode(): val(0), left(nullptr), right(nullptr) {}\n    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}\n    TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}\n};\n*/\nclass Solution {\npublic:\n    TreeNode* increasingBST(TreeNode* root) {\n        \n    }\n};"}, "fn": "increasingBST", "params": [{"name": "root", "type": "tree_node"}], "outputType": "tree_node", "tests": [["[5,3,6,2,4,null,8,1,null,null,null,7,9]"], ["[5,1,7]"], ["[1]"], ["[2,1,3]"], ["[3,2,4,1]"], ["[10,5,15,3,7,12,20]"], ["[1,null,2]"], ["[2,null,3]"], ["[4,2,6,1,3,5,7]"], ["[5,3,8,1,4,7,9]"], ["[1,null,2,null,3]"], ["[3,null,4,null,5]"], ["[7,3,10,1,5,null,12]"], ["[2,1]"], ["[1,0]"], ["[0]"], ["[1000]"], ["[50,30,70,20,40,60,80]"], ["[8,3,10,1,6,null,14,null,null,4,7,13]"], ["[5,4,null,3,null,2,null,1]"], ["[1,null,3,2]"], ["[6,2,8,0,4,7,9,null,null,3,5]"], ["[10,1,20]"], ["[15,10,20,8,12,17,25]"], ["[3,1,4,null,2]"], ["[9,5,12,3,7,11,15]"], ["[2,null,5,4,7]"], ["[11,6,15,3,8,13,17]"]], "expected": null, "loose": false}

package/data/problems/increasing-triplet-subsequence.json

@@ -0,0 +1 @@
+{"basic": false, "label": "419", "slug": "increasing-triplet-subsequence", "id": 419, "title": "Increasing Triplet Subsequence", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/increasing-triplet-subsequence/", "examples": [{"input": "nums = [1,2,3,4,5]", "output": "true", "explanation": "The whole list climbs, so any three positions qualify."}, {"input": "nums = [5,4,3,2,1]", "output": "false", "explanation": "Every later value is smaller, blocking any climb."}, {"input": "nums = [2,1,5,0,4,6]", "output": "true", "explanation": "Values 1, 4, 6 appear in order and rise strictly."}], "hints": ["Keep the smallest value seen and the smallest valid middle value above it.", "A new value larger than the middle completes a triple; otherwise shrink the tracked pair."], "statement": "You are handed a list of integers `nums`. Determine whether it hides three positions `i < j < k` whose values climb strictly, i.e. `nums[i] < nums[j] < nums[k]`.\n\nThe three entries need not sit next to each other \u2014 only their order and values matter. Return `true` when such a triple exists and `false` otherwise.\n\n**Constraints:**\n- `1 <= nums.length <= 5 * 10^5`\n- `-2^31 <= nums[i] <= 2^31 - 1`\n", "solution": "## Approach\n\nSweep once while remembering two thresholds: the lowest value observed and the lowest second-step value above it. Each new number either lowers the first threshold, sets or lowers the second threshold, or exceeds both \u2014 the last case proves a rising triple ends here. This keeps only constant state yet detects any valid pattern.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), a single pass over the list.\n- **Space Complexity:** O(1) extra space.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def increasingTriplet(self, nums: List[int]) -> bool:\n        first = second = float(\"inf\")\n        for x in nums:\n            if x <= first:\n                first = x\n            elif x <= second:\n                second = x\n            else:\n                return True\n        return False\n```\n", "starter": {"go": "package main\n\nfunc IncreasingTriplet(nums []int) bool {\n    \n}", "python": "from typing import List\nclass Solution:\n    def increasingTriplet(self, nums: List[int]) -> bool:\n        ", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    bool increasingTriplet(vector<int>& nums) {\n        return false;\n    }\n};"}, "fn": "increasingTriplet", "params": [{"name": "nums", "type": "int_array"}], "outputType": "boolean", "tests": [["[1,2,3,4,5]"], ["[5,4,3,2,1]"], ["[2,1,5,0,4,6]"], ["[1]"], ["[1,2]"], ["[1,2,3]"], ["[3,2,1,0]"], ["[1,1,1,1]"], ["[1,2,1,2,1,2]"], ["[20,100,10,12,5,13]"], ["[5,1,5,5,2,5,4]"], ["[0,4,2,1,0,-1,-3]"], ["[-1,0,1]"], ["[1,0,0,0,10,0,0,0,100]"], ["[2,1,5,0,3]"], ["[1,5,0,4,1,3]"], ["[10,9,8,7,6,5,11]"], ["[1,2,2147483647]"], ["[-2147483648,0,2147483647]"], ["[3,1,2]"], ["[1,3,2,4]"], ["[5,4,5,4,5,4,5]"], ["[0,0,1]"], ["[1,0,2,0,3]"], ["[9,8,7,6,5,4,3,2,1,10]"], ["[1,2,3,1,2,3]"], ["[6,7,1,2,8]"]], "expected": [true, false, true, false, false, true, false, false, false, true, true, false, true, true, false, true, false, true, true, false, true, false, false, true, false, true, true], "loose": false}

package/data/problems/inorder-successor-in-bst-ii.json

@@ -0,0 +1 @@
+{"basic": false, "label": "572", "slug": "inorder-successor-in-bst-ii", "id": 572, "title": "Inorder Successor in BST II", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/inorder-successor-in-bst-ii/", "examples": [{"input": "root = [2,1,3], parents = [null,2,2], p = 1", "output": "2", "explanation": "Inorder visits 1, 2, 3, so the node after 1 holds 2."}, {"input": "root = [2,1,3], parents = [null,2,2], p = 3", "output": "-1", "explanation": "3 is the largest value, hence has no successor."}, {"input": "root = [5,3,6,2,4,null,null,1], parents = [null,5,5,3,3,2], p = 3", "output": "4", "explanation": "The inorder order is 1, 2, 3, 4, 5, 6, so 4 follows 3."}], "hints": ["Adaptation: the original Node carries left/right/parent links and the answer is a Node (or null); here links arrive as the parents string and the answer is the successor value (-1 when absent).", "Rebuild val -> parent-val links by zipping the non-null values of root with the parents entries.", "From the target: if it has a right subtree the answer is that subtree's minimum, otherwise climb parents until stepping up from a left child."], "statement": "A binary search tree stores pairwise different values with the usual ordering: everything in the left subtree is smaller than the node, everything in the right subtree is larger. In the classic follow-up each node also knows its parent, so the successor can be found from the target node alone by walking down and up.\n\n**Adaptation used here.** Parent references cannot travel through this judge's value-based interface, so the tree is passed explicitly together with its parent links: `root` is the level-order serialization (with `null` gaps, e.g. `\"[2,1,3]\"`), `parents` encodes one parent value per non-`null` entry of `root` in the same left-to-right order (`null` for the tree root), and `p` is the value of the target node. For example, `root = [2,1,3]` pairs with `parents = [null,2,2]` because nodes 1 and 3 both have parent 2. Rebuild the parent links from that pair, then answer exactly as the parent-pointer version would.\n\nGiven this encoding and a target value `p` present in the tree, return the value of the node visited straight after `p` in inorder order. Return `-1` when `p` is the largest value (or when the tree is empty / `p` is absent).\n\n**Constraints:**\n- `0 <= number of nodes <= 10^4`\n- `-10^5 <= Node.val <= 10^5`\n- All values are unique; the tree is a valid binary search tree\n- `parents` has one entry per non-null value of `root`, in matching order\n", "solution": "## Approach\n\nRebuild the parent-pointer view first: walk the tree breadth-first to list nodes in serialization order, then zip that list with the `parents` entries to obtain each node's parent value (falling back to structural parents if the encoding ever disagrees). From the target node, apply the textbook parent-pointer rule: with a right subtree the successor is its leftmost node, otherwise climb through parent links until moving up from a left child. A missing target, an empty tree, or climbing past the root all yield `-1`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) for the breadth-first rebuild plus O(h) for the successor walk, where h is the tree height.\n- **Space Complexity:** O(n) for the node and parent tables.\n\n## Implementation\n\n```python\nfrom collections import deque\n\nclass Solution:\n    def inorderSuccessor(self, root, parents: str, p: int) -> int:\n        if root is None:\n            return -1\n        bfs, by_val, structural = [], {}, {}\n        q = deque([root])\n        structural[root.val] = None\n        while q:\n            cur = q.popleft()\n            bfs.append(cur)\n            by_val[cur.val] = cur\n            if cur.left is not None:\n                structural[cur.left.val] = cur.val\n                q.append(cur.left)\n            if cur.right is not None:\n                structural[cur.right.val] = cur.val\n                q.append(cur.right)\n        if p not in by_val:\n            return -1\n        inner = parents.strip()[1:-1].strip()\n        toks = [] if not inner else [t.strip() for t in inner.split(\",\")]\n        parent_of = dict(structural)\n        if len(toks) == len(bfs):\n            parent_of = {}\n            for node, tok in zip(bfs, toks):\n                parent_of[node.val] = None if tok == \"null\" else int(tok)\n        target = by_val[p]\n        if target.right is not None:\n            cur = target.right\n            while cur.left is not None:\n                cur = cur.left\n            return cur.val\n        cur = target\n        while True:\n            pv = parent_of.get(cur.val)\n            if pv is None:\n                return -1\n            parent = by_val.get(pv)\n            if parent is None:\n                return -1\n            if parent.left is cur:\n                return parent.val\n            cur = parent\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 InorderSuccessor(root *TreeNode, parents string, p 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\nclass Solution:\n    def inorderSuccessor(self, root, parents: str, p: int) -> 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*/\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    int inorderSuccessor(TreeNode* root, string parents, int p) {\n        \n    }\n};"}, "fn": "inorderSuccessor", "params": [{"name": "root", "type": "tree_node"}, {"name": "parents", "type": "string"}, {"name": "p", "type": "int"}], "outputType": "int", "tests": [["[2,1,3]", "[null,2,2]", "1"], ["[2,1,3]", "[null,2,2]", "2"], ["[2,1,3]", "[null,2,2]", "3"], ["[5,3,6,2,4,null,null,1]", "[null,5,5,3,3,2]", "3"], ["[5,3,6,2,4,null,null,1]", "[null,5,5,3,3,2]", "1"], ["[5,3,6,2,4,null,null,1]", "[null,5,5,3,3,2]", "6"], ["[1]", "[null]", "1"], ["[]", "[]", "1"], ["[4,2,6,1,3,5,7]", "[null,4,4,2,2,6,6]", "4"], ["[4,2,6,1,3,5,7]", "[null,4,4,2,2,6,6]", "5"], ["[4,2,6,1,3,5,7]", "[null,4,4,2,2,6,6]", "7"], ["[4,2,6,1,3,5,7]", "[null,4,4,2,2,6,6]", "1"], ["[15,10,20,8,12,16,25]", "[null,15,15,10,10,20,20]", "12"], ["[15,10,20,8,12,16,25]", "[null,15,15,10,10,20,20]", "15"], ["[15,10,20,8,12,16,25]", "[null,15,15,10,10,20,20]", "25"], ["[3,1,4,null,2]", "[null,3,3,1]", "2"], ["[3,1,4,null,2]", "[null,3,3,1]", "1"], ["[3,1,4,null,2]", "[null,3,3,1]", "4"], ["[1,null,2,null,3]", "[null,1,2]", "1"], ["[1,null,2,null,3]", "[null,1,2]", "2"], ["[1,null,2,null,3]", "[null,1,2]", "3"], ["[3,null,4,null,5]", "[null,3,4]", "4"], ["[10,5,15,2,7,null,20]", "[null,10,10,5,5,15]", "7"], ["[10,5,15,2,7,null,20]", "[null,10,10,5,5,15]", "10"], ["[10,5,15,2,7,null,20]", "[null,10,10,5,5,15]", "2"], ["[8,3,10,1,6,null,14,null,null,4,7,13]", "[null,8,8,3,3,10,6,6,14]", "7"], ["[8,3,10,1,6,null,14,null,null,4,7,13]", "[null,8,8,3,3,10,6,6,14]", "13"], ["[8,3,10,1,6,null,14,null,null,4,7,13]", "[null,8,8,3,3,10,6,6,14]", "14"]], "expected": [2, 3, -1, 4, 2, -1, -1, -1, 5, 6, -1, 2, 15, 16, -1, 3, 2, -1, 2, 3, -1, 5, 10, 15, 5, 8, 14, -1], "loose": false}

package/data/problems/inorder-successor-in-bst.json

@@ -0,0 +1 @@
+{"basic": false, "label": "383", "slug": "inorder-successor-in-bst", "id": 383, "title": "Inorder Successor in BST", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/inorder-successor-in-bst/", "examples": [{"input": "root = [2,1,3], p = 1", "output": "2", "explanation": "Inorder is [1,2,3]; after 1 comes 2."}, {"input": "root = [2,1,3], p = 2", "output": "3", "explanation": "After 2 comes 3."}, {"input": "root = [2,1,3], p = 3", "output": "-1", "explanation": "3 is largest, so no successor."}], "hints": ["Adaptation: p is given as a value and the answer is the successor value, or -1 when p is largest (instead of a node/null).", "Walk down using BST order, remembering the last ancestor greater than p.", "Inorder successor is the smallest value larger than p."], "statement": "In a binary search tree, find the inorder successor of the node with value `p`.\n\n**Adaptation:** instead of node references, `p` is given as an integer value\npresent in the tree and you return the successor's value, or `-1` when `p`\nis the maximum (the original would return null). Implement\n`inorderSuccessor(root, p)`.\n\n**Constraints:**\n- `1 <= nodes <= 10^4`\n- Tree is a valid BST; `p` exists in the tree.\n", "solution": "## Approach\n\nSearch the BST for p while tracking the best successor candidate: whenever the current node exceeds p, it could be the answer so record it and go left; otherwise go right. The last recorded value is the smallest key larger than p.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(h) where h is tree height.\n- **Space Complexity:** O(1)\n\n## Implementation\n\n```python\nclass Solution:\n    def inorderSuccessor(self, root, p: int) -> int:\n        succ = -1\n        cur = root\n        while cur:\n            if p < cur.val:\n                succ = cur.val\n                cur = cur.left\n            else:\n                cur = cur.right\n        return succ\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 InorderSuccessor(root *TreeNode, p 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\nclass Solution:\n    def inorderSuccessor(self, root, p: int) -> 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    int inorderSuccessor(TreeNode* root, int p) {\n        \n    }\n};"}, "fn": "inorderSuccessor", "params": [{"name": "root", "type": "tree_node"}, {"name": "p", "type": "int"}], "outputType": "int", "tests": [["[2,1,3]", "1"], ["[2,1,3]", "2"], ["[2,1,3]", "3"], ["[5,3,6,2,4,null,null,1]", "1"], ["[5,3,6,2,4,null,null,1]", "2"], ["[5,3,6,2,4,null,null,1]", "3"], ["[5,3,6,2,4,null,null,1]", "4"], ["[5,3,6,2,4,null,null,1]", "5"], ["[5,3,6,2,4,null,null,1]", "6"], ["[1]", "1"], ["[2,1]", "1"], ["[2,1]", "2"], ["[3,1,4,null,2]", "2"], ["[3,1,4,null,2]", "1"], ["[4,2,6,1,3,5,7]", "3"], ["[4,2,6,1,3,5,7]", "7"], ["[10,5,15,3,7,12,20]", "7"], ["[10,5,15,3,7,12,20]", "15"], ["[2,null,3]", "2"], ["[5,3,6,2,4]", "4"], ["[4,2,6,1,3,5,7]", "4"], ["[4,2,6,1,3,5,7]", "5"], ["[4,2,6,1,3,5,7]", "6"], ["[15,10,20,8,12,17,25]", "10"], ["[15,10,20,8,12,17,25]", "12"], ["[15,10,20,8,12,17,25]", "25"], ["[1,null,2,null,3,null,4]", "3"], ["[5,3,8,1,4,7,9]", "8"]], "expected": [2, 3, -1, 2, 3, 4, 5, 6, -1, -1, 2, -1, 3, 2, 4, -1, 10, 20, 3, 5, 5, 6, 7, 12, 15, -1, 4, 9], "loose": false}

package/data/problems/insert-delete-getrandom-o1-duplicates-allowed.json

@@ -0,0 +1 @@
+{"basic": false, "label": "457", "slug": "insert-delete-getrandom-o1-duplicates-allowed", "id": 457, "title": "Insert Delete GetRandom O(1) - Duplicates Allowed", "difficulty": "Hard", "category": "array", "link": "https://leetcode.com/problems/insert-delete-getrandom-o1-duplicates-allowed/", "examples": [{"explanation": "The first insert of 1 is new (true); the second insert of 1 finds a copy (false); inserting 2 is new (true).", "input": "operations = [\"RandomizedCollection\",\"insert\",\"insert\",\"insert\"], values = [[],[1],[1],[2]]", "output": "[null,true,false,true]"}, {"explanation": "After two inserts of 2, each remove deletes one copy; one copy remains.", "input": "operations = [\"RandomizedCollection\",\"insert\",\"insert\",\"remove\",\"remove\"], values = [[],[2],[2],[2],[2]]", "output": "[null,true,false,true,true]"}, {"explanation": "With only 9 held, getRandom must return 9.", "input": "operations = [\"RandomizedCollection\",\"insert\",\"getRandom\"], values = [[],[9],[]]", "output": "[null,true,9]"}], "hints": ["Keep a list of values plus, per value, the set of list positions holding it.", "Insertion appends and records the new index; removal swaps the chosen index with the tail and fixes both index sets.", "Sampling draws a uniform list position; the judge accepts any held value."], "statement": "`RandomizedCollection` is a data structure that contains a collection of numbers, possibly duplicates (i.e., a multiset). It should support inserting and removing specific elements and also reporting a random element.\n\nImplement the `RandomizedCollection` class:\n\n- `RandomizedCollection()` Initializes the empty object.\n- `bool insert(int val)` Inserts an item `val` into the multiset, even if the item is already present. Returns `true` if the item is not present, `false` otherwise.\n- `bool remove(int val)` Removes an item `val` from the multiset if present. Returns `true` if the item is present, `false` otherwise. Note that if `val` has multiple occurrences, only one of them is removed.\n- `int getRandom()` Returns a random element from the current multiset. The probability of each element being returned is linearly related to the number of same values it contains (it is guaranteed that at least one element exists when this method is called).\n\nYou must implement the functions of the class such that each function works in average O(1) time complexity.\n\nThe class keeps its LeetCode name `RandomizedCollection` here (instead of `Solution`) because the judge harness reserves `Solution` for its driver; the constructor and methods match the original.\n\nGrading: `insert`/`remove` booleans are compared exactly against a reference model tracking per-value counts, and each `getRandom` output must have a remaining copy at that point. Only validity is checked \u2014 the sampling distribution is not statistically tested.\n\n**Constraints:**\n- `-2^31 <= val <= 2^31 - 1`\n- At most `2 * 10^5` calls will be made to `insert`, `remove`, and `getRandom`.\n- `getRandom` will only be called when at least one copy is held.\n", "solution": "## Approach\n\nKeep a list of values plus, per value, the set of list positions holding it. `insert` appends the value and records the new index, reporting whether no copy existed before. `remove` takes an arbitrary recorded index for the value, swaps that slot with the tail, fixes both values' index sets, and pops \u2014 deleting exactly one copy. `getRandom` draws a uniform list position, so multiplicity is respected automatically.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1) average per operation.\n- **Space Complexity:** O(n) for the list plus the per-value index sets.\n\n## Implementation\n\n```python\nimport random\nfrom collections import defaultdict\n\nclass RandomizedCollection:\n    def __init__(self):\n        self.a = []\n        self.pos = defaultdict(set)\n\n    def insert(self, val: int) -> bool:\n        fresh = len(self.pos[val]) == 0\n        self.pos[val].add(len(self.a))\n        self.a.append(val)\n        return fresh\n\n    def remove(self, val: int) -> bool:\n        if not self.pos[val]:\n            return False\n        i = next(iter(self.pos[val]))\n        self.pos[val].discard(i)\n        last = self.a[-1]\n        if i != len(self.a) - 1:\n            self.a[i] = last\n            self.pos[last].discard(len(self.a) - 1)\n            self.pos[last].add(i)\n        self.a.pop()\n        if not self.pos[val]:\n            del self.pos[val]\n        return True\n\n    def getRandom(self) -> int:\n        return random.choice(self.a)\n```\n", "starter": {"go": "package main\n\ntype RandomizedCollection struct {\n\n}\n\nfunc Constructor() RandomizedCollection {\n    return RandomizedCollection{}\n}\n\nfunc (this *RandomizedCollection) Insert(val int) bool {\n    return false\n}\n\nfunc (this *RandomizedCollection) Remove(val int) bool {\n    return false\n}\n\nfunc (this *RandomizedCollection) GetRandom() int {\n    return 0\n}\n", "python": "import random\nfrom collections import defaultdict\n\nclass RandomizedCollection:\n    def __init__(self):\n\n    def insert(self, val: int) -> bool:\n        return False\n\n    def remove(self, val: int) -> bool:\n        return False\n\n    def getRandom(self) -> int:\n        return 0\n", "cpp": "#include <vector>\n#include <unordered_map>\n#include <unordered_set>\nusing namespace std;\n\nclass RandomizedCollection {\npublic:\n    RandomizedCollection() {\n        \n    }\n\n    bool insert(int val) {\n        return false;\n    }\n\n    bool remove(int val) {\n        return false;\n    }\n\n    int getRandom() {\n        return 0;\n    }\n};"}, "fn": "solve", "params": [{"name": "operations", "type": "string_array"}, {"name": "values", "type": "int_array_2d"}], "outputType": "string_list", "tests": [["[\"RandomizedCollection\", \"insert\", \"insert\", \"insert\", \"getRandom\", \"remove\", \"getRandom\"]", "[[], [1], [1], [2], [], [1], []]"], ["[\"RandomizedCollection\", \"insert\", \"remove\", \"remove\"]", "[[], [4], [4], [4]]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"remove\"]", "[[], [2], [2], [2]]"], ["[\"RandomizedCollection\", \"insert\", \"getRandom\"]", "[[], [9], []]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"insert\", \"getRandom\"]", "[[], [5], [5], [5], []]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"remove\", \"getRandom\"]", "[[], [3], [3], [3], []]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"remove\", \"insert\", \"getRandom\"]", "[[], [1], [2], [1], [3], []]"], ["[\"RandomizedCollection\", \"remove\", \"insert\", \"getRandom\"]", "[[], [10], [10], []]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"getRandom\", \"remove\", \"getRandom\"]", "[[], [6], [7], [], [6], []]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"remove\", \"insert\", \"getRandom\"]", "[[], [-3], [-3], [-3], [5], []]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"insert\", \"remove\", \"remove\", \"getRandom\"]", "[[], [8], [8], [9], [8], [8], []]"], ["[\"RandomizedCollection\", \"remove\", \"remove\", \"insert\", \"getRandom\"]", "[[], [1], [2], [3], []]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"getRandom\"]", "[[], [7], [7], [7], [8], [8], []]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"remove\", \"remove\", \"insert\", \"getRandom\"]", "[[], [0], [0], [1], [1], [2], [2], [3], [3], [4], [4], [5], [5], [6], [6], [7], [7], [8], [8], [9], [9], [10], [10], [11], [11], [12], [12], [13], [13], [14], [14], [15], [15], [16], [16], [17], [17], [18], [18], [19], [19], [20], [20], [21], [21], [22], [22], [23], [23], [24], [24], [25], [25], [26], [26], [27], [27], [28], [28], [29], [29], [], [], [], [], [], [], [], [], [], [], [0], [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], [], [], [], [], [], [], [], [], [], [], [0], [999], [0], []]"], ["[\"RandomizedCollection\", \"remove\", \"insert\", \"getRandom\", \"insert\", \"remove\", \"getRandom\"]", "[[], [4], [0], [], [0], [6], []]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"getRandom\", \"remove\", \"insert\", \"remove\", \"insert\", \"insert\", \"getRandom\"]", "[[], [0], [0], [], [4], [1], [3], [5], [4], []]"], ["[\"RandomizedCollection\", \"insert\", \"remove\", \"getRandom\", \"getRandom\", \"remove\", \"getRandom\", \"insert\", \"insert\", \"getRandom\", \"getRandom\", \"getRandom\", \"insert\", \"insert\"]", "[[], [5], [1], [], [], [4], [], [0], [3], [], [], [], [5], [0]]"], ["[\"RandomizedCollection\", \"insert\", \"getRandom\", \"remove\", \"getRandom\", \"getRandom\", \"getRandom\", \"insert\", \"insert\"]", "[[], [1], [], [4], [], [], [], [1], [2]]"], ["[\"RandomizedCollection\", \"insert\", \"remove\", \"insert\", \"remove\", \"getRandom\", \"insert\", \"insert\", \"insert\", \"getRandom\", \"insert\", \"getRandom\", \"getRandom\"]", "[[], [1], [6], [1], [1], [], [0], [0], [0], [], [6], [], []]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"remove\", \"getRandom\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"getRandom\", \"insert\", \"insert\", \"getRandom\", \"insert\", \"getRandom\", \"insert\"]", "[[], [2], [1], [1], [], [0], [0], [2], [3], [3], [], [4], [6], [], [0], [], [0]]"], ["[\"RandomizedCollection\", \"insert\", \"insert\", \"getRandom\", \"getRandom\", \"insert\", \"getRandom\", \"remove\", \"remove\", \"getRandom\", \"insert\", \"remove\", \"getRandom\", \"getRandom\"]", "[[], [5], [6], [], [], [3], [], [5], [2], [], [2], [4], [], []]"], ["[\"RandomizedCollection\", \"remove\", \"insert\", \"insert\", \"remove\", \"getRandom\", \"insert\", \"getRandom\", \"remove\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\"]", "[[], [1], [4], [2], [0], [], [1], [], [0], [5], [5], [3], [0], [4], [0]]"], ["[\"RandomizedCollection\", \"insert\", \"getRandom\", \"remove\", \"insert\", \"remove\", \"remove\", \"remove\", \"insert\", \"getRandom\", \"getRandom\", \"getRandom\"]", "[[], [2], [], [2], [5], [5], [5], [1], [2], [], [], []]"], ["[\"RandomizedCollection\", \"insert\", \"getRandom\", \"insert\", \"remove\", \"getRandom\", \"getRandom\", \"getRandom\", \"insert\", \"remove\", \"getRandom\", \"insert\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\"]", "[[], [1], [], [5], [4], [], [], [], [5], [2], [], [1], [], [], [], []]"], ["[\"RandomizedCollection\", \"insert\", \"getRandom\", \"insert\", \"getRandom\", \"getRandom\", \"insert\", \"insert\", \"remove\", \"remove\", \"remove\", \"insert\", \"getRandom\"]", "[[], [1], [], [0], [], [], [1], [6], [2], [5], [3], [1], []]"]], "expected": null, "loose": false}

package/data/problems/insert-delete-getrandom-o1.json

@@ -0,0 +1 @@
+{"basic": false, "label": "456", "slug": "insert-delete-getrandom-o1", "id": 456, "title": "Insert Delete GetRandom O(1)", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/insert-delete-getrandom-o1/", "examples": [{"explanation": "Insert 1 and 2 (both new), then remove 1.", "input": "operations = [\"RandomizedSet\",\"insert\",\"insert\",\"remove\"], values = [[],[1],[2],[1]]", "output": "[null,true,true,true]"}, {"explanation": "Inserting 0 twice records true then false; removing the absent 1 records false.", "input": "operations = [\"RandomizedSet\",\"insert\",\"insert\",\"remove\"], values = [[],[0],[0],[1]]", "output": "[null,true,false,false]"}, {"explanation": "With only 5 in the set, getRandom must return 5; removing 5 then succeeds.", "input": "operations = [\"RandomizedSet\",\"insert\",\"getRandom\",\"remove\"], values = [[],[5],[],[5]]", "output": "[null,true,5,true]"}], "hints": ["Pair a value-to-index map with a dense list of values.", "Insert appends at the end; removal swaps the target with the last entry and pops.", "getRandom picks a uniform index; the judge accepts any current member."], "statement": "Implement the `RandomizedSet` class:\n\n- `RandomizedSet()` Initializes the `RandomizedSet` object.\n- `bool insert(int val)` Inserts an item `val` into the set if not present. Returns `true` if the item was not present, `false` otherwise.\n- `bool remove(int val)` Removes an item `val` from the set if present. Returns `true` if the item was present, `false` otherwise.\n- `int getRandom()` Returns a random element from the current set of elements (it is guaranteed that at least one element exists when this method is called). Each element must have the same probability of being returned.\n\nYou must implement the functions of the class such that each function works in average O(1) time complexity.\n\nThe class keeps its LeetCode name `RandomizedSet` here (instead of `Solution`) because the judge harness reserves `Solution` for its driver; the constructor and methods match the original.\n\nGrading: `insert`/`remove` booleans are compared exactly against a reference model, and each `getRandom` output must be a member of the live set at that point. Only validity is checked \u2014 uniformity over the set is not statistically tested.\n\n**Constraints:**\n- `-2^31 <= val <= 2^31 - 1`\n- At most `2 * 10^5` calls will be made to `insert`, `remove`, and `getRandom`.\n- `getRandom` will only be called when the set holds at least one element.\n", "solution": "## Approach\n\nPair a value-to-index map with a dense list of values. `insert` appends a new value at the end and records its index; `remove` swaps the target with the last entry, updates the moved entry's index, and pops the tail \u2014 all average O(1). `getRandom` draws a uniform list index.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1) average per operation.\n- **Space Complexity:** O(n) for the list plus the index map.\n\n## Implementation\n\n```python\nimport random\n\nclass RandomizedSet:\n    def __init__(self):\n        self.a = []\n        self.pos = {}\n\n    def insert(self, val: int) -> bool:\n        if val in self.pos:\n            return False\n        self.pos[val] = len(self.a)\n        self.a.append(val)\n        return True\n\n    def remove(self, val: int) -> bool:\n        if val not in self.pos:\n            return False\n        i = self.pos[val]\n        last = self.a[-1]\n        self.a[i] = last\n        self.pos[last] = i\n        self.a.pop()\n        del self.pos[val]\n        return True\n\n    def getRandom(self) -> int:\n        return random.choice(self.a)\n```\n", "starter": {"go": "package main\n\ntype RandomizedSet struct {\n\n}\n\nfunc Constructor() RandomizedSet {\n    return RandomizedSet{}\n}\n\nfunc (this *RandomizedSet) Insert(val int) bool {\n    return false\n}\n\nfunc (this *RandomizedSet) Remove(val int) bool {\n    return false\n}\n\nfunc (this *RandomizedSet) GetRandom() int {\n    return 0\n}\n", "python": "import random\n\nclass RandomizedSet:\n    def __init__(self):\n\n    def insert(self, val: int) -> bool:\n        return False\n\n    def remove(self, val: int) -> bool:\n        return False\n\n    def getRandom(self) -> int:\n        return 0\n", "cpp": "#include <vector>\n#include <unordered_map>\nusing namespace std;\n\nclass RandomizedSet {\npublic:\n    RandomizedSet() {\n        \n    }\n\n    bool insert(int val) {\n        return false;\n    }\n\n    bool remove(int val) {\n        return false;\n    }\n\n    int getRandom() {\n        return 0;\n    }\n};"}, "fn": "solve", "params": [{"name": "operations", "type": "string_array"}, {"name": "values", "type": "int_array_2d"}], "outputType": "string_list", "tests": [["[\"RandomizedSet\", \"insert\", \"remove\", \"insert\", \"getRandom\", \"remove\", \"insert\", \"getRandom\"]", "[[], [1], [2], [2], [], [1], [2], []]"], ["[\"RandomizedSet\", \"insert\", \"insert\", \"getRandom\"]", "[[], [5], [5], []]"], ["[\"RandomizedSet\", \"insert\", \"remove\", \"remove\"]", "[[], [3], [3], [3]]"], ["[\"RandomizedSet\", \"insert\", \"getRandom\"]", "[[], [7], []]"], ["[\"RandomizedSet\", \"insert\", \"insert\", \"remove\", \"getRandom\"]", "[[], [1], [2], [1], []]"], ["[\"RandomizedSet\", \"insert\", \"insert\", \"insert\", \"getRandom\"]", "[[], [-1], [0], [1], []]"], ["[\"RandomizedSet\", \"insert\", \"insert\", \"remove\", \"remove\", \"insert\"]", "[[], [4], [5], [4], [5], [6]]"], ["[\"RandomizedSet\", \"insert\", \"getRandom\", \"getRandom\", \"remove\"]", "[[], [9], [], [], [9]]"], ["[\"RandomizedSet\", \"remove\", \"insert\", \"getRandom\"]", "[[], [100], [100], []]"], ["[\"RandomizedSet\", \"insert\", \"remove\", \"insert\", \"remove\", \"insert\", \"getRandom\"]", "[[], [6], [6], [6], [6], [6], []]"], ["[\"RandomizedSet\", \"insert\", \"insert\", \"getRandom\", \"getRandom\"]", "[[], [2147483647], [-2147483648], [], []]"], ["[\"RandomizedSet\", \"insert\", \"getRandom\", \"insert\", \"getRandom\", \"remove\", \"getRandom\"]", "[[], [1], [], [2], [], [1], []]"], ["[\"RandomizedSet\", \"remove\", \"remove\", \"insert\", \"getRandom\"]", "[[], [1], [2], [3], []]"], ["[\"RandomizedSet\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"remove\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"insert\", \"insert\", \"remove\", \"getRandom\"]", "[[], [0], [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], [31], [32], [33], [34], [35], [36], [37], [38], [39], [40], [41], [42], [43], [44], [45], [46], [47], [48], [49], [], [], [], [], [], [], [], [], [], [], [0], [2], [4], [6], [8], [10], [12], [14], [16], [18], [20], [22], [24], [26], [28], [30], [32], [34], [36], [38], [40], [42], [44], [46], [48], [], [], [], [], [], [], [], [], [], [], [1], [1], [999], []]"], ["[\"RandomizedSet\", \"insert\", \"getRandom\", \"getRandom\", \"remove\", \"insert\", \"insert\", \"getRandom\", \"insert\", \"getRandom\", \"insert\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\"]", "[[], [1], [], [], [8], [2], [4], [], [2], [], [8], [], [], [], [], []]"], ["[\"RandomizedSet\", \"remove\", \"insert\", \"remove\", \"getRandom\", \"insert\", \"insert\", \"remove\", \"getRandom\"]", "[[], [4], [4], [2], [], [7], [8], [6], []]"], ["[\"RandomizedSet\", \"remove\", \"insert\", \"insert\", \"getRandom\", \"insert\", \"insert\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\", \"insert\"]", "[[], [1], [1], [1], [], [0], [4], [], [], [], [], [3]]"], ["[\"RandomizedSet\", \"insert\", \"remove\", \"insert\", \"insert\", \"insert\", \"insert\", \"insert\", \"remove\", \"getRandom\", \"insert\", \"insert\", \"insert\", \"getRandom\", \"getRandom\", \"getRandom\", \"getRandom\"]", "[[], [0], [4], [9], [7], [7], [1], [9], [6], [], [5], [1], [6], [], [], [], []]"], ["[\"RandomizedSet\", \"insert\", \"insert\", \"insert\", \"insert\", \"getRandom\", \"getRandom\", \"insert\", \"insert\", \"insert\", \"insert\", \"remove\"]", "[[], [1], [3], [7], [0], [], [], [3], [2], [4], [0], [0]]"], ["[\"RandomizedSet\", \"insert\", \"getRandom\", \"insert\", \"insert\", \"insert\", \"getRandom\", \"getRandom\", \"insert\", \"remove\", \"insert\", \"insert\", \"getRandom\"]", "[[], [4], [], [4], [3], [5], [], [], [6], [2], [7], [6], []]"], ["[\"RandomizedSet\", \"insert\", \"remove\", \"insert\", \"insert\", \"insert\", \"insert\", \"getRandom\"]", "[[], [9], [3], [2], [5], [1], [5], []]"], ["[\"RandomizedSet\", \"insert\", \"remove\", \"getRandom\", \"insert\", \"remove\", \"remove\", \"getRandom\", \"insert\", \"insert\", \"insert\", \"getRandom\", \"insert\"]", "[[], [2], [4], [], [6], [8], [9], [], [4], [2], [8], [], [0]]"], ["[\"RandomizedSet\", \"insert\", \"insert\", \"getRandom\", \"insert\", \"remove\", \"insert\", \"insert\", \"remove\", \"getRandom\", \"insert\", \"insert\", \"getRandom\", \"remove\", \"insert\", \"insert\", \"getRandom\"]", "[[], [5], [7], [], [9], [6], [3], [1], [3], [], [0], [9], [], [5], [7], [8], []]"], ["[\"RandomizedSet\", \"remove\", \"insert\", \"insert\", \"getRandom\", \"getRandom\", \"insert\", \"insert\", \"getRandom\", \"getRandom\", \"remove\", \"insert\", \"getRandom\", \"insert\", \"getRandom\", \"insert\"]", "[[], [3], [3], [7], [], [], [7], [4], [], [], [5], [7], [], [5], [], [1]]"], ["[\"RandomizedSet\", \"insert\", \"remove\", \"getRandom\", \"remove\", \"insert\", \"insert\"]", "[[], [4], [1], [], [7], [0], [1]]"]], "expected": null, "loose": false}

package/data/problems/insert-greatest-common-divisors-in-linked-list.json

@@ -0,0 +1 @@
+{"basic": false, "label": "245", "slug": "insert-greatest-common-divisors-in-linked-list", "id": 245, "title": "Insert Greatest Common Divisors in Linked List", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/insert-greatest-common-divisors-in-linked-list/", "examples": [{"input": "head = [18,6,10,3]", "output": "[18,6,6,2,10,1,3]", "explanation": "gcd(18,6)=6, gcd(6,10)=2, gcd(10,3)=1 are inserted between adjacent nodes."}, {"input": "head = [7]", "output": "[7]"}], "hints": ["Walk the list while keeping a pointer to the current node; while the node has a next, insert a node with value gcd(current.val, next.val) in between.", "After inserting, advance past the newly inserted node so each original adjacent pair is visited exactly once."], "statement": "You are given the first node `head` of a singly linked list whose nodes each store an integer.\n\nFor every neighboring pair in the current chain, splice in a fresh node positioned between them whose stored value equals the greatest common divisor of the two neighbors' values.\n\nHand back the head of the chain once all insertions are complete.\n\nRecall that the greatest common divisor of a pair is the biggest positive integer dividing both values without remainder.\n\n**Constraints:**\n\n- The number of nodes in the list is in the range `[1, 5000]`.\n- `1 <= Node.val <= 1000`\n", "solution": "## Approach\n\nWalk the list with a pointer `cur`. While `cur` has a next node, create a new node whose value is `gcd(cur.val, cur.next.val)`, link it between `cur` and `cur.next`, then advance `cur` past the inserted node so each original adjacent pair is processed exactly once. A list with a single node is returned unchanged.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where `n` is the number of nodes, since each pair's gcd is computed once and each gcd is O(log(max value)).\n- **Space Complexity:** O(1) besides the output nodes created.\n\n## Implementation\n\n```python\nfrom typing import Optional\nfrom math import gcd\n\n# 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 insertGreatestCommonDivisors(self, head: Optional[ListNode]) -> Optional[ListNode]:\n        cur = head\n        while cur and cur.next:\n            gcd_node = ListNode(gcd(cur.val, cur.next.val), cur.next)\n            cur.next = gcd_node\n            cur = gcd_node.next\n        return head\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 InsertGreatestCommonDivisors(head *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\nfrom typing import Optional\nclass Solution:\n    def insertGreatestCommonDivisors(self, head: Optional[ListNode]) -> Optional[ListNode]:\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* insertGreatestCommonDivisors(ListNode* head) {\n        return nullptr;\n    }\n};"}, "fn": "insertGreatestCommonDivisors", "params": [{"name": "head", "type": "list_node"}], "outputType": "list_node", "tests": [["[18,6,10,3]"], ["[7]"], ["[1,1]"], ["[2,4,8,16]"], ["[1000,500,250,125]"], ["[3,5,7,9,11]"], ["[1,2,3,4,5,6,7,8,9,10]"], ["[999]"], ["[12,18,24,36,48]"], ["[7,14,21,35,49,98]"], ["[1]"], ["[997,991,983,977]"], ["[2,3,5,8,13,21,34,55,89,144]"], ["[6, 12, 18]"], ["[5, 10]"], ["[1000, 1]"], ["[8, 12]"], ["[9, 27, 81]"], ["[4, 6]"], ["[15, 25, 35]"], ["[100, 75, 50, 25]"], ["[990, 945, 900]"], ["[11, 13]"], ["[16, 24]"], ["[30, 42, 70]"], ["[500, 750]"], ["[2, 2, 2, 2]"], ["[7, 7, 7]"], ["[36, 48, 60, 72]"], ["[101, 202, 303]"]], "expected": [[18, 6, 6, 2, 10, 1, 3], [7], [1, 1, 1], [2, 2, 4, 4, 8, 8, 16], [1000, 500, 500, 250, 250, 125, 125], [3, 1, 5, 1, 7, 1, 9, 1, 11], [1, 1, 2, 1, 3, 1, 4, 1, 5, 1, 6, 1, 7, 1, 8, 1, 9, 1, 10], [999], [12, 6, 18, 6, 24, 12, 36, 12, 48], [7, 7, 14, 7, 21, 7, 35, 7, 49, 49, 98], [1], [997, 1, 991, 1, 983, 1, 977], [2, 1, 3, 1, 5, 1, 8, 1, 13, 1, 21, 1, 34, 1, 55, 1, 89, 1, 144], [6, 6, 12, 6, 18], [5, 5, 10], [1000, 1, 1], [8, 4, 12], [9, 9, 27, 27, 81], [4, 2, 6], [15, 5, 25, 5, 35], [100, 25, 75, 25, 50, 25, 25], [990, 45, 945, 45, 900], [11, 1, 13], [16, 8, 24], [30, 6, 42, 14, 70], [500, 250, 750], [2, 2, 2, 2, 2, 2, 2], [7, 7, 7, 7, 7], [36, 12, 48, 12, 60, 12, 72], [101, 101, 202, 101, 303]], "loose": false}

package/data/problems/insert-interval.json

@@ -0,0 +1 @@
+{"basic": false, "label": "35", "slug": "insert-interval", "id": 35, "title": "Insert Interval", "difficulty": "Medium", "category": "interval", "link": "https://leetcode.com/problems/insert-interval/", "examples": [{"input": "intervals = [[1,3],[6,9]], newInterval = [2,5]", "output": "[[1,5],[6,9]]", "explanation": "[2,5] overlaps with [1,3], so they merge into [1,5]. [6,9] is unchanged."}, {"input": "intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]", "output": "[[1,2],[3,10],[12,16]]", "explanation": "[4,8] overlaps with [3,5], [6,7], and [8,10], merging into [3,10]. [1,2] and [12,16] are unchanged."}, {"input": "intervals = [], newInterval = [5,7]", "output": "[[5,7]]", "explanation": "The interval list is empty, so the result is just [[5,7]]."}], "hints": ["Walk through intervals in order: add all intervals ending before newInterval starts.", "For overlapping intervals, merge by expanding newInterval to [min(start), max(end)] until overlaps end.", "After merging, append the merged newInterval, then append the remaining intervals.", "You don't need to sort if the input is already sorted and non-overlapping."], "statement": "Insert a new interval into a list of non-overlapping, start-sorted intervals and merge if necessary.\n\n**Constraints:**\n\n- 0 \u2264 intervals.length \u2264 10^4\n- intervals[i].length == 2\n- 0 \u2264 starti \u2264 endi \u2264 10^5\n- intervals is sorted by starti in ascending order.\n- newInterval.length == 2\n- 0 \u2264 start \u2264 end \u2264 10^5\n", "solution": "## Approach\n\nLinear scan through the sorted intervals: add all intervals ending before the new interval starts, merge overlapping intervals by extending the new interval bounds, then append the merged interval and remaining intervals.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of intervals.\n- **Space Complexity:** O(n) for the output list.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:\n        res = []\n        i, n = 0, len(intervals)\n        while i < n and intervals[i][1] < newInterval[0]:\n            res.append(intervals[i])\n            i += 1\n        while i < n and intervals[i][0] <= newInterval[1]:\n            newInterval[0] = min(newInterval[0], intervals[i][0])\n            newInterval[1] = max(newInterval[1], intervals[i][1])\n            i += 1\n        res.append(newInterval)\n        while i < n:\n            res.append(intervals[i])\n            i += 1\n        return res\n```\n", "starter": {"go": "package main\n\nfunc Insert(intervals [][]int, newInterval []int) [][]int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def insert(self, intervals: List[List[int]], newInterval: List[int]) -> List[List[int]]:\n        pass\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<vector<int>> insert(vector<vector<int>>& intervals, vector<int>& newInterval) {\n        return {};\n    }\n};"}, "fn": "insert", "params": [{"name": "intervals", "type": "int_array_2d"}, {"name": "newInterval", "type": "int_array"}], "outputType": "int_array_2d", "tests": [["[[1,3],[6,9]]", "[2,5]"], ["[[1,2],[3,5],[6,7],[8,10],[12,16]]", "[4,8]"], ["[]", "[5,7]"], ["[[1,5]]", "[2,3]"], ["[[1,5]]", "[2,7]"], ["[[1,5]]", "[6,8]"], ["[[1,2],[3,4]]", "[0,0]"], ["[[1,2],[3,4]]", "[5,6]"], ["[[1,2],[3,4]]", "[2,3]"], ["[[1,4],[5,7],[8,10]]", "[2,9]"], ["[[3, 5], [7, 9]]", "[1, 2]"], ["[[3, 5], [7, 9]]", "[10, 12]"], ["[[1, 2], [5, 6], [9, 10]]", "[3, 4]"], ["[[1, 2], [5, 6], [9, 10]]", "[3, 8]"], ["[[2, 4]]", "[0, 1]"], ["[[2, 4]]", "[4, 6]"], ["[[1, 10]]", "[3, 4]"], ["[[1, 10]]", "[0, 11]"], ["[]", "[0, 0]"], ["[[5, 5]]", "[5, 5]"], ["[[1, 2], [4, 5]]", "[2, 4]"], ["[[0, 5], [10, 15], [20, 25]]", "[6, 9]"], ["[[0, 5], [10, 15], [20, 25]]", "[6, 22]"], ["[[1, 3], [4, 6], [7, 9], [10, 12]]", "[0, 13]"], ["[[10, 20]]", "[0, 5]"], ["[[10, 20]]", "[25, 30]"], ["[[1, 2], [3, 4], [5, 6]]", "[7, 8]"], ["[[100, 200], [300, 400]]", "[150, 350]"], ["[[0, 100000]]", "[50000, 60000]"], ["[[5, 10], [15, 20]]", "[11, 14]"]], "expected": [[[1, 5], [6, 9]], [[1, 2], [3, 10], [12, 16]], [[5, 7]], [[1, 5]], [[1, 7]], [[1, 5], [6, 8]], [[0, 0], [1, 2], [3, 4]], [[1, 2], [3, 4], [5, 6]], [[1, 4]], [[1, 10]], [[1, 2], [3, 5], [7, 9]], [[3, 5], [7, 9], [10, 12]], [[1, 2], [3, 4], [5, 6], [9, 10]], [[1, 2], [3, 8], [9, 10]], [[0, 1], [2, 4]], [[2, 6]], [[1, 10]], [[0, 11]], [[0, 0]], [[5, 5]], [[1, 5]], [[0, 5], [6, 9], [10, 15], [20, 25]], [[0, 5], [6, 25]], [[0, 13]], [[0, 5], [10, 20]], [[10, 20], [25, 30]], [[1, 2], [3, 4], [5, 6], [7, 8]], [[100, 400]], [[0, 100000]], [[5, 10], [11, 14], [15, 20]]], "loose": false}

package/data/problems/insert-into-a-binary-search-tree.json

@@ -0,0 +1 @@
+{"basic": false, "label": "197", "slug": "insert-into-a-binary-search-tree", "id": 197, "title": "Insert into a Binary Search Tree", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/insert-into-a-binary-search-tree/", "examples": [{"input": "root = [4,2,7,1,3], val = 5", "output": "[4,2,7,1,3,5]", "explanation": "Insert 5 as left child of 7."}, {"input": "root = [40,20,60,10,30,50,70], val = 25", "output": "[40,20,60,10,30,50,70,null,null,25]"}], "hints": ["Walk down the BST until you find a null child to attach the new node."], "statement": "You receive the `root` of a binary search tree (BST) along with an integer `val` that must be added to the structure. Produce the `root` of the tree once the addition is done. The incoming value is guaranteed absent from the starting tree.\n\nSeveral placements can preserve BST ordering; returning any tree that is a valid BST containing all old values plus the new one is acceptable.\n\n**Constraints:**\n- The number of nodes in the tree is in the range `[0, 10^4]`\n- `-10^8 <= Node.val <= 10^8`\n- All the values `Node.val` are unique\n- `-10^8 <= val <= 10^8`\n- It's guaranteed that `val` does not exist in the original BST\n", "solution": "## Approach\n\nWalk from the root: go left if `val` is smaller, right if larger, until a null child is found, then attach the new node.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(h)\n- **Space Complexity:** O(h) recursion\n\n## Implementation\n\n```python\nclass Solution:\n    def insertIntoBST(self, root, val: int):\n        if root is None:\n            return TreeNode(val)\n        if val < root.val:\n            root.left = self.insertIntoBST(root.left, val)\n        else:\n            root.right = self.insertIntoBST(root.right, val)\n        return root\n```\n", "starter": {"go": "package main\n\nfunc InsertIntoBST(root *TreeNode, val int) *TreeNode {\n    return nil\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\nclass Solution:\n    def insertIntoBST(self, root, val: 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    TreeNode* insertIntoBST(TreeNode* root, int val) {\n        return nullptr;\n    }\n};"}, "fn": "insertIntoBST", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}, {"name": "val", "type": "int"}], "outputType": "tree_node", "tests": [["[4,2,7,1,3]", "5"], ["[40,20,60,10,30,50,70]", "25"], ["[]", "1"], ["[4,2,7,1,3]", "0"], ["[4,2,7,1,3]", "8"], ["[5]", "3"], ["[5]", "7"], ["[2,1,3]", "4"], ["[10,5,15,3,7,null,18]", "12"], ["[1,null,2,null,3]", "0"], ["[8,3,10,1,6,null,14,null,null,4,7,13]", "5"], ["[8,3,10,1,6,null,14,null,null,4,7,13]", "2"], ["[1,null,2,null,3,null,4]", "5"], ["[5,3,7,2,4,6,8]", "1"], ["[5,3,7,2,4,6,8]", "9"], ["[10,5,null,3,7]", "6"], ["[10,5,null,3,7]", "12"], ["[50,30,70,20,40,60,80]", "35"], ["[50,30,70,20,40,60,80]", "90"], ["[3,1,4,null,2]", "5"], ["[3,1,4,null,2]", "0"], ["[100,50,150]", "75"], ["[100,50,150]", "25"], ["[20,10,30,null,null,null,40]", "35"], ["[20,10,30,null,null,null,40]", "5"], ["[6,2,8,0,4,7,9,null,null,3,5]", "1"], ["[15,10,20,8,12,17,25]", "13"], ["[7,3,null,1,5]", "4"], ["[7,3,null,1,5]", "6"], ["[9,4,null,2,6]", "7"]], "expected": null, "loose": false}

package/data/problems/insert-into-a-sorted-circular-linked-list.json

@@ -0,0 +1 @@
+{"basic": false, "label": "716", "slug": "insert-into-a-sorted-circular-linked-list", "id": 716, "title": "Insert into a Sorted Circular Linked List", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/insert-into-a-sorted-circular-linked-list/", "examples": [{"input": "head = [3,4,1], insertVal = 2", "output": "[3,4,1,2]", "explanation": "2 fits between 1 and 3."}, {"input": "head = [], insertVal = 1", "output": "[1]", "explanation": "Single self-loop."}, {"input": "head = [1], insertVal = 0", "output": "[1,0]", "explanation": "Ring 1 -> 0 -> 1."}], "hints": ["Adaptation: the circular ring is encoded linearly from the head; the output must start from the same head (new node only when empty).", "Walk the ring once: insert between cur and next when cur.val <= insertVal <= next.val, or at the max-to-min drop when insertVal lies outside the current span.", "If no spot matches (all values equal), insert directly after the head."], "statement": "A circular linked list is sorted when its values increase around the ring except for one drop from the maximum back to the minimum. The list is given as a linear encoding `head` that lists values in circular order starting from the current head node (for example `[3,4,1]` means `3 -> 4 -> 1 -> 3`). An empty list is `[]`.\n\nInsert a new value `insertVal` so the ring stays sorted, and return the linear encoding that starts from the original head (or the single new value when the input was empty). The head itself never changes unless the list was empty.\n\n**Constraints:**\n- `0 <= head.length <= 1000`\n- `-1000 <= Node.val, insertVal <= 1000`\n- The input ring is sorted in the circular sense.\n- The judge checks that the output starts from the same head, holds all old values plus the new one, and is circularly sorted.\n", "solution": "## Approach\n\nRebuild the ring from the linear encoding and walk it once from the given head. A new value belongs between two neighbours when it lies inside their interval, or at the single high-to-low turnover when it extends beyond the current span. Falling through the whole loop (possible only with uniform values) inserts right after the head. The resulting ring is then unwrapped into a linear chain that starts at the original head, preserving the required representation.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) for one ring traversal.\n- **Space Complexity:** O(n) for the rebuilt chain.\n\n## Implementation\n\n```python\nclass Solution:\n    def insert(self, head, insertVal: int):\n        vals = []\n        p = head\n        while p:\n            vals.append(p.val)\n            p = p.next\n        if not vals:\n            return ListNode(insertVal)\n        n = len(vals)\n        idx = None\n        for i in range(n):\n            cur = vals[i]\n            nxt = vals[(i + 1) % n]\n            if cur <= insertVal <= nxt:\n                idx = i + 1\n                break\n            if cur > nxt and (insertVal >= cur or insertVal <= nxt):\n                idx = i + 1\n                break\n        if idx is None:\n            idx = 1\n        new_vals = vals[:idx] + [insertVal] + vals[idx:]\n        dummy = ListNode(0)\n        cur = dummy\n        for v in new_vals:\n            cur.next = ListNode(v)\n            cur = cur.next\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 Insert(head *ListNode, insertVal int) *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 insert(self, head, insertVal: int):\n        pass\n", "cpp": "/*\nDefinition for singly-linked list.\nstruct ListNode {\n    int val;\n    ListNode *next;\n    ListNode(): val(0), next(nullptr) {}\n    ListNode(int x): val(x), next(nullptr) {}\n    ListNode(int x, ListNode* next): val(x), next(next) {}\n};\n*/\nclass Solution {\npublic:\n    ListNode* insert(ListNode* head, int insertVal) {\n        return nullptr;\n    }\n};"}, "fn": "insert", "params": [{"name": "head", "type": "list_node"}, {"name": "insertVal", "type": "int"}], "outputType": "list_node", "tests": [["[3,4,1]", "2"], ["[]", "1"], ["[1]", "0"], ["[1]", "2"], ["[3,3,3]", "0"], ["[3,3,3]", "3"], ["[1,2,3,4,5]", "0"], ["[1,2,3,4,5]", "6"], ["[1,2,3,4,5]", "3"], ["[5,1,2,3,4]", "0"], ["[5,1,2,3,4]", "6"], ["[2,2,2,1,2]", "2"], ["[1,3,5]", "4"], ["[1,3,5]", "0"], ["[1,3,5]", "6"], ["[3,5,1]", "4"], ["[3,5,1]", "2"], ["[1,1,1,1]", "1"], ["[2,3,4,1]", "1"], ["[2,3,4,1]", "5"], ["[10,5,6,7,8,9]", "4"], ["[10,5,6,7,8,9]", "11"], ["[-5,-3,0,2]", "-4"], ["[-5,-3,0,2]", "3"], ["[1,2]", "1"], ["[4,1,2,3]", "0"], ["[4,1,2,3]", "4"], ["[7,7,7,8,9,1,2]", "7"]], "expected": [[3, 4, 1, 2], [1], [1, 0], [1, 2], [3, 0, 3, 3], [3, 3, 3, 3], [1, 2, 3, 4, 5, 0], [1, 2, 3, 4, 5, 6], [1, 2, 3, 3, 4, 5], [5, 0, 1, 2, 3, 4], [5, 6, 1, 2, 3, 4], [2, 2, 2, 2, 1, 2], [1, 3, 4, 5], [1, 3, 5, 0], [1, 3, 5, 6], [3, 4, 5, 1], [3, 5, 1, 2], [1, 1, 1, 1, 1], [2, 3, 4, 1, 1], [2, 3, 4, 5, 1], [10, 4, 5, 6, 7, 8, 9], [10, 11, 5, 6, 7, 8, 9], [-5, -4, -3, 0, 2], [-5, -3, 0, 2, 3], [1, 1, 2], [4, 0, 1, 2, 3], [4, 4, 1, 2, 3], [7, 7, 7, 7, 8, 9, 1, 2]], "loose": false}

package/data/problems/insertion-sort-list.json

@@ -0,0 +1 @@
+{"basic": false, "label": "304", "slug": "insertion-sort-list", "id": 304, "title": "Insertion Sort List", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/insertion-sort-list/", "examples": [{"input": "head = [4,2,1,3]", "output": "[1,2,3,4]", "explanation": "Inserting 2 before 4, then 1 at the front, then 3 before 4 gives sorted order."}, {"input": "head = [-1,5,3,4,0]", "output": "[-1,0,3,4,5]", "explanation": "Each value is relocated into the growing sorted prefix."}], "hints": ["Keep a dummy head for the sorted prefix so front insertions need no special case.", "For each input node, scan from the dummy until the next value exceeds it.", "Splice the node in; because the prefix is sorted, the scan can stop early."], "statement": "Sort a singly linked list using insertion sort and return the head of the ordered list.\n\nInsertion sort builds the answer one element at a time: take the next input node, find where it belongs among the already sorted prefix, and splice it in. Repeat until no input nodes remain.\n\n**Constraints:**\n- The list holds between 1 and 5000 nodes.\n- `-5000 <= Node.val <= 5000`\n", "solution": "## Approach\n\nMaintain a dummy-headed sorted prefix. Repeatedly detach the next input node and walk the prefix until the following value would exceed it, then splice the node there. Because the prefix stays sorted, each insertion lands in the correct spot.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2) in the worst case, where n is the list length. Each insertion scans the sorted prefix.\n- **Space Complexity:** O(1) extra, rewiring nodes in place.\n\n## Implementation\n\n```python\nclass Solution:\n    def insertionSortList(self, head):\n        dummy = ListNode(-1)\n        cur = head\n        while cur:\n            nxt = cur.next\n            p = dummy\n            while p.next and p.next.val < cur.val:\n                p = p.next\n            cur.next = p.next\n            p.next = cur\n            cur = nxt\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 InsertionSortList(head *ListNode) *ListNode {\n    \n}", "python": "# Definition for singly-linked list.\n# class ListNode:\n#     def __init__(self, val=0, next=None):\n#         self.val = val\n#         self.next = next\n\nclass Solution:\n    def insertionSortList(self, head):\n        pass", "cpp": "/*\nDefinition for singly-linked list.\nstruct ListNode {\n    int val;\n    ListNode *next;\n    ListNode(): val(0), next(nullptr) {}\n    ListNode(int x): val(x), next(nullptr) {}\n    ListNode(int x, ListNode* next): val(x), next(next) {}\n};\n*/\nclass Solution {\npublic:\n    ListNode* insertionSortList(ListNode* head) {\n        \n    }\n};"}, "fn": "insertionSortList", "params": [{"name": "head", "type": "list_node"}], "outputType": "list_node", "tests": [["[4,2,1,3]"], ["[-1,5,3,4,0]"], ["[1]"], ["[2,1]"], ["[1,2,3]"], ["[3,2,1]"], ["[1,1,1]"], ["[5,4,3,2,1]"], ["[1,2,3,4,5]"], ["[0]"], ["[-1,-2,-3]"], ["[3,1,2]"], ["[2,3,1]"], ["[4,2,1,3,5,0]"], ["[10,9,8,7,6,5,4,3,2,1]"], ["[1,3,2,4,5]"], ["[5,1,4,2,3]"], ["[0,0,0,1]"], ["[1,0,0,0]"], ["[-5000,5000,0]"], ["[2,2,1,1]"], ["[7,3,9,1,5]"], ["[100,50,75,25]"], ["[1,5,3,4,2,6]"], ["[9,8]"], ["[4,4,4,4]"], ["[6,5,3,1,8,7,2,4]"], ["[-3,0,3,-2,2]"]], "expected": [[1, 2, 3, 4], [-1, 0, 3, 4, 5], [1], [1, 2], [1, 2, 3], [1, 2, 3], [1, 1, 1], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [0], [-3, -2, -1], [1, 2, 3], [1, 2, 3], [0, 1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [0, 0, 0, 1], [0, 0, 0, 1], [-5000, 0, 5000], [1, 1, 2, 2], [1, 3, 5, 7, 9], [25, 50, 75, 100], [1, 2, 3, 4, 5, 6], [8, 9], [4, 4, 4, 4], [1, 2, 3, 4, 5, 6, 7, 8], [-3, -2, 0, 2, 3]], "loose": false}

package/data/problems/integer-break.json

@@ -0,0 +1 @@
+{"basic": false, "label": "229", "slug": "integer-break", "id": 229, "title": "Integer Break", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/integer-break/", "examples": [{"input": "n = 2", "output": "1", "explanation": "2 = 1 + 1, 1 \u00d7 1 = 1."}, {"input": "n = 10", "output": "36", "explanation": "10 = 3 + 3 + 4, 3 \u00d7 3 \u00d7 4 = 36."}], "hints": ["There is a simple O(n) solution to this problem.", "You may check the breaking results of n ranging from 7 to 10 to discover the regularities."], "statement": "Take an integer `n` and express it as a sum of `k` positive integers with `k >= 2`. Among all such decompositions, make the product of the parts as large as possible.\n\nReturn that largest attainable product.\n\n**Constraints:**\n- 2 \u2264 n \u2264 58\n", "solution": "## Approach\n\nUse 1D dynamic programming. Let `dp[i]` be the maximum product obtainable by breaking `i` into a sum of at least two positive integers. Base case: `dp[1] = 1`. For each `i` from 2 to `n`, pick a first part `j` (1 <= j < i). The remaining value `i - j` can either be kept whole or broken further, so the best product using part `j` is `max(j, dp[j]) * (i - j)`. Take the maximum over all `j`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2), as for each of the n values we try up to n candidate first parts.\n- **Space Complexity:** O(n) for the dp array.\n\n## Implementation\n\n```python\nclass Solution:\n    def integerBreak(self, n: int) -> int:\n        dp = [0] * (n + 1)\n        dp[1] = 1\n        for i in range(2, n + 1):\n            for j in range(1, i):\n                dp[i] = max(dp[i], max(j, dp[j]) * (i - j))\n        return dp[n]\n```", "starter": {"go": "package main\n\nfunc IntegerBreak(n int) int {\n    \n}", "python": "class Solution:\n    def integerBreak(self, n: int) -> int:\n        ", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    int integerBreak(int n) {\n        \n    }\n};"}, "fn": "integerBreak", "params": [{"name": "n", "type": "int"}], "outputType": "int", "tests": [["2"], ["10"], ["3"], ["4"], ["5"], ["6"], ["7"], ["8"], ["9"], ["11"], ["12"], ["20"], ["50"], ["57"], ["58"], ["13"], ["14"], ["15"], ["16"], ["17"], ["18"], ["19"], ["21"], ["22"], ["25"], ["30"], ["35"], ["40"], ["45"], ["55"]], "expected": [1, 36, 2, 4, 6, 9, 12, 18, 27, 54, 81, 1458, 86093442, 1162261467, 1549681956, 108, 162, 243, 324, 486, 729, 972, 2187, 2916, 8748, 59049, 354294, 2125764, 14348907, 516560652], "loose": false}

package/data/problems/integer-replacement.json

@@ -0,0 +1 @@
+{"basic": false, "label": "472", "slug": "integer-replacement", "id": 472, "title": "Integer Replacement", "difficulty": "Medium", "category": "math", "link": "https://leetcode.com/problems/integer-replacement/", "examples": [{"explanation": "8 -> 4 -> 2 -> 1 uses three halvings.", "input": "n = 8", "output": "3"}, {"explanation": "7 -> 8 -> 4 -> 2 -> 1 beats going down first.", "input": "n = 7", "output": "4"}, {"explanation": "4 -> 2 -> 1.", "input": "n = 4", "output": "2"}], "hints": ["Halve every even value immediately.", "For odd values above 3, look at the lowest two bits: ...01 prefers decrement, ...11 prefers increment.", "Treat 3 as a special case where decrementing wins."], "statement": "Starting from a positive integer `n`, you may apply these moves: when the current value is even, halve it; when it is odd, either increment or decrement it by one. Count the fewest moves that reduce `n` to `1`.\n\nThe choice on odd values matters: sometimes going up first beats going down first, and the best local move depends on the lower bits.\n\n**Constraints:**\n- `1 <= n <= 2^31 - 1`\n\nCare is needed near the upper bound, where incrementing temporarily exceeds 32-bit range.\n", "solution": "## Approach\n\nHalve evens without choice. For an odd value, the two lowest bits decide: ending in `01` (or the special value 3) is best decreased so the result has more trailing zeros, while ending in `11` is best increased for the same reason. More trailing zeros mean more free halvings afterwards. Use a 64-bit variable so incrementing the maximum input does not overflow.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(log n) steps.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nclass Solution:\n    def integerReplacement(self, n: int) -> int:\n        x = n\n        steps = 0\n        while x != 1:\n            if x % 2 == 0:\n                x //= 2\n            elif x == 3 or x % 4 == 1:\n                x -= 1\n            else:\n                x += 1\n            steps += 1\n        return steps\n```\n", "starter": {"go": "package main\n\nfunc IntegerReplacement(n int) int {\n    return 0\n}", "python": "class Solution:\n    def integerReplacement(self, n: int) -> int:\n        pass", "cpp": "class Solution {\npublic:\n    int integerReplacement(int n) {\n        return 0;\n    }\n};"}, "fn": "integerReplacement", "params": [{"name": "n", "type": "int"}], "outputType": "int", "tests": [["8"], ["7"], ["4"], ["1"], ["2"], ["3"], ["5"], ["6"], ["9"], ["10"], ["11"], ["12"], ["15"], ["16"], ["17"], ["31"], ["32"], ["33"], ["100"], ["1000"], ["10000"], ["100000"], ["1000000"], ["2147483647"], ["2147483646"], ["2000000000"], ["123456789"], ["65535"], ["65536"], ["27"]], "expected": [3, 4, 2, 0, 1, 2, 3, 3, 4, 4, 5, 4, 5, 4, 5, 6, 5, 6, 8, 12, 16, 21, 24, 32, 32, 39, 37, 17, 16, 7], "loose": false}

package/data/problems/integer-to-english-words.json

@@ -0,0 +1 @@
+{"basic": false, "label": "372", "slug": "integer-to-english-words", "id": 372, "title": "Integer to English Words", "difficulty": "Hard", "category": "math", "link": "https://leetcode.com/problems/integer-to-english-words/", "examples": [{"input": "num = 123", "output": "\"One Hundred Twenty Three\"", "explanation": "123 reads as one hundred twenty three."}, {"input": "num = 12345", "output": "\"Twelve Thousand Three Hundred Forty Five\"", "explanation": "Split into 12 thousand and 345."}, {"input": "num = 0", "output": "\"Zero\"", "explanation": "Zero is a special case."}], "hints": ["Split the number into groups of three digits (thousands, millions, billions) and convert each group under 1000 separately.", "Handle zero alone as \"Zero\"; skip any three-digit group that equals zero so no extra scale word appears.", "Use word lists for 0-19 and tens (Twenty, Thirty, ...) plus \"Hundred\" for the sub-thousand helper."], "statement": "Convert a non-negative integer into its English words form.\n\nWrite `numberToWords(num)` that spells out `num` using words for each\nthree-digit block combined with scale names `Thousand`, `Million`, and\n`Billion`. A block that is zero is skipped (except when the whole number\nis zero, which is `\"Zero\"`). Separate words with single spaces and use no\nleading or trailing spaces.\n\n**Constraints:**\n- `0 <= num <= 2^31 - 1`\n", "solution": "## Approach\n\nBreak the number into billions, millions, thousands, and remainder blocks of three digits. Convert each non-zero block under 1000 with a helper that handles hundreds plus tens/units via lookup tables, then join the block with its scale word.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1) \u2014 at most 4 blocks of constant work.\n- **Space Complexity:** O(1) extra besides the output string.\n\n## Implementation\n\n```python\nclass Solution:\n    def numberToWords(self, num: int) -> str:\n        if num == 0:\n            return \"Zero\"\n        below20 = [\"\", \"One\", \"Two\", \"Three\", \"Four\", \"Five\", \"Six\", \"Seven\", \"Eight\", \"Nine\", \"Ten\", \"Eleven\", \"Twelve\", \"Thirteen\", \"Fourteen\", \"Fifteen\", \"Sixteen\", \"Seventeen\", \"Eighteen\", \"Nineteen\"]\n        tens = [\"\", \"\", \"Twenty\", \"Thirty\", \"Forty\", \"Fifty\", \"Sixty\", \"Seventy\", \"Eighty\", \"Ninety\"]\n\n        def helper(n: int) -> str:\n            parts = []\n            if n >= 100:\n                parts.append(below20[n // 100] + \" Hundred\")\n                n %= 100\n            if n >= 20:\n                parts.append(tens[n // 10] + (\"\" if n % 10 == 0 else \" \" + below20[n % 10]))\n            elif n > 0:\n                parts.append(below20[n])\n            return \" \".join(parts)\n\n        out = []\n        for chunk, scale in ((num // 1000000000, \"Billion\"), ((num // 1000000) % 1000, \"Million\"), ((num // 1000) % 1000, \"Thousand\")):\n            if chunk:\n                out.append(helper(chunk) + \" \" + scale)\n        if num % 1000:\n            out.append(helper(num % 1000))\n        return \" \".join(out)\n```\n", "starter": {"go": "package main\n\nfunc NumberToWords(num int) string {\n    \n}", "python": "class Solution:\n    def numberToWords(self, num: int) -> str:\n        pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    string numberToWords(int num) {\n        return \"\";\n    }\n};"}, "fn": "numberToWords", "params": [{"name": "num", "type": "int"}], "outputType": "string", "tests": [["0"], ["5"], ["13"], ["20"], ["21"], ["58"], ["99"], ["100"], ["101"], ["110"], ["115"], ["123"], ["1000"], ["1001"], ["1010"], ["1100"], ["1234"], ["12345"], ["100000"], ["1000010"], ["1234567"], ["1000000"], ["10000000"], ["1000000000"], ["1234567891"], ["2147483647"], ["20"], ["10000"]], "expected": ["Zero", "Five", "Thirteen", "Twenty", "Twenty One", "Fifty Eight", "Ninety Nine", "One Hundred", "One Hundred One", "One Hundred Ten", "One Hundred Fifteen", "One Hundred Twenty Three", "One Thousand", "One Thousand One", "One Thousand Ten", "One Thousand One Hundred", "One Thousand Two Hundred Thirty Four", "Twelve Thousand Three Hundred Forty Five", "One Hundred Thousand", "One Million Ten", "One Million Two Hundred Thirty Four Thousand Five Hundred Sixty Seven", "One Million", "Ten Million", "One Billion", "One Billion Two Hundred Thirty Four Million Five Hundred Sixty Seven Thousand Eight Hundred Ninety One", "Two Billion One Hundred Forty Seven Million Four Hundred Eighty Three Thousand Six Hundred Forty Seven", "Twenty", "Ten Thousand"], "loose": false}

package/data/problems/integer-to-roman.json

@@ -0,0 +1 @@
+{"basic": false, "label": "254", "slug": "integer-to-roman", "id": 254, "title": "Integer to Roman", "difficulty": "Medium", "category": "hash-table", "link": "https://leetcode.com/problems/integer-to-roman/", "examples": [{"input": "num = 3749", "output": "\"MMMDCCXLIX\"", "explanation": "3000 = MMM, 700 = DCC, 40 = XL, and 9 = IX."}, {"input": "num = 58", "output": "\"LVIII\"", "explanation": "50 = L, 5 = V, and 3 = III."}, {"input": "num = 1994", "output": "\"MCMXCIV\"", "explanation": "1000 = M, 900 = CM, 90 = XC, and 4 = IV."}], "hints": ["List the 13 values (including the six subtractive pairs) from largest to smallest and greedily take each while it fits.", "Because the table is fixed and tiny, the whole conversion is effectively constant time."], "statement": "Seven symbols form the basis of Roman numerals: `I` (1), `V` (5), `X` (10), `L` (50), `C` (100), `D` (500), and `M` (1000). Larger values are written from the biggest place value down to the smallest, using these composition rules:\n\n- Otherwise, repeatedly take the largest symbol value that fits into what remains, append its symbol, and subtract.\n- The amounts 4, 9, 40, 90, 400, and 900 use subtractive pairs instead: `IV`, `IX`, `XL`, `XC`, `CD`, and `CM`.\n- The symbols `I`, `X`, `C`, and `M` may repeat at most three times in a row; `V`, `L`, and `D` are never repeated.\n\nGiven an integer `num`, produce its Roman numeral string.\n\n**Constraints:**\n- `1 <= num <= 3999`\n", "solution": "## Approach\n\nPair each of the 13 usable values (the seven symbols plus the six subtractive forms) with its text, ordered from largest to smallest. Repeatedly append the biggest value that still fits and subtract it from the remainder until nothing is left. Greedy works here because every Roman value is a canonical building block of the ones below it.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1), since `num <= 3999` bounds the output to at most 15 characters.\n- **Space Complexity:** O(1) besides the output string.\n\n## Implementation\n\n```python\nclass Solution:\n    def intToRoman(self, num: int) -> str:\n        table = [(1000, \"M\"), (900, \"CM\"), (500, \"D\"), (400, \"CD\"),\n                 (100, \"C\"), (90, \"XC\"), (50, \"L\"), (40, \"XL\"),\n                 (10, \"X\"), (9, \"IX\"), (5, \"V\"), (4, \"IV\"), (1, \"I\")]\n        out = []\n        for value, sym in table:\n            while num >= value:\n                out.append(sym)\n                num -= value\n        return \"\".join(out)\n```\n", "starter": {"go": "package main\n\nfunc IntToRoman(num int) string {\n    \n}", "python": "class Solution:\n    def intToRoman(self, num: int) -> str:\n        pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    string intToRoman(int num) {\n        return \"\";\n    }\n};"}, "fn": "intToRoman", "params": [{"name": "num", "type": "int"}], "outputType": "string", "tests": [["1"], ["2"], ["3"], ["4"], ["5"], ["6"], ["9"], ["10"], ["11"], ["14"], ["19"], ["40"], ["44"], ["49"], ["50"], ["58"], ["90"], ["94"], ["99"], ["100"], ["400"], ["444"], ["500"], ["900"], ["999"], ["1000"], ["1994"], ["2026"], ["3000"], ["3749"], ["3999"]], "expected": ["I", "II", "III", "IV", "V", "VI", "IX", "X", "XI", "XIV", "XIX", "XL", "XLIV", "XLIX", "L", "LVIII", "XC", "XCIV", "XCIX", "C", "CD", "CDXLIV", "D", "CM", "CMXCIX", "M", "MCMXCIV", "MMXXVI", "MMM", "MMMDCCXLIX", "MMMCMXCIX"], "loose": false}

package/data/problems/interleaving-string.json

@@ -0,0 +1 @@
+{"basic": false, "label": "132", "slug": "interleaving-string", "id": 132, "title": "Interleaving String", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/interleaving-string/", "examples": [{"input": "s1 = \"aabcc\", s2 = \"dbbca\", s3 = \"aadbbcbcac\"", "output": "true", "explanation": "\"aadbbcbcac\" can be formed by interleaving the characters of \"aabcc\" and \"dbbca\" in order."}, {"input": "s1 = \"aabcc\", s2 = \"dbbca\", s3 = \"aadbbbaccc\"", "output": "false", "explanation": "\"aadbbbaccc\" cannot be formed by interleaving \"aabcc\" and \"dbbca\"."}, {"input": "s1 = \"\", s2 = \"\", s3 = \"\"", "output": "true", "explanation": "Empty strings can always be interleaved to form an empty string."}], "hints": ["First reject inputs whose lengths do not add up.", "Use dp[j] to represent whether prefixes of s1 and s2 can form the corresponding prefix of s3."], "statement": "Given strings `s1`, `s2`, and `s3`, return `true` if `s3` is formed by interleaving\n`s1` and `s2`, or `false` otherwise.\n\nAn interleaving uses every character from `s1` and `s2` exactly once while preserving\nthe left-to-right order of characters from each source string.\n\n**Constraints:**\n- `0 <= s1.length, s2.length <= 100`\n- `0 <= s3.length <= 200`\n- All strings contain only lowercase English letters.\n", "solution": "## Approach\n\nFirst reject any input whose lengths cannot add up. Let `possible[j]` indicate whether\nthe current prefix of `s1` together with the first `j` characters of `s2` forms the\ncorresponding prefix of `s3`. Each state can consume its next character from either\nsource while preserving both source orders.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n), where `m = len(s1)` and `n = len(s2)`.\n- **Space Complexity:** O(n).\n\n## Implementation\n\n```python\nclass Solution:\n    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:\n        if len(s1) + len(s2) != len(s3):\n            return False\n\n        possible = [False] * (len(s2) + 1)\n        possible[0] = True\n        for j in range(1, len(s2) + 1):\n            possible[j] = possible[j - 1] and s2[j - 1] == s3[j - 1]\n        for i in range(1, len(s1) + 1):\n            possible[0] = possible[0] and s1[i - 1] == s3[i - 1]\n            for j in range(1, len(s2) + 1):\n                next_char = s3[i + j - 1]\n                possible[j] = (\n                    possible[j] and s1[i - 1] == next_char\n                ) or (\n                    possible[j - 1] and s2[j - 1] == next_char\n                )\n        return possible[-1]\n```\n", "starter": {"go": "package main\n\nfunc IsInterleave(s1 string, s2 string, s3 string) bool {\n    return false\n}", "python": "class Solution:\n    def isInterleave(self, s1: str, s2: str, s3: str) -> bool:\n        return False\n", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    bool isInterleave(string s1, string s2, string s3) {\n        return false;\n    }\n};"}, "fn": "isInterleave", "params": [{"name": "s1", "type": "string"}, {"name": "s2", "type": "string"}, {"name": "s3", "type": "string"}], "outputType": "boolean", "tests": [["aabcc", "dbbca", "aadbbcbcac"], ["aabcc", "dbbca", "aadbbbaccc"], ["", "", ""], ["", "a", "a"], ["a", "", "a"], ["", "a", "b"], ["a", "b", "ab"], ["a", "b", "ba"], ["a", "b", "aa"], ["a", "b", "a"], ["ab", "cd", "acbd"], ["ab", "cd", "cadb"], ["ab", "cd", "adbc"], ["ab", "cd", "abcd"], ["ab", "cd", "cdab"], ["abc", "def", "adbcef"], ["abc", "def", "abcdef"], ["abc", "def", "defabc"], ["abc", "def", "abdfec"], ["abc", "def", "abcdefg"], ["aa", "aa", "aaaa"], ["aa", "ab", "aaba"], ["aa", "ab", "abaa"], ["aa", "ab", "abba"], ["aaaa", "bbbb", "abababab"], ["aaaa", "bbbb", "bbbbaaaa"], ["aaaa", "bbbb", "aaaabbbb"], ["aaaa", "bbbb", "aaabbbba"], ["abcabc", "xyzxyz", "axbyczaxbycz"], ["abcabc", "xyzxyz", "xyzxyzabcabc"], ["abcabc", "xyzxyz", "axbyczaxybcz"], ["ace", "bdf", "abcdef"], ["ace", "bdf", "abcedf"], ["ace", "bdf", "abcfde"], ["cat", "dog", "cdaotg"], ["cat", "dog", "dogcat"], ["cat", "dog", "coatdg"], ["xxy", "xxz", "xxxxyz"], ["xxy", "xxz", "xxxxzy"], ["xxy", "xxz", "xxxyxz"], ["aacaac", "aacaaeaac", "aacaaeaaeaacaac"], ["aacaac", "aacaaeaac", "aacaaeaaaacaac"], ["abcde", "fghij", "afbgchdiej"], ["abcde", "fghij", "fghijabcde"], ["abcde", "fghij", "afbgchdije"], ["mnop", "qrst", "mqnropstu"], ["mnop", "qrst", "mqnrospt"], ["mnop", "qrst", "qrstmnop"], ["hello", "world", "hweolrllod"], ["hello", "world", "worldhello"], ["hello", "world", "hweolrldlo"], ["aaaaab", "aaaaac", "aaaaaaaaaabc"], ["aaaaab", "aaaaac", "aaaaaaaaaacb"], ["qwerty", "asdfgh", "qawsedrftgyhx"], ["qwerty", "asdfgh", "qawsedrftgyh"], ["qwerty", "asdfgh", "asdfghqwerty"], ["@javascript:'a'.repeat(100)", "@javascript:'b'.repeat(100)", "@javascript:'ab'.repeat(100)"], ["@javascript:'a'.repeat(100)", "@javascript:'b'.repeat(100)", "@javascript:'ab'.repeat(99)+'a'"]], "expected": [true, false, true, true, true, false, true, true, false, false, true, true, false, true, true, true, true, true, false, false, true, true, true, false, true, true, true, true, true, true, true, true, true, false, true, true, false, true, true, true, false, false, true, true, true, false, true, true, true, true, true, true, true, false, true, true, true, false], "loose": false}

package/data/problems/intersection-of-two-arrays-ii.json

@@ -0,0 +1 @@
+{"basic": false, "label": "430", "slug": "intersection-of-two-arrays-ii", "id": 430, "title": "Intersection of Two Arrays II", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/intersection-of-two-arrays-ii/", "examples": [{"input": "nums1 = [1,2,2,1], nums2 = [2,2]", "output": "[2,2]", "explanation": "Two copies of 2 exist on both sides, so both are kept."}, {"input": "nums1 = [4,9,5], nums2 = [9,4,9,8,4]", "output": "[4,9]", "explanation": "One shared copy of 4 and one of 9 survive; order is free."}], "hints": ["Count occurrences of the first list in a frequency map.", "Walk the second list, emitting a value while its remaining count is positive and decrementing."], "statement": "You receive two integer lists `nums1` and `nums2`. Return the values they share, respecting repetition counts: each distinct value should appear in the answer as many times as it appears in both lists simultaneously (the minimum of its two frequencies).\n\nThe order of the answer carries no meaning.\n\n**Constraints:**\n- `1 <= nums1.length, nums2.length <= 1000`\n- `0 <= nums1[i], nums2[i] <= 1000`\n\n**Follow up:** Sort both lists first and walk them with two pointers to use less extra memory; for already-sorted inputs this needs only output space.\n", "solution": "## Approach\n\nTally the first list's frequencies in a map. Then stream through the second list: whenever the current value still has a positive remaining count, append it to the answer and decrement the count. This keeps exactly the shared multiplicity of every value while preserving linear time.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + m), where n and m are the list lengths.\n- **Space Complexity:** O(min(n, m)) for the frequency table (count the shorter list in practice).\n\n## Implementation\n\n```python\nfrom typing import List\nfrom collections import Counter\nclass Solution:\n    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:\n        count = Counter(nums1)\n        out = []\n        for x in nums2:\n            if count.get(x, 0) > 0:\n                out.append(x)\n                count[x] -= 1\n        return out\n```\n", "starter": {"go": "package main\n\nfunc Intersect(nums1 []int, nums2 []int) []int {\n    return []int{}\n}", "python": "from typing import List\nclass Solution:\n    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:\n        return []\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<int> intersect(vector<int>& nums1, vector<int>& nums2) {\n        return {};\n    }\n};"}, "fn": "intersect", "params": [{"name": "nums1", "type": "int_array"}, {"name": "nums2", "type": "int_array"}], "outputType": "int_array", "tests": [["[1,2,2,1]", "[2,2]"], ["[4,9,5]", "[9,4,9,8,4]"], ["[1]", "[1]"], ["[1]", "[2]"], ["[1,2,3]", "[4,5,6]"], ["[1,2,3]", "[1,2,3]"], ["[0,0,0]", "[0,0]"], ["[3,1,2]", "[1,1]"], ["[1,1,1,2,2]", "[1,1,2]"], ["[5,5,5]", "[5,5,5,5]"], ["[1,2,2,3,3,3]", "[2,2,3,3]"], ["[0]", "[0]"], ["[7,7,7]", "[7]"], ["[1,2,3,4]", "[3,4,5,6]"], ["[100,200,300]", "[300,300]"], ["[2,2,2]", "[2,2,2]"], ["[1,2,3,4,5]", "[6,7,8,9,10]"], ["[8,6,4,2]", "[2,4,6,8,10]"], ["[0,1000]", "[1000,0,0]"], ["[1,1,2,2,3,3]", "[1,2,3]"], ["[9,9,8,8]", "[9,8,9,8,9]"], ["[4,4,4,4]", "[4,4]"], ["[1,3,5]", "[2,4,6,1,3]"], ["[10,20,30,20,10]", "[20,20,10]"], ["[1,2]", "[1,2,1,2]"], ["[0,1,0,1]", "[0,0,1,1,1]"]], "expected": [[2, 2], [4, 9], [1], [], [], [1, 2, 3], [0, 0], [1], [1, 1, 2], [5, 5, 5], [2, 2, 3, 3], [0], [7], [3, 4], [300], [2, 2, 2], [], [2, 4, 6, 8], [0, 1000], [1, 2, 3], [8, 8, 9, 9], [4, 4], [1, 3], [10, 20, 20], [1, 2], [0, 0, 1, 1]], "loose": true}

package/data/problems/intersection-of-two-arrays.json

@@ -0,0 +1 @@
+{"basic": false, "label": "429", "slug": "intersection-of-two-arrays", "id": 429, "title": "Intersection of Two Arrays", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/intersection-of-two-arrays/", "examples": [{"input": "nums1 = [1,2,2,1], nums2 = [2,2]", "output": "[2]", "explanation": "2 is the only value present on both sides."}, {"input": "nums1 = [4,9,5], nums2 = [9,4,9,8,4]", "output": "[9,4]", "explanation": "4 and 9 are shared; any order of them is accepted."}], "hints": ["Load one list into a hash set for O(1) membership tests.", "Insert matches into a second set to suppress duplicates, then return them."], "statement": "You receive two integer lists `nums1` and `nums2`. Collect every value that occurs in both lists, keeping each shared value exactly once.\n\nThe order of the answer carries no meaning \u2014 any arrangement of the shared values is accepted.\n\n**Constraints:**\n- `1 <= nums1.length, nums2.length <= 1000`\n- `0 <= nums1[i], nums2[i] <= 1000`\n", "solution": "## Approach\n\nPlace all values of the first list into a hash set, then scan the second list and collect hits into another set that automatically drops repeats. Converting the survivor set to an array finishes the task. Set lookups keep the total work linear in the combined input size.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + m), where n and m are the list lengths.\n- **Space Complexity:** O(n) for the lookup set.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:\n        have = set(nums1)\n        return list({x for x in nums2 if x in have})\n```\n", "starter": {"go": "package main\n\nfunc Intersection(nums1 []int, nums2 []int) []int {\n    return []int{}\n}", "python": "from typing import List\nclass Solution:\n    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:\n        return []\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<int> intersection(vector<int>& nums1, vector<int>& nums2) {\n        return {};\n    }\n};"}, "fn": "intersection", "params": [{"name": "nums1", "type": "int_array"}, {"name": "nums2", "type": "int_array"}], "outputType": "int_array", "tests": [["[1,2,2,1]", "[2,2]"], ["[4,9,5]", "[9,4,9,8,4]"], ["[1]", "[1]"], ["[1]", "[2]"], ["[1,2,3]", "[4,5,6]"], ["[1,2,3]", "[1,2,3]"], ["[0,0,0]", "[0]"], ["[1000]", "[1000]"], ["[1,2]", "[2,1]"], ["[3,1,2]", "[1,1]"], ["[5,5,5,5]", "[5,5]"], ["[1,3,5,7]", "[2,4,6,8]"], ["[0,1,2,3,4,5]", "[5,4,3]"], ["[9,8,7]", "[7,8,9,10]"], ["[1,2,3,4,5,6,7,8,9,10]", "[10,9,8]"], ["[42]", "[42,42,42]"], ["[1,2,2,3,3,3]", "[2,3,4]"], ["[0]", "[1]"], ["[7,7,7]", "[8,8,8]"], ["[1,2,3,4]", "[3,4,5,6]"], ["[100,200,300]", "[300,400]"], ["[2,2,2]", "[2,2,2]"], ["[1,2,3,4,5]", "[6,7,8,9,10]"], ["[8,6,4,2]", "[2,4,6,8,10]"], ["[0,1000]", "[1000,0]"], ["[11,22,33]", "[33,44]"]], "expected": [[2], [4, 9], [1], [], [], [1, 2, 3], [0], [1000], [1, 2], [1], [5], [], [3, 4, 5], [7, 8, 9], [8, 9, 10], [42], [2, 3], [], [], [3, 4], [300], [2], [], [2, 4, 6, 8], [0, 1000], [33]], "loose": true}

package/data/problems/intersection-of-two-linked-lists.json

@@ -0,0 +1 @@
+{"basic": false, "label": "313", "slug": "intersection-of-two-linked-lists", "id": 313, "title": "Intersection of Two Linked Lists", "difficulty": "Easy", "category": "linked-list", "link": "https://leetcode.com/problems/intersection-of-two-linked-lists/", "examples": [{"explanation": "Both lists end with 8 -> 4 -> 5, so the intersecting tail is [8,4,5].", "input": "headA = [4,1,8,4,5], headB = [5,6,1,8,4,5]", "output": "[8,4,5]"}, {"explanation": "Both lists end with 2 -> 4.", "input": "headA = [1,9,1,2,4], headB = [3,2,4]", "output": "[2,4]"}, {"explanation": "The endings differ, so there is no intersection (null, shown as []).", "input": "headA = [2,6,4], headB = [1,5]", "output": "[]"}], "hints": ["Walk to the end of each list to learn their lengths, then advance the longer one so both have the same remaining distance.", "Compare the remaining tails value by value; the first position where the rest matches is the start of the shared suffix."], "statement": "You are given the heads of two singly linked lists, `headA` and `headB`.\n\nIn the original setting the two lists join at some shared node. Because this offline judge builds each list separately, intersection is defined by values instead: the lists intersect when they end with the same non-empty run of values. That is, there are positions `i` in the first list and `j` in the second list such that the remaining tails are equal element by element.\n\nReturn the intersecting tail (the suffix starting at its first shared value), or null when the lists share no common ending values. Test data avoids coincidental single-value matches for non-intersecting cases, so a shared ending genuinely represents a meeting point.\n\n**Constraints:**\n- `0 <= number of nodes <= 10^4`\n- `0 <= Node.val <= 100`\n- Each list is acyclic.\n", "solution": "## Approach\n\nCollect both lists into arrays and walk backwards from the tails while the values agree. The number of matching steps is the length of the shared ending; rebuilding that suffix gives the intersecting tail. If nothing matches, the answer is null. Comparing from the back directly yields the longest common ending without extra alignment work.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m + n), where m and n are the list lengths.\n- **Space Complexity:** O(m + n) for the collected values and the rebuilt suffix.\n\n## Implementation\n\n```python\n# class ListNode:\n#     def __init__(self, val=0, next=None):\n#         self.val = val\n#         self.next = next\n\nclass Solution:\n    def getIntersectionNode(self, headA, headB):\n        a, b = [], []\n        p = headA\n        while p:\n            a.append(p.val)\n            p = p.next\n        p = headB\n        while p:\n            b.append(p.val)\n            p = p.next\n        i, j = len(a) - 1, len(b) - 1\n        match = 0\n        while i >= 0 and j >= 0 and a[i] == b[j]:\n            match += 1\n            i -= 1\n            j -= 1\n        if match == 0:\n            return None\n        dummy = ListNode(0)\n        cur = dummy\n        for v in a[len(a) - match:]:\n            cur.next = ListNode(v)\n            cur = cur.next\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 GetIntersectionNode(headA *ListNode, headB *ListNode) *ListNode {\n    return nil\n}", "python": "# class ListNode:\n#     def __init__(self, val=0, next=None):\n#         self.val = val\n#         self.next = next\n\nclass Solution:\n    def getIntersectionNode(self, headA, headB):\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* getIntersectionNode(ListNode* headA, ListNode* headB) {\n        return nullptr;\n    }\n};"}, "fn": "getIntersectionNode", "params": [{"name": "headA", "type": "list_node"}, {"name": "headB", "type": "list_node"}], "outputType": "list_node", "tests": [["[4,1,8,4,5]", "[5,6,1,8,4,5]"], ["[1,9,1,2,4]", "[3,2,4]"], ["[2,6,4]", "[1,5]"], ["[0,9,1,2,4]", "[3,2,4]"], ["[]", "[]"], ["[]", "[1,2]"], ["[1,2]", "[]"], ["[1]", "[1]"], ["[1]", "[2]"], ["[1,2,3]", "[1,2,3]"], ["[5,4,3,2,1]", "[9,8,2,1]"], ["[1,3,5,7,9]", "[2,4,5,7,9]"], ["[10,20,30]", "[40,50]"], ["[7,7,7]", "[7,7,7,7]"], ["[1,2]", "[3,4,5,1,2]"], ["[9,8,7,6]", "[1,8,7,6]"], ["[100]", "[0,100]"], ["[1,2,3,4]", "[5,6]"], ["[4,4,4]", "[4,4]"], ["[1,5,9]", "[2,5,9]"], ["[0]", "[1]"], ["[11,22]", "[33,44]"], ["[1,2,3,4,5]", "[6,7,4,5]"], ["[8,4,5]", "[5,6,1,8,4,5]"], ["[2,4]", "[1,9,1,2,4]"], ["[3,1,5,9]", "[7,1,5,9]"]], "expected": [[1, 8, 4, 5], [2, 4], null, [2, 4], null, null, null, [1], null, [1, 2, 3], [2, 1], [5, 7, 9], null, [7, 7, 7], [1, 2], [8, 7, 6], [100], null, [4, 4], [5, 9], null, null, [4, 5], [8, 4, 5], [2, 4], [1, 5, 9]], "loose": false}

package/data/problems/interval-list-intersections.json

@@ -0,0 +1 @@
+{"basic": false, "label": "969", "slug": "interval-list-intersections", "id": 969, "title": "Interval List Intersections", "difficulty": "Medium", "category": "interval", "link": "https://leetcode.com/problems/interval-list-intersections/", "examples": [{"input": "firstList = [[0,2],[5,10],[13,23],[24,25]], secondList = [[1,5],[8,12],[15,24],[25,26]]", "output": "[[1,2],[5,5],[8,10],[15,23],[24,24],[25,25]]", "explanation": "Each overlapping pair contributes its shared segment; touching endpoints count as length-zero intersections."}, {"input": "firstList = [[1,3],[5,9]], secondList = []", "output": "[]", "explanation": "With one list empty there are no overlaps."}], "hints": ["Walk both sorted lists with two pointers, always advancing the interval that ends first.", "Two intervals [a,b] and [c,d] overlap exactly when max(a,c) <= min(b,d); that pair of extremes is the intersection.", "Each step emits at most one intersection, giving linear time."], "statement": "You are given two lists of closed intervals, `firstList` and `secondList`. Within each list the intervals are pairwise disjoint and sorted by start. Compute all pairwise intersections: for every `I` in the first list and `J` in the second list, if they share at least one point, include their overlap `[max(starts), min(ends)]` in the answer. Return the intersections sorted by start (the two-pointer scan naturally produces this order).\n\n**Constraints:**\n- `0 <= firstList.length, secondList.length <= 1000`\n- `firstList[i], secondList[i]` each hold `[start, end]` with `0 <= start <= end <= 10^9`.\n- Intervals inside each list are disjoint and sorted.\n", "solution": "## Approach\n\nSweep both sorted lists with indices i and j. For the current pair, the overlap candidate is [max of starts, min of ends]; keep it when the start does not pass the end. Then advance the interval finishing first, since it cannot overlap anything later in the other list. Each interval is consumed once.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m + n), where m and n are the list lengths.\n- **Space Complexity:** O(m + n) for the output in the worst case.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def intervalIntersection(self, firstList: List[List[int]], secondList: List[List[int]]) -> List[List[int]]:\n        out = []\n        i = j = 0\n        while i < len(firstList) and j < len(secondList):\n            lo = max(firstList[i][0], secondList[j][0])\n            hi = min(firstList[i][1], secondList[j][1])\n            if lo <= hi:\n                out.append([lo, hi])\n            if firstList[i][1] < secondList[j][1]:\n                i += 1\n            else:\n                j += 1\n        return out\n```\n", "starter": {"go": "package main\n\nfunc IntervalIntersection(firstList [][]int, secondList [][]int) [][]int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def intervalIntersection(self, firstList: List[List[int]], secondList: List[List[int]]) -> List[List[int]]:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<vector<int>> intervalIntersection(vector<vector<int>>& firstList, vector<vector<int>>& secondList) {\n        return {};\n    }\n};"}, "fn": "intervalIntersection", "params": [{"name": "firstList", "type": "int_array_2d"}, {"name": "secondList", "type": "int_array_2d"}], "outputType": "int_array_2d", "tests": [["[[0,2],[5,10],[13,23],[24,25]]", "[[1,5],[8,12],[15,24],[25,26]]"], ["[[1,3],[5,9]]", "[]"], ["[]", "[[1,3]]"], ["[]", "[]"], ["[[0,5]]", "[[0,5]]"], ["[[1,2]]", "[[3,4]]"], ["[[1,5]]", "[[2,3]]"], ["[[1,10]]", "[[2,3],[4,5],[6,7]]"], ["[[0,2],[3,5]]", "[[1,4]]"], ["[[1,3],[5,7]]", "[[2,6]]"], ["[[1,1],[3,3]]", "[[1,3]]"], ["[[0,10]]", "[[10,10]]"], ["[[5,10]]", "[[0,5]]"], ["[[1,4],[6,8]]", "[[0,2],[3,5],[7,9]]"], ["[[0,1],[2,3],[4,5]]", "[[1,2],[3,4]]"], ["[[1,7]]", "[[3,10]]"], ["[[0,2],[5,10]]", "[[1,1],[8,8]]"], ["[[3,5],[9,20]]", "[[1,3],[4,6],[15,25]]"], ["[[1,2],[3,4],[5,6]]", "[[2,3],[4,5]]"], ["[[0,100]]", "[[10,20],[30,40],[50,60]]"], ["[[1,5],[10,15]]", "[[5,10]]"], ["[[2,4]]", "[[0,10]]"], ["[[1,3]]", "[[1,3]]"], ["[[0,2]]", "[[2,4]]"], ["[[8,15]]", "[[2,6],[14,20]]"], ["[[1,2],[5,6],[9,10]]", "[[0,11]]"], ["[[0,5],[10,15],[20,25]]", "[[3,12],[18,22]]"], ["[[1,4]]", "[[2,3]]"]], "expected": [[[1, 2], [5, 5], [8, 10], [15, 23], [24, 24], [25, 25]], [], [], [], [[0, 5]], [], [[2, 3]], [[2, 3], [4, 5], [6, 7]], [[1, 2], [3, 4]], [[2, 3], [5, 6]], [[1, 1], [3, 3]], [[10, 10]], [[5, 5]], [[1, 2], [3, 4], [7, 8]], [[1, 1], [2, 2], [3, 3], [4, 4]], [[3, 7]], [[1, 1], [8, 8]], [[3, 3], [4, 5], [15, 20]], [[2, 2], [3, 3], [4, 4], [5, 5]], [[10, 20], [30, 40], [50, 60]], [[5, 5], [10, 10]], [[2, 4]], [[1, 3]], [[2, 2]], [[14, 15]], [[1, 2], [5, 6], [9, 10]], [[3, 5], [10, 12], [20, 22]], [[2, 3]]], "loose": false}

package/data/problems/invert-binary-tree.json

@@ -0,0 +1 @@
+{"basic": false, "label": "62", "slug": "invert-binary-tree", "id": 62, "title": "Invert/Flip Binary Tree", "difficulty": "Easy", "category": "tree", "link": "https://leetcode.com/problems/invert-binary-tree/", "examples": [{"input": "root = [4,2,7,1,3,6,9]", "output": "[4,7,2,9,6,3,1]", "explanation": "Inverting [4,2,7,1,3,6,9] produces [4,7,2,9,6,3,1].\n\n![Invert binary tree example](/api/problems/invert-binary-tree/asset/explanation1.png)"}, {"input": "root = [2,1,3]", "output": "[2,3,1]", "explanation": "Inverting [2,1,3] produces [2,3,1].\n\n![Invert binary tree example 2](/api/problems/invert-binary-tree/asset/explanation2.png)"}, {"input": "root = []", "output": "[]", "explanation": "Inverting an empty tree produces an empty tree."}], "hints": ["Swap left and right children for every node (mirror the tree) using recursion or BFS."], "statement": "Starting from the `root` of a binary tree, exchange every left and right child throughout the structure to create its mirror image, then return the `root` of the mirrored tree.\n\n**Constraints:**\n\n- The number of nodes in the tree is in the range [0, 100].\n- -100 \u2264 Node.val \u2264 100\n", "solution": "## Approach\n\nRecursively traverse the tree swapping the left and right children of each node. A null node returns null as the base case.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of nodes in the tree.\n- **Space Complexity:** O(h), where h is the height of the tree (recursion stack depth).\n\n## Implementation\n\n```python\nfrom typing import Optional\nclass Solution:\n    def invertTree(self, root: Optional[TreeNode]) -> Optional[TreeNode]:\n        if not root:\n            return None\n        root.left, root.right = root.right, root.left\n        self.invertTree(root.left)\n        self.invertTree(root.right)\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 InvertTree(root *TreeNode) *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 invertTree(self, root):\n        # TODO: return the root of the inverted tree\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    TreeNode* invertTree(TreeNode* root) {\n        \n    }\n};\n"}, "fn": "invertTree", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}], "outputType": "tree_node", "tests": [["[4,2,7,1,3,6,9]"], ["[2,1,3]"], ["[]"], ["[1,null,2,null,3]"], ["[1,2,null,3]"], ["[0]"], ["[5,3,8,1,4,7,9]"], ["[1]"], ["[1,2]"], ["[1,null,2]"], ["[3,9,20,null,null,15,7]"], ["[1,2,3,4,5,6,7]"], ["[1,2,3,4,5]"], ["[10,5,-3,3,2,null,11,3,-2,null,1]"], ["[0,0,0]"], ["[-100,100]"], ["[100,-100]"], ["[2,null,3,null,4]"], ["[4,null,2,null,1]"], ["[7,7,7]"], ["[1,2,2,3,4,4,3]"], ["[10,5,15]"], ["[10,15,5]"], ["[8,4,12,2,6,10,14]"], ["[1,2,3,null,4,null,5]"], ["[-5,-3,-8,0,2]"], ["[50,null,60,null,70]"], ["[9,6,null,3,null,1]"], ["[2,1]"], ["[5,null,9,8,null,7]"], ["[3,1,2]"]], "expected": null, "loose": false}

package/data/problems/ip-to-cidr.json

@@ -0,0 +1 @@
+{"basic": false, "label": "754", "slug": "ip-to-cidr", "id": 754, "title": "IP to CIDR", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/ip-to-cidr/", "examples": [{"input": "ip = \"255.0.0.7\", n = 10", "output": "[\"255.0.0.7/32\",\"255.0.0.8/29\",\"255.0.0.16/32\"]", "explanation": "Sizes 1, 8, 1 cover ten addresses minimally."}, {"input": "ip = \"117.145.102.62\", n = 8", "output": "[\"117.145.102.62/31\",\"117.145.102.64/30\",\"117.145.102.68/31\"]", "explanation": "Sizes 2, 4, 2 cover eight addresses."}], "hints": ["Translate the dotted address into a 32-bit integer so alignment becomes arithmetic.", "From the current start, the biggest usable block is limited both by the lowest set bit of start and by the largest power of two fitting in the remainder.", "Emit that block, advance start by its size, and repeat until n reaches zero."], "statement": "An IPv4 address writes a 32-bit number as four decimal groups joined by dots. A CIDR block adds a slash and a prefix length, such as `255.0.0.8/29`, meaning all addresses sharing the first 29 bits with the base.\n\nYou are given a starting address `ip` and a count `n`. Cover exactly the `n` consecutive addresses from `ip` upward with as few CIDR blocks as possible, using no address outside the range.\n\nReturn the blocks as strings in increasing address order.\n\n**Constraints:**\n- `ip` is a valid IPv4 address.\n- Every address from `ip` through `ip + n - 1` is valid.\n- `1 <= n <= 1000`\n", "solution": "## Approach\n\nConvert the dotted address to a 32-bit integer. While addresses remain, compute two limits: the alignment limit from the lowest set bit of the current start, and the size limit from the largest power of two not exceeding the remainder. Take the smaller as the next block size, translate it to a prefix length, emit the block, and advance. Both limits guarantee validity and greediness yields the fewest blocks.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) in the worst case, but at most O(log MaxIP + number of blocks) steps since each block at least halves alignment or remainder effects; with n <= 1000 it is tiny.\n- **Space Complexity:** O(1) besides the output list.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def ipToCIDR(self, ip: str, n: int) -> List[str]:\n        parts = list(map(int, ip.split('.')))\n        start = (parts[0] << 24) | (parts[1] << 16) | (parts[2] << 8) | parts[3]\n        ans = []\n        def to_ip(v):\n            return f\"{(v >> 24) & 255}.{(v >> 16) & 255}.{(v >> 8) & 255}.{v & 255}\"\n        while n > 0:\n            low = start & -start if start != 0 else 1 << 32\n            mx = 1 << (n.bit_length() - 1)\n            step = low if low < mx else mx\n            import math\n            prefix = 32 - (step.bit_length() - 1)\n            ans.append(f\"{to_ip(start)}/{prefix}\")\n            start += step\n            n -= step\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc IpToCIDR(ip string, n int) []string {\n    return []string{}\n}", "python": "from typing import List\nclass Solution:\n    def ipToCIDR(self, ip: str, n: int) -> List[str]:\n        return []", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    vector<string> ipToCIDR(string ip, int n) {\n        return {};\n    }\n};"}, "fn": "ipToCIDR", "params": [{"name": "ip", "type": "string"}, {"name": "n", "type": "int"}], "outputType": "string_list", "tests": [["255.0.0.7", "10"], ["117.145.102.62", "8"], ["0.0.0.0", "1"], ["0.0.0.0", "2"], ["0.0.0.0", "4"], ["0.0.0.0", "8"], ["192.168.1.0", "16"], ["10.0.0.1", "1"], ["10.0.0.1", "2"], ["10.0.0.0", "4"], ["1.1.1.1", "5"], ["255.255.255.255", "1"], ["0.0.0.1", "3"], ["192.168.0.0", "32"], ["10.10.10.10", "6"], ["172.16.0.5", "11"], ["8.8.8.8", "8"], ["1.2.3.4", "100"], ["100.64.0.0", "64"], ["0.0.0.0", "1000"], ["192.0.2.1", "7"], ["203.0.113.0", "24"], ["10.1.2.3", "13"], ["11.22.33.44", "9"], ["5.6.7.8", "16"], ["127.0.0.1", "4"], ["192.168.100.200", "20"], ["9.9.9.0", "256"]], "expected": [["255.0.0.7/32", "255.0.0.8/29", "255.0.0.16/32"], ["117.145.102.62/31", "117.145.102.64/30", "117.145.102.68/31"], ["0.0.0.0/32"], ["0.0.0.0/31"], ["0.0.0.0/30"], ["0.0.0.0/29"], ["192.168.1.0/28"], ["10.0.0.1/32"], ["10.0.0.1/32", "10.0.0.2/32"], ["10.0.0.0/30"], ["1.1.1.1/32", "1.1.1.2/31", "1.1.1.4/31"], ["255.255.255.255/32"], ["0.0.0.1/32", "0.0.0.2/31"], ["192.168.0.0/27"], ["10.10.10.10/31", "10.10.10.12/30"], ["172.16.0.5/32", "172.16.0.6/31", "172.16.0.8/29"], ["8.8.8.8/29"], ["1.2.3.4/30", "1.2.3.8/29", "1.2.3.16/28", "1.2.3.32/27", "1.2.3.64/27", "1.2.3.96/29"], ["100.64.0.0/26"], ["0.0.0.0/23", "0.0.2.0/24", "0.0.3.0/25", "0.0.3.128/26", "0.0.3.192/27", "0.0.3.224/29"], ["192.0.2.1/32", "192.0.2.2/31", "192.0.2.4/30"], ["203.0.113.0/28", "203.0.113.16/29"], ["10.1.2.3/32", "10.1.2.4/30", "10.1.2.8/29"], ["11.22.33.44/30", "11.22.33.48/30", "11.22.33.52/32"], ["5.6.7.8/29", "5.6.7.16/29"], ["127.0.0.1/32", "127.0.0.2/31", "127.0.0.4/32"], ["192.168.100.200/29", "192.168.100.208/29", "192.168.100.216/30"], ["9.9.9.0/24"]], "loose": false}

package/data/problems/ipo.json

@@ -0,0 +1 @@
+{"basic": false, "label": "206", "slug": "ipo", "id": 206, "title": "IPO", "difficulty": "Hard", "category": "heap", "link": "https://leetcode.com/problems/ipo/", "examples": [{"input": "k = 2, w = 0, profits = [1,2,3], capital = [0,1,1]", "output": "4", "explanation": "Since your initial capital is 0, you can only start the project indexed 0."}, {"input": "k = 3, w = 0, profits = [1,2,3], capital = [0,1,2]", "output": "6"}], "hints": ["At each step you may only start the affordable project with the largest profit.", "Sort projects by required capital and sweep affordable ones into a max-heap of profits.", "Reach into the heap up to k times; stop early when nothing is affordable."], "statement": "A firm wants to grow its funds before going public by completing selected ventures. It can complete no more than `k` different ventures.\n\nThere are `n` candidate ventures, where venture `i` yields a net gain of `profits[i]` and requires holding at least `capital[i]` before it may begin.\n\nYou begin with `w` in capital. Completing a venture adds its gain to your holdings.\n\nChoose up to `k` different ventures in a feasible sequence to leave your holdings as large as possible, and return that final holding amount.\n\nThe result is guaranteed to fit in a 32-bit signed integer.\n\n**Constraints:**\n\n- `1 <= k <= 10^5`\n- `0 <= w <= 10^9`\n- `n == profits.length`\n- `n == capital.length`\n- `1 <= n <= 10^5`\n- `0 <= profits[i] <= 10^4`\n- `0 <= capital[i] <= 10^9`\n", "solution": "## Approach\n\nSort projects by required capital and use a max-heap of profits. Do up to `k` rounds: push every affordable project into the heap, then take the most profitable one and add it to the current capital. Stop early if no project is affordable.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n log n + k log n), where n is the number of projects. Sorting costs O(n log n) and each heap operation costs O(log n).\n- **Space Complexity:** O(n) for the sorted indices and the heap.\n\n## Implementation\n\n```python\nimport heapq\nclass Solution:\n    def findMaximizedCapital(self, k: int, w: int, profits: list[int], capital: list[int]) -> int:\n        order = sorted(range(len(profits)), key=lambda i: capital[i])\n        heap = []\n        i = 0\n        cur = w\n        for _ in range(k):\n            while i < len(order) and capital[order[i]] <= cur:\n                heapq.heappush(heap, -profits[order[i]])\n                i += 1\n            if not heap:\n                break\n            cur += -heapq.heappop(heap)\n        return cur\n```\n", "starter": {"go": "package main\n\nfunc FindMaximizedCapital(k int, w int, profits []int, capital []int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def findMaximizedCapital(self, k: int, w: int, profits: List[int], capital: List[int]) -> int:\n        ", "cpp": "#include <vector>\n#include <queue>\nusing namespace std;\n\nclass Solution {\npublic:\n    int findMaximizedCapital(int k, int w, vector<int>& profits, vector<int>& capital) {\n        \n    }\n};"}, "fn": "findMaximizedCapital", "params": [{"name": "k", "type": "int"}, {"name": "w", "type": "int"}, {"name": "profits", "type": "int_array"}, {"name": "capital", "type": "int_array"}], "outputType": "int", "tests": [["2", "0", "[1,2,3]", "[0,1,1]"], ["3", "0", "[1,2,3]", "[0,1,2]"], ["1", "2", "[1,2,3]", "[1,1,2]"], ["2", "0", "[1,2,3]", "[0,9,9]"], ["1", "0", "[5]", "[0]"], ["1", "0", "[5]", "[1]"], ["1", "100", "[1,2,3]", "[0,0,0]"], ["3", "0", "[1,2,3]", "[3,3,3]"], ["5", "1", "[2,4,6,8,10]", "[0,1,2,3,4]"], ["4", "1", "[1,1,1,1]", "[100,100,100,100]"], ["20", "10", "[5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]", "[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19]"], ["3", "5", "[10,20,30,40]", "[1,2,3,4]"], ["4", "5", "[10,20,30,40]", "[1,2,3,4]"], ["2", "5", "[1,3,5,7]", "[0,100,1000,10000]"], ["10", "0", "[1,1,1,1,1,1,1,1,1,1]", "[0,0,0,0,0,0,0,0,0,0]"], ["10", "0", "[1,1,1,1,1,1,1,1,1,1]", "[5,5,5,5,5,5,5,5,5,5]"], ["5", "1000000000", "[1,2,3,4,5]", "[1000000000,1000000000,1000000000,1000000000,1000000000]"], ["6", "0", "[6,5,4,3,2,1]", "[0,1,2,3,4,5]"], ["1", "0", "[0]", "[0]"], ["2", "1", "[5, 10]", "[0, 1]"], ["3", "0", "[4, 5, 6]", "[0, 0, 0]"], ["1", "0", "[10000]", "[1000000000]"], ["100", "0", "[1, 2]", "[0, 0]"], ["2", "3", "[2, 2, 2]", "[3, 3, 3]"], ["4", "0", "[0, 0, 5, 10]", "[0, 0, 0, 5]"], ["3", "10", "[1, 1, 100]", "[5, 10, 10]"], ["5", "0", "[3, 1, 2]", "[0, 0, 0]"], ["2", "100", "[10, 20]", "[0, 50]"], ["3", "7", "[6, 7, 8, 9]", "[7, 8, 9, 10]"], ["10", "5", "[100, 1, 1, 1, 1]", "[5, 5, 5, 5, 105]"]], "expected": [4, 6, 5, 1, 5, 0, 103, 0, 31, 1, 110, 95, 105, 6, 10, 0, 1000000015, 21, 0, 16, 15, 0, 3, 7, 15, 112, 6, 130, 30, 109], "loose": false}

package/data/problems/is-graph-bipartite.json

@@ -0,0 +1 @@
+{"basic": false, "label": "784", "slug": "is-graph-bipartite", "id": 784, "title": "Is Graph Bipartite?", "difficulty": "Medium", "category": "graph", "link": "https://leetcode.com/problems/is-graph-bipartite/", "examples": [{"input": "graph = [[1,2,3],[0,2],[0,1,3],[0,2]]", "output": "false", "explanation": "Three mutually linked vertices form a triangle."}, {"input": "graph = [[1,3],[0,2],[1,3],[0,2]]", "output": "true", "explanation": "Even and odd vertices can take opposite colors."}, {"input": "graph = [[1],[0]]", "output": "true", "explanation": "A single edge is two-colorable."}], "hints": ["Paint vertices with two colors using breadth-first search from every unvisited start.", "When you cross an edge, the neighbor must take the opposite color; a clash means failure.", "Disconnected pieces are handled by restarting the search at each uncolored vertex."], "statement": "An undirected network has `n` vertices numbered `0` through `n-1`. For each\nvertex `u`, the list `graph[u]` names all vertices directly linked to `u`\nby an edge. The network has no loops, no duplicate edges, and every link is\nlisted in both directions. It may split into several disconnected pieces.\n\nThe network is called two-colorable when every vertex can be painted with\none of two colors so that no edge joins two vertices of the same color.\nEquivalently, the vertices split into two groups with all edges crossing\nbetween the groups.\n\nGiven the adjacency lists, decide whether the network has this property.\n\n**Constraints:**\n- `graph.length == n`\n- `1 <= n <= 100`\n- `0 <= graph[u].length < n`\n- `0 <= graph[u][i] <= n - 1`\n- `graph[u]` holds no `u` itself and no repeats.\n- Whenever `v` appears in `graph[u]`, `u` appears in `graph[v]`.\n", "solution": "## Approach\n\nColor the network with two labels using breadth-first search. Start each\nunvisited component with label zero, then force every neighbor to carry the\nopposite label. If an edge ever connects two equally labeled vertices, the\ngraph cannot be split as required. Surviving all components without a clash\nconfirms two-colorability.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + e), where n is the vertex count and e the edge count.\n- **Space Complexity:** O(n) for colors and the queue.\n\n## Implementation\n\n```python\nfrom typing import List\nfrom collections import deque\n\n\nclass Solution:\n    def isBipartite(self, graph: List[List[int]]) -> bool:\n        n = len(graph)\n        color = [-1] * n\n        for start in range(n):\n            if color[start] != -1:\n                continue\n            color[start] = 0\n            queue = deque([start])\n            while queue:\n                u = queue.popleft()\n                for v in graph[u]:\n                    if color[v] == -1:\n                        color[v] = 1 - color[u]\n                        queue.append(v)\n                    elif color[v] == color[u]:\n                        return False\n        return True\n```\n", "starter": {"go": "package main\n\nfunc IsBipartite(graph [][]int) bool {\n    return false\n}", "python": "from typing import List\nclass Solution:\n    def isBipartite(self, graph: List[List[int]]) -> bool:\n        return False\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    bool isBipartite(vector<vector<int>>& graph) {\n        return false;\n    }\n};"}, "fn": "isBipartite", "params": [{"name": "graph", "type": "int_array_2d"}], "outputType": "boolean", "tests": [["[[1,2,3],[0,2],[0,1,3],[0,2]]"], ["[[1,3],[0,2],[1,3],[0,2]]"], ["[[1],[0]]"], ["[[]]"], ["[[1,2],[0,2],[0,1]]"], ["[[1],[0],[3],[2]]"], ["[[1,2],[0],[0]]"], ["[[1],[0],[3],[2],[5],[4]]"], ["[[1,2,3],[0],[0],[0]]"], ["[[1],[0],[3],[2],[5],[4],[7],[6]]"], ["[[2],[2],[0,1]]"], ["[[1,2],[0,2],[0,1],[4],[3]]"], ["[[1],[0],[3],[2],[6],[7],[4],[5]]"], ["[[3],[3],[3],[0,1,2]]"], ["[[1,4],[0,2],[1,3],[2,4],[0,3]]"], ["[[1,4],[0,2],[1,3],[2],[0]]"], ["[[1],[0,2],[1,3],[2]]"], ["[[2,3],[2,3],[0,1],[0,1]]"], ["[[1,2],[0,3],[0,3],[1,2]]"], ["[[1,2,4],[0,3],[0,3],[1,2],[0]]"], ["[[2],[3],[0],[1],[5],[4]]"], ["[[1],[0],[3],[2],[5],[4],[8],[8],[6,7]]"], ["[[4],[4],[4],[4],[0,1,2,3]]"], ["[[1],[0,2],[1,3],[2,4],[3,5],[4]]"], ["[[1,2],[0,2],[0,1],[4,5],[3,5],[3,4]]"], ["[[2,5],[2],[0,1],[4],[3],[0]]"], ["[[1],[0],[3,4],[2],[2]]"], ["[[3,4],[5],[5],[0],[0],[1,2]]"]], "expected": [false, true, true, true, false, true, true, true, true, true, true, false, true, true, false, true, true, true, true, true, true, true, true, true, false, true, true, true], "loose": false}