offcode 0.0.0-stage → 0.1.1

package/data/problems/sliding-window-median.json

@@ -0,0 +1 @@
+{"basic": false, "label": "544", "slug": "sliding-window-median", "id": 544, "title": "Sliding Window Median", "difficulty": "Hard", "category": "heap", "link": "https://leetcode.com/problems/sliding-window-median/", "examples": [{"input": "nums = [1,3,-1,-3,5,3,6,7], k = 3", "output": "[\"1.0\",\"-1.0\",\"-1.0\",\"3.0\",\"5.0\",\"6.0\"]", "explanation": "Sorted windows give middles 1, -1, -1, 3, 5, 6."}, {"input": "nums = [1,2,3,4,2,3,1,4,2], k = 3", "output": "[\"2.0\",\"3.0\",\"3.0\",\"3.0\",\"2.0\",\"3.0\",\"2.0\"]", "explanation": "Each triple contributes its middle value."}], "hints": ["Adaptation: format each median with default double-to-string; the checker allows 1e-5 error.", "Keep two balanced heaps with lazy deletions so insert, erase, and median are logarithmic.", "For even k average the two heap tops using double arithmetic."], "statement": "Slide a window of exactly `k` spots from the left end of `nums` to the right end, one step at a time. For each placement, sort that slice in your head and take its middle value \u2014 or the mean of the two middle values when `k` is even. Collect those medians in order.\n\n**Portable adaptation:** Medians can be fractional (ending in `.5`), and this judge has no double type. Each median is therefore returned as a decimal string (for example `\"2.5\"` or `\"1.0\"`), and grading accepts any decimal within `1e-5` of the true value.\n\n**Constraints:**\n\n- `1 <= k <= nums.length <= 10^5`\n- `-2^31 <= nums[i] <= 2^31 - 1`\n- Answers within `1e-5` of truth are accepted.\n", "solution": "## Approach\n\nMaintain the current window in two heaps: a max-heap holds the lower half and a min-heap holds the upper half, with sizes kept within one of each other. Insertions go to the appropriate heap, removals are recorded lazily in a delay map and pruned from heap tops, and rebalancing restores the size rule. The median is then either the max-heap top (odd window) or the mean of both tops (even window), formatted as a decimal string.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n log k) for n windows with heap operations.\n- **Space Complexity:** O(k) for the heaps and delay map.\n\n## Implementation\n\n```python\nimport heapq\nfrom collections import defaultdict\nfrom typing import List\n\nclass Solution:\n    def medianSlidingWindow(self, nums: List[int], k: int) -> List[str]:\n        small: List[int] = []  # max-heap via negatives\n        large: List[int] = []  # min-heap\n        delayed: dict = defaultdict(int)\n        small_size = 0\n        large_size = 0\n\n        def prune(heap, is_small: bool) -> None:\n            while heap:\n                v = -heap[0] if is_small else heap[0]\n                if delayed.get(v, 0) == 0:\n                    break\n                heapq.heappop(heap)\n                delayed[v] -= 1\n                if delayed[v] == 0:\n                    del delayed[v]\n\n        def balance() -> None:\n            nonlocal small_size, large_size\n            if small_size > large_size + 1:\n                v = -heapq.heappop(small)\n                heapq.heappush(large, v)\n                small_size -= 1\n                large_size += 1\n                prune(small, True)\n            elif small_size < large_size:\n                v = heapq.heappop(large)\n                heapq.heappush(small, -v)\n                small_size += 1\n                large_size -= 1\n                prune(large, False)\n\n        out: List[str] = []\n        for i, v in enumerate(nums):\n            if not small or v <= -small[0]:\n                heapq.heappush(small, -v)\n                small_size += 1\n            else:\n                heapq.heappush(large, v)\n                large_size += 1\n            balance()\n            if i >= k:\n                old = nums[i - k]\n                delayed[old] += 1\n                if old <= -small[0]:\n                    small_size -= 1\n                    if old == -small[0]:\n                        prune(small, True)\n                else:\n                    large_size -= 1\n                    if large and old == large[0]:\n                        prune(large, False)\n                balance()\n            if i >= k - 1:\n                if k % 2 == 1:\n                    out.append(repr(float(-small[0])))\n                else:\n                    out.append(repr((-small[0] + large[0]) / 2.0))\n        return out\n```\n", "starter": {"go": "package main\n\nfunc MedianSlidingWindow(nums []int, k int) []string {\n    return []string{}\n}", "python": "from typing import List\nclass Solution:\n    def medianSlidingWindow(self, nums: List[int], k: int) -> List[str]:\n        return []\n", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<string> medianSlidingWindow(vector<int>& nums, int k) {\n        return {};\n    }\n};"}, "fn": "medianSlidingWindow", "params": [{"name": "nums", "type": "int_array"}, {"name": "k", "type": "int"}], "outputType": "string_list", "tests": [["[1,3,-1,-3,5,3,6,7]", "3"], ["[1,2,3,4,2,3,1,4,2]", "3"], ["[1,4,2,3]", "4"], ["[1]", "1"], ["[5,5,5,5]", "2"], ["[1,2,3,4,5]", "1"], ["[5,4,3,2,1]", "5"], ["[0,0,0,0,0]", "3"], ["[-1,-2,-3,-4]", "2"], ["[2147483647,-2147483648,0,1]", "2"], ["[1,3,2,6,7,8,9]", "4"], ["[4,1,7,2,9,3]", "3"], ["[2,2,2,2,2,2]", "4"], ["[9,8,7,6,5,4,3,2,1]", "3"], ["[1,2]", "2"], ["[3,1,2]", "2"], ["[-5,10,-3,8,0]", "3"], ["[100,50,25,75,125]", "5"], ["[1,2,3,4]", "2"], ["[5,2,2,7,8]", "3"], ["[0,1,2,3,4,5]", "6"], ["[10,-10,10,-10]", "4"], ["[7,9,3,1,5]", "1"], ["[2,1]", "1"], ["[1000000,-1000000,500000]", "3"], ["[3,3,3,3,3]", "5"], ["[6,5,4,3,2,1]", "2"], ["[1,3,5,7,9,11]", "3"], ["[4,4,4,1,1,1]", "3"], ["[2147483647,2147483647,-2147483648]", "3"]], "expected": [["1.0", "-1.0", "-1.0", "3.0", "5.0", "6.0"], ["2.0", "3.0", "3.0", "3.0", "2.0", "3.0", "2.0"], ["2.5"], ["1.0"], ["5.0", "5.0", "5.0"], ["1.0", "2.0", "3.0", "4.0", "5.0"], ["3.0"], ["0.0", "0.0", "0.0"], ["-1.5", "-2.5", "-3.5"], ["-0.5", "-1.073741824E9", "0.5"], ["2.5", "4.5", "6.5", "7.5"], ["4.0", "2.0", "7.0", "3.0"], ["2.0", "2.0", "2.0"], ["8.0", "7.0", "6.0", "5.0", "4.0", "3.0", "2.0"], ["1.5"], ["2.0", "1.5"], ["-3.0", "8.0", "0.0"], ["75.0"], ["1.5", "2.5", "3.5"], ["2.0", "2.0", "7.0"], ["2.5"], ["0.0"], ["7.0", "9.0", "3.0", "1.0", "5.0"], ["2.0", "1.0"], ["500000.0"], ["3.0"], ["5.5", "4.5", "3.5", "2.5", "1.5"], ["3.0", "5.0", "7.0", "9.0"], ["4.0", "4.0", "1.0", "1.0"], ["2.147483647E9"]], "loose": false}

package/data/problems/smallest-good-base.json

@@ -0,0 +1 @@
+{"basic": false, "label": "547", "slug": "smallest-good-base", "id": 547, "title": "Smallest Good Base", "difficulty": "Hard", "category": "math", "link": "https://leetcode.com/problems/smallest-good-base/", "examples": [{"input": "n = \"13\"", "output": "\"3\"", "explanation": "13 is 111 in base 3."}, {"input": "n = \"4681\"", "output": "\"8\"", "explanation": "4681 is 11111 in base 8."}, {"input": "n = \"1000000000000000000\"", "output": "\"999999999999999999\"", "explanation": "Only 11 in base n-1 works."}], "hints": ["A longer all-ones run means a smaller base, so try long lengths first.", "For a fixed length, the value grows with the base: binary-search it.", "Accumulate 1+k+...+k^m with early exit once the sum passes n to avoid overflow."], "statement": "An integer `n` (given as its decimal text) has a *good base* `k >= 2` when writing `n` in base `k` uses only the digit `1` \u2014 that is, `n = 1 + k + k^2 + ... + k^m` for some length `m >= 1`. Every `n >= 3` has at least the trivial base `n - 1` (form `11`).\n\nReturn the smallest such base, again as decimal text.\n\n**Constraints:**\n\n- `n` is an integer in `[3, 10^18]` with no leading zeroes.\n", "solution": "## Approach\n\nA longer block of ones implies a smaller base, so examine possible exponents from large to small. For a fixed exponent `m` (meaning `m+1` ones), the geometric sum grows monotonically in the base, which allows binary search between 2 and roughly `n^(1/m)`. Summation stops early as soon as the partial total passes `n`, keeping arithmetic inside 64 bits. The first base found while scanning exponents downward is the smallest good base; the fallback `n-1` (form `11`) always works.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(log^2 n) \u2014 up to 60 exponents times a logarithmic binary search.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nclass Solution:\n    def smallestGoodBase(self, n: str) -> str:\n        N = int(n)\n        max_m = N.bit_length() - 1\n        for m in range(max_m, 0, -1):\n            lo, hi = 2, int(round(N ** (1.0 / m))) + 1\n            hi = max(hi, 2)\n            hi = min(hi, N - 1)\n            while lo <= hi:\n                mid = (lo + hi) // 2\n                s = 1\n                cur = 1\n                overflow = False\n                for _ in range(m):\n                    if cur > N // mid:\n                        overflow = True\n                        break\n                    cur *= mid\n                    s += cur\n                    if s > N:\n                        overflow = True\n                        break\n                if not overflow and s == N:\n                    return str(mid)\n                if overflow or s > N:\n                    hi = mid - 1\n                else:\n                    lo = mid + 1\n        return str(N - 1)\n```\n", "starter": {"go": "package main\n\nfunc SmallestGoodBase(n string) string {\n    return \"\"\n}", "python": "class Solution:\n    def smallestGoodBase(self, n: str) -> str:\n        return \"\"\n", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    string smallestGoodBase(string n) {\n        return \"\";\n    }\n};"}, "fn": "smallestGoodBase", "params": [{"name": "n", "type": "string"}], "outputType": "string", "tests": [["13"], ["4681"], ["1000000000000000000"], ["3"], ["4"], ["7"], ["8"], ["15"], ["21"], ["31"], ["8191"], ["121"], ["1000"], ["999999999999999999"], ["100000000000000000"], ["160"], ["225"], ["1023"], ["1000000"], ["1099511627775"], ["9"], ["63"], ["255"], ["26"], ["100"], ["10000"], ["999999"], ["123456789"], ["99999999999999999"], ["1048575"]], "expected": ["3", "8", "999999999999999999", "2", "3", "2", "7", "2", "4", "2", "2", "3", "999", "999999999999999998", "99999999999999999", "159", "224", "2", "999999", "2", "8", "2", "2", "25", "99", "9999", "999998", "123456788", "99999999999999998", "2"], "loose": false}

package/data/problems/smallest-range-covering-elements-from-k-lists.json

@@ -0,0 +1 @@
+{"basic": false, "label": "654", "slug": "smallest-range-covering-elements-from-k-lists", "id": 654, "title": "Smallest Range Covering Elements from K Lists", "difficulty": "Hard", "category": "heap", "link": "https://leetcode.com/problems/smallest-range-covering-elements-from-k-lists/", "examples": [{"input": "nums = [[4,10,15,24,26],[0,9,12,20],[5,18,22,30]]", "output": "[20,24]", "explanation": "20 comes from list 2, 22/24 from others; span 4 is minimal."}, {"input": "nums = [[1,2,3],[1,2,3],[1,2,3]]", "output": "[1,1]", "explanation": "Picking 1 from each list gives a zero-width range."}, {"input": "nums = [[10,10],[11,11]]", "output": "[10,11]", "explanation": "One entry per list forces [10,11]."}], "hints": ["Seed a min-heap with the first entry of every list and record the maximum among them.", "Repeatedly pop the minimum: the current [min, max] is a candidate covering all lists.", "Then advance inside the popped list (updating the max) until some list runs dry; keep the shortest candidate, breaking ties by smaller start.", "Adaptation: the nested input maps to int_array_2d and the two-element answer maps to int_array in this judge."], "statement": "You are given `k` sorted integer lists. Find the narrowest interval `[a, b]` that contains at least one number from every list.\n\nCompare candidates by width `b - a` first; when widths tie, prefer the smaller start `a`. Return the winning pair.\n\n**Constraints:**\n- At least one list is present; each list is sorted increasingly.\n- Values fit comfortably in 32-bit signed range.\n\n*Adaptation: the nested input maps to `int_array_2d` and the two-element answer maps to `int_array` in this judge, even though the natural statement uses lists of lists.*\n", "solution": "## Approach\n\nPush the head of every list into a min-heap and note the largest head as the running maximum, so [heap-min, running-max] always covers all lists. Pop the minimum to form a candidate, keep it when it narrows the best span (or ties with a smaller start), then push the next element from the same list and refresh the maximum. Stop once any list is exhausted, since no further range can cover it.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(N log k), where N is total elements and k the list count.\n- **Space Complexity:** O(k) for the heap.\n\n## Implementation\n\n```python\nfrom typing import List\nimport heapq\nclass Solution:\n    def smallestRange(self, nums: List[List[int]]) -> List[int]:\n        pq = []\n        cur_max = float(\"-inf\")\n        for i, lst in enumerate(nums):\n            heapq.heappush(pq, (lst[0], i, 0))\n            cur_max = max(cur_max, lst[0])\n        best_a, best_b = 0, float(\"inf\")\n        while True:\n            v, li, ei = heapq.heappop(pq)\n            if cur_max - v < best_b - best_a or (cur_max - v == best_b - best_a and v < best_a):\n                best_a, best_b = v, cur_max\n            if ei + 1 >= len(nums[li]):\n                break\n            nv = nums[li][ei + 1]\n            heapq.heappush(pq, (nv, li, ei + 1))\n            cur_max = max(cur_max, nv)\n        return [best_a, best_b]\n```\n", "starter": {"go": "package main\n\nfunc SmallestRange(nums [][]int) []int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def smallestRange(self, nums: List[List[int]]) -> List[int]:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<int> smallestRange(vector<vector<int>>& nums) {\n        return {};\n    }\n};"}, "fn": "smallestRange", "params": [{"name": "nums", "type": "int_array_2d"}], "outputType": "int_array", "tests": [["[[4,10,15,24,26],[0,9,12,20],[5,18,22,30]]"], ["[[1,2,3],[1,2,3],[1,2,3]]"], ["[[10,10],[11,11]]"], ["[[1]]"], ["[[1,5],[2,6]]"], ["[[1,2,3],[4,5,6]]"], ["[[1,10],[2,11],[3,12]]"], ["[[0,0,0],[1,1,1]]"], ["[[-5,-2,0],[1,2,3]]"], ["[[1,2],[3,4],[5,6]]"], ["[[4,4,4],[4,4,4]]"], ["[[1,100],[50,51],[49,52]]"], ["[[10,20,30],[5,15,25],[1,2,35]]"], ["[[1,2,3,4,5]]"], ["[[1,3,5],[2,4,6],[0,7]]"], ["[[-10,-5,0,5],[1,2]]"], ["[[18,28],[2,22],[17,29]]"], ["[[1,2,3],[1,2,3,4],[1,2]]"], ["[[100,200],[150,300],[120,180]]"], ["[[0,9],[4,10],[8,12]]"], ["[[1,4,7],[2,5,8],[3,6,9]]"], ["[[5],[10],[15],[20]]"], ["[[-3,-1,4],[0,2],[1,3,5]]"], ["[[1,2],[1,3],[1,4]]"], ["[[6,10,15],[3,8,20]]"], ["[[0,5,10],[1,6,11],[2,7,12]]"], ["[[25,30],[5,10,15,20]]"], ["[[1,9],[2,8],[3,7],[4,6]]"]], "expected": [[20, 24], [1, 1], [10, 11], [1, 1], [1, 2], [3, 4], [1, 3], [0, 1], [0, 1], [2, 5], [4, 4], [1, 50], [2, 10], [1, 1], [0, 2], [0, 1], [17, 22], [1, 1], [100, 150], [8, 10], [1, 3], [5, 20], [-1, 1], [1, 1], [6, 8], [0, 2], [20, 25], [1, 4]], "loose": false}

package/data/problems/smallest-range-i.json

@@ -0,0 +1 @@
+{"basic": false, "label": "897", "slug": "smallest-range-i", "id": 897, "title": "Smallest Range I", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/smallest-range-i/", "examples": [{"input": "nums = [1], k = 0", "output": "0", "explanation": "Only one element exists, so the score is 0 however it is shifted."}, {"input": "nums = [0,10], k = 2", "output": "6", "explanation": "Move 0 up to 2 and 10 down to 8; the spread becomes 8 - 2 = 6, which is the best possible."}, {"input": "nums = [1,3,6], k = 3", "output": "0", "explanation": "Shift every value to 4 (1 + 3, 3 + 1, 6 - 2); all equal, so the score is 0."}], "hints": ["Only the smallest and largest values matter: everything else lands between them after shifting.", "Push the minimum up by k and pull the maximum down by k; if they cross, the answer is 0.", "The result is max(0, max(nums) - min(nums) - 2 * k)."], "statement": "You are given an integer array `nums` and an integer `k`. For each element you may pick a shift amount between `-k` and `k` (each element gets its own choice, and choosing `0` leaves it unchanged) and add it to that element.\n\nAfter all shifts, the score is the difference between the largest and the smallest value. Return the smallest score you can achieve.\n\n**Constraints:**\n- `1 <= nums.length <= 50`\n- `0 <= nums[i] <= 10000`\n- `0 <= k <= 10000`\n", "solution": "## Approach\n\nOnly the extreme values influence the spread, since every shifted element stays between the shifted minimum and the shifted maximum. Raising the minimum by the full `k` and lowering the maximum by the full `k` squeezes the interval as much as possible, and the bounds can cross, in which case every element can be made equal.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) to scan for the minimum and maximum.\n- **Space Complexity:** O(1) extra space.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def smallestRangeI(self, nums: List[int], k: int) -> int:\n        return max(0, max(nums) - min(nums) - 2 * k)\n```\n", "starter": {"go": "package main\n\nfunc SmallestRangeI(nums []int, k int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def smallestRangeI(self, nums: List[int], k: int) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int smallestRangeI(vector<int>& nums, int k) {\n        return 0;\n    }\n};"}, "fn": "smallestRangeI", "params": [{"name": "nums", "type": "int_array"}, {"name": "k", "type": "int"}], "outputType": "int", "tests": [["[1]", "0"], ["[0,10]", "2"], ["[1,3,6]", "3"], ["[2,7,2]", "1"], ["[10,10,10]", "5"], ["[0,0,0]", "0"], ["[1,100]", "50"], ["[1,100]", "10"], ["[5]", "100"], ["[4,9,2,7]", "2"], ["[10000,0]", "10000"], ["[10000,0]", "0"], ["[3,1,4,1,5,9,2,6]", "3"], ["[7,7,7,7]", "0"], ["[0,5]", "3"], ["[0,6]", "3"], ["[0,7]", "3"], ["[100,200,300]", "50"], ["[1,2,3,4,5]", "0"], ["[1,2,3,4,5]", "2"], ["[1,2,3,4,5]", "1"], ["[8,3]", "4"], ["[8,3]", "2"], ["[50,50]", "0"], ["[0,10000]", "4999"], ["[0,10000]", "5000"], ["[9,1,8,2,7]", "2"], ["[6,6,1]", "4"]], "expected": [0, 6, 0, 3, 0, 0, 0, 79, 0, 3, 0, 10000, 2, 0, 0, 0, 1, 100, 4, 0, 2, 0, 1, 0, 2, 0, 4, 0], "loose": false}

package/data/problems/smallest-range-ii.json

@@ -0,0 +1 @@
+{"basic": false, "label": "899", "slug": "smallest-range-ii", "id": 899, "title": "Smallest Range II", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/smallest-range-ii/", "examples": [{"input": "nums = [1], k = 0", "output": "0", "explanation": "A single element always has spread 0."}, {"input": "nums = [0,10], k = 2", "output": "6", "explanation": "Adjust to 2 and 8 (or -2 and 12); the best spread is 6."}, {"input": "nums = [1,3,6], k = 3", "output": "3", "explanation": "Adjust to 4, 6 and 3 (each shifted by exactly 3); the spread is 6 - 3 = 3, which is optimal."}], "hints": ["Sort the array first: in an optimal answer the values raised by k form a prefix and the lowered ones a suffix (or vice versa).", "Try every split point between the raised group and the lowered group and measure max minus min of the two boundary values.", "The initial spread (no effective split) is also a candidate; take the minimum over all splits."], "statement": "You are given an integer array `nums` and an integer `k`. You must adjust every element by exactly `k`: each `nums[i]` becomes either `nums[i] + k` or `nums[i] - k` (your choice per element).\n\nAfter all adjustments, the score is the difference between the largest and the smallest value. Return the smallest score you can achieve.\n\n**Constraints:**\n- `1 <= nums.length <= 2000`\n- `0 <= nums[i] <= 10000`\n- `0 <= k <= 10000`\n", "solution": "## Approach\n\nSort the values. In an optimal assignment there is a dividing line: smaller elements are raised and larger ones are lowered (any interleaving can be uncrossed without hurting the spread). For each possible dividing line the spread is determined by the largest of the two group maxima minus the smallest of the two group minima. Checking every line plus the untouched spread gives the optimum.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n log n) for sorting, then O(n) for the scan.\n- **Space Complexity:** O(n) for the sorted copy (O(1) extra besides sorting).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def smallestRangeII(self, nums: List[int], k: int) -> int:\n        a = sorted(nums)\n        ans = a[-1] - a[0]\n        for i in range(1, len(a)):\n            hi = max(a[i - 1] + k, a[-1] - k)\n            lo = min(a[0] + k, a[i] - k)\n            ans = min(ans, hi - lo)\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc SmallestRangeII(nums []int, k int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def smallestRangeII(self, nums: List[int], k: int) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int smallestRangeII(vector<int>& nums, int k) {\n        return 0;\n    }\n};"}, "fn": "smallestRangeII", "params": [{"name": "nums", "type": "int_array"}, {"name": "k", "type": "int"}], "outputType": "int", "tests": [["[1]", "0"], ["[0,10]", "2"], ["[1,3,6]", "3"], ["[2,7,2]", "1"], ["[10,10,10]", "5"], ["[0,0,0]", "0"], ["[1,100]", "50"], ["[1,100]", "10"], ["[5]", "100"], ["[4,9,2,7]", "2"], ["[10000,0]", "10000"], ["[10000,0]", "0"], ["[3,1,4,1,5,9,2,6]", "3"], ["[7,7,7,7]", "0"], ["[0,5]", "3"], ["[0,6]", "3"], ["[0,7]", "3"], ["[100,200,300]", "50"], ["[1,2,3,4,5]", "0"], ["[1,2,3,4,5]", "2"], ["[1,2,3,4,5]", "1"], ["[8,3]", "4"], ["[8,3]", "2"], ["[50,50]", "0"], ["[0,10000]", "4999"], ["[0,10000]", "5000"], ["[9,1,8,2,7]", "2"], ["[6,6,1]", "4"]], "expected": [0, 6, 3, 3, 0, 0, 1, 79, 0, 3, 10000, 10000, 5, 0, 1, 0, 1, 100, 4, 3, 2, 3, 1, 0, 2, 0, 4, 3], "loose": false}

package/data/problems/smallest-rectangle-enclosing-black-pixels.json

@@ -0,0 +1 @@
+{"basic": false, "label": "395", "slug": "smallest-rectangle-enclosing-black-pixels", "id": 395, "title": "Smallest Rectangle Enclosing Black Pixels", "difficulty": "Hard", "category": "matrix", "link": "https://leetcode.com/problems/smallest-rectangle-enclosing-black-pixels/", "examples": [{"input": "image = [[\"0\",\"0\",\"1\",\"0\"],[\"0\",\"1\",\"1\",\"0\"],[\"0\",\"1\",\"0\",\"0\"]], x = 0, y = 2", "output": "6", "explanation": "Rows 0..2 and columns 1..2 enclose every black pixel."}, {"input": "image = [[\"1\"]], x = 0, y = 0", "output": "1", "explanation": "One pixel covers area 1."}, {"input": "image = [[\"1\",\"1\"],[\"1\",\"1\"]], x = 1, y = 1", "output": "4", "explanation": "The full 2 x 2 frame is black."}], "hints": ["The answer is (lowest black row .. highest) times (leftmost .. rightmost black column).", "One linear scan of the picture suffices to find those four extremes.", "The given (x, y) only guarantees a black pixel exists; the bounds still come from the whole picture."], "statement": "A binary picture is given as rows of `'0'` (white) and `'1'` (black) characters holding at\nleast one black pixel; all black pixels link together through shared sides. You are also\ngiven the coordinates `(x, y)` of one black pixel. Return the area of the smallest\naxis-aligned rectangle that covers every black pixel.\n\n**Constraints:**\n- `1 <= m, n <= 850`\n- `image[x][y] == '1'`.\n- The picture contains at least one `'1'`, all linked 4-directionally.\n", "solution": "## Approach\n\nScan every cell once, tracking the extreme black rows and columns; the enclosing area is height times width of that bounding box.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m x n)\n- **Space Complexity:** O(1)\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def minArea(self, image: List[List[str]], x: int, y: int) -> int:\n        top = bottom = x\n        left = right = y\n        for i, row in enumerate(image):\n            for j, c in enumerate(row):\n                if c == '1':\n                    top, bottom = min(top, i), max(bottom, i)\n                    left, right = min(left, j), max(right, j)\n        return (bottom - top + 1) * (right - left + 1)\n```\n", "starter": {"go": "package main\n\nfunc MinArea(image [][]byte, x int, y int) int {\n    return 0\n}", "python": "from typing import List\nclass Solution:\n    def minArea(self, image: List[List[str]], x: int, y: int) -> int:\n        ", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int minArea(vector<vector<char>>& image, int x, int y) {\n        return 0;\n    }\n};"}, "fn": "minArea", "params": [{"name": "image", "type": "char_array_2d"}, {"name": "x", "type": "int"}, {"name": "y", "type": "int"}], "outputType": "int", "tests": [["[[\"0\",\"0\",\"1\",\"0\"],[\"0\",\"1\",\"1\",\"0\"],[\"0\",\"1\",\"0\",\"0\"]]", "0", "2"], ["[[\"1\"]]", "0", "0"], ["[[\"1\",\"1\"],[\"1\",\"1\"]]", "1", "1"], ["[[\"0\",\"1\",\"0\"],[\"0\",\"1\",\"0\"]]", "0", "1"], ["[[\"1\",\"0\"],[\"0\",\"0\"]]", "0", "0"], ["[[\"0\",\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"1\",\"0\"]]", "4", "3"], ["[[\"0\",\"0\"],[\"0\",\"0\"],[\"0\",\"0\"],[\"1\",\"0\"]]", "3", "0"], ["[[\"0\"],[\"0\"],[\"0\"],[\"0\"],[\"1\"]]", "4", "0"], ["[[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"1\",\"0\",\"0\"],[\"0\",\"1\",\"0\",\"0\"]]", "3", "1"], ["[[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"1\",\"1\"]]", "1", "2"], ["[[\"0\",\"1\"]]", "0", "1"], ["[[\"1\",\"1\",\"1\"],[\"1\",\"1\",\"1\"]]", "0", "0"], ["[[\"1\"],[\"1\"],[\"1\"]]", "2", "0"], ["[[\"1\"],[\"1\"],[\"1\"]]", "1", "0"], ["[[\"0\",\"0\"],[\"0\",\"1\"],[\"0\",\"1\"]]", "1", "1"], ["[[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"1\",\"1\",\"0\"],[\"0\",\"1\",\"1\",\"0\"]]", "1", "2"], ["[[\"0\",\"0\",\"0\",\"0\",\"1\"],[\"0\",\"0\",\"0\",\"0\",\"1\"],[\"0\",\"0\",\"0\",\"0\",\"0\"]]", "1", "4"], ["[[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"1\"],[\"0\",\"0\",\"0\",\"1\"],[\"0\",\"0\",\"0\",\"1\"],[\"0\",\"0\",\"0\",\"0\"]]", "2", "3"], ["[[\"1\",\"0\",\"0\",\"0\"]]", "0", "0"], ["[[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\"],[\"1\",\"0\",\"0\",\"0\"]]", "4", "0"], ["[[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"1\",\"0\"]]", "4", "2"], ["[[\"0\"],[\"1\"],[\"1\"],[\"0\"]]", "2", "0"], ["[[\"1\"],[\"1\"],[\"0\"]]", "1", "0"], ["[[\"1\",\"1\"]]", "0", "0"], ["[[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"1\",\"1\",\"0\"],[\"0\",\"1\",\"1\",\"0\"],[\"0\",\"0\",\"0\",\"0\"]]", "3", "2"], ["[[\"0\",\"0\"],[\"1\",\"1\"]]", "1", "0"], ["[[\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"1\"],[\"0\",\"0\",\"0\",\"1\"]]", "2", "3"], ["[[\"0\",\"0\",\"0\",\"0\",\"0\"],[\"0\",\"1\",\"1\",\"1\",\"0\"],[\"0\",\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\",\"0\"],[\"0\",\"0\",\"0\",\"0\",\"0\"]]", "1", "3"], ["[[\"1\"]]", "0", "0"], ["[[\"0\",\"0\",\"1\",\"0\"],[\"0\",\"0\",\"0\",\"0\"]]", "0", "2"]], "expected": [6, 1, 4, 2, 1, 1, 1, 1, 2, 2, 1, 6, 3, 3, 2, 4, 2, 3, 1, 1, 1, 2, 2, 2, 4, 2, 2, 3, 1, 1], "loose": false}

package/data/problems/smallest-rotation-with-highest-score.json

@@ -0,0 +1 @@
+{"basic": false, "label": "796", "slug": "smallest-rotation-with-highest-score", "id": 796, "title": "Smallest Rotation with Highest Score", "difficulty": "Hard", "category": "array", "link": "https://leetcode.com/problems/smallest-rotation-with-highest-score/", "examples": [{"input": "nums = [2,3,1,4,0]", "output": "3", "explanation": "Rotation 3 gives the unique top score of 4."}, {"input": "nums = [1,3,0,2,4]", "output": "0", "explanation": "Rotation 0 ties for the best score."}, {"input": "nums = [0]", "output": "0", "explanation": "Only one rotation exists."}], "hints": ["Each element contributes to a contiguous circular interval of rotations; add +1 over that interval with a difference array.", "For the element at index j with value v, the scoring rotations form the forward interval from j + 1 to j - v.", "Prefix-summing the difference array yields every score, then the first maximum is the answer."], "statement": "You are handed an array `nums` of length `n` where each entry satisfies `0 <= nums[i] < n`. Rotating left by `k` produces a new arrangement `rot` with `rot[i] = nums[(i + k) % n]`. The score of that rotation counts indices with `rot[i] <= i`.\n\nReturn the smallest rotation index `k` that achieves the highest possible score. If several rotations tie, pick the least `k`.\n\n**Constraints:**\n- `1 <= nums.length <= 2000`\n- `0 <= nums[i] < nums.length`\n", "solution": "## Approach\n\nFix an element originally at index `j` with value `v`; it scores exactly for those rotations whose shifted position is at least `v`. Those rotations form one circular interval from `j + 1` to `j - v`. Adding one over every such interval with a difference array and prefix-summing gives all scores, and the first index with the maximum wins.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), one interval update per element plus one scan.\n- **Space Complexity:** O(n) for the difference array.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def bestRotation(self, nums: List[int]) -> int:\n        n = len(nums)\n        if n == 0:\n            return 0\n        diff = [0] * (n + 1)\n        for j, v in enumerate(nums):\n            start = (j + 1) % n\n            end = (j - v) % n\n            if start <= end:\n                diff[start] += 1\n                diff[end + 1] -= 1\n            else:\n                diff[start] += 1\n                diff[n] -= 1\n                diff[0] += 1\n                diff[end + 1] -= 1\n        best = mx = cur = 0\n        mx = -1\n        for k in range(n):\n            cur += diff[k]\n            if cur > mx:\n                mx = cur\n                best = k\n        return best\n```\n", "starter": {"go": "package main\n\nfunc BestRotation(nums []int) int {\n    return 0\n}", "python": "from typing import List\nclass Solution:\n    def bestRotation(self, nums: List[int]) -> int:\n        return 0", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int bestRotation(vector<int>& nums) {\n        return 0;\n    }\n};"}, "fn": "bestRotation", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[2, 3, 1, 4, 0]"], ["[1, 3, 0, 2, 4]"], ["[0]"], ["[0, 0]"], ["[1, 0]"], ["[0, 1]"], ["[1, 1, 1]"], ["[2, 2, 2]"], ["[0, 1, 2]"], ["[2, 1, 0]"], ["[3, 2, 1, 0]"], ["[0, 0, 0, 0]"], ["[1, 2, 3, 4, 0]"], ["[4, 3, 2, 1, 0]"], ["[0, 1, 2, 3, 4]"], ["[2, 0, 1]"], ["[1, 0, 2]"], ["[0, 2, 1]"], ["[5, 4, 3, 2, 1, 0]"], ["[0, 0, 1, 1, 2, 2]"], ["[3, 3, 3, 3]"], ["[4, 0, 1, 2, 3]"], ["[2, 3, 1, 4, 0, 5]"], ["[1]"], ["[0, 1, 2, 3, 4, 5, 6, 7]"], ["[7, 6, 5, 4, 3, 2, 1, 0]"], ["[3, 1, 2]"], ["[4, 4, 4, 4, 4]"]], "expected": [3, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 4, 0, 0, 1, 0, 0, 1, 0, 0, 1, 4, 0, 0, 1, 0, 0], "loose": false}

package/data/problems/smallest-string-starting-from-leaf.json

@@ -0,0 +1 @@
+{"basic": false, "label": "971", "slug": "smallest-string-starting-from-leaf", "id": 971, "title": "Smallest String Starting From Leaf", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/smallest-string-starting-from-leaf/", "examples": [{"input": "root = [0,1,2,3,4,3,4]", "output": "\"dba\"", "explanation": "Leaf-to-root strings include dba, eba and others; dba is the smallest."}, {"input": "root = [25,1,3,1,3,0,2]", "output": "\"adz\"", "explanation": "The covering leaf strings are compared; adz is minimal."}, {"input": "root = [2,2,1,null,1,0,null,0]", "output": "\"abc\"", "explanation": "Only a few root paths exist and abc is the smallest leaf-up spelling."}], "hints": ["Map node values 0..25 to letters a..z and read each root-to-leaf path backwards (leaf first).", "Depth-first search carrying the current root-to-leaf character path lets you build each candidate at the leaf.", "Keep the lexicographically smallest candidate across all leaves."], "statement": "Each node of the binary tree holds an integer `0` to `25`, encoding letters `a` to `z` (`0` is `a`, `25` is `z`).\n\nFor every leaf (a node with no children), write the letters along the path from that leaf up to the root, leaf first. Among all such leaf-to-root strings, return the lexicographically smallest one.\n\n**Constraints:**\n- `1 <= number of nodes <= 8500`\n- `0 <= node value <= 25`\n", "solution": "## Approach\n\nDo a depth-first walk carrying the root-to-leaf letters seen so far. At each leaf, reverse the accumulated path to obtain the leaf-to-root spelling and keep the smallest across leaves via lexicographic comparison. Backtracking restores the path for sibling subtrees.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * h), where n is the node count and h is the height, due to reversing leaf paths.\n- **Space Complexity:** O(h) for recursion and the current path.\n\n## Implementation\n\n```python\nclass Solution:\n    def smallestFromLeaf(self, root) -> str:\n        self.best = None\n        path = []\n        def dfs(node):\n            if not node:\n                return\n            path.append(chr(ord('a') + node.val))\n            if not node.left and not node.right:\n                cand = ''.join(reversed(path))\n                if self.best is None or cand < self.best:\n                    self.best = cand\n            else:\n                dfs(node.left)\n                dfs(node.right)\n            path.pop()\n        dfs(root)\n        return self.best or ''\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 SmallestFromLeaf(root *TreeNode) string {\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 smallestFromLeaf(self, root) -> str:\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    string smallestFromLeaf(TreeNode* root) {\n        return \"\";\n    }\n};"}, "fn": "smallestFromLeaf", "params": [{"name": "root", "type": "tree_node"}], "outputType": "string", "tests": [["[0,1,2,3,4,3,4]"], ["[25,1,3,1,3,0,2]"], ["[2,2,1,null,1,0,null,0]"], ["[0]"], ["[25]"], ["[0,1]"], ["[1,0]"], ["[0,null,1]"], ["[2,1,0]"], ["[0,1,2]"], ["[3,2,1,0]"], ["[25,25,25]"], ["[0,0,0,0,0]"], ["[1,2,3,4,5,6,7]"], ["[7,6,5,4,3,2,1]"], ["[0,1,null,2,null,3]"], ["[2,null,1,null,0]"], ["[4,3,2,1,0]"], ["[0,5,5,1,1,1,1]"], ["[10,5,15,3,7,12,20]"], ["[25,1,null,0,null,2]"], ["[3,9,20,null,null,15,7]"], ["[1,2,3,4,null,null,5]"], ["[0,1,2,3,4,5,6,7,8,9,10,11,12,13]"], ["[5,4,3,2,1,0]"], ["[2,2,2,2,2]"], ["[13,12,11,10,9,8]"], ["[0,null,25,null,0,null,25]"]], "expected": ["dba", "adz", "abc", "a", "z", "ba", "ab", "ba", "ac", "ba", "acd", "zz", "aa", "ecb", "bfh", "dcba", "abc", "ade", "bfa", "dfk", "cabz", "hud", "ecb", "hdba", "adf", "cc", "iln", "zaza"], "loose": false}

package/data/problems/smallest-subtree-with-all-the-deepest-nodes.json

@@ -0,0 +1 @@
+{"basic": false, "label": "860", "slug": "smallest-subtree-with-all-the-deepest-nodes", "id": 860, "title": "Smallest Subtree with All the Deepest Nodes", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/smallest-subtree-with-all-the-deepest-nodes/", "examples": [{"input": "root = [3,5,1,6,2,0,8,null,null,7,4]", "output": "[2,7,4]", "explanation": "Deepest leaves 7 and 4 meet at 2."}, {"input": "root = [1]", "output": "[1]", "explanation": "Only one node."}, {"input": "root = [0,1,3,null,2]", "output": "[2]", "explanation": "Single deepest leaf 2."}], "hints": ["Depth of a subtree is one plus the larger of its children's depths; an empty child has depth zero.", "If the left and right depths match, the current node is the meeting point of the deepest leaves below it.", "Otherwise the answer lies entirely in the deeper side, so recurse there."], "statement": "You are given the root of a binary tree in level-order form. Among all nodes, look at those sitting at the greatest depth (the longest root-to-leaf distance).\n\nFind the smallest subtree that holds every such deepest node. Return the root of that subtree, again encoded in level-order form.\n\nIntuitively, walk down until the branches holding the deepest leaves finally meet; that meeting point is the answer.\n\n**Constraints:**\n- The tree holds `1 <= n <= 500` nodes.\n- `0 <= node.val <= 500`\n- All values are unique.\n", "solution": "## Approach\n\nReturn both the depth and the answer for each subtree. An empty spot has depth zero and no answer. For a node, compare the depths from its children: equal depths mean the current node is the lowest common holder of all deepest leaves, while an imbalance means the answer comes from the deeper side with depth increased by one.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of nodes. Each node is visited once.\n- **Space Complexity:** O(h) recursion depth, where h is the tree height.\n\n## Implementation\n\n```python\nclass Solution:\n    def subtreeWithAllDeepest(self, root):\n        def helper(n):\n            if not n:\n                return (None, 0)\n            ln, ld = helper(n.left)\n            rn, rd = helper(n.right)\n            if ld == rd:\n                return (n, ld + 1)\n            if ld > rd:\n                return (ln, ld + 1)\n            return (rn, rd + 1)\n        return helper(root)[0]\n```\n", "starter": {"go": "// Definition for a binary tree node.\n// type TreeNode struct {\n//     Val int\n//     Left *TreeNode\n//     Right *TreeNode\n// }\npackage main\n\nfunc SubtreeWithAllDeepest(root *TreeNode) *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 subtreeWithAllDeepest(self, root):\n        pass", "cpp": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *right;\n *     TreeNode() : val(0), left(nullptr), right(nullptr) {}\n *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n *     TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}\n * };\n */\nclass Solution {\npublic:\n    TreeNode* subtreeWithAllDeepest(TreeNode* root) {\n        return nullptr;\n    }\n};"}, "fn": "subtreeWithAllDeepest", "params": [{"name": "root", "type": "tree_node"}], "outputType": "tree_node", "tests": [["[3,5,1,6,2,0,8,null,null,7,4]"], ["[1]"], ["[0,1,3,null,2]"], ["[1,2,3,4,5,6,7]"], ["[1,2,null,3]"], ["[1,null,2,null,3]"], ["[0,1,2]"], ["[0,3,1,4,null,2]"], ["[1,2,3,4,null,null,null,5]"], ["[10,5,15,3,7,12,20]"], ["[1,2,3,null,4,null,5]"], ["[0]"], ["[5,1,2,3,4]"], ["[1,2]"], ["[2,1]"], ["[1,2,3,4,5,null,6]"], ["[0,1,null,2,null,3]"], ["[3,1,4,null,2]"], ["[7,3,9,1,5,null,10]"], ["[1,null,2,3,4]"], ["[0,1,2,3,null,null,4]"], ["[100,50,150,25,75,125,175]"], ["[1,2,3,4,5,6,null]"], ["[9,8,7,6,5]"], ["[1,2,3,null,null,4,5]"], ["[0,2,1,3,null,null,null,4]"], ["[11,10,12,9,null,null,13]"], ["[1,2,3,4,null,5,6,null,null,7]"]], "expected": null, "loose": false}

package/data/problems/snakes-and-ladders.json

@@ -0,0 +1 @@
+{"basic": false, "label": "898", "slug": "snakes-and-ladders", "id": 898, "title": "Snakes and Ladders", "difficulty": "Medium", "category": "graph", "link": "https://leetcode.com/problems/snakes-and-ladders/", "examples": [{"input": "board = [[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,35,-1,-1,13,-1],[-1,-1,-1,-1,-1,-1],[-1,15,-1,-1,-1,-1]]", "output": "4", "explanation": "Climb the ladder from square 2 to 15, then advance and ride the remaining jumps to reach square 36 in 4 throws."}, {"input": "board = [[-1,-1],[-1,3]]", "output": "1", "explanation": "Roll from square 1 to square 2, whose ladder leads directly to square 4."}, {"input": "board = [[-1,-1,-1],[-1,-1,-1],[-1,-1,-1]]", "output": "2", "explanation": "With no snakes or ladders, two throws of 6 reach square 9 (1 -> 7 -> 9)."}], "hints": ["Number the squares from 1 at the bottom-left, snaking back and forth each row, so every cell maps to exactly one square.", "From each square the reachable squares are the next 1 to 6 labels (capped at n squared), following any snake or ladder immediately.", "Breadth-first search over squares gives the fewest throws; return -1 when the last square is never reached."], "statement": "An `n x n` board holds the squares numbered `1` to `n * n`. Numbering starts at the bottom-left corner with `1`, runs left to right across the bottom row, then continues right to left on the row above, alternating direction on every row (boustrophedon order).\n\nEach cell is either `-1` (nothing happens there) or the number of a destination square: landing on it via a die throw forces an immediate jump to that destination (a ladder when the destination is larger, a snake when it is smaller). You start on square `1`. Each throw lets you pick any of the next 1 to 6 squares ahead (never past `n * n`); if the chosen square holds a jump, you take it at once. Return the smallest number of throws needed to land exactly on square `n * n`, or `-1` if it cannot be reached.\n\n**Constraints:**\n- `n == board.length == board[i].length`\n- `2 <= n <= 20`\n- `board[i][j]` is `-1` or an integer in `[1, n * n]`\n", "solution": "## Approach\n\nLabel every cell with its square number by walking rows from the bottom, flipping the column direction on alternate rows. From a square, each die outcome leads to one of the following six labels (clamped to the final square), with snakes and ladders applied instantly. Since every throw costs the same, breadth-first search from square 1 yields the minimum throw count, and an unvisited final square means it is unreachable.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2), each square is enqueued at most once with up to 6 transitions.\n- **Space Complexity:** O(n^2) for the distance table and queue.\n\n## Implementation\n\n```python\nfrom typing import List\nfrom collections import deque\nclass Solution:\n    def snakesAndLadders(self, board: List[List[int]]) -> int:\n        n = len(board)\n        target = n * n\n        def coords(s: int):\n            q, r = divmod(s - 1, n)\n            row = n - 1 - q\n            col = r if q % 2 == 0 else n - 1 - r\n            return row, col\n        dist = {1: 0}\n        dq = deque([1])\n        while dq:\n            cur = dq.popleft()\n            if cur == target:\n                return dist[cur]\n            for nxt in range(cur + 1, min(cur + 6, target) + 1):\n                r, c = coords(nxt)\n                dest = board[r][c] if board[r][c] != -1 else nxt\n                if dest not in dist:\n                    dist[dest] = dist[cur] + 1\n                    dq.append(dest)\n        return -1\n```\n", "starter": {"go": "package main\n\nfunc SnakesAndLadders(board [][]int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def snakesAndLadders(self, board: List[List[int]]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int snakesAndLadders(vector<vector<int>>& board) {\n        return 0;\n    }\n};"}, "fn": "snakesAndLadders", "params": [{"name": "board", "type": "int_array_2d"}], "outputType": "int", "tests": [["[[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,-1,-1,-1,-1,-1],[-1,35,-1,-1,13,-1],[-1,-1,-1,-1,-1,-1],[-1,15,-1,-1,-1,-1]]"], ["[[-1,-1],[-1,3]]"], ["[[-1,-1,-1],[-1,-1,-1],[-1,-1,-1]]"], ["[[1,1,1],[1,1,1],[1,1,-1]]"], ["[[-1, -1, -1], [-1, -1, -1], [5, -1, -1]]"], ["[[-1, -1, 13, -1, -1, -1], [-1, -1, -1, 36, -1, -1], [-1, -1, -1, -1, -1, 31], [-1, -1, 9, 30, 25, 13], [-1, -1, 34, 3, 14, -1], [24, 15, 5, -1, 25, -1]]"], ["[[-1, -1, -1], [4, 7, -1], [-1, -1, -1]]"], ["[[-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1]]"], ["[[-1, -1, -1, -1], [14, -1, -1, -1], [-1, 1, -1, 9], [-1, -1, -1, -1]]"], ["[[-1, 4], [-1, -1]]"], ["[[-1, -1, -1, -1], [-1, -1, -1, -1], [-1, -1, -1, -1], [-1, -1, -1, -1]]"], ["[[-1, -1, -1], [-1, -1, -1], [-1, 1, -1]]"], ["[[-1, -1], [-1, 4]]"], ["[[-1, -1, 4, -1], [-1, -1, -1, -1], [12, -1, -1, 3], [-1, -1, 5, 10]]"], ["[[-1, -1, -1, -1, 17, 10], [-1, -1, 29, 16, -1, -1], [-1, -1, -1, -1, -1, 27], [-1, 18, -1, -1, -1, -1], [-1, -1, -1, 5, 30, -1], [-1, 19, -1, 24, -1, 17]]"], ["[[-1, -1, -1, 16], [-1, -1, -1, -1], [11, -1, 11, 1], [-1, 14, -1, -1]]"], ["[[8, -1, -1], [5, -1, -1], [-1, -1, -1]]"], ["[[-1, -1], [-1, -1]]"], ["[[-1, 29, -1, 8, -1, 17], [-1, -1, -1, -1, -1, 23], [34, -1, 29, -1, -1, -1], [-1, -1, -1, 2, -1, -1], [19, -1, 14, -1, -1, -1], [-1, 9, 35, -1, -1, -1]]"], ["[[-1, 6, -1, 11], [-1, -1, 8, 9], [-1, -1, 3, -1], [13, -1, 14, -1]]"], ["[[4, -1, -1], [8, -1, 2], [5, -1, -1]]"], ["[[-1, -1, -1], [-1, -1, -1], [-1, 6, 1]]"], ["[[-1, 6, -1], [7, -1, -1], [-1, -1, -1]]"], ["[[-1, -1, -1], [-1, 3, -1], [-1, 4, -1]]"], ["[[-1, 13, -1, 5, -1], [-1, -1, -1, -1, 11], [-1, -1, 23, 3, 21], [-1, -1, -1, -1, -1], [-1, -1, -1, -1, -1]]"], ["[[-1, 4, -1], [-1, 4, -1], [-1, -1, -1]]"], ["[[-1, -1, -1], [-1, -1, 8], [-1, 1, -1]]"], ["[[-1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1]]"]], "expected": [4, 1, 2, -1, 2, 2, 2, 4, 3, 1, 3, 2, 1, 2, 3, 2, 2, 1, 2, 2, 2, 2, 2, 2, 3, 2, 2, 6], "loose": false}

package/data/problems/solve-the-equation.json

@@ -0,0 +1 @@
+{"basic": false, "label": "662", "slug": "solve-the-equation", "id": 662, "title": "Solve the Equation", "difficulty": "Medium", "category": "math", "link": "https://leetcode.com/problems/solve-the-equation/", "examples": [{"input": "equation = \"x+5-3+x=6+x-2\"", "output": "\"x=2\"", "explanation": "The left side groups to 2x+2 and the right side to x+4, so x = 2."}, {"input": "equation = \"x=x\"", "output": "\"Infinite solutions\""}, {"input": "equation = \"2x=x\"", "output": "\"x=0\""}], "hints": ["Parse each side separately into (x-coefficient, constant) by scanning sign by sign.", "A missing number before x means 1; a lone sign before x means +1 or -1.", "Move everything to one side: (lc - rc) * x = rconst - lconst, then branch on a zero coefficient."], "statement": "You get a string equation with exactly one `=` sign, for example `\"x+5-3+x=6+x-2\"`. Each side is a sum of integer constants and `x` terms such as `\"2x\"`, `\"-x\"`, or `\"x\"`. There are no parentheses and no powers.\n\nSolve for `x` and implement `solveEquation(equation)`:\n\n- If exactly one integer solution exists, return `\"x=<value>\"`, e.g. `\"x=2\"`.\n- If every integer satisfies the equation, return `\"Infinite solutions\"`.\n- If no value satisfies it, return `\"No solution\"`.\n\n**Constraints:**\n- `3 <= equation.length <= 1000`\n- The equation holds digits, `x`, `+`, `-`, and exactly one `=`.\n- Every term is valid; a bare `x` means coefficient 1 and `-x` means -1.\n- If a unique solution exists, it fits in a 32-bit signed integer.\n", "solution": "## Approach\n\nSplit the equation at `=` and fold each side into a pair of (x coefficient, constant) with a single left-to-right scan that tracks the current sign. A digit run followed by `x` adds to the coefficient (defaulting to 1 when no digits precede it); otherwise it adds to the constant. Subtracting the right pair from the left pair reduces the problem to `cx * x = cc`, which yields the three answer shapes directly.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the equation length. Each character is visited once.\n- **Space Complexity:** O(1) beyond the input.\n\n## Implementation\n\n```python\nclass Solution:\n    def solveEquation(self, equation: str) -> str:\n        def parse(s):\n            coeff = con = i = 0\n            n = len(s)\n            while i < n:\n                sign = 1\n                if s[i] == \"+\":\n                    i += 1\n                elif s[i] == \"-\":\n                    sign = -1\n                    i += 1\n                num, has = 0, False\n                while i < n and s[i].isdigit():\n                    num = num * 10 + int(s[i])\n                    i += 1\n                    has = True\n                if i < n and s[i] == \"x\":\n                    coeff += sign * (num if has else 1)\n                    i += 1\n                else:\n                    con += sign * num\n            return coeff, con\n        left, right = equation.split(\"=\")\n        lc, lcon = parse(left)\n        rc, rcon = parse(right)\n        cx, cc = lc - rc, rcon - lcon\n        if cx == 0:\n            return \"Infinite solutions\" if cc == 0 else \"No solution\"\n        return f\"x={cc // cx}\"\n```\n", "starter": {"go": "package main\n\nfunc SolveEquation(equation string) string {\n    return \"\"\n}", "python": "from typing import List\nclass Solution:\n    def solveEquation(self, equation: str) -> str:\n        pass", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    string solveEquation(string equation) {\n        return \"\";\n    }\n};"}, "fn": "solveEquation", "params": [{"name": "equation", "type": "string"}], "outputType": "string", "tests": [["x+5-3+x=6+x-2"], ["x=x"], ["2x=x"], ["x=x+1"], ["2x+3x-6x=x+2"], ["3x=33+22+11"], ["-x=-1"], ["x+1=x+1"], ["2x+1=2x+1"], ["2x+1=2x+2"], ["0x=0"], ["0x=1"], ["x-1=2"], ["2-x=0"], ["10x-5=5"], ["x-5x+3=7"], ["100=10x"], ["-2x+4=0"], ["x+100=200"], ["99x=99"], ["1+1=x"], ["2=x"], ["x=2"], ["3x+2=11"], ["-x+5=3"], ["4x-8=12"], ["7=7"], ["8=9"]], "expected": ["x=2", "Infinite solutions", "x=0", "No solution", "x=-1", "x=22", "x=1", "Infinite solutions", "Infinite solutions", "No solution", "Infinite solutions", "No solution", "x=3", "x=2", "x=1", "x=-1", "x=10", "x=2", "x=100", "x=1", "x=2", "x=2", "x=2", "x=3", "x=2", "x=5", "Infinite solutions", "No solution"], "loose": false}