offcode 0.0.0-stage → 0.1.1

package/data/problems/profitable-schemes.json

@@ -0,0 +1 @@
+{"basic": false, "label": "871", "slug": "profitable-schemes", "id": 871, "title": "Profitable Schemes", "difficulty": "Hard", "category": "dp", "link": "https://leetcode.com/problems/profitable-schemes/", "examples": [{"input": "n = 5, minProfit = 3, group = [2,2], profit = [2,3]", "output": "2", "explanation": "Running only the second scheme earns 3, and running both earns 5; both plans fit in 5 members."}, {"input": "n = 10, minProfit = 5, group = [2,3,5], profit = [6,7,8]", "output": "7", "explanation": "Every non-empty collection earns at least 5 and uses at most 10 members, giving 2^3 - 1 = 7 plans."}, {"input": "n = 1, minProfit = 1, group = [1], profit = [1]", "output": "1", "explanation": "The single scheme fits and earns exactly 1."}], "hints": ["Treat this as a knapsack over people and profit: dp[j][p] counts ways using j members to reach profit p.", "Cap every profit at minProfit so the table stays small, iterate members and profit downward per scheme, and take all counts modulo 10^9 + 7."], "statement": "A gang wants to run criminal schemes. There are `group.length` schemes; scheme `i` needs `group[i]` members and yields `profit[i]` coins. You have at most `n` members in total, and each scheme can be used at most once.\n\nA plan is any collection of schemes whose member requirement fits within `n` people and whose total profit reaches at least `minProfit`. Count all such plans, including the choice of running nothing when it qualifies. Return the count modulo `10^9 + 7`.\n\n**Constraints:**\n- `1 <= n <= 100`\n- `0 <= minProfit <= 100`\n- `1 <= group.length <= 100`\n- `1 <= group[i] <= 100`\n- `0 <= profit[i] <= 100`\n", "solution": "## Approach\n\nThis is a two-dimensional knapsack: `dp[j][p]` counts the plans that use exactly `j` members and bank profit `p`, where every profit above the target is folded down into the target column so the table stays compact. Each scheme is considered once, updating the table backwards over members and profit so no scheme is reused within its own step. The answer sums the target-profit column over all feasible member counts, modulo `10^9 + 7`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n * minProfit), where m is the number of schemes.\n- **Space Complexity:** O(n * minProfit) for the counting table.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n    def profitableSchemes(self, n: int, minProfit: int, group: List[int], profit: List[int]) -> int:\n        MOD = 1000000007\n        dp = [[0] * (minProfit + 1) for _ in range(n + 1)]\n        dp[0][0] = 1\n        for g, p in zip(group, profit):\n            for j in range(n, g - 1, -1):\n                for k in range(minProfit, -1, -1):\n                    nk = min(minProfit, k + p)\n                    dp[j][nk] = (dp[j][nk] + dp[j - g][k]) % MOD\n        return sum(dp[j][minProfit] for j in range(n + 1)) % MOD\n```\n", "starter": {"go": "package main\n\nfunc ProfitableSchemes(n int, minProfit int, group []int, profit []int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def profitableSchemes(self, n: int, minProfit: int, group: List[int], profit: List[int]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int profitableSchemes(int n, int minProfit, vector<int>& group, vector<int>& profit) {\n        return 0;\n    }\n};"}, "fn": "profitableSchemes", "params": [{"name": "n", "type": "int"}, {"name": "minProfit", "type": "int"}, {"name": "group", "type": "int_array"}, {"name": "profit", "type": "int_array"}], "outputType": "int", "tests": [["5", "3", "[2,2]", "[2,3]"], ["10", "5", "[2,3,5]", "[6,7,8]"], ["1", "1", "[1]", "[1]"], ["1", "2", "[1]", "[1]"], ["2", "2", "[1,1,1]", "[1,1,1]"], ["3", "0", "[1,2]", "[0,0]"], ["100", "100", "[100]", "[100]"], ["4", "4", "[2,2,2]", "[3,3,3]"], ["6", "4", "[2,2,2]", "[3,3,3]"], ["3", "3", "[1,1,1,1]", "[1,2,1,2]"], ["5", "5", "[1,1,1]", "[2,2,2]"], ["10", "1", "[5,5]", "[0,1]"], ["2", "5", "[2,2]", "[5,5]"], ["7", "6", "[3,2,2]", "[4,3,3]"], ["5", "10", "[2,3]", "[5,6]"], ["1", "0", "[1,1]", "[0,0]"], ["10", "10", "[1,2,3,4]", "[1,2,3,4]"], ["20", "8", "[4,4,4,4]", "[3,3,3,3]"], ["3", "2", "[3]", "[5]"], ["2", "2", "[3]", "[5]"], ["50", "25", "[10,10,10,10,10]", "[10,10,10,10,10]"], ["6", "3", "[1,1,1,1,1,1]", "[1,1,1,1,1,1]"], ["8", "7", "[2,3,4]", "[2,5,5]"], ["15", "12", "[5,5,5]", "[6,6,6]"], ["4", "1", "[4,4]", "[1,1]"], ["30", "20", "[5,5,5,5,5,5,5,5]", "[4,4,4,4,4,4,4,4]"], ["100", "50", "[10,10,10,10,10,10,10,10,10,10]", "[10,10,10,10,10,10,10,10,10,10]"], ["2", "0", "[1]", "[0]"]], "expected": [2, 7, 1, 0, 3, 4, 1, 3, 4, 9, 1, 2, 2, 4, 1, 3, 1, 5, 1, 0, 16, 42, 3, 4, 2, 84, 638, 2], "loose": false}

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

@@ -0,0 +1 @@
+{"basic": false, "label": "874", "slug": "projection-area-of-3d-shapes", "id": 874, "title": "Projection Area of 3D Shapes", "difficulty": "Easy", "category": "matrix", "link": "https://leetcode.com/problems/projection-area-of-3d-shapes/", "examples": [{"input": "grid = [[1,2],[3,4]]", "output": "17", "explanation": "4 squares from above, 2 + 4 = 6 from the front, and 3 + 4 = 7 from the side."}, {"input": "grid = [[2]]", "output": "5", "explanation": "1 from above, 2 from the front, and 2 from the side."}, {"input": "grid = [[1,0],[0,2]]", "output": "8", "explanation": "2 from above, 1 + 2 = 3 from the front, and 1 + 2 = 3 from the side."}], "hints": ["The top view is simply the count of cells holding at least one cube.", "The front view sums each row's maximum and the side view sums each column's maximum."], "statement": "A square `n x n` grid describes stacks of unit cubes: `grid[i][j]` cubes are piled on cell `(i, j)`. Picture the solid from three sides and count the visible unit squares:\n\n- From above, every non-empty cell shows exactly one square.\n- From the front, each row shows as many squares as its tallest stack.\n- From the side, each column shows as many squares as its tallest stack.\n\nReturn the sum of the three views.\n\n**Constraints:**\n- `n == grid.length == grid[i].length`\n- `1 <= n <= 50`\n- `0 <= grid[i][j] <= 100`\n", "solution": "## Approach\n\nThe three views separate cleanly. Scan every cell once: each positive cell adds one to the top view, and each row's running maximum feeds the front view. A second pass over the columns collects each column's maximum for the side view. Adding the three totals gives the answer.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2) for the full scan of the n x n grid.\n- **Space Complexity:** O(1) besides the input.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n    def projectionArea(self, grid: List[List[int]]) -> int:\n        n = len(grid)\n        top = sum(1 for i in range(n) for j in range(n) if grid[i][j] > 0)\n        front = sum(max(row) for row in grid)\n        side = sum(max(grid[i][j] for i in range(n)) for j in range(n))\n        return top + front + side\n```\n", "starter": {"go": "package main\n\nfunc ProjectionArea(grid [][]int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def projectionArea(self, grid: List[List[int]]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int projectionArea(vector<vector<int>>& grid) {\n        return 0;\n    }\n};"}, "fn": "projectionArea", "params": [{"name": "grid", "type": "int_array_2d"}], "outputType": "int", "tests": [["[[1,2],[3,4]]"], ["[[2]]"], ["[[1,0],[0,2]]"], ["[[1,1,1],[1,0,1],[1,1,1]]"], ["[[2,2,2],[2,1,2],[2,2,2]]"], ["[[0]]"], ["[[5]]"], ["[[0,0],[0,0]]"], ["[[3,0,0],[0,0,0],[0,0,0]]"], ["[[1,2,3],[4,5,6],[7,8,9]]"], ["[[9,8,7],[6,5,4],[3,2,1]]"], ["[[0,1],[1,0]]"], ["[[4,4],[4,4]]"], ["[[1,3],[5,4]]"], ["[[0,0,5],[0,0,0],[0,0,0]]"], ["[[2,0,0],[0,3,0],[0,0,4]]"], ["[[7,7,7,7],[7,7,7,7],[7,7,7,7],[7,7,7,7]]"], ["[[1,0,0,0],[0,2,0,0],[0,0,3,0],[0,0,0,4]]"], ["[[100]]"], ["[[0,5],[5,0]]"], ["[[6,1,6],[1,6,1],[6,1,6]]"], ["[[2,5,1],[1,4,3],[6,2,7]]"], ["[[10,0],[0,10]]"], ["[[3,3,3],[0,0,0],[2,2,2]]"], ["[[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]"], ["[[0,0,0,9],[0,0,0,0],[0,0,0,0],[0,0,0,0]]"], ["[[5,1],[2,3]]"], ["[[8,3,5],[2,9,1],[4,6,7]]"]], "expected": [17, 5, 8, 14, 21, 0, 11, 0, 7, 51, 51, 6, 20, 21, 11, 21, 72, 24, 201, 22, 45, 43, 42, 20, 114, 19, 20, 57], "loose": false}

package/data/problems/push-dominoes.json

@@ -0,0 +1 @@
+{"basic": false, "label": "836", "slug": "push-dominoes", "id": 836, "title": "Push Dominoes", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/push-dominoes/", "examples": [{"input": "dominoes = \"RR.L\"", "output": "\"RR.L\"", "explanation": "The middle dot is pulled both ways and stays upright."}, {"input": "dominoes = \".L.R...LR..L..\"", "output": "\"LL.RR.LLRRLL..\""}], "hints": ["Compute a left-to-right force wave (R pushes decay with distance, L resets it) and a mirrored right-to-left wave, then combine them.", "A positive combined force means R wins, a negative one means L wins, and zero means the piece stays upright.", "Segments between an R and a later L split in the middle; equal halves leave the centre standing when the gap is odd."], "statement": "A row of dominoes is written as a string where `L` means the piece already falls left, `R` means it falls right, and `.` means it stands upright. All standing dominoes then topple simultaneously in rounds: in each round, a standing piece falls left if its left neighbour already falls (or is falling) left, and falls right if its right neighbour falls right. A piece with one neighbour pulling left and the other pulling right stays upright (the forces balance). Fallen pieces never move again. Return the final configuration once nothing can change.\n\n**Constraints:**\n- `1 <= dominoes.length <= 10^5`\n- `dominoes[i]` is `L`, `R`, or `.`\n", "solution": "## Approach\n\nSweep left to right carrying a decaying rightward force that an R refreshes to full strength and an L clears; add it per cell. Sweep right to left the same way for leftward force and subtract it. Each cell's sign then decides its fate: positive falls right, negative falls left, zero stays upright \u2014 which naturally splits R...L gaps down the middle.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) where n is the number of dominoes; two linear sweeps.\n- **Space Complexity:** O(n) for the force array.\n\n## Implementation\n\n```python\nclass Solution:\n    def pushDominoes(self, dominoes: str) -> str:\n        n = len(dominoes)\n        force = [0] * n\n        f = 0\n        for i, c in enumerate(dominoes):\n            if c == \"R\":\n                f = n\n            elif c == \"L\":\n                f = 0\n            else:\n                f = max(f - 1, 0)\n            force[i] += f\n        f = 0\n        for i in range(n - 1, -1, -1):\n            c = dominoes[i]\n            if c == \"L\":\n                f = n\n            elif c == \"R\":\n                f = 0\n            else:\n                f = max(f - 1, 0)\n            force[i] -= f\n        return \"\".join(\"R\" if x > 0 else (\"L\" if x < 0 else \".\") for x in force)\n```\n", "starter": {"go": "package main\n\nfunc PushDominoes(dominoes string) string {\n    return \"\"\n}", "python": "class Solution:\n    def pushDominoes(self, dominoes: str) -> str:\n        return \"\"\n", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    string pushDominoes(string dominoes) {\n        return \"\";\n    }\n};"}, "fn": "pushDominoes", "params": [{"name": "dominoes", "type": "string"}], "outputType": "string", "tests": [["RR.L"], [".L.R...LR..L.."], ["R.R.L"], ["."], ["L"], ["R"], ["..."], ["LLL"], ["RRR"], ["R....L"], ["R...L"], ["R..L"], ["R.L"], ["R..........L"], ["L..........R"], [".L.R."], ["R......"], ["......L"], ["RRRR....LLLL"], ["R.L.R.L.R.L"], ["..R..LL..R.."], ["L.R.L.R.L.R."], [".R..L..R..L."], ["R"], ["RL"], ["LR"], [".R."], [".L.L.R.R."]], "expected": ["RR.L", "LL.RR.LLRRLL..", "RRR.L", ".", "L", "R", "...", "LLL", "RRR", "RRRLLL", "RR.LL", "RRLL", "R.L", "RRRRRRLLLLLL", "L..........R", "LL.RR", "RRRRRRR", "LLLLLLL", "RRRRRRLLLLLL", "R.L.R.L.R.L", "..RRLLL..RRR", "L.R.L.R.L.RR", ".RRLL..RRLL.", "R", "RL", "LR", ".RR", "LLLL.RRRR"], "loose": false}

package/data/problems/pyramid-transition-matrix.json

@@ -0,0 +1 @@
+{"basic": false, "label": "758", "slug": "pyramid-transition-matrix", "id": 758, "title": "Pyramid Transition Matrix", "difficulty": "Medium", "category": "backtracking", "link": "https://leetcode.com/problems/pyramid-transition-matrix/", "examples": [{"input": "bottom = \"BCD\", allowed = [\"BCC\",\"CDE\",\"CEA\",\"FFF\"]", "output": "true", "explanation": "Build CE then A."}, {"input": "bottom = \"AAAA\", allowed = [\"AAB\",\"AAC\",\"BCD\",\"BBE\",\"DEF\"]", "output": "false", "explanation": "No second row leads to a full pyramid."}], "hints": ["Group allowed triples by their two-letter base so each pair quickly yields its possible tops.", "Build the next row one position at a time with backtracking; abandon a row as soon as a pair has no options.", "Memoize failed rows to avoid re-exploring dead ends from different paths."], "statement": "You stack colored blocks into a centered pyramid. The bottom row is the string `bottom`, and every row above holds one fewer block than the row below it.\n\nA block resting on two neighbors is allowed only when the triple (left base, right base, top) appears in the list `allowed`. Each entry of `allowed` is a three-letter string where the first two letters are the base pair and the third is the block they support. Order matters: `ABC` differs from `BAC`.\n\nDecide whether the bottom row can grow all the way to a single top block using only allowed triples.\n\nAdaptation for this judge: the original input gives `allowed` as a list of strings; here it arrives as a string array with the same contents.\n\n**Constraints:**\n- `2 <= bottom.length <= 6`\n- `0 <= allowed.length <= 216`\n- Each entry of `allowed` has length 3.\n- All letters come from `A` through `F`.\n- All entries of `allowed` are distinct.\n", "solution": "## Approach\n\nIndex every allowed triple by its two-letter base to list possible tops instantly. Then search depth-first: expand the current row into all candidate rows above it by combining per-pair options, and recurse on each candidate. Cache rows proven impossible so repeated states are skipped. Reaching a single block means success.\n\n## Complexity Analysis\n\n- **Time Complexity:** Exponential in the worst case, but tiny here since the base holds at most 6 blocks over 6 letters.\n- **Space Complexity:** O(R * B) for the map plus recursion state, where R is the number of distinct pairs and B bounds the candidate rows.\n\n## Implementation\n\n```python\nfrom typing import List\nfrom collections import defaultdict\nclass Solution:\n    def pyramidTransition(self, bottom: str, allowed: List[str]) -> bool:\n        table = defaultdict(list)\n        for s in allowed:\n            table[s[:2]].append(s[2])\n        failed = set()\n        def dfs(row):\n            if len(row) == 1:\n                return True\n            if row in failed:\n                return False\n            cands = ['']\n            for i in range(len(row) - 1):\n                tops = table.get(row[i:i+2])\n                if not tops:\n                    failed.add(row)\n                    return False\n                cands = [r + c for r in cands for c in tops]\n            for nx in cands:\n                if dfs(nx):\n                    return True\n            failed.add(row)\n            return False\n        return dfs(bottom)\n```\n", "starter": {"go": "package main\n\nfunc PyramidTransition(bottom string, allowed []string) bool {\n    return false\n}", "python": "from typing import List\nclass Solution:\n    def pyramidTransition(self, bottom: str, allowed: List[str]) -> bool:\n        pass", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    bool pyramidTransition(string bottom, vector<string>& allowed) {\n        return false;\n    }\n};"}, "fn": "pyramidTransition", "params": [{"name": "bottom", "type": "string"}, {"name": "allowed", "type": "string_array"}], "outputType": "boolean", "tests": [["BCD", "['BCC', 'CDE', 'CEA', 'FFF']"], ["AAAA", "['AAB', 'AAC', 'BCD', 'BBE', 'DEF']"], ["AB", "['ABC']"], ["AB", "[]"], ["AB", "['BAC']"], ["BCD", "['BCC', 'CDE', 'CEA']"], ["BCD", "['BCC', 'CDE']"], ["BCD", "['CDE', 'CEA']"], ["AAA", "['AAA']"], ["AAA", "['AAB']"], ["AAAAAA", "['AAA']"], ["ABCDEF", "[]"], ["AA", "['AAB', 'AAC']"], ["AB", "['ABC', 'ABD']"], ["ABC", "['ABC', 'BCD', 'CDE', 'DEF', 'EFA', 'FAB']"], ["AB", "['ABA', 'ABB', 'ABC', 'ABD', 'ABE', 'ABF']"], ["FF", "['FFF']"], ["FF", "['FFE']"], ["ABC", "['ABD', 'BCE', 'DEF']"], ["ABC", "['ABD', 'BCE']"], ["AABB", "['AAB', 'ABB', 'BBB', 'BBC']"], ["ABCD", "['ABC', 'BCD', 'CDE', 'DEF', 'EFG']"], ["EF", "['EFA', 'EFB']"], ["CD", "['CDA', 'CDB', 'CDC']"], ["BC", "['BCB', 'BCC']"], ["AAAB", "['AAA', 'AAB']"], ["ABCDEF", "['ABC', 'BCD', 'CDE', 'DEF', 'EFA', 'FAB']"], ["ABCDE", "['ABC', 'BCD', 'CDE', 'DEF', 'EFA', 'BCA', 'CAB']"]], "expected": null, "loose": false}

package/data/problems/queue-reconstruction-by-height.json

@@ -0,0 +1 @@
+{"basic": false, "label": "480", "slug": "queue-reconstruction-by-height", "id": 480, "title": "Queue Reconstruction by Height", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/queue-reconstruction-by-height/", "examples": [{"input": "people = [[7,0],[4,4],[7,1],[5,0],[6,1],[5,2]]", "output": "[[5,0],[7,0],[5,2],[6,1],[4,4],[7,1]]", "explanation": "Sorting tall-first then slotting each person at their k index rebuilds the line."}, {"input": "people = [[6,0],[5,0],[4,0],[3,2],[2,2],[1,4]]", "output": "[[4,0],[5,0],[2,2],[3,2],[1,4],[6,0]]", "explanation": "Shorter people slide into the gaps left by taller ones already placed."}], "hints": ["Order people by height descending, breaking ties by k ascending.", "Insert each person at index k of the growing line; taller people already placed are exactly the ones each k counts.", "Insertion into a list gives O(n^2) time, fine for n up to 2000."], "statement": "A crowd is described by pairs `[h, k]`: person height `h` and the count `k` of people in front who are at least as tall as `h`. The given `people` array holds these pairs in no particular order, and exactly one line ordering satisfies every pair.\n\nRebuild that line: return the pairs from front to back so that each entry's `k` equals the number of earlier entries whose height is greater than or equal to its own.\n\n**Constraints:**\n- `1 <= people.length <= 2000`\n- `0 <= h <= 10^6`\n- `0 <= k < people.length`\n- A valid reconstruction always exists.\n", "solution": "## Approach\n\nSort everyone tallest first, with smaller k first among equal heights. Then walk that order and insert each person at index k of the current line. Because all previously placed people are at least as tall, index k is precisely where that person's taller-or-equal count matches, and later shorter arrivals never disturb earlier counts.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2) due to sorting plus list insertions.\n- **Space Complexity:** O(n) for the growing line.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:\n        people = sorted(people, key=lambda x: (-x[0], x[1]))\n        line: List[List[int]] = []\n        for p in people:\n            line.insert(p[1], p)\n        return line\n```\n", "starter": {"go": "package main\n\nfunc ReconstructQueue(people [][]int) [][]int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def reconstructQueue(self, people: List[List[int]]) -> List[List[int]]:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<vector<int>> reconstructQueue(vector<vector<int>>& people) {\n        return {};\n    }\n};"}, "fn": "reconstructQueue", "params": [{"name": "people", "type": "int_array_2d"}], "outputType": "int_array_2d", "tests": [["[[7, 0], [4, 4], [7, 1], [5, 0], [6, 1], [5, 2]]"], ["[[6, 0], [5, 0], [4, 0], [3, 2], [2, 2], [1, 4]]"], ["[[1, 0]]"], ["[[2, 0], [1, 0]]"], ["[[3, 0], [1, 0]]"], ["[[1, 2], [4, 0], [6, 0]]"], ["[[2, 0], [4, 0], [1, 1], [5, 0]]"], ["[[5, 2], [5, 0], [5, 1], [3, 4], [5, 3]]"], ["[[1, 3], [6, 1], [0, 3], [5, 2], [1, 1], [6, 0]]"], ["[[4, 1], [4, 2], [2, 4], [0, 3], [6, 0], [0, 6], [2, 1]]"], ["[[6, 0], [4, 1], [3, 2], [0, 1], [0, 2], [3, 4], [5, 1], [4, 3]]"], ["[[3, 3], [4, 1], [3, 0], [4, 4], [5, 3], [6, 1], [5, 0], [6, 0], [1, 4]]"], ["[[5, 0], [1, 1]]"], ["[[2, 1], [1, 2], [3, 0]]"], ["[[6, 0], [3, 0], [6, 1], [4, 1]]"], ["[[3, 1], [1, 0], [2, 1], [1, 3], [6, 0]]"], ["[[2, 5], [4, 3], [6, 0], [4, 2], [3, 1], [5, 1]]"], ["[[5, 2], [5, 0], [6, 0], [0, 1], [0, 2], [2, 0], [6, 1]]"], ["[[0, 3], [4, 3], [4, 1], [1, 3], [5, 0], [1, 6], [2, 2], [5, 1]]"], ["[[6, 1], [2, 3], [6, 0], [0, 6], [4, 2], [0, 0], [2, 0], [1, 1], [6, 2]]"], ["[[5, 1], [6, 0]]"], ["[[1, 2], [1, 1], [1, 0]]"], ["[[5, 1], [5, 0], [2, 0], [1, 2]]"], ["[[2, 1], [4, 2], [1, 0], [5, 0], [6, 0]]"], ["[[4, 1], [1, 0], [4, 3], [5, 1], [1, 2], [5, 0]]"], ["[[1, 3], [0, 1], [5, 1], [6, 0], [4, 2], [1, 4], [3, 3]]"], ["[[4, 2], [4, 0], [2, 4], [1, 3], [2, 3], [5, 0], [0, 5], [6, 0]]"], ["[[0, 7], [2, 3], [2, 0], [3, 3], [6, 0], [0, 8], [0, 4], [6, 2], [6, 1]]"], ["[[2, 1], [4, 0]]"], ["[[1, 1], [1, 0], [6, 0]]"]], "expected": [[[5, 0], [7, 0], [5, 2], [6, 1], [4, 4], [7, 1]], [[4, 0], [5, 0], [2, 2], [3, 2], [1, 4], [6, 0]], [[1, 0]], [[1, 0], [2, 0]], [[1, 0], [3, 0]], [[4, 0], [6, 0], [1, 2]], [[2, 0], [1, 1], [4, 0], [5, 0]], [[5, 0], [5, 1], [5, 2], [5, 3], [3, 4]], [[6, 0], [1, 1], [6, 1], [0, 3], [1, 3], [5, 2]], [[6, 0], [2, 1], [4, 1], [0, 3], [4, 2], [2, 4], [0, 6]], [[6, 0], [0, 1], [0, 2], [4, 1], [3, 2], [5, 1], [3, 4], [4, 3]], [[3, 0], [5, 0], [4, 1], [3, 3], [1, 4], [6, 0], [6, 1], [4, 4], [5, 3]], [[5, 0], [1, 1]], [[3, 0], [2, 1], [1, 2]], [[3, 0], [6, 0], [4, 1], [6, 1]], [[1, 0], [6, 0], [2, 1], [1, 3], [3, 1]], [[6, 0], [3, 1], [5, 1], [4, 2], [4, 3], [2, 5]], [[2, 0], [0, 1], [0, 2], [5, 0], [6, 0], [5, 2], [6, 1]], [[5, 0], [4, 1], [2, 2], [0, 3], [1, 3], [5, 1], [4, 3], [1, 6]], [[0, 0], [2, 0], [1, 1], [6, 0], [6, 1], [2, 3], [0, 6], [4, 2], [6, 2]], [[6, 0], [5, 1]], [[1, 0], [1, 1], [1, 2]], [[2, 0], [5, 0], [1, 2], [5, 1]], [[1, 0], [5, 0], [2, 1], [6, 0], [4, 2]], [[1, 0], [5, 0], [1, 2], [4, 1], [5, 1], [4, 3]], [[6, 0], [0, 1], [5, 1], [4, 2], [1, 3], [1, 4], [3, 3]], [[4, 0], [5, 0], [4, 2], [1, 3], [2, 3], [0, 5], [2, 4], [6, 0]], [[2, 0], [6, 0], [6, 1], [2, 3], [0, 4], [6, 2], [3, 3], [0, 7], [0, 8]], [[4, 0], [2, 1]], [[1, 0], [1, 1], [6, 0]]], "loose": false}

package/data/problems/rabbits-in-forest.json

@@ -0,0 +1 @@
+{"basic": false, "label": "780", "slug": "rabbits-in-forest", "id": 780, "title": "Rabbits in Forest", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/rabbits-in-forest/", "examples": [{"input": "answers = [1,1,2]", "output": "5", "explanation": "A pair plus a trio gives five rabbits."}, {"input": "answers = [10,10,10]", "output": "11", "explanation": "Three speakers fit inside one group of eleven."}, {"input": "answers = [0,0,1,1,1]", "output": "6", "explanation": "Two lone rabbits plus two pairs (one with a silent partner) total six."}], "hints": ["Rabbits giving the same answer a can share groups of size a+1; count how many speakers gave each answer.", "For each distinct answer, the number of groups needed is the ceiling of count/(a+1).", "Multiply groups by group size and sum across all distinct answers."], "statement": "Several rabbits each claim a number: when asked how many other rabbits share\ntheir fur color, rabbit `i` answers with `answers[i]`. Different rabbits\nthat name the same number might belong to one shared color group or to\nseveral separate groups, and rabbits that name different numbers surely\nhave different colors.\n\nGiven all the answers, estimate the smallest total population that could\nhave produced them. Every rabbit that spoke must fit into some color group\nwhose size matches its answer plus one (itself plus the others it counted).\n\n**Constraints:**\n- `1 <= answers.length <= 1000`\n- `0 <= answers[i] < 1000`\n", "solution": "## Approach\n\nGroup speakers by their answer. An answer of `a` means its color group holds\nexactly `a+1` rabbits, so `c` speakers with that answer need\n`ceil(c / (a+1))` full groups. Summing `groups * (a+1)` over every distinct\nanswer yields the smallest feasible population, with silent rabbits filling\nany partially empty groups.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of answers.\n- **Space Complexity:** O(n) for the frequency table.\n\n## Implementation\n\n```python\nfrom typing import List\nfrom collections import Counter\nimport math\n\n\nclass Solution:\n    def numRabbits(self, answers: List[int]) -> int:\n        total = 0\n        for a, c in Counter(answers).items():\n            size = a + 1\n            groups = (c + size - 1) // size\n            total += groups * size\n        return total\n```\n", "starter": {"go": "package main\n\nfunc NumRabbits(answers []int) int {\n    return 0\n}", "python": "from typing import List\nclass Solution:\n    def numRabbits(self, answers: List[int]) -> int:\n        return 0\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    int numRabbits(vector<int>& answers) {\n        return 0;\n    }\n};"}, "fn": "numRabbits", "params": [{"name": "answers", "type": "int_array"}], "outputType": "int", "tests": [["[1,1,2]"], ["[10,10,10]"], ["[0,0,1,1,1]"], ["[0]"], ["[1]"], ["[2]"], ["[0,0,0]"], ["[1,1,1]"], ["[1,1,1,1]"], ["[2,2,2,2,2]"], ["[0,1,2,3,4]"], ["[5,5,5,5,5,5]"], ["[5,5,5,5,5,5,5]"], ["[3,3,3,3,3,3,3]"], ["[4,4,4,4,4]"], ["[4,4,4,4,4,4]"], ["[0,0,0,0,0]"], ["[2,2,2]"], ["[2,2,2,2]"], ["[1,0,1,0,1]"], ["[999]"], ["[0,0,0,0,0,0,0,0,0,0]"], ["[1,1,2,2,2,3,3,3,3]"], ["[7,7,7,7,7,7,7,7]"], ["[7,7,7,7,7,7,7,7,7]"], ["[0,1,0,1,0,1]"], ["[2,3,2,3,2,3]"], ["[10,10,10,10,10,10,10,10,10,10,10,10]"]], "expected": [5, 11, 6, 1, 2, 3, 3, 4, 4, 6, 15, 6, 12, 8, 5, 10, 5, 3, 6, 6, 1000, 10, 9, 8, 16, 7, 7, 22], "loose": false}

package/data/problems/race-car.json

@@ -0,0 +1 @@
+{"basic": false, "label": "816", "slug": "race-car", "id": 816, "title": "Race Car", "difficulty": "Hard", "category": "dp", "link": "https://leetcode.com/problems/race-car/", "examples": [{"input": "target = 3", "output": "2", "explanation": "Drive forward twice: positions 1 then 3, using two A commands."}, {"input": "target = 6", "output": "5", "explanation": "One shortest plan is A,A,R,A,A: overshoot to 7, reverse, then advance to 6."}, {"input": "target = 1", "output": "1", "explanation": "A single forward move reaches the flag."}], "hints": ["Let n be the smallest run of A commands passing the flag (position 2^n - 1): either stop exactly or overshoot and come back.", "Memoize results: overshooting costs n+1 plus the mirrored remainder; alternatively stop one step early and add a short forward burst."], "statement": "A car starts at position 0 with speed 1. Two commands are available: `A` (accelerate) moves the car forward by its current speed and then doubles the speed, while `R` (reverse) turns the car around and resets the speed to 1 in the new direction (positions stay put on `R`).\n\nGiven a flag at integer `target > 0`, find the smallest number of commands that lands the car exactly on the flag. The car may pass the flag and come back.\n\nAdaptation note: this task uses plain integers for input and output.\n\n**Constraints:**\n- `1 <= target <= 10000`\n", "solution": "## Approach\n\nThink in terms of full forward bursts: n accelerations from rest reach 2^n - 1. If that equals the flag, n moves are optimal. Otherwise either overshoot with n moves, reverse, and solve the mirrored remainder, or drive n-1 moves, reverse, creep forward m moves, reverse again, and solve what is left. Trying every m and memoizing the remainders yields the optimum because any shortest plan has one of these two shapes.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(T log T) for target T with memoization.\n- **Space Complexity:** O(T) for the memo table plus recursion depth.\n\n## Implementation\n\n```python\nclass Solution:\n    def racecar(self, target: int) -> int:\n        from functools import lru_cache\n        @lru_cache(maxsize=None)\n        def dfs(t: int) -> int:\n            if t == 0:\n                return 0\n            n = 1\n            while (1 << n) - 1 < t:\n                n += 1\n            if (1 << n) - 1 == t:\n                return n\n            ans = n + 1 + dfs((1 << n) - 1 - t)\n            for m in range(n - 1):\n                cand = n + m + 1 + dfs(t - (1 << (n - 1)) + (1 << m))\n                if cand < ans:\n                    ans = cand\n            return ans\n        return dfs(target)\n```\n", "starter": {"go": "package main\n\nfunc Racecar(target int) int {\n    return 0\n}", "python": "class Solution:\n    def racecar(self, target: int) -> int:\n        return 0\n", "cpp": "class Solution {\npublic:\n    int racecar(int target) {\n        return 0;\n    }\n};"}, "fn": "racecar", "params": [{"name": "target", "type": "int"}], "outputType": "int", "tests": [["3"], ["6"], ["1"], ["2"], ["4"], ["5"], ["7"], ["8"], ["9"], ["10"], ["15"], ["20"], ["25"], ["30"], ["50"], ["100"], ["200"], ["500"], ["1000"], ["12"], ["16"], ["21"], ["33"], ["64"], ["127"], ["256"], ["10000"], ["9999"]], "expected": [2, 5, 1, 4, 5, 7, 3, 6, 8, 7, 4, 12, 11, 7, 16, 19, 22, 20, 23, 7, 7, 10, 10, 9, 7, 11, 45, 43], "loose": false}

package/data/problems/random-flip-matrix.json

@@ -0,0 +1 @@
+{"basic": false, "label": "519", "slug": "random-flip-matrix", "id": 519, "title": "Random Flip Matrix", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/random-flip-matrix/", "examples": [{"explanation": "One valid trace: [1,0] and [2,0] are flipped, then the last free cell [0,0]; after reset any cell (here [2,0]) may come first.", "input": "operations = [\"FlipMatrix\",\"flip\",\"flip\",\"flip\",\"reset\",\"flip\"], values = [[3,1],[],[],[],[],[]]", "output": "[null,[1,0],[2,0],[0,0],null,[2,0]]"}, {"explanation": "Draining a 2x2 board must return each of the four cells exactly once, in any order.", "input": "operations = [\"FlipMatrix\",\"flip\",\"flip\",\"flip\",\"flip\"], values = [[2,2],[],[],[],[]]", "output": "[null,[0,0],[0,1],[1,0],[1,1]]"}, {"explanation": "Reset clears the flipped set, so the single cell may be flipped again.", "input": "operations = [\"FlipMatrix\",\"flip\",\"reset\",\"flip\"], values = [[1,1],[],[],[]]", "output": "[null,[0,0],null,[0,0]]"}], "hints": ["Treat the board as virtual indices 0..m*n-1 and draw without replacement Fisher-Yates style: keep a remap table from drawn slots to still-unused ones so each flip costs O(1) random calls.", "Convert a drawn index k to coordinates via [k / n, k % n].", "Reset just clears the remap table and restores the pool size to m * n."], "statement": "There is an `m x n` binary grid matrix with all the values set `0` initially. Design an algorithm to randomly pick an index `(i, j)` where `matrix[i][j] == 0` and flips it to `1`. All the indices `(i, j)` where `matrix[i][j] == 0` should be equally likely to be returned.\n\nImplement the `FlipMatrix` class:\n\n- `FlipMatrix(int m, int n)` Initializes the object with the size of the binary matrix `m` and `n`.\n- `int[] flip()` Returns a random index `[i, j]` of the matrix where `matrix[i][j] == 0` and flips it to `1`.\n- `void reset()` Resets all the values of the matrix to be `0`.\n\nThe class is named `FlipMatrix` here instead of LeetCode's `Solution` because the judge harness reserves `Solution` for its driver; the constructor and methods match the original.\n\nGrading: each `flip` must return an in-bounds cell that has not been flipped since construction or the last `reset`. Any valid trace is accepted \u2014 uniformity is not statistically tested (LeetCode likewise allows at most 1000 calls, too few for a distribution test).\n\n**Constraints:**\n- `1 <= m, n <= 10^4`\n- There will be at least one free cell for each call to `flip`.\n- At most `1000` calls will be made to `flip` and `reset`.\n", "solution": "## Approach\n\nSample without replacement over the `m * n` virtual cell indices using the Fisher-Yates idea with a remap table. Keep `total` as the count of still-unflipped cells: each `flip` draws a uniform index `x` from `[0, total)`, resolves it through the table (`idx = remap.get(x, x)`), then moves the pool's last element into slot `x` (`remap[x] = remap.get(total - 1, total - 1)`) and shrinks `total`. Converting via `row = idx // n`, `col = idx % n` yields distinct valid coordinates with one random call per flip. `reset` clears the table and restores `total` to `m * n`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1) per `flip` and O(k) per `reset` (clearing k table entries).\n- **Space Complexity:** O(k) for the remap table, where k is the number of flips since the last reset.\n\n## Implementation\n\n```python\nimport random\nfrom typing import List, Dict\n\nclass FlipMatrix:\n    def __init__(self, m: int, n: int):\n        self.m = m\n        self.n = n\n        self.total = m * n\n        self.remap: Dict[int, int] = {}\n\n    def flip(self) -> List[int]:\n        self.total -= 1\n        x = random.randint(0, self.total)\n        idx = self.remap.get(x, x)\n        self.remap[x] = self.remap.get(self.total, self.total)\n        return [idx // self.n, idx % self.n]\n\n    def reset(self) -> None:\n        self.total = self.m * self.n\n        self.remap.clear()\n```\n", "starter": {"go": "package main\n\ntype FlipMatrix struct {\n\n}\n\nfunc Constructor(m int, n int) FlipMatrix {\n    return FlipMatrix{}\n}\n\nfunc (this *FlipMatrix) Flip() []int {\n    return []int{}\n}\n\nfunc (this *FlipMatrix) Reset() {\n\n}", "python": "from typing import List\n\nclass FlipMatrix:\n    def __init__(self, m: int, n: int):\n\n    def flip(self) -> List[int]:\n        return []\n\n    def reset(self) -> None:\n\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass FlipMatrix {\npublic:\n    FlipMatrix(int m, int n) {\n        \n    }\n\n    vector<int> flip() {\n        return {};\n    }\n\n    void reset() {\n        \n    }\n};"}, "fn": "solve", "params": [{"name": "operations", "type": "string_array"}, {"name": "values", "type": "int_array_2d"}], "outputType": "string_list", "tests": [["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"reset\", \"flip\"]", "[[3, 1], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[2, 2], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"reset\", \"flip\"]", "[[1, 1], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"reset\", \"flip\"]", "[[1, 2], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\"]", "[[2, 3], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[2, 3], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[3, 3], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[3, 3], [], [], [], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[4, 4], [], [], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[5, 5], [], [], [], [], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[10, 10], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"reset\", \"flip\", \"flip\", \"reset\", \"flip\"]", "[[2, 2], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[1, 5], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[5, 1], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[3, 4], [], [], [], [], [], [], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"reset\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[4, 5], [], [], [], [], [], [], [], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[6, 6], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[20, 20], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[50, 50], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"reset\", \"flip\", \"flip\"]", "[[1, 3], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[3, 2], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"reset\", \"flip\", \"flip\", \"reset\", \"flip\"]", "[[2, 2], [], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[4, 3], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"reset\", \"flip\", \"reset\", \"flip\"]", "[[1, 1], [], [], [], [], []]"], ["[\"FlipMatrix\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\", \"flip\"]", "[[5, 2], [], [], [], [], [], []]"]], "expected": null, "loose": false}

package/data/problems/random-pick-index.json

@@ -0,0 +1 @@
+{"basic": false, "label": "398", "slug": "random-pick-index", "id": 398, "title": "Random Pick Index", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/random-pick-index/", "examples": [{"input": "operations = [\"RandomPickIndex\",\"pick\",\"pick\",\"pick\",\"pick\",\"pick\",\"pick\"], values = [[1,2,3,3,3],[3],[3],[3],[3],[3],[3]]", "output": "[null,2,3,4,2,4,3]", "explanation": "Valid indexes are 2, 3 and 4. The exact sequence varies; every returned index must hold target 3."}, {"input": "operations = [\"RandomPickIndex\",\"pick\",\"pick\",\"pick\"], values = [[1,2,3,3,3],[1],[1],[1]]", "output": "[null,0,0,0]", "explanation": "Only index 0 holds the value 1, so every pick must return 0."}, {"input": "operations = [\"RandomPickIndex\",\"pick\",\"pick\",\"pick\",\"pick\",\"pick\",\"pick\"], values = [[5,5,5,5],[5],[5],[5],[5],[5],[5]]", "output": "[null,0,2,3,1,0,2]", "explanation": "All four indexes are valid; over a long trace each one must be able to appear."}], "hints": ["Store the indexes for each value, or use reservoir sampling while scanning nums for a target.", "Every index whose value equals target must have the same chance of being returned.", "The judge runs long traces and requires every valid index to appear; always returning the first match fails."], "statement": "Given an integer array `nums` that may contain duplicate values, implement the `RandomPickIndex` class:\n\n- `RandomPickIndex(int[] nums)` initializes the object with the array `nums`.\n- `int pick(int target)` returns a random index `i` such that `nums[i] == target`.\n\nEvery index whose value equals `target` must have the same probability of being returned. The given `target` is guaranteed to occur at least once in `nums`.\n\n**Constraints:**\n- `1 <= nums.length <= 2 * 10^4`\n- `-2^31 <= nums[i] <= 2^31 - 1`\n- `target` occurs at least once in `nums`\n- At most `10^4` calls will be made to `pick`\n\n**Judge note:** the checker validates each returned index and runs long traces against the same object. A long trace must produce every valid index at least once, and the checker rejects fixed or short repeating sequences. Always returning the first match therefore fails even though it is a valid index.\n", "solution": "## Approach\n\nUse **reservoir sampling with a reservoir of size one**. Scan `nums` and count how many matching positions have been seen so far. For the `k`-th match, replace the current answer with that index with probability `1/k`.\n\nAfter scanning the whole array, every one of the `m` matching indexes has probability `1/m` of being the final answer:\n\n- The first match is chosen with probability `1`.\n- The second match replaces it with probability `1/2`, and the first survives with probability `1/2`.\n- By induction, after `k` matches every candidate seen so far has probability `1/k`; processing the next match preserves that property.\n\nThe random decision must be made on every `pick` call. Returning a cached index would pass a single validity check but would fail the judge's repeated-call randomness check.\n\nAn alternative is to build a map from each value to all of its indexes in the constructor. That gives `O(1)` expected time per pick at the cost of `O(n)` extra space.\n\n## Complexity Analysis\n\n- **Time Complexity:** `O(n)` per `pick`, where `n = nums.length`.\n- **Space Complexity:** `O(1)` extra space beyond the input array.\n\n## Implementation\n\n```python\nimport random\nfrom typing import List\n\n\nclass RandomPickIndex:\n    def __init__(self, nums: List[int]):\n        self.nums = nums\n\n    def pick(self, target: int) -> int:\n        chosen = -1\n        seen = 0\n\n        for i, value in enumerate(self.nums):\n            if value != target:\n                continue\n            seen += 1\n            if random.randrange(seen) == 0:\n                chosen = i\n\n        return chosen\n```\n", "starter": {"go": "package main\n\ntype RandomPickIndex struct {\n\n}\n\nfunc Constructor(nums []int) RandomPickIndex {\n    return RandomPickIndex{}\n}\n\nfunc (this *RandomPickIndex) Pick(target int) int {\n    return 0\n}", "python": "from typing import List\n\nclass RandomPickIndex:\n    def __init__(self, nums: List[int]):\n        pass\n\n    def pick(self, target: int) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\n\nclass RandomPickIndex {\npublic:\n    RandomPickIndex(vector<int>& nums) {\n        \n    }\n\n    int pick(int target) {\n        return 0;\n    }\n};"}, "fn": "solve", "params": [{"name": "operations", "type": "string_array"}, {"name": "values", "type": "int_array_2d"}], "outputType": "string_list", "tests": [["@javascript:JSON.stringify(['RandomPickIndex', ...Array(160).fill('pick')])", "@javascript:JSON.stringify([[1,2,3,3,3], ...Array(160).fill([3])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(160).fill('pick')])", "@javascript:JSON.stringify([[5,5,5,5], ...Array(160).fill([5])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(100).fill('pick'), ...Array(100).fill('pick')])", "@javascript:JSON.stringify([[1,2,1,2,1,2], ...Array(100).fill([1]), ...Array(100).fill([2])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(160).fill('pick')])", "@javascript:JSON.stringify([[7,8,7,8,7], ...Array(160).fill([8])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(160).fill('pick')])", "@javascript:JSON.stringify([[7,8,7,8,7], ...Array(160).fill([7])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(160).fill('pick')])", "@javascript:JSON.stringify([[-2147483648,0,2147483647,2147483647], ...Array(160).fill([2147483647])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(30).fill('pick')])", "@javascript:JSON.stringify([[42], ...Array(30).fill([42])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(240).fill('pick')])", "@javascript:JSON.stringify([[3,3,3,3,3,3], ...Array(240).fill([3])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(120).fill('pick'), ...Array(120).fill('pick')])", "@javascript:JSON.stringify([[100,200,100,200,100,200], ...Array(120).fill([100]), ...Array(120).fill([200])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(120).fill('pick'), 'RandomPickIndex', ...Array(120).fill('pick')])", "@javascript:JSON.stringify([[5,5,5], ...Array(120).fill([5]), [1,2,3,3,3], ...Array(120).fill([3])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(30).fill('pick')])", "@javascript:JSON.stringify([[1,1,1,1,2], ...Array(30).fill([2])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(180).fill('pick')])", "@javascript:JSON.stringify([[0,0,0,1,0,0,0], ...Array(180).fill([0])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(180).fill('pick')])", "@javascript:JSON.stringify([Array.from({length: 20000}, (_, i) => (i === 0 || i === 9999 || i === 19999) ? 7 : 1), ...Array(180).fill([7])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(160).fill('pick')])", "@javascript:JSON.stringify([[3,3], ...Array(160).fill([3])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(160).fill('pick')])", "@javascript:JSON.stringify([[3,0,0,0,3], ...Array(160).fill([3])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(240).fill('pick')])", "@javascript:JSON.stringify([[9,1,9,2,9,3,9], ...Array(240).fill([9])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(240).fill('pick')])", "@javascript:JSON.stringify([[4,4,4,4,4], ...Array(240).fill([4])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(300).fill('pick')])", "@javascript:JSON.stringify([[6,1,6,2,6,3,6,4,6,5,6], ...Array(300).fill([6])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(160).fill('pick')])", "@javascript:JSON.stringify([[-5,-5,-5], ...Array(160).fill([-5])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(160).fill('pick')])", "@javascript:JSON.stringify([[0,1,2,0,3,0], ...Array(160).fill([0])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(160).fill('pick')])", "@javascript:JSON.stringify([[-2147483648,2147483647,-2147483648,0,2147483647], ...Array(160).fill([2147483647])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(120).fill('pick'), ...Array(120).fill('pick'), ...Array(120).fill('pick')])", "@javascript:JSON.stringify([[1,2,3,1,2,3], ...Array(120).fill([1]), ...Array(120).fill([2]), ...Array(120).fill([3])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(120).fill('pick'), 'RandomPickIndex', ...Array(120).fill('pick')])", "@javascript:JSON.stringify([[5,5], ...Array(120).fill([5]), [8,9,8,9,8], ...Array(120).fill([8])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(300).fill('pick')])", "@javascript:JSON.stringify([Array.from({length: 50000}, (_, i) => (i === 0 || i === 25000 || i === 49999) ? 42 : 1), ...Array(300).fill([42])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(150).fill('pick')])", "@javascript:JSON.stringify([[7], ...Array(150).fill([7])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(240).fill('pick')])", "@javascript:JSON.stringify([[1,1,1,1,2,2,2,2], ...Array(240).fill([2])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(240).fill('pick')])", "@javascript:JSON.stringify([[0,1,0,1,0,1,0,1], ...Array(240).fill([0])])"], ["@javascript:JSON.stringify(['RandomPickIndex', ...Array(160).fill('pick')])", "@javascript:JSON.stringify([[9,8,7,6,5,9,8,7,6,5], ...Array(160).fill([5])])"]], "expected": null, "loose": false}

package/data/problems/random-pick-with-blacklist.json

@@ -0,0 +1 @@
+{"basic": false, "label": "718", "slug": "random-pick-with-blacklist", "id": 718, "title": "Random Pick with Blacklist", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/random-pick-with-blacklist/", "examples": [{"input": "n = 7, blacklist = [2,3,5], calls = [0,1,2,3]", "output": "[0,1,6,4]", "explanation": "Valid numbers are 0, 1, 4 and 6. Each draw value is wrapped into that set; with tail remapping the four draws land on 0, 1, 6 and 4."}, {"input": "n = 4, blacklist = [2], calls = [0,1,2]", "output": "[0,1,3]", "explanation": "Valid numbers are 0, 1 and 3. The third draw maps past the blocked value 2 onto 3."}, {"input": "n = 1, blacklist = [], calls = [5,-3]", "output": "[0,0]", "explanation": "Only 0 is available, so every draw returns 0."}], "hints": ["Let sz = n - blacklist.length. Remap every blocked value below sz to a free value from the tail; wrapping each draw with a non-negative modulo gives an index in [0, sz).", "Build a hash set of blocked values, then assign tail replacements from n-1 downward skipping blocked entries.", "Adaptation: calls stands in for random draws so the task is deterministic. The checker only verifies that each answer lies in range and avoids the blacklist; any valid pick is accepted. Rust note: vectors arrive as usual integer lists."], "statement": "You are given a range `0` to `n - 1` with some values blocked in `blacklist`. Each call should return a uniformly chosen unblocked number.\n\nBecause random output cannot be compared directly, this task uses a deterministic stand-in: `calls` holds one integer per draw. For each entry, wrap it into the set of valid numbers and return the corresponding valid value (blocked entries below `sz` are remapped to free tail values, where `sz = n - blacklist.length`). The reference method builds that remapping once and answers every draw with a binary-free O(1) lookup.\n\nReturn one answer per entry of `calls`. The judge accepts any output whose entries are all inside `[0, n)` and avoid every blocked value, so any fair generator would pass; the wrapped-draw rule simply makes testing repeatable.\n\n*Adaptation note:* the function is named `runBlacklist` and takes `(n, blacklist, calls)` so every supported type stays within the allowed set. Correctness is validity-only.\n\n**Constraints:**\n- `1 <= n <= 10^9`\n- `0 <= blacklist.length < n`\n- All blocked values are distinct and inside `[0, n)`.\n- `1 <= calls.length <= 1000`\n", "solution": "## Approach\n\nPreprocess the blacklist once. Values below `sz = n - m` that are blocked are remapped to free tail values found by scanning down from `n - 1`. Each draw is wrapped into `[0, sz)` with a non-negative modulo and then translated through the map, giving a valid pick in O(1).\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m + q), where m is the blacklist size and q the number of draws.\n- **Space Complexity:** O(m) for the set and remap.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def runBlacklist(self, n: int, blacklist: List[int], calls: List[int]) -> List[int]:\n        sz = n - len(blacklist)\n        black = set(blacklist)\n        mp = {}\n        w = n - 1\n        for b in blacklist:\n            if b < sz:\n                while w in black:\n                    w -= 1\n                mp[b] = w\n                w -= 1\n        ans = []\n        for c in calls:\n            t = c % sz\n            ans.append(mp.get(t, t))\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc RunBlacklist(n int, blacklist []int, calls []int) []int {\n    return []int{}\n}", "python": "from typing import List\nclass Solution:\n    def runBlacklist(self, n: int, blacklist: List[int], calls: List[int]) -> List[int]:\n        return []", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<int> runBlacklist(int n, vector<int>& blacklist, vector<int>& calls) {\n        return {};\n    }\n};"}, "fn": "runBlacklist", "params": [{"name": "n", "type": "int"}, {"name": "blacklist", "type": "int_array"}, {"name": "calls", "type": "int_array"}], "outputType": "int_array", "tests": [["7", "[2,3,5]", "[0,1,2,3]"], ["4", "[2]", "[0,1,2]"], ["1", "[]", "[5,-3]"], ["5", "[]", "[0,1,2,3,4]"], ["5", "[0,1,2,3]", "[0,7,-2]"], ["10", "[3,5,7]", "[0,3,5,9,14]"], ["6", "[0,5]", "[0,1,2,3]"], ["8", "[1,2,3]", "[4,5,6,7,8]"], ["3", "[1]", "[0,1,2,3,4]"], ["100", "[10,20,30]", "[0,50,99,100,101]"], ["2", "[0]", "[0,1,2]"], ["2", "[1]", "[0,1,2]"], ["9", "[4,5,6,7,8]", "[0,1,2,3]"], ["9", "[0,1,2,3,4]", "[0,1,2,3]"], ["12", "[0,11]", "[0,10,11,12,22]"], ["20", "[5,6,7,8,9]", "[5,6,14,15,19]"], ["1000", "[0,1,2]", "[0,997,998,999,1000]"], ["15", "[3,8,12]", "[-5,-1,0,14,30]"], ["4", "[]", "[100,-100,0]"], ["6", "[2,4]", "[2,4,6,8]"], ["7", "[6]", "[6,7,13]"], ["11", "[5]", "[5,10,15,20]"], ["30", "[10,11,12,13,14]", "[10,11,25,29,30]"], ["50", "[0,25,49]", "[0,25,49,50,99]"], ["8", "[0,1,6,7]", "[0,1,2,3,4,5]"], ["16", "[4,8,12]", "[4,8,12,16,20]"], ["5", "[4]", "[4,5,9]"], ["1000000", "[0,999999]", "[0,1,999998,999999]"]], "expected": [[0, 1, 6, 4], [0, 1, 3], [0, 0], [0, 1, 2, 3, 4], [4, 4, 4], [0, 9, 8, 2, 0], [4, 1, 2, 3], [4, 0, 7, 6, 5], [0, 2, 0, 2, 0], [0, 50, 2, 3, 4], [1, 1, 1], [0, 0, 0], [0, 1, 2, 3], [8, 7, 6, 5], [10, 10, 1, 2, 2], [19, 18, 14, 0, 4], [999, 999, 998, 997, 3], [7, 11, 0, 2, 6], [0, 0, 0], [5, 0, 5, 0], [0, 1, 1], [10, 0, 10, 0], [29, 28, 0, 4, 5], [48, 47, 2, 3, 5], [5, 4, 2, 3, 5, 4], [15, 14, 13, 3, 7], [0, 1, 1], [999998, 1, 999998, 1]], "loose": true}