offcode 0.0.0-stage → 0.1.1

package/data/problems/plus-one-linked-list.json

@@ -0,0 +1 @@
+{"basic": false, "label": "448", "slug": "plus-one-linked-list", "id": 448, "title": "Plus One Linked List", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/plus-one-linked-list/", "examples": [{"input": "head = [1,2,3]", "output": "[1,2,4]", "explanation": "123 + 1 = 124."}, {"input": "head = [9,9]", "output": "[1,0,0]", "explanation": "99 + 1 = 100."}, {"input": "head = [0]", "output": "[1]", "explanation": "0 + 1 = 1."}], "hints": ["Find the rightmost digit that is not 9; it absorbs the carry.", "If no such digit exists, prepend a new node with value 1 and set the rest to 0.", "Otherwise increment that digit and set every digit after it to 0."], "statement": "Add one to a number stored digit-by-digit in forward order in a linked list.\n\nEach node of the singly linked list holds one decimal digit, with the most significant digit at the head. Interpret the whole chain as a non-negative integer without leading zeros (except the single digit `0` itself) and return the head of the list that represents the value plus one. The length may grow by one digit when every digit rolls over, for example `[9,9]` becoming `[1,0,0]`.\n\n**Constraints:**\n- `1 <= number of nodes <= 100`\n- `0 <= Node.val <= 9`\n- The digits contain no leading zeros except the number zero itself.\n", "solution": "## Approach\n\nScan for the rightmost non-nine digit. When one exists, bump it by one and zero out its suffix; the prefix stays untouched. When every digit is nine, place a fresh leading one in front and turn the whole tail to zeros.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of nodes, for the right-to-left carry pass.\n- **Space Complexity:** O(1) extra besides the possible new head node (O(n) with a recursive carry).\n\n## Implementation\n\n```python\nclass Solution:\n    def plusOne(self, head):\n        carry = self._add(head)\n        if carry:\n            n = ListNode(1)\n            n.next = head\n            return n\n        return head\n\n    def _add(self, node):\n        if node is None:\n            return 1\n        c = self._add(node.next)\n        s = node.val + c\n        node.val = s % 10\n        return s // 10\n```\n", "starter": {"go": "package main\n\n/*\nDefinition for singly-linked list.\ntype ListNode struct {\n    Val int\n    Next *ListNode\n}\n*/\n\nfunc PlusOne(head *ListNode) *ListNode {\n    return nil\n}", "python": "# Definition for singly-linked list.\n# class ListNode:\n#     def __init__(self, val=0, next=None):\n#         self.val = val\n#         self.next = next\n\nclass Solution:\n    def plusOne(self, head):\n        pass\n", "cpp": "/*\nstruct ListNode {\n    int val;\n    ListNode *next;\n    ListNode(): val(0), next(nullptr) {}\n    ListNode(int x): val(x), next(nullptr) {}\n    ListNode(int x, ListNode* next): val(x), next(next) {}\n};\n*/\nclass Solution {\npublic:\n    ListNode* plusOne(ListNode* head) {\n        return nullptr;\n    }\n};"}, "fn": "plusOne", "params": [{"name": "head", "type": "list_node"}], "outputType": "list_node", "tests": [["[1,2,3]"], ["[9,9]"], ["[0]"], ["[9]"], ["[1]"], ["[8,9,9]"], ["[9,8,9]"], ["[1,9,9,9]"], ["[9,9,9]"], ["[9,9,9,9]"], ["[1,0,0,0]"], ["[2,7,4]"], ["[5]"], ["[1,2,9]"], ["[9,0,9]"], ["[1,1,1,1]"], ["[7,9,9,9,9]"], ["[4,9,3,9]"], ["[9,9,0,9]"], ["[3,2,1]"], ["[6,6,6,9]"], ["[1,9]"], ["[8,9]"], ["[9,1]"], ["[2,9,9,9,9,9]"], ["[5,4,3,2,1]"], ["[9,9,9,9,9,9]"], ["[1,0,9]"], ["[4,5,6,7,8]"], ["[1,0]"], ["[9,0,0,9]"], ["[2,0,0,0,9]"]], "expected": [[1, 2, 4], [1, 0, 0], [1], [1, 0], [2], [9, 0, 0], [9, 9, 0], [2, 0, 0, 0], [1, 0, 0, 0], [1, 0, 0, 0, 0], [1, 0, 0, 1], [2, 7, 5], [6], [1, 3, 0], [9, 1, 0], [1, 1, 1, 2], [8, 0, 0, 0, 0], [4, 9, 4, 0], [9, 9, 1, 0], [3, 2, 2], [6, 6, 7, 0], [2, 0], [9, 0], [9, 2], [3, 0, 0, 0, 0, 0], [5, 4, 3, 2, 2], [1, 0, 0, 0, 0, 0, 0], [1, 1, 0], [4, 5, 6, 7, 9], [1, 1], [9, 0, 1, 0], [2, 0, 0, 1, 0]], "loose": false}

package/data/problems/plus-one.json

@@ -0,0 +1 @@
+{"basic": false, "label": "146", "slug": "plus-one", "id": 146, "title": "Plus One", "difficulty": "Easy", "category": "math", "link": "https://leetcode.com/problems/plus-one/", "examples": [{"input": "digits = [1,2,3]", "output": "[1,2,4]", "explanation": "Adding 1 to [1, 2, 3] gives [1, 2, 4]."}, {"input": "digits = [4,3,2,1]", "output": "[4,3,2,2]", "explanation": "Adding 1 to [4, 3, 2, 1] gives [4, 3, 2, 2]."}, {"input": "digits = [9,9]", "output": "[1,0,0]", "explanation": "Adding 1 to 99 produces 100."}], "hints": ["Process the digits from right to left, just as in elementary addition.", "Stop as soon as a digit is smaller than 9; otherwise turn each trailing 9 into 0.", "If every digit was 9, return a new array one element longer with a leading 1."], "statement": "You are given a nonempty array of decimal digits representing a nonnegative integer. The most significant digit is first, and the representation has no leading zero unless the number itself is zero.\n\nAdd one to the integer and return its digit array. Do not convert the entire input to a built-in integer type, because the array may represent a value larger than that type can hold.\n\n**Constraints:**\n- `1 <= digits.length <= 100`\n- `0 <= digits[i] <= 9`\n- `digits` has no leading zero unless it is exactly `[0]`\n", "solution": "## Approach\n\nCopy the input and scan its digits from right to left. Increment the first digit smaller than `9`; every trailing `9` becomes `0` while the carry continues. If every digit was `9`, prepend a new leading `1`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of digits.\n- **Space Complexity:** O(n) for the returned digit array.\n\n## Implementation\n\n```python\nfrom typing import List\n\n\nclass Solution:\n    def plusOne(self, digits: List[int]) -> List[int]:\n        result = digits[:]\n        for index in range(len(result) - 1, -1, -1):\n            if result[index] < 9:\n                result[index] += 1\n                return result\n            result[index] = 0\n        return [1] + result\n```\n", "starter": {"go": "package main\n\nfunc PlusOne(digits []int) []int {\n    return []int{}\n}", "python": "from typing import List\n\nclass Solution:\n    def plusOne(self, digits: List[int]) -> List[int]:\n        return []\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<int> plusOne(vector<int>& digits) {\n        return {};\n    }\n};"}, "fn": "plusOne", "params": [{"name": "digits", "type": "int_array"}], "outputType": "int_array", "tests": [["[0]"], ["[1]"], ["[2]"], ["[3]"], ["[4]"], ["[5]"], ["[6]"], ["[7]"], ["[8]"], ["[9]"], ["[1,0]"], ["[1,1]"], ["[1,8]"], ["[1,9]"], ["[2,9]"], ["[5,0]"], ["[5,9]"], ["[8,9]"], ["[9,0]"], ["[9,9]"], ["[1,0,0]"], ["[1,0,9]"], ["[1,2,3]"], ["[1,9,9]"], ["[2,9,9]"], ["[4,3,2,1]"], ["[5,0,9]"], ["[8,9,9]"], ["[9,0,9]"], ["[9,9,9]"], ["[1,2,9,9]"], ["[1,9,9,9]"], ["[2,0,0,0]"], ["[2,9,9,9]"], ["[7,8,9,9]"], ["[8,9,9,9]"], ["[9,0,0,0]"], ["[9,9,0,9]"], ["[9,9,9,0]"], ["[9,9,9,9]"], ["[1,2,3,4,5]"], ["[1,2,3,9,9]"], ["[3,9,9,9,9]"], ["[8,0,8,0,9]"], ["[9,9,9,9,9]"], ["[1,2,3,4,5,6,7,8,9,0]"], ["[1,9,9,9,9,9,9,9,9,9]"], ["[8,9,9,9,9,9,9,9,9,9]"], ["[9,0,9,9,9,9,9,9,9,9]"], ["[9,9,9,9,9,9,9,9,9,9]"], ["[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]"], ["[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]"], ["[1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,9]"], ["[9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9]"], ["[2,1,4,7,4,8,3,6,4,7]"], ["[6,2,5,0,4,0,9,9,9,9,9]"], ["[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9]"], ["[7,7,7,7,7,7,7,7,7,7,7,7,7,7,7]"], ["[3,1,4,1,5,9,2,6,5,3,5,8,9,7,9,3,2,3,8,4,6]"], ["[5,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,9,9,9]"], ["@javascript:JSON.stringify([1,...Array(98).fill(9)])"], ["@javascript:JSON.stringify([1,...Array(99).fill(0)])"], ["@javascript:JSON.stringify(Array(100).fill(9))"]], "expected": [[1], [2], [3], [4], [5], [6], [7], [8], [9], [1, 0], [1, 1], [1, 2], [1, 9], [2, 0], [3, 0], [5, 1], [6, 0], [9, 0], [9, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 2, 4], [2, 0, 0], [3, 0, 0], [4, 3, 2, 2], [5, 1, 0], [9, 0, 0], [9, 1, 0], [1, 0, 0, 0], [1, 3, 0, 0], [2, 0, 0, 0], [2, 0, 0, 1], [3, 0, 0, 0], [7, 9, 0, 0], [9, 0, 0, 0], [9, 0, 0, 1], [9, 9, 1, 0], [9, 9, 9, 1], [1, 0, 0, 0, 0], [1, 2, 3, 4, 6], [1, 2, 4, 0, 0], [4, 0, 0, 0, 0], [8, 0, 8, 1, 0], [1, 0, 0, 0, 0, 0], [1, 2, 3, 4, 5, 6, 7, 8, 9, 1], [2, 0, 0, 0, 0, 0, 0, 0, 0, 0], [9, 0, 0, 0, 0, 0, 0, 0, 0, 0], [9, 1, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 2, 0], [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, 0, 0], [2, 1, 4, 7, 4, 8, 3, 6, 4, 8], [6, 2, 5, 0, 4, 1, 0, 0, 0, 0, 0], [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0], [7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8], [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5, 8, 9, 7, 9, 3, 2, 3, 8, 4, 7], [5, 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, 0, 0], [2, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], "loose": false}

package/data/problems/poor-pigs.json

@@ -0,0 +1 @@
+{"basic": false, "label": "525", "slug": "poor-pigs", "id": 525, "title": "Poor Pigs", "difficulty": "Hard", "category": "math", "link": "https://leetcode.com/problems/poor-pigs/", "examples": [{"input": "buckets = 1000, minutesToDie = 15, minutesToTest = 60", "output": "5"}, {"input": "buckets = 4, minutesToDie = 15, minutesToTest = 15", "output": "2", "explanation": "With one round of testing each pig has 2 outcomes, and 2 pigs cover 2 * 2 = 4 buckets."}, {"input": "buckets = 4, minutesToDie = 15, minutesToTest = 30", "output": "2", "explanation": "Two rounds give each pig 3 outcomes, so 2 pigs cover 3 * 3 = 9 buckets, but 1 pig covers only 3."}], "hints": ["The number of full test rounds is `minutesToTest / minutesToDie` (integer division), so each pig distinguishes `rounds + 1` outcomes.", "Find the smallest `p` with `(rounds + 1)^p >= buckets`."], "statement": "There are `buckets` buckets of liquid, and exactly one of them is poisoned. A pig that drinks the poison dies `minutesToDie` minutes later; otherwise it survives. You have `minutesToTest` minutes in total, and within that window a pig can drink in several rounds: after each round you wait long enough to see which pigs die before the next round.\n\nWith `r` full rounds available, one pig can distinguish `r + 1` different outcomes (dying in round 1, 2, ..., `r`, or surviving everything). With `p` pigs the number of distinguishable outcomes multiplies to `(r + 1)^p`.\n\nReturn the smallest number of pigs needed to guarantee finding the poisoned bucket in time.\n\n**Constraints:**\n- `1 <= buckets <= 1000`\n- `1 <= minutesToDie, minutesToTest <= 100`\n", "solution": "## Approach\n\nCompute the number of full rounds as integer division of the total time by the time to die. Each pig then has `rounds + 1` observable outcomes, and `p` pigs jointly cover `(rounds + 1)^p` buckets. Grow the pig count until the coverage reaches the number of buckets; that count is minimal because any smaller count covers fewer buckets.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(p), where p is the answer (a handful of multiplications).\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nclass Solution:\n    def poorPigs(self, buckets: int, minutesToDie: int, minutesToTest: int) -> int:\n        states = minutesToTest // minutesToDie + 1\n        pigs = 0\n        coverage = 1\n        while coverage < buckets:\n            pigs += 1\n            coverage *= states\n        return pigs\n```\n", "starter": {"go": "package main\n\nfunc PoorPigs(buckets int, minutesToDie int, minutesToTest int) int {\n    \n}", "python": "class Solution:\n    def poorPigs(self, buckets: int, minutesToDie: int, minutesToTest: int) -> int:\n        pass", "cpp": "class Solution {\npublic:\n    int poorPigs(int buckets, int minutesToDie, int minutesToTest) {\n        return 0;\n    }\n};"}, "fn": "poorPigs", "params": [{"name": "buckets", "type": "int"}, {"name": "minutesToDie", "type": "int"}, {"name": "minutesToTest", "type": "int"}], "outputType": "int", "tests": [["1000", "15", "60"], ["4", "15", "15"], ["4", "15", "30"], ["1", "15", "15"], ["2", "15", "15"], ["3", "15", "15"], ["8", "15", "15"], ["9", "15", "15"], ["25", "15", "60"], ["125", "12", "60"], ["1000", "12", "60"], ["1000", "15", "15"], ["5", "10", "100"], ["100", "10", "100"], ["27", "15", "45"], ["8", "15", "30"], ["16", "15", "30"], ["100", "15", "60"], ["1000", "10", "100"], ["500", "20", "60"], ["81", "15", "60"], ["10", "10", "10"], ["32", "10", "10"], ["64", "15", "30"], ["1000", "1", "100"], ["1", "1", "1"], ["2", "1", "1"], ["1000", "50", "100"]], "expected": [5, 2, 2, 0, 1, 2, 3, 4, 2, 3, 4, 10, 1, 2, 3, 2, 3, 3, 3, 5, 3, 4, 5, 4, 2, 0, 1, 7], "loose": false}

package/data/problems/populating-next-right-pointers-in-each-node-ii.json

@@ -0,0 +1 @@
+{"basic": false, "label": "294", "slug": "populating-next-right-pointers-in-each-node-ii", "id": 294, "title": "Populating Next Right Pointers in Each Node II", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/populating-next-right-pointers-in-each-node-ii/", "examples": [{"input": "root = [1,2,3,4,5,null,7]", "output": "[1,2,3,4,5,null,7]", "explanation": "Row 2 links 2 -> 3 and row 3 links 4 -> 5 -> 7; the serialized shape is unchanged."}, {"input": "root = []", "output": "[]", "explanation": "Nothing to link."}], "hints": ["Breadth-first search links each row regardless of missing children.", "A constant-space method chains the next row using a dummy head while walking the current row via established links.", "Adaptation: the original Node type carries a next pointer which this judge does not model; return the same tree and the checker confirms its values and shape are preserved."], "statement": "Extend neighbor linking to any binary tree, not just perfect ones.\n\nFor every node, imagine an arrow to the closest node on the same depth to its right (or nothing if it is the row's last node). Fill in all such arrows level by level and return the root.\n\n**Constraints:**\n- `0 <= number of nodes <= 6000`\n- `-100 <= Node.val <= 100`\n\n**Adaptation note:** The original statement uses a `Node` type with `left`, `right`, and `next` fields. This judge models only `TreeNode` (`val`, `left`, `right`); neighbor links cannot be serialized, so solutions return the same tree and grading verifies that values and structure are preserved.\n", "solution": "## Approach\n\nA queue-based level walk handles arbitrary shapes: each row is processed left to right, which matches the desired neighbor order even when children are missing. In the full `Node` version each node (except the row tail) would be assigned its queue successor as `next`. Here the `TreeNode` lacks that field, so the walk simply visits rows and returns the root, keeping values and links intact.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), one queue visit per node.\n- **Space Complexity:** O(n) with a queue (O(1) with the dummy-head chaining technique).\n\n## Implementation\n\n```python\nfrom collections import deque\nclass Solution:\n    def connect(self, root):\n        # Adaptation: TreeNode has no `next` field; walk levels and return root.\n        if not root:\n            return None\n        q = deque([root])\n        while q:\n            for _ in range(len(q)):\n                n = q.popleft()\n                # In Node formulation: n.next = next node in row or None\n                if n.left:\n                    q.append(n.left)\n                if n.right:\n                    q.append(n.right)\n        return root\n```\n", "starter": {"go": "// Definition for a binary tree node.\n// type TreeNode struct {\n//     Val int\n//     Left *TreeNode\n//     Right *TreeNode\n// }\npackage main\n\nfunc Connect(root *TreeNode) *TreeNode {\n    \n}", "python": "# Definition for a binary tree node.\n# class TreeNode:\n#     def __init__(self, val=0, left=None, right=None):\n#         self.val = val\n#         self.left = left\n#         self.right = right\n\nclass Solution:\n    def connect(self, root):\n        pass\n", "cpp": "/*\nDefinition for a binary tree node.\nstruct TreeNode {\n    int val;\n    TreeNode *left;\n    TreeNode *right;\n    TreeNode(): val(0), left(nullptr), right(nullptr) {}\n    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}\n    TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}\n};\n*/\nclass Solution {\npublic:\n    TreeNode* connect(TreeNode* root) {\n        \n    }\n};"}, "fn": "connect", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}], "outputType": "tree_node", "tests": [["[1,2,3,4,5,null,7]"], ["[]"], ["[1]"], ["[1,2,3,4,5,6,7]"], ["[1,2,null,3,4]"], ["[1,2,3,4,null,null,5]"], ["[3,9,20,null,null,15,7]"], ["[1,null,2,3,4]"], ["[2,1,3]"], ["[1,2,3,4,5]"], ["[5,4,6,3,null,null,7]"], ["[10,5,15,2,7,12,20]"], ["[1,null,2,null,3,null,4]"], ["[4,2,6,1,3,5,7]"], ["[0]"], ["[-5,-10,0]"], ["[100,50,150,25,75]"], ["[7,3,10,2,5,null,12]"], ["[6,3,9,1,4,8,10]"], ["[2,null,3,null,4,null,5]"], ["[8,3,10,1,6,null,14]"], ["[5,null,4,null,3,null,2]"], ["[1,2,3,4,null,null,5,6]"], ["[9,5,12,3,7,10,15]"], ["[15,10,20,8,12,17,25]"], ["[1,2,3,null,4,null,5]"]], "expected": null, "loose": false}

package/data/problems/populating-next-right-pointers-in-each-node.json

@@ -0,0 +1 @@
+{"basic": false, "label": "293", "slug": "populating-next-right-pointers-in-each-node", "id": 293, "title": "Populating Next Right Pointers in Each Node", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/populating-next-right-pointers-in-each-node/", "examples": [{"input": "root = [1,2,3,4,5,6,7]", "output": "[1,2,3,4,5,6,7]", "explanation": "Every level is fully filled; after linking, nodes on each row point left-to-right and the structure serializes unchanged."}, {"input": "root = []", "output": "[]", "explanation": "Nothing to link."}], "hints": ["Process the tree one level at a time; within a level link each node to its successor.", "Because the tree is perfect, each parent connects its two children and bridges the right child to the next parent's left child.", "Breadth-first search with a queue solves it generally; a constant-space walk can reuse already-built links.", "Adaptation: the original Node type carries a next pointer which this judge does not model; return the same tree and the checker confirms its values and shape are preserved."], "statement": "Consider a perfect binary tree \u2014 every interior node has two children and all leaves sit on the same depth. Conceptually, each node should gain a link to its nearest neighbor on the same level (or nothing at the row end).\n\nLink every level left-to-right using these neighbor pointers, ideally reusing constant extra space by walking the already-linked upper row. Return the root afterwards.\n\n**Constraints:**\n- `0 <= number of nodes <= 2^12 - 1`\n- `-1000 <= Node.val <= 1000`\n- The input is a perfect binary tree.\n\n**Adaptation note:** The original statement uses a `Node` type with `left`, `right`, and `next` fields. This judge models only `TreeNode` (`val`, `left`, `right`); neighbor links cannot be serialized, so solutions return the same tree and grading verifies that values and structure are preserved. Document your level-linking logic in comments.\n", "solution": "## Approach\n\nBreadth-first search visits each level left to right, which is exactly the order neighbor links would follow. In the full `Node` formulation each dequeued node (except the last in its row) would point to the next queued node, and the row's last node would point to null; parents in a perfect tree additionally bridge their right child to the next parent's left child. Because this judge's `TreeNode` has no `next` field, the implementation performs the level walk and returns the root unchanged, preserving values and shape.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), one visit per node.\n- **Space Complexity:** O(n) with a queue (O(1) with the classic next-pointer walk on a perfect tree).\n\n## Implementation\n\n```python\nfrom collections import deque\nclass Solution:\n    def connect(self, root):\n        # Adaptation: TreeNode has no `next` field; walk levels and return root.\n        if not root:\n            return None\n        q = deque([root])\n        while q:\n            for _ in range(len(q)):\n                n = q.popleft()\n                # In Node formulation: n.next = q[0] if same level remains else None\n                if n.left:\n                    q.append(n.left)\n                if n.right:\n                    q.append(n.right)\n        return root\n```\n", "starter": {"go": "// Definition for a binary tree node.\n// type TreeNode struct {\n//     Val int\n//     Left *TreeNode\n//     Right *TreeNode\n// }\npackage main\n\nfunc Connect(root *TreeNode) *TreeNode {\n    \n}", "python": "# Definition for a binary tree node.\n# class TreeNode:\n#     def __init__(self, val=0, left=None, right=None):\n#         self.val = val\n#         self.left = left\n#         self.right = right\n\nclass Solution:\n    def connect(self, root):\n        pass\n", "cpp": "/*\nDefinition for a binary tree node.\nstruct TreeNode {\n    int val;\n    TreeNode *left;\n    TreeNode *right;\n    TreeNode(): val(0), left(nullptr), right(nullptr) {}\n    TreeNode(int x): val(x), left(nullptr), right(nullptr) {}\n    TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}\n};\n*/\nclass Solution {\npublic:\n    TreeNode* connect(TreeNode* root) {\n        \n    }\n};"}, "fn": "connect", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}], "outputType": "tree_node", "tests": [["[1,2,3,4,5,6,7]"], ["[]"], ["[1,2,3]"], ["[1]"], ["[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]"], ["[5,4,6,3,null,null,7]"], ["[10,5,15,2,7,12,20]"], ["[4,2,6,1,3,5,7]"], ["[7,3,10,2,5,null,12]"], ["[6,3,9,1,4,8,10]"], ["[2,1,3]"], ["[0,-1,1]"], ["[1,2,3,4,5,6,7,8]"], ["[100,50,150,25,75,125,175]"], ["[8,3,10,1,6,null,14]"], ["[9,5,12,3,7,10,15]"], ["[15,10,20,8,12,17,25]"], ["[3,9,20,15,7]"], ["[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31]"], ["[11,22,33,44,55,66,77]"], ["[1,2,3,4,5,6,7,8,9]"], ["[5,3,8,1,4,7,9]"], ["[2,1,3,4,5,6,7]"], ["[42]"], ["[1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]"], ["[3,1,4,null,2]"]], "expected": null, "loose": false}

package/data/problems/positions-of-large-groups.json

@@ -0,0 +1 @@
+{"basic": false, "label": "828", "slug": "positions-of-large-groups", "id": 828, "title": "Positions of Large Groups", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/positions-of-large-groups/", "examples": [{"input": "s = \"abbxxxxzzy\"", "output": "[[3,6]]", "explanation": "Only the run of x's qualifies."}, {"input": "s = \"abc\"", "output": "[]", "explanation": "Every run has length 1."}, {"input": "s = \"abcdddeeeeaabbbcd\"", "output": "[[3,5],[6,9],[12,14]]"}], "hints": ["Walk the string once, tracking where the current run of equal letters started.", "A run ends when the next character differs or the string ends; record it only if its length is 3 or more.", "Pairs are naturally produced in increasing order, so no extra sorting is needed."], "statement": "Given a string `s` of lowercase letters, a large group is a maximal run of the same character with length at least 3. Maximal means the run cannot be extended on either side with the same letter. Return the start and end indices of every large group as `[start, end]` pairs in left-to-right order.\n\n**Constraints:**\n- `1 <= s.length <= 1000`\n- `s` consists of lowercase English letters only\n", "solution": "## Approach\n\nScan the string once while remembering where the current run of identical letters began. Whenever the next character differs (or the string ends), measure the run length and keep the [start, end] pair if it reaches 3. Because runs are found left to right, the collected pairs are already in the required order.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) where n is the string length.\n- **Space Complexity:** O(1) besides the output list.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n    def largeGroupPositions(self, s: str) -> List[List[int]]:\n        ans = []\n        n = len(s)\n        start = 0\n        for i in range(n + 1):\n            if i == n or s[i] != s[start]:\n                if i - start >= 3:\n                    ans.append([start, i - 1])\n                start = i\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc LargeGroupPositions(s string) [][]int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def largeGroupPositions(self, s: str) -> List[List[int]]:\n        pass", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    vector<vector<int>> largeGroupPositions(string s) {\n        return {};\n    }\n};"}, "fn": "largeGroupPositions", "params": [{"name": "s", "type": "string"}], "outputType": "int_list_2d", "tests": [["abbxxxxzzy"], ["abc"], ["abcdddeeeeaabbbcd"], ["aaa"], ["aa"], ["a"], ["aaaa"], ["abbccc"], ["aaabbb"], ["aaabbbccc"], ["zzzzzzzzzz"], ["abcdefg"], ["aabbbcc"], ["abcdefffg"], ["nnnooopppqqq"], ["abbbcccddeeee"], ["xxxyyyzzz"], ["aabbccddeeffgg"], ["aaabaaa"], ["baaaab"], ["lll"], ["abbxxxxzzywww"], ["abcdddeeeeaabbbcdxxx"], ["qwerrrtyyyyuu"], ["mississippi"], ["aaabbbaaacccaaaddd"], ["abcdefghijklmnopqrstuvwxyz"], ["aabbbaaabbbbaaaabbbb"]], "expected": [[[3, 6]], [], [[3, 5], [6, 9], [12, 14]], [[0, 2]], [], [], [[0, 3]], [[3, 5]], [[0, 2], [3, 5]], [[0, 2], [3, 5], [6, 8]], [[0, 9]], [], [[2, 4]], [[5, 7]], [[0, 2], [3, 5], [6, 8], [9, 11]], [[1, 3], [4, 6], [9, 12]], [[0, 2], [3, 5], [6, 8]], [], [[0, 2], [4, 6]], [[1, 4]], [[0, 2]], [[3, 6], [10, 12]], [[3, 5], [6, 9], [12, 14], [17, 19]], [[3, 5], [7, 10]], [], [[0, 2], [3, 5], [6, 8], [9, 11], [12, 14], [15, 17]], [], [[2, 4], [5, 7], [8, 11], [12, 15], [16, 19]]], "loose": false}

package/data/problems/possible-bipartition.json

@@ -0,0 +1 @@
+{"basic": false, "label": "877", "slug": "possible-bipartition", "id": 877, "title": "Possible Bipartition", "difficulty": "Medium", "category": "graph", "link": "https://leetcode.com/problems/possible-bipartition/", "examples": [{"input": "n = 4, dislikes = [[1,2],[1,3],[2,4]]", "output": "true", "explanation": "Put 1 and 4 in one group and 2 and 3 in the other; every rival pair is separated."}, {"input": "n = 3, dislikes = [[1,2],[1,3],[2,3]]", "output": "false", "explanation": "All three people pairwise dislike each other, so two groups can never separate every pair."}, {"input": "n = 5, dislikes = [[1,2],[2,3],[3,4],[4,5],[1,5]]", "output": "false", "explanation": "The rivalries form a ring of five, an odd cycle that no two-group split can satisfy."}], "hints": ["View rivalries as graph edges and paint the graph with two colors so neighbors always differ.", "Run BFS/DFS from every unpainted person; a neighbor that already wears the same color proves the split is impossible."], "statement": "There are `n` people numbered `1` to `n`. Each pair in `dislikes` holds two people who refuse to sit in the same group. Decide whether everyone can be split into two groups so that every rival pair lands in different groups.\n\nReturn `true` when such a split exists and `false` otherwise.\n\n**Constraints:**\n- `1 <= n <= 2000`\n- `1 <= dislikes.length <= 10^4`\n- `dislikes[i] = [a, b]` with `1 <= a, b <= n` and `a != b`\n", "solution": "## Approach\n\nTreat each rivalry as an undirected graph edge and try to paint every person one of two colors so that neighbors always differ. A BFS from each unpainted person assigns forced colors outward; reaching a neighbor that already carries the same color exposes an odd cycle and proves the answer false. If every component paints cleanly, the two color classes form a valid split.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + E), where E is the number of rivalry pairs. Each person and edge is processed once.\n- **Space Complexity:** O(n + E) for the adjacency lists, colors, and queue.\n\n## Implementation\n\n```python\nfrom collections import deque\nfrom typing import List\n\nclass Solution:\n    def possibleBipartition(self, n: int, dislikes: List[List[int]]) -> bool:\n        g = [[] for _ in range(n + 1)]\n        for a, b in dislikes:\n            g[a].append(b)\n            g[b].append(a)\n        color = [0] * (n + 1)\n        for i in range(1, n + 1):\n            if color[i] != 0:\n                continue\n            color[i] = 1\n            q = deque([i])\n            while q:\n                u = q.popleft()\n                for v in g[u]:\n                    if color[v] == 0:\n                        color[v] = -color[u]\n                        q.append(v)\n                    elif color[v] == color[u]:\n                        return False\n        return True\n```\n", "starter": {"go": "package main\n\nfunc PossibleBipartition(n int, dislikes [][]int) bool {\n    \n}", "python": "from typing import List\nclass Solution:\n    def possibleBipartition(self, n: int, dislikes: List[List[int]]) -> bool:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    bool possibleBipartition(int n, vector<vector<int>>& dislikes) {\n        return false;\n    }\n};"}, "fn": "possibleBipartition", "params": [{"name": "n", "type": "int"}, {"name": "dislikes", "type": "int_array_2d"}], "outputType": "boolean", "tests": [["4", "[[1,2],[1,3],[2,4]]"], ["3", "[[1,2],[1,3],[2,3]]"], ["5", "[[1,2],[2,3],[3,4],[4,5],[1,5]]"], ["1", "[]"], ["2", "[[1,2]]"], ["2", "[]"], ["4", "[[1,2],[3,4]]"], ["4", "[[1,2],[2,3],[3,4],[4,1]]"], ["4", "[[1,2],[2,3],[3,1]]"], ["6", "[[1,2],[2,3],[3,4],[4,5],[5,6]]"], ["6", "[[1,2],[2,3],[3,4],[4,5],[5,6],[6,1]]"], ["5", "[[1,3],[2,4],[3,5],[1,5]]"], ["5", "[[1,2],[3,4]]"], ["7", "[[1,2],[2,3],[4,5],[5,6],[6,7]]"], ["3", "[]"], ["4", "[[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]"], ["6", "[[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]"], ["6", "[[1,2],[1,3],[1,4],[1,5],[1,6]]"], ["8", "[[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8]]"], ["8", "[[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,1]]"], ["10", "[[1,2],[2,3],[1,3],[4,5],[5,6],[4,6]]"], ["10", "[[1,2],[3,4],[5,6],[7,8],[9,10]]"], ["9", "[[1,2],[2,3],[4,5],[5,6],[7,8],[8,9],[1,4],[4,7],[2,5],[5,8],[3,6],[6,9]]"], ["9", "[[1,2],[2,3],[4,5],[5,6],[7,8],[8,9],[1,4],[4,7],[2,5],[5,8],[3,6],[6,9],[1,5]]"], ["15", "[[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9],[9,10],[10,11],[11,12],[12,13],[13,14],[14,15]]"], ["15", "[[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9],[9,10],[10,11],[11,12],[12,13],[13,14],[14,15],[1,3]]"], ["20", "[[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9],[9,10],[10,11],[11,12],[12,13],[13,14],[14,15],[15,16],[16,17],[17,18],[18,19],[19,20],[20,1]]"], ["20", "[[1,2],[2,3],[3,4],[4,5],[5,6],[6,7],[7,8],[8,9],[9,10],[10,11],[11,12],[12,13],[13,14],[14,15],[15,16],[16,17],[17,18],[18,19],[19,1]]"]], "expected": [true, false, false, true, true, true, true, true, false, true, true, false, true, true, true, false, true, true, true, false, false, true, true, false, true, false, true, false], "loose": false}

package/data/problems/pour-water.json

@@ -0,0 +1 @@
+{"basic": false, "label": "757", "slug": "pour-water", "id": 757, "title": "Pour Water", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/pour-water/", "examples": [{"input": "heights = [2,1,1,2,1,2,2], volume = 4, k = 3", "output": "[2,2,2,3,2,2,2]", "explanation": "Two left, one right, one stays."}, {"input": "heights = [1,2,3,4], volume = 2, k = 2", "output": "[2,3,3,4]", "explanation": "Both drift left."}, {"input": "heights = [3,1,3], volume = 5, k = 1", "output": "[4,4,4]", "explanation": "Dip fills then levels out."}], "hints": ["Handle units sequentially; each decision sees all previously placed water.", "To probe left, scan outward while heights do not rise and track the lowest position; only move when it beats the start level.", "Try the left side before the right side, and stay put when neither side improves."], "statement": "You are given terrain heights `heights`, a number of water units `volume`, and a drop index `k`.\n\nProcess the units one at a time. For each unit, decide where it settles by this rule. First look left: walk left while the level (terrain plus water already placed) never rises, and remember the leftmost lowest reachable spot. If that spot sits lower than the drop column, the unit rests there. Otherwise perform the mirror search to the right. If neither side offers a lower home, the unit stays at `k`. Each settled unit raises its column by one before the next unit falls.\n\nReturn the final levels after all units settle. The input array may be updated in place.\n\n**Constraints:**\n- `1 <= heights.length <= 100`\n- `0 <= heights[i] <= 99`\n- `0 <= volume <= 2000`\n- `0 <= k < heights.length`\n", "solution": "## Approach\n\nPour units one by one. For each unit, scan left while levels never rise, remembering the lowest reachable column; if it sits below the drop column, place the water there. Otherwise repeat the scan to the right. When neither side improves, raise the drop column itself. Updating levels immediately keeps later units aware of earlier ones.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(volume * n), where n is the terrain length, since each unit scans at most the whole array twice.\n- **Space Complexity:** O(1) besides the input array.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def pourWater(self, heights: List[int], volume: int, k: int) -> List[int]:\n        n = len(heights)\n        for _ in range(volume):\n            best = k\n            for i in range(k - 1, -1, -1):\n                if heights[i] > heights[best]:\n                    break\n                if heights[i] < heights[best]:\n                    best = i\n            if best != k:\n                heights[best] += 1\n                continue\n            best = k\n            for i in range(k + 1, n):\n                if heights[i] > heights[best]:\n                    break\n                if heights[i] < heights[best]:\n                    best = i\n            heights[best] += 1\n        return heights\n```\n", "starter": {"go": "package main\n\nfunc PourWater(heights []int, volume int, k int) []int {\n    return heights\n}", "python": "from typing import List\nclass Solution:\n    def pourWater(self, heights: List[int], volume: int, k: int) -> List[int]:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    vector<int> pourWater(vector<int>& heights, int volume, int k) {\n        return {};\n    }\n};"}, "fn": "pourWater", "params": [{"name": "heights", "type": "int_array"}, {"name": "volume", "type": "int"}, {"name": "k", "type": "int"}], "outputType": "int_array", "tests": [["[2,1,1,2,1,2,2]", "4", "3"], ["[1,2,3,4]", "2", "2"], ["[3,1,3]", "5", "1"], ["[1,2,3,4]", "0", "2"], ["[5]", "10", "0"], ["[0,0,0]", "3", "1"], ["[3,2,1]", "2", "0"], ["[1,2,3]", "2", "2"], ["[2,1,1,2,1,2,2]", "1", "3"], ["[2,1,1,2,1,2,2]", "0", "0"], ["[0]", "5", "0"], ["[4,4,4]", "3", "1"], ["[5,4,3,2,1]", "3", "4"], ["[1,2,1,2,1]", "4", "2"], ["[0,1,0]", "2", "1"], ["[2,2,2]", "2", "0"], ["[2,2,2]", "2", "2"], ["[1,0,2,1,0,1,3]", "5", "3"], ["[6,5,4,3,2,1]", "4", "0"], ["[1,2,3,4,5]", "5", "0"], ["[3,3,3,3]", "4", "2"], ["[0,2,0]", "4", "1"], ["[1,1,1,1]", "1", "1"], ["[4,1,4]", "3", "1"], ["[2,3,1,2]", "3", "1"], ["[0,0,5,0,0]", "6", "2"], ["[1,3,2]", "2", "1"], ["[2,1,2]", "3", "1"]], "expected": [[2, 2, 2, 3, 2, 2, 2], [2, 3, 3, 4], [4, 4, 4], [1, 2, 3, 4], [15], [1, 1, 1], [3, 3, 2], [2, 3, 3], [2, 1, 2, 2, 1, 2, 2], [2, 1, 1, 2, 1, 2, 2], [5], [5, 5, 5], [5, 4, 3, 3, 3], [2, 2, 3, 2, 2], [1, 1, 1], [3, 3, 2], [2, 3, 3], [2, 2, 2, 2, 1, 1, 3], [6, 5, 4, 4, 3, 3], [4, 4, 3, 4, 5], [4, 4, 4, 4], [2, 2, 2], [1, 2, 1, 1], [4, 4, 4], [3, 3, 3, 2], [3, 3, 5, 0, 0], [3, 3, 2], [3, 3, 2]], "loose": false}

package/data/problems/power-of-four.json

@@ -0,0 +1 @@
+{"basic": false, "label": "425", "slug": "power-of-four", "id": 425, "title": "Power of Four", "difficulty": "Easy", "category": "math", "link": "https://leetcode.com/problems/power-of-four/", "examples": [{"input": "n = 16", "output": "true", "explanation": "16 is 4 squared."}, {"input": "n = 5", "output": "false", "explanation": "No integer exponent of 4 equals 5."}, {"input": "n = 1", "output": "true", "explanation": "4 to the power 0 is 1."}], "hints": ["A power of four is a power of two whose single set bit sits in an odd position.", "Check positivity, a single set bit, and divisibility of (n - 1) by 3."], "statement": "Given an integer `n`, decide whether it can be written as a power of four \u2014 that is, whether some non-negative integer `x` satisfies `n == 4^x` (1, 4, 16, 64, ...).\n\nReturn `true` for such values and `false` otherwise. Zero, negatives, and numbers with odd prime factors never qualify.\n\n**Constraints:**\n- `-2^31 <= n <= 2^31 - 1`\n", "solution": "## Approach\n\nA power of four must be positive and hold exactly one binary 1, which the classic `n & (n-1)` test confirms. Among powers of two, only those with the lone bit in an even slot (values 1, 4, 16, ...) are powers of four; these are precisely the powers of two one less than a multiple of three. Combining the three checks decides membership in constant time.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1).\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nclass Solution:\n    def isPowerOfFour(self, n: int) -> bool:\n        return n > 0 and (n & (n - 1)) == 0 and (n - 1) % 3 == 0\n```\n", "starter": {"go": "package main\n\nfunc IsPowerOfFour(n int) bool {\n    return false\n}", "python": "class Solution:\n    def isPowerOfFour(self, n: int) -> bool:\n        pass", "cpp": "class Solution {\npublic:\n    bool isPowerOfFour(int n) {\n        return false;\n    }\n};"}, "fn": "isPowerOfFour", "params": [{"name": "n", "type": "int"}], "outputType": "boolean", "tests": [["16"], ["5"], ["1"], ["0"], ["2"], ["3"], ["4"], ["8"], ["32"], ["64"], ["256"], ["1024"], ["4096"], ["65536"], ["262144"], ["1048576"], ["1073741824"], ["-4"], ["-16"], ["-1"], ["6"], ["12"], ["15"], ["17"], ["20"], ["24"], ["48"], ["100"], ["2147483647"], ["-2147483648"]], "expected": [true, false, true, false, false, false, true, false, false, true, true, true, true, true, true, true, true, false, false, false, false, false, false, false, false, false, false, false, false, false], "loose": false}

package/data/problems/power-of-three.json

@@ -0,0 +1 @@
+{"basic": false, "label": "413", "slug": "power-of-three", "id": 413, "title": "Power of Three", "difficulty": "Easy", "category": "math", "link": "https://leetcode.com/problems/power-of-three/", "examples": [{"explanation": "27 equals 3 multiplied by itself 3 times.", "input": "n = 27", "output": "true"}, {"explanation": "No power of 3 equals 0.", "input": "n = 0", "output": "false"}, {"explanation": "Powers of 3 are positive, so -1 is impossible.", "input": "n = -1", "output": "false"}], "hints": ["Any power of 3 is positive, so non-positive inputs are immediately false.", "The largest power of 3 fitting in 32 bits is 3^19 = 1162261467, and every smaller power divides it.", "Alternatively divide out factors of 3 in a loop until the value is no longer divisible."], "statement": "Given an integer `n`, decide whether it can be written as `3` raised to some non-negative integer power (`1, 3, 9, 27, ...`). Return `true` when such an exponent exists and `false` otherwise.\n\n**Constraints:**\n- `-2^31 <= n <= 2^31 - 1`\n", "solution": "## Approach\n\nEvery power of 3 below 2^31 divides the largest one, 3^19 = 1162261467, and no other positive integer does. So the test reduces to checking positivity plus this single divisibility. Equivalently, one can repeatedly divide by 3 and see whether the remainder reaches 1.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1).\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nclass Solution:\n    def isPowerOfThree(self, n: int) -> bool:\n        return n > 0 and 1162261467 % n == 0\n```\n", "starter": {"go": "package main\n\nfunc IsPowerOfThree(n int) bool {\n    \n}", "python": "class Solution:\n    def isPowerOfThree(self, n: int) -> bool:\n        pass", "cpp": "class Solution {\npublic:\n    bool isPowerOfThree(int n) {\n        return false;\n    }\n};"}, "fn": "isPowerOfThree", "params": [{"name": "n", "type": "int"}], "outputType": "boolean", "tests": [["27"], ["0"], ["-1"], ["1"], ["3"], ["9"], ["81"], ["243"], ["2"], ["4"], ["6"], ["8"], ["10"], ["12"], ["18"], ["45"], ["100"], ["1162261467"], ["387420489"], ["129140163"], ["2147483647"], ["-2147483648"], ["-3"], ["-9"], ["-27"], ["5"], ["7"], ["28"], ["59049"], ["1594323"]], "expected": [true, false, false, true, true, true, true, true, false, false, false, false, false, false, false, false, false, true, true, true, false, false, false, false, false, false, false, false, true, true], "loose": false}

package/data/problems/power-of-two.json

@@ -0,0 +1 @@
+{"basic": false, "label": "342", "slug": "power-of-two", "id": 342, "title": "Power of Two", "difficulty": "Easy", "category": "binary", "link": "https://leetcode.com/problems/power-of-two/", "examples": [{"input": "n = 1", "output": "true", "explanation": "2^0 equals 1."}, {"input": "n = 16", "output": "true", "explanation": "2^4 equals 16."}, {"input": "n = 3", "output": "false", "explanation": "No integer power of two equals 3."}], "hints": ["A positive power of two has exactly one bit set in binary.", "For n > 0, the expression (n & (n - 1)) == 0 detects a single set bit."], "statement": "Given an integer `n`, determine whether it is a power of two.\n\nAn integer is a power of two when some non-negative integer `x` satisfies `n == 2^x`. In binary this means exactly one bit is set and the value is positive.\n\nReturn `true` when `n` meets that definition, otherwise return `false`.\n\n**Constraints:**\n- `-2^31 <= n <= 2^31 - 1`\n", "solution": "## Approach\n\nA positive integer is a power of two exactly when its binary form contains a single set bit. Clearing the lowest set bit with `n & (n - 1)` leaves zero only in that case. Non-positive inputs can never qualify, so they return `False` immediately.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1), a constant number of bit operations.\n- **Space Complexity:** O(1), no extra storage.\n\n## Implementation\n\n```python\nclass Solution:\n    def isPowerOfTwo(self, n: int) -> bool:\n        return n > 0 and (n & (n - 1)) == 0\n```\n", "starter": {"go": "package main\n\nfunc IsPowerOfTwo(n int) bool {\n    \n}", "python": "class Solution:\n    def isPowerOfTwo(self, n: int) -> bool:\n        pass", "cpp": "class Solution {\npublic:\n    bool isPowerOfTwo(int n) {\n        return false;\n    }\n};"}, "fn": "isPowerOfTwo", "params": [{"name": "n", "type": "int"}], "outputType": "boolean", "tests": [["1"], ["16"], ["3"], ["0"], ["-1"], ["-16"], ["2"], ["4"], ["5"], ["8"], ["6"], ["1024"], ["1023"], ["1025"], ["1073741824"], ["2147483647"], ["-2147483648"], ["536870912"], ["536870911"], ["64"], ["32"], ["128"], ["256"], ["12"], ["7"], ["100"], ["2048"], ["2097152"], ["-2"], ["1073741823"]], "expected": [true, true, false, false, false, false, true, true, false, true, false, true, false, false, true, false, false, true, false, true, true, true, true, false, false, false, true, true, false, false], "loose": false}

package/data/problems/powerful-integers.json

@@ -0,0 +1 @@
+{"basic": false, "label": "956", "slug": "powerful-integers", "id": 956, "title": "Powerful Integers", "difficulty": "Medium", "category": "math", "link": "https://leetcode.com/problems/powerful-integers/", "examples": [{"input": "x = 2, y = 3, bound = 10", "output": "[2,3,4,5,7,9,10]", "explanation": "The sums 2^i + 3^j within bound are 2, 3, 4, 5, 7, 9 and 10 (order does not matter)."}, {"input": "x = 3, y = 5, bound = 15", "output": "[2,4,6,8,10,14]", "explanation": "Reachable sums are 2, 4, 6, 8, 10 and 14; everything else overshoots the bound."}, {"input": "x = 2, y = 1, bound = 10", "output": "[2,3,5,9]", "explanation": "Since 1^j is always 1, the sums are 2, 3, 5 and 9."}], "hints": ["Loop over powers of x and, nested inside, powers of y, keeping sums within bound.", "A base of 1 never grows \u2014 take its single power and move on to avoid an infinite loop.", "Deduplicate with a set; order is irrelevant to the judge."], "statement": "Call an integer powerful when it can be written as `x^i + y^j` for some non-negative integers `i` and `j`. Given `x`, `y` and `bound`, return every powerful integer that does not exceed `bound`, in increasing order, as an integer list. Any order is accepted by the judge.\n\n**Constraints:**\n- `1 <= x, y <= 100`\n- `0 <= bound <= 10^6`\n- The answers form an integer list.\n", "solution": "## Approach\n\nEnumerate all powers of x up to the bound, and for each enumerate all powers of y while the sum stays within the bound. Collect the sums in a set to drop duplicates, then sort. When x or y equals 1 its powers never grow, so stop after the first one to avoid looping forever. Only logarithmically many powers exist, so the double loop is tiny.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(log^2 bound) power pairs.\n- **Space Complexity:** O(answer size) for the result set.\n\n## Implementation\n\n```python\nclass Solution:\n    def powerfulIntegers(self, x: int, y: int, bound: int) -> list[int]:\n        s = set()\n        px = 1\n        while px <= bound:\n            py = 1\n            while px + py <= bound:\n                s.add(px + py)\n                if y == 1:\n                    break\n                py *= y\n            if x == 1:\n                break\n            px *= x\n        return sorted(s)\n```\n", "starter": {"go": "package main\n\nfunc PowerfulIntegers(x int, y int, bound int) []int {\n    return nil\n}", "python": "from typing import List\nclass Solution:\n    def powerfulIntegers(self, x: int, y: int, bound: int) -> List[int]:\n        return []", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<int> powerfulIntegers(int x, int y, int bound) {\n        return {};\n    }\n};"}, "fn": "powerfulIntegers", "params": [{"name": "x", "type": "int"}, {"name": "y", "type": "int"}, {"name": "bound", "type": "int"}], "outputType": "int_list", "tests": [["2", "3", "10"], ["3", "5", "15"], ["2", "1", "10"], ["1", "1", "10"], ["1", "1", "0"], ["2", "2", "0"], ["100", "100", "1000000"], ["1", "2", "100"], ["2", "3", "0"], ["2", "3", "1"], ["2", "3", "2"], ["2", "3", "3"], ["2", "3", "4"], ["2", "3", "5"], ["3", "3", "10"], ["5", "5", "50"], ["1", "100", "100"], ["100", "1", "100"], ["2", "4", "20"], ["4", "2", "20"], ["3", "2", "30"], ["2", "5", "50"], ["7", "7", "100"], ["1", "3", "7"], ["3", "1", "7"], ["10", "10", "200"], ["2", "6", "40"], ["9", "9", "200"]], "expected": [[2, 3, 4, 5, 7, 9, 10], [2, 4, 6, 8, 10, 14], [2, 3, 5, 9], [2], [], [], [2, 101, 200, 10001, 10100, 20000], [2, 3, 5, 9, 17, 33, 65], [], [], [2], [2, 3], [2, 3, 4], [2, 3, 4, 5], [2, 4, 6, 10], [2, 6, 10, 26, 30, 50], [2], [2], [2, 3, 5, 6, 8, 9, 12, 17, 18, 20], [2, 3, 5, 6, 8, 9, 12, 17, 18, 20], [2, 3, 4, 5, 7, 9, 10, 11, 13, 17, 19, 25, 28, 29], [2, 3, 5, 6, 7, 9, 13, 17, 21, 26, 27, 29, 33, 37, 41], [2, 8, 14, 50, 56, 98], [2, 4], [2, 4], [2, 11, 20, 101, 110, 200], [2, 3, 5, 7, 8, 9, 10, 14, 17, 22, 33, 37, 38, 40], [2, 10, 18, 82, 90, 162]], "loose": true}

package/data/problems/powx-n.json

@@ -0,0 +1 @@
+{"basic": false, "label": "147", "slug": "powx-n", "id": 147, "title": "Pow(x, n)", "difficulty": "Medium", "category": "math", "link": "https://leetcode.com/problems/powx-n/", "examples": [{"input": "x = \"2.0\", n = 10", "output": "\"1024.0\"", "explanation": "\"2.0\"^10 = \"1024.0\"."}, {"input": "x = \"2.1\", n = 3", "output": "\"9.261\"", "explanation": "\"2.1\"^3 = \"9.261\"."}, {"input": "x = \"2.0\", n = -2", "output": "\"0.25\"", "explanation": "\"2.0\"^-2 = \"0.25\"."}], "hints": ["This is a portable adaptation: parse the input string as a double and return a finite, double-parseable decimal string.", "Use exponentiation by squaring, halving the exponent at each step.", "Store the exponent in a wider signed integer before negating it so the minimum 32-bit exponent is handled safely.", "For a negative exponent, invert the base and use the positive magnitude of the exponent."], "statement": "Implement exponentiation for a decimal base `x` and a 32-bit integer exponent `n`.\n\nReturn `x` raised to `n`. Your algorithm should run in `O(log |n|)` time rather than multiplying `|n|` times.\n\n**Portable string adaptation:** The base is supplied as a valid finite decimal string so every supported language receives the same input. Parse `x` as a double-precision floating-point value and return the result as a decimal string that can be parsed as a double. Scientific notation is allowed. Answers are checked with absolute and relative tolerance. `NaN`, infinity, and malformed output strings are rejected.\n\n**Constraints:**\n- `-100 < x < 100`\n- `-2^31 <= n <= 2^31 - 1`\n- Either `x != 0` or `n > 0`\n- `-10^4 <= x^n <= 10^4`\n", "solution": "## Approach\n\nParse the portable string base as a double and use exponentiation by squaring. For a negative exponent, invert the base and negate the exponent before repeatedly consuming one binary exponent bit. Format the final double with 17 significant digits so the returned string round-trips reliably through a double parser.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(log |n|), because each iteration halves the exponent.\n- **Space Complexity:** O(1), excluding the returned decimal string.\n\n## Implementation\n\n```python\nclass Solution:\n    def myPow(self, x: str, n: int) -> str:\n        base = float(x)\n        exponent = n\n        if exponent < 0:\n            base = 1.0 / base\n            exponent = -exponent\n\n        result = 1.0\n        while exponent > 0:\n            if exponent % 2 == 1:\n                result *= base\n            base *= base\n            exponent //= 2\n        return format(result, \".17g\")\n```\n", "starter": {"go": "package main\n\nfunc MyPow(x string, n int) string {\n    return \"\"\n}", "python": "class Solution:\n    def myPow(self, x: str, n: int) -> str:\n        return \"\"\n", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    string myPow(string x, int n) {\n        return \"\";\n    }\n};"}, "fn": "myPow", "params": [{"name": "x", "type": "string"}, {"name": "n", "type": "int"}], "outputType": "string", "tests": [["2.0", "10"], ["2.1", "3"], ["2.0", "-2"], ["-2.0", "5"], ["-2.0", "6"], ["0", "1"], ["0.0", "5"], ["0", "2147483647"], ["1", "-2147483648"], ["-1", "-2147483648"], ["-1", "2147483647"], ["1", "2147483647"], ["1.5", "0"], ["0.5", "10"], ["0.5", "-10"], ["10", "-8"], ["0.1", "8"], ["1.01", "100"], ["0.99", "100"], ["1.0001", "10000"], ["0.9999", "10000"], ["3", "7"], ["3", "-7"], ["-3", "-7"], ["-3", "-8"], ["5", "5"], ["5", "-12"], ["1.25", "20"], ["0.8", "20"], ["2.5", "8"], ["2.5", "-15"], ["-0.5", "9"], ["-0.5", "-9"], ["7", "1"], ["7", "-1"], ["-7", "1"], ["-7", "-1"], ["99.999", "2"], ["-21.5", "3"], ["0.0001", "2"], ["99.999", "-2"], ["9.999", "4"], ["0.125", "7"], ["8", "-7"], ["1.2", "30"], ["1.2", "-30"], ["-1.2", "31"], ["-1.2", "-31"], ["2", "13"], ["2", "-30"], ["-2", "13"], ["-2", "-31"], ["1.0000001", "1000000"], ["0.9999999", "1000000"], ["1.000001", "100000"], ["0.999999", "100000"], ["2.225", "4"], ["-4.75", "4"], ["-4.75", "3"], ["6.022", "5"], ["3.1415926535", "2"], ["2.718281828", "3"], ["0.3333333333", "5"], ["1.4142135623", "10"], ["-1.4142135623", "11"], ["+2.5", "6"], ["0002.500", "-4"], ["-0.0", "7"], ["42.125", "1"], ["42.125", "0"], ["99.99999999999999", "1"], ["-99.99999999999999", "1"], ["10", "4"], ["-20", "3"], ["2.2250738585072014e-308", "1"], ["-2.2250738585072014e-308", "1"], ["0.999999999", "-2147483648"], ["1.0000001", "-2147483647"], ["1.000000001", "2147483647"], ["0.9999999", "2147483646"]], "expected": ["1024.0", "9.261000000000001", "0.25", "-32.0", "64.0", "0.0", "0.0", "0.0", "1.0", "1.0", "-1.0", "1.0", "1.0", "9.765625E-4", "1024.0", "1.0000000000000008E-8", "1.0000000000000008E-8", "2.704813829421529", "0.3660323412732289", "2.718145926824356", "0.36786104643302414", "2187.0", "4.5724737082761767E-4", "-4.5724737082761767E-4", "1.5241579027587256E-4", "3125.0", "4.096000000000006E-9", "86.73617379884035", "0.011529215046068495", "1525.87890625", "1.0737418240000018E-6", "-0.001953125", "-512.0", "7.0", "0.14285714285714285", "-7.0", "-0.14285714285714285", "9999.800001", "-9938.375", "1.0E-8", "1.0000200003000041E-4", "9996.000599960003", "4.76837158203125E-7", "4.76837158203125E-7", "237.37631379976966", "0.004212720233087435", "-284.8515765597236", "-0.0035106001942395294", "8192.0", "9.313225746154785E-10", "-8192.0", "-4.656612873077393E-10", "1.1051709126081526", "0.9048374135477304", "1.1051708628105146", "0.9048373727913885", "24.508687890625005", "509.06640625", "-107.171875", "7919.609280312835", "9.869604400525171", "20.085536913011932", "0.0041152263353909455", "31.999999983460484", "-45.254833970209596", "244.140625", "0.02560000000000001", "-0.0", "42.125", "1.0", "99.99999999999999", "-99.99999999999999", "10000.0", "-8000.0", "2.2250738585072014E-308", "-2.2250738585072014E-308", "8.563284397535678", "5.444710603638906E-94", "8.563284388972392", "5.444595631078263E-94"], "loose": false}

package/data/problems/predict-the-winner.json

@@ -0,0 +1 @@
+{"basic": false, "label": "550", "slug": "predict-the-winner", "id": 550, "title": "Predict the Winner", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/predict-the-winner/", "examples": [{"input": "nums = [1,5,2]", "output": "false", "explanation": "Second player always secures the 5 and wins."}, {"input": "nums = [1,5,233,7]", "output": "true", "explanation": "First player takes 1 then 233 to win."}, {"input": "nums = [1]", "output": "true", "explanation": "Single pick wins."}], "hints": ["Track the best net lead the player to move can build on any interval.", "An interval's value is the better of taking the left or right end minus the opponent's reply.", "Non-negative lead over the whole array means the first player ties or wins."], "statement": "Two opponents alternately remove one number from either tip of an array `nums`, adding it to their own total. The first player moves first, and both sides play perfectly to maximize their own final total. A drawn total still counts as a first-player success.\n\nDecide whether the first player can finish with at least as many points as the second.\n\n**Constraints:**\n\n- `1 <= nums.length <= 20`\n- `0 <= nums[i] <= 10^7`\n", "solution": "## Approach\n\nLet the table hold the largest net advantage the player about to move can secure on each subarray. Single cells are worth their own value; wider intervals take the better of grabbing the left end or the right end and then subtracting the opponent's optimal reply on the remainder. A non-negative advantage on the full array means the opener ties or wins.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2) for all intervals, with n <= 20.\n- **Space Complexity:** O(n^2) for the table.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n    def predictTheWinner(self, nums: List[int]) -> bool:\n        n = len(nums)\n        dp = [[0] * n for _ in range(n)]\n        for i in range(n):\n            dp[i][i] = nums[i]\n        for length in range(2, n + 1):\n            for i in range(n - length + 1):\n                j = i + length - 1\n                dp[i][j] = max(nums[i] - dp[i + 1][j], nums[j] - dp[i][j - 1])\n        return dp[0][n - 1] >= 0\n```\n", "starter": {"go": "package main\n\nfunc PredictTheWinner(nums []int) bool {\n    return false\n}", "python": "from typing import List\nclass Solution:\n    def predictTheWinner(self, nums: List[int]) -> bool:\n        return False\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    bool predictTheWinner(vector<int>& nums) {\n        return false;\n    }\n};"}, "fn": "predictTheWinner", "params": [{"name": "nums", "type": "int_array"}], "outputType": "boolean", "tests": [["[1,5,2]"], ["[1,5,233,7]"], ["[1]"], ["[1,2]"], ["[2,1]"], ["[0]"], ["[1,1]"], ["[5,3,4,5]"], ["[1,5,2,4,6]"], ["[10,1,1,1,1,1]"], ["[3,7,2,5]"], ["[0,0,0,0]"], ["[1000000,999999,1]"], ["[2,4,55,6,8]"], ["[1,2,3,4,5,6]"], ["[7,7,7,7,7]"], ["[1,100,1]"], ["[5,5,5]"], ["[8,15,3,7]"], ["[20,10,30,40]"], ["[1,2,3,4,5,6,7]"], ["[0,0]"], ["[5,4,3,2,1]"], ["[10,20,30]"], ["[7,8,9,10,11,12]"], ["[100,1,1,100]"], ["[3,3,3,3]"], ["[1,1000000,1,1000000]"]], "expected": [false, true, true, true, true, true, true, true, true, true, true, true, true, false, true, true, false, true, true, true, true, true, true, true, true, true, true, true], "loose": false}

package/data/problems/prefix-and-suffix-search.json

@@ -0,0 +1 @@
+{"basic": false, "label": "749", "slug": "prefix-and-suffix-search", "id": 749, "title": "Prefix and Suffix Search", "difficulty": "Hard", "category": "trie", "link": "https://leetcode.com/problems/prefix-and-suffix-search/", "examples": [{"input": "words = [\"apple\"], pref = \"a\", suff = \"e\"", "output": "0", "explanation": "Index 0 fits both ends."}, {"input": "words = [\"apple\",\"apply\",\"ape\"], pref = \"ap\", suff = \"e\"", "output": "2", "explanation": "Indices 0 and 2 fit; return the larger."}, {"input": "words = [\"hello\",\"world\"], pref = \"x\", suff = \"y\"", "output": "-1", "explanation": "No word fits."}], "hints": ["Scanning indices from the end downward lets you return the first fit, which is automatically the largest.", "A word fits when it starts with pref and ends with suff; both checks are linear in the word length.", "For many repeated queries a combined prefix-suffix map or trie pays off, but a single scan is enough for one query."], "statement": "You are given a dictionary `words` where each entry is a lowercase word. For one query you also receive a prefix string `pref` and a suffix string `suff`.\n\nFind the largest index `i` such that `words[i]` starts with `pref` and ends with `suff`. If no dictionary word satisfies both ends, return `-1`.\n\nAdaptation for this judge: the original task defines a `WordFilter` class whose constructor stores the dictionary and whose method `f(pref, suff)` answers each query. Here the whole job is condensed into a single function call `wordFilter(words, pref, suff)` that builds the structure and answers one query at once.\n\n**Constraints:**\n- `1 <= words.length <= 10^4`\n- `1 <= words[i].length <= 7`\n- `1 <= pref.length, suff.length <= 7`\n- `words[i]`, `pref` and `suff` hold lowercase English letters only.\n", "solution": "## Approach\n\nIterate the dictionary from the last index toward the first and test each word with a prefix check and a suffix check. The first word passing both is the largest valid index, so return it at once. If the loop ends, no word fits and the answer is -1.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * L), where m is the number of words and L is the average word length for the two checks.\n- **Space Complexity:** O(1) besides the inputs.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def wordFilter(self, words: List[str], pref: str, suff: str) -> int:\n        for i in range(len(words) - 1, -1, -1):\n            if words[i].startswith(pref) and words[i].endswith(suff):\n                return i\n        return -1\n```\n", "starter": {"go": "package main\n\nfunc WordFilter(words []string, pref string, suff string) int {\n    return -1\n}", "python": "from typing import List\nclass Solution:\n    def wordFilter(self, words: List[str], pref: str, suff: str) -> int:\n        pass", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    int wordFilter(vector<string>& words, string pref, string suff) {\n        return -1;\n    }\n};"}, "fn": "wordFilter", "params": [{"name": "words", "type": "string_array"}, {"name": "pref", "type": "string"}, {"name": "suff", "type": "string"}], "outputType": "int", "tests": [["['apple']", "a", "e"], ["['apple']", "b", "e"], ["['apple', 'apply', 'ape']", "ap", "e"], ["['apple', 'apricot', 'banana']", "a", "e"], ["['test', 'testing', 'tester']", "test", "er"], ["['abc', 'abcd', 'abcde']", "ab", "d"], ["['a', 'aa', 'aaa']", "a", "a"], ["['cat', 'car', 'cart']", "ca", "t"], ["['hello', 'world']", "h", "o"], ["['hello', 'world']", "w", "d"], ["['hello', 'world']", "x", "y"], ["['ab', 'ba', 'aba']", "a", "a"], ["['prefix', 'suffix', 'fix']", "fix", "fix"], ["['aaaa', 'aaab', 'aabb']", "aa", "bb"], ["['dog', 'cat', 'bird']", "d", "g"], ["['dog', 'cat', 'bird']", "c", "t"], ["['dog', 'cat', 'bird']", "b", "d"], ["['apple', 'apple']", "a", "e"], ["['x', 'y', 'z']", "x", "x"], ["['x', 'y', 'z']", "y", "y"], ["['x', 'y', 'z']", "a", "a"], ["['abcdefg', 'abcxyzg', 'abczzzg']", "abc", "g"], ["['one', 'two', 'three']", "t", "o"], ["['same', 'same', 'same']", "s", "e"], ["['a', 'b', 'c']", "a", "b"], ["['ababa', 'babab']", "aba", "aba"], ["['word', 'words', 'wordy']", "word", "s"], ["['alpha', 'beta', 'gamma']", "a", "a"]], "expected": null, "loose": false}

package/data/problems/preimage-size-of-factorial-zeroes-function.json

@@ -0,0 +1 @@
+{"basic": false, "label": "791", "slug": "preimage-size-of-factorial-zeroes-function", "id": 791, "title": "Preimage Size of Factorial Zeroes Function", "difficulty": "Hard", "category": "math", "link": "https://leetcode.com/problems/preimage-size-of-factorial-zeroes-function/", "examples": [{"input": "k = 0", "output": "5", "explanation": "Values 0 through 4 have zero trailing zeroes."}, {"input": "k = 5", "output": "0", "explanation": "The zero count skips from 4 to 6."}, {"input": "k = 3", "output": "5", "explanation": "Values 15 through 19 each give three zeroes."}], "hints": ["Trailing zeroes of x! equal floor(x/5) + floor(x/25) + floor(x/125) + ... .", "That count function is monotone, so binary-search the smallest x reaching at least k.", "If that x yields exactly k, a full block of five consecutive values shares it; otherwise the answer is 0."], "statement": "For a non-negative integer `x`, write `zeros(x)` for the count of trailing\nzeroes in the decimal form of `x!` (the factorial), with `zeros(0) = 0`\nsince `0! = 1`. The function climbs in flat stretches: several consecutive\n`x` values share the same zero count, and some counts never occur at all.\n\nGiven `k`, count how many `x` satisfy `zeros(x) == k`. The answer turns out\nto be either five (a full block between multiples of five) or zero (a count\nthat the factorial skips over).\n\n**Constraints:**\n- `0 <= k <= 10^9`\n", "solution": "## Approach\n\nThe zero count of `x!` is the sum of `floor(x/5^i)` over all powers of\nfive, which grows monotonically. Binary-search the smallest `x` whose count\nreaches at least `k`. When that position yields exactly `k`, the five values\nfrom the block start through the next multiple-of-five boundary all share\nit; otherwise `k` is skipped and the answer is zero.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(log k) search steps, each evaluating the zero sum in O(log x).\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nclass Solution:\n    def preimageSizeFZF(self, k: int) -> int:\n        def zeros(x: int) -> int:\n            total = 0\n            while x:\n                x //= 5\n                total += x\n            return total\n\n        lo, hi = 0, 5 * (k + 1)\n        while lo < hi:\n            mid = (lo + hi) // 2\n            if zeros(mid) < k:\n                lo = mid + 1\n            else:\n                hi = mid\n        return 5 if zeros(lo) == k else 0\n```\n", "starter": {"go": "package main\n\nfunc PreimageSizeFZF(k int) int {\n    return 0\n}", "python": "class Solution:\n    def preimageSizeFZF(self, k: int) -> int:\n        return 0\n", "cpp": "class Solution {\npublic:\n    int preimageSizeFZF(int k) {\n        return 0;\n    }\n};"}, "fn": "preimageSizeFZF", "params": [{"name": "k", "type": "int"}], "outputType": "int", "tests": [["0"], ["5"], ["3"], ["1"], ["2"], ["4"], ["6"], ["10"], ["11"], ["7"], ["13"], ["24"], ["25"], ["26"], ["29"], ["30"], ["31"], ["100"], ["124"], ["125"], ["1000"], ["1000000"], ["1000000000"], ["999999999"], ["42"], ["99"], ["101"], ["100000000"]], "expected": [5, 0, 5, 5, 5, 5, 5, 5, 0, 5, 5, 5, 5, 5, 0, 0, 5, 5, 5, 5, 5, 5, 5, 5, 0, 5, 5, 5], "loose": false}

package/data/problems/prime-number-of-set-bits-in-binary-representation.json

@@ -0,0 +1 @@
+{"basic": false, "label": "764", "slug": "prime-number-of-set-bits-in-binary-representation", "id": 764, "title": "Prime Number of Set Bits in Binary Representation", "difficulty": "Easy", "category": "math", "link": "https://leetcode.com/problems/prime-number-of-set-bits-in-binary-representation/", "examples": [{"input": "left = 6, right = 10", "output": "4", "explanation": "6, 7, 9, 10 have 2, 3, 2, 2 one-bits (all prime); 8 has 1."}, {"input": "left = 10, right = 15", "output": "5", "explanation": "Only 15 (4 bits) misses a prime count."}, {"input": "left = 1, right = 1", "output": "0", "explanation": "A single one-bit is not prime."}], "hints": ["Count one-bits with a loop or a builtin popcount, then test membership in the small prime set.", "Values up to 10^6 need at most 20 bits, so only primes 2, 3, 5, 7, 11, 13, 17, 19 can occur."], "statement": "Given two integers `left` and `right` with `left <= right`, count how many integers `x` in the closed interval `[left, right]` have a prime number of `1` bits in their binary form.\n\nThe bit count of `x` is the number of ones when `x` is written in base two; for instance `21 = 10101` has three such bits.\n\n**Constraints:**\n- `1 <= left <= right <= 10^6`\n- `0 <= right - left <= 10^4`\n", "solution": "## Approach\n\nIterate over the closed interval and count the one-bits of each value with a popcount operation. Look up whether that count is prime (only 2, 3, 5, 7, 11, 13, 17, 19 are reachable below 10^6) and tally the hits.\n\n## Complexity Analysis\n\n- **Time Complexity:** O((right - left + 1) * log right) for scanning and bit counting.\n- **Space Complexity:** O(1) besides the answer.\n\n## Implementation\n\n```python\nclass Solution:\n    def countPrimeSetBits(self, left: int, right: int) -> int:\n        primes = {2, 3, 5, 7, 11, 13, 17, 19}\n        ans = 0\n        for x in range(left, right + 1):\n            if bin(x).count(\"1\") in primes:\n                ans += 1\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc CountPrimeSetBits(left int, right int) int {\n    return 0\n}", "python": "class Solution:\n    def countPrimeSetBits(self, left: int, right: int) -> int:\n        pass\n", "cpp": "class Solution {\npublic:\n    int countPrimeSetBits(int left, int right) {\n        return 0;\n    }\n};"}, "fn": "countPrimeSetBits", "params": [{"name": "left", "type": "int"}, {"name": "right", "type": "int"}], "outputType": "int", "tests": [["6", "10"], ["10", "15"], ["1", "1"], ["1", "2"], ["2", "2"], ["3", "3"], ["4", "4"], ["1", "10"], ["20", "30"], ["100", "110"], ["1", "100"], ["512", "512"], ["1023", "1023"], ["1024", "1024"], ["999983", "999993"], ["1000000", "1000000"], ["500000", "500010"], ["7", "7"], ["8", "8"], ["15", "15"], ["16", "16"], ["31", "31"], ["32", "32"], ["255", "255"], ["256", "256"], ["1", "1000"], ["990000", "1000000"], ["123456", "123466"]], "expected": [4, 5, 0, 0, 0, 1, 0, 6, 7, 6, 65, 0, 0, 0, 2, 1, 1, 1, 0, 0, 0, 1, 0, 0, 0, 530, 3754, 4], "loose": false}

package/data/problems/prime-palindrome.json

@@ -0,0 +1 @@
+{"basic": false, "label": "861", "slug": "prime-palindrome", "id": 861, "title": "Prime Palindrome", "difficulty": "Medium", "category": "math", "link": "https://leetcode.com/problems/prime-palindrome/", "examples": [{"input": "n = 6", "output": "7", "explanation": "7 is the next prime palindrome."}, {"input": "n = 8", "output": "11", "explanation": "11 is the first prime palindrome at or above 8."}, {"input": "n = 13", "output": "101", "explanation": "101 is the first prime palindrome at or above 13."}], "hints": ["Even-length palindromes beyond 11 are all multiples of 11, so only the number 11 matters among them.", "It is enough to build palindromes by mirroring the first half; generate odd-length candidates in increasing order plus the special 11.", "Test primality by trial division up to the square root, skipping even divisors after 2."], "statement": "You are given an integer `n`. A prime palindrome is a number that reads the same forward and backward (in decimal, without leading zeros) and is also prime.\n\nReturn the smallest prime palindrome that is greater than or equal to `n`.\n\nSingle-digit numbers that are prime (2, 3, 5, 7) already qualify, and two-digit 11 qualifies as well.\n\n**Constraints:**\n- `1 <= n <= 10^8`\n", "solution": "## Approach\n\nSmall inputs are answered directly, since 2, 3, 5, 7 and 11 cover everything up to 11. Longer even-length palindromes are divisible by 11, so only odd lengths can yield new prime palindromes. Build each odd-length palindrome by mirroring its first half in numeric order and return the first one that is at least `n` and passes a trial-division primality test.\n\n## Complexity Analysis\n\n- **Time Complexity:** Roughly proportional to the count of palindromes tried times the square root of the value for trial division; tiny in practice for the given limits.\n- **Space Complexity:** O(1) besides a few counters.\n\n## Implementation\n\n```python\nclass Solution:\n    def primePalindrome(self, n: int) -> int:\n        def is_prime(x: int) -> bool:\n            if x < 2:\n                return False\n            if x % 2 == 0:\n                return x == 2\n            d = 3\n            while d * d <= x:\n                if x % d == 0:\n                    return False\n                d += 2\n            return True\n        if n <= 2:\n            return 2\n        if n <= 3:\n            return 3\n        if n <= 5:\n            return 5\n        if n <= 7:\n            return 7\n        if n <= 11:\n            return 11\n        length = len(str(n))\n        while True:\n            if length % 2 == 1:\n                start = 10 ** ((length - 1) // 2)\n                end = 10 ** ((length + 1) // 2)\n                for half in range(start, end):\n                    s = str(half)\n                    pal = int(s + s[-2::-1])\n                    if pal < n:\n                        continue\n                    if is_prime(pal):\n                        return pal\n            length += 1\n```\n", "starter": {"go": "package main\n\nfunc PrimePalindrome(n int) int {\n    return 0\n}", "python": "class Solution:\n    def primePalindrome(self, n: int) -> int:\n        pass", "cpp": "class Solution {\npublic:\n    int primePalindrome(int n) {\n        return 0;\n    }\n};"}, "fn": "primePalindrome", "params": [{"name": "n", "type": "int"}], "outputType": "int", "tests": [["6"], ["8"], ["13"], ["1"], ["2"], ["3"], ["7"], ["10"], ["11"], ["12"], ["70"], ["100"], ["101"], ["131"], ["1000"], ["1968"], ["7654"], ["12345"], ["99999"], ["100000"], ["128000"], ["100005"], ["9989900"], ["9999999"], ["20"], ["30"], ["4"], ["5"]], "expected": [7, 11, 101, 2, 2, 3, 7, 11, 11, 101, 101, 101, 101, 131, 10301, 10301, 10301, 12421, 1003001, 1003001, 1003001, 1003001, 100030001, 100030001, 101, 101, 5, 5], "loose": false}

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

@@ -0,0 +1 @@
+{"basic": false, "label": "675", "slug": "print-binary-tree", "id": 675, "title": "Print Binary Tree", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/print-binary-tree/", "examples": [{"input": "root = [1,2]", "output": "[[\"\",\"1\",\"\"],[\"2\",\"\",\"\"]]"}, {"input": "root = [1,2,3,null,4]", "output": "[[\"\",\"\",\"\",\"1\",\"\",\"\",\"\"],[\"\",\"2\",\"\",\"\",\"\",\"3\",\"\"],[\"\",\"\",\"4\",\"\",\"\",\"\",\"\"]]"}], "hints": ["The height h sets the canvas size: h rows and 2^h - 1 columns filled with empty strings.", "Put the root at the middle of the top row, then place each child at the middle of its own side region one row down.", "A depth-first fill that carries the left and right column bounds keeps every label centered."], "statement": "You are given the root of a binary tree. Lay the tree out on a text canvas as follows:\n\n- Let the height `h` be the number of levels. The canvas has `h` rows and `2^h - 1` columns, initially all empty strings.\n- Put the root label at the middle column of row 0.\n- For a node placed at row `r` and column `c` with left bound `L` and right bound `R`, put its left child at row `r+1` and the middle of `[L, c-1]`, and its right child at row `r+1` and the middle of `[c+1, R]`. Keep splitting until every node is placed.\n\nReturn the filled canvas.\n\n**Adaptation:** the canvas maps to a nested string list in this judge.\n\n**Constraints:**\n- `1 <= number of nodes <= 200`\n- `-100 <= node value <= 100`\n", "solution": "## Approach\n\nMeasure the height `h`, then create an `h` by `2^h - 1` grid of empty strings. Fill it depth-first: a node covering columns `[L, R]` sits at `(L + R) // 2` on its row, and its children cover the left and right halves on the next row. Node values become strings.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(h * 2^h) to create and fill the grid.\n- **Space Complexity:** O(h * 2^h) for the canvas.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def printTree(self, root) -> List[List[str]]:\n        def height(n):\n            if not n:\n                return 0\n            return 1 + max(height(n.left), height(n.right))\n        h = height(root)\n        w = (1 << h) - 1\n        ans = [[\"\" for _ in range(w)] for _ in range(h)]\n        def fill(n, r, l, rr):\n            if not n:\n                return\n            c = (l + rr) // 2\n            ans[r][c] = str(n.val)\n            fill(n.left, r + 1, l, c - 1)\n            fill(n.right, r + 1, c + 1, rr)\n        fill(root, 0, 0, w - 1)\n        return ans\n```\n", "starter": {"go": "// Definition for a binary tree node.\n// type TreeNode struct {\n//     Val int\n//     Left *TreeNode\n//     Right *TreeNode\n// }\npackage main\n\nfunc PrintTree(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\n\nfrom typing import List\nclass Solution:\n    def printTree(self, root) -> List[List[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 <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    vector<vector<string>> printTree(TreeNode* root) {\n        return {};\n    }\n};"}, "fn": "printTree", "params": [{"name": "root", "type": "tree_node"}], "outputType": "string_list_2d", "tests": [["[1,2]"], ["[1,2,3,null,4]"], ["[1]"], ["[1,2,3]"], ["[1,null,2]"], ["[1,2,null]"], ["[1,2,3,4,5,6,7]"], ["[1,2,3,4,null,null,5]"], ["[5,3,8,1,4,null,9]"], ["[1,2,null,3,null,4,null]"], ["[1,null,2,null,3,null,4]"], ["[2,1,3]"], ["[10,5,15,3,7,12,20]"], ["[1,2,3,null,5,null,7]"], ["[0,-1,2,-3,null,null,4]"], ["[1,2,2,3,null,null,3]"], ["[4,2,6,1,3,5,7,0,null,null,null,null,null,null,8]"], ["[1,null,2,null,3]"], ["[3,1,4,null,2]"], ["[7,3,9,1,5,null,10]"], ["[1,2,3,4,5,null,null,6,null,null,null]"], ["[100,50,150]"], ["[1,2,null,null,3]"], ["[2,null,3,null,4,null,5]"], ["[6,4,8,3,5,7,9,1,null,null,null,null,null,null,10]"], ["[1,2,3,null,null,4,5,6,null,null,7]"], ["[9,7,11,6,8,10,12]"], ["[1,2,3,4,null,6,7,null,5]"]], "expected": [[["", "1", ""], ["2", "", ""]], [["", "", "", "1", "", "", ""], ["", "2", "", "", "", "3", ""], ["", "", "4", "", "", "", ""]], [["1"]], [["", "1", ""], ["2", "", "3"]], [["", "1", ""], ["", "", "2"]], [["", "1", ""], ["2", "", ""]], [["", "", "", "1", "", "", ""], ["", "2", "", "", "", "3", ""], ["4", "", "5", "", "6", "", "7"]], [["", "", "", "1", "", "", ""], ["", "2", "", "", "", "3", ""], ["4", "", "", "", "", "", "5"]], [["", "", "", "5", "", "", ""], ["", "3", "", "", "", "8", ""], ["1", "", "4", "", "", "", "9"]], [["", "", "", "", "", "", "", "1", "", "", "", "", "", "", ""], ["", "", "", "2", "", "", "", "", "", "", "", "", "", "", ""], ["", "3", "", "", "", "", "", "", "", "", "", "", "", "", ""], ["4", "", "", "", "", "", "", "", "", "", "", "", "", "", ""]], [["", "", "", "", "", "", "", "1", "", "", "", "", "", "", ""], ["", "", "", "", "", "", "", "", "", "", "", "2", "", "", ""], ["", "", "", "", "", "", "", "", "", "", "", "", "", "3", ""], ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "4"]], [["", "2", ""], ["1", "", "3"]], [["", "", "", "10", "", "", ""], ["", "5", "", "", "", "15", ""], ["3", "", "7", "", "12", "", "20"]], [["", "", "", "1", "", "", ""], ["", "2", "", "", "", "3", ""], ["", "", "5", "", "", "", "7"]], [["", "", "", "0", "", "", ""], ["", "-1", "", "", "", "2", ""], ["-3", "", "", "", "", "", "4"]], [["", "", "", "1", "", "", ""], ["", "2", "", "", "", "2", ""], ["3", "", "", "", "", "", "3"]], [["", "", "", "", "", "", "", "4", "", "", "", "", "", "", ""], ["", "", "", "2", "", "", "", "", "", "", "", "6", "", "", ""], ["", "1", "", "", "", "3", "", "", "", "5", "", "", "", "7", ""], ["0", "", "", "", "", "", "", "", "", "", "", "", "", "", "8"]], [["", "", "", "1", "", "", ""], ["", "", "", "", "", "2", ""], ["", "", "", "", "", "", "3"]], [["", "", "", "3", "", "", ""], ["", "1", "", "", "", "4", ""], ["", "", "2", "", "", "", ""]], [["", "", "", "7", "", "", ""], ["", "3", "", "", "", "9", ""], ["1", "", "5", "", "", "", "10"]], [["", "", "", "", "", "", "", "1", "", "", "", "", "", "", ""], ["", "", "", "2", "", "", "", "", "", "", "", "3", "", "", ""], ["", "4", "", "", "", "5", "", "", "", "", "", "", "", "", ""], ["6", "", "", "", "", "", "", "", "", "", "", "", "", "", ""]], [["", "100", ""], ["50", "", "150"]], [["", "", "", "1", "", "", ""], ["", "2", "", "", "", "", ""], ["", "", "3", "", "", "", ""]], [["", "", "", "", "", "", "", "2", "", "", "", "", "", "", ""], ["", "", "", "", "", "", "", "", "", "", "", "3", "", "", ""], ["", "", "", "", "", "", "", "", "", "", "", "", "", "4", ""], ["", "", "", "", "", "", "", "", "", "", "", "", "", "", "5"]], [["", "", "", "", "", "", "", "6", "", "", "", "", "", "", ""], ["", "", "", "4", "", "", "", "", "", "", "", "8", "", "", ""], ["", "3", "", "", "", "5", "", "", "", "7", "", "", "", "9", ""], ["1", "", "", "", "", "", "", "", "", "", "", "", "", "", "10"]], [["", "", "", "", "", "", "", "1", "", "", "", "", "", "", ""], ["", "", "", "2", "", "", "", "", "", "", "", "3", "", "", ""], ["", "", "", "", "", "", "", "", "", "4", "", "", "", "5", ""], ["", "", "", "", "", "", "", "", "6", "", "", "", "", "", "7"]], [["", "", "", "9", "", "", ""], ["", "7", "", "", "", "11", ""], ["6", "", "8", "", "10", "", "12"]], [["", "", "", "", "", "", "", "1", "", "", "", "", "", "", ""], ["", "", "", "2", "", "", "", "", "", "", "", "3", "", "", ""], ["", "4", "", "", "", "", "", "", "", "6", "", "", "", "7", ""], ["", "", "5", "", "", "", "", "", "", "", "", "", "", "", ""]]], "loose": false}

package/data/problems/prison-cells-after-n-days.json

@@ -0,0 +1 @@
+{"basic": false, "label": "943", "slug": "prison-cells-after-n-days", "id": 943, "title": "Prison Cells After N Days", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/prison-cells-after-n-days/", "examples": [{"input": "cells = [0,1,0,1,1,0,0,1], N = 7", "output": "[0,0,1,1,0,0,0,0]", "explanation": "After seven daily updates the row settles into [0,0,1,1,0,0,0,0]."}, {"input": "cells = [1,0,0,1,0,0,1,0], N = 1", "output": "[0,0,0,1,0,0,1,0]", "explanation": "A single update turns each interior cell on exactly when its two neighbours match."}, {"input": "cells = [1,1,1,0,1,1,1,1], N = 2", "output": "[0,1,1,1,1,0,0,0]", "explanation": "Two updates in a row propagate the single gap across the row."}], "hints": ["Only 256 row layouts exist, so the evolution must eventually loop.", "Record the first day each layout appears; on a repeat, skip whole cycles at once.", "The two border cells always clear to 0 after day one."], "statement": "Eight holding cells sit in a row, each either occupied (`1`) or empty (`0`). Every day each cell is refreshed at the same time: a cell becomes occupied when its left and right neighbours currently hold the same value (both occupied or both empty), and becomes empty otherwise. The two end cells have only one neighbour, so they always become empty after the first day.\n\nGiven the starting layout `cells` and a day count `N`, return the layout of the row right after the `N`-th daily refresh.\n\n**Constraints:**\n- `cells.length == 8`\n- Each entry of `cells` is `0` or `1`\n- `1 <= N <= 10^9` (so a day-by-day simulation needs cycle skipping)\n", "solution": "## Approach\n\nSimulate the daily refresh, but memoize every layout seen so far. Because there are only finitely many rows, the layouts must eventually repeat, forming a cycle. Once a repeat is found, fast-forward over whole cycles in one jump and simulate only the leftover days. Each step compares the two neighbours of every interior cell while the ends always clear to zero.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1) \u2014 at most a few hundred simulated days regardless of N.\n- **Space Complexity:** O(1) for the memo table of past layouts.\n\n## Implementation\n\n```python\nclass Solution:\n    def prisonAfterNDays(self, cells: list[int], N: int) -> list[int]:\n        cur = list(cells)\n        seen = {}\n        day = 0\n        while day < N:\n            key = tuple(cur)\n            if key in seen:\n                period = day - seen[key]\n                rem = N - day\n                if period > 0 and rem >= period:\n                    day += (rem // period) * period\n                    continue\n            else:\n                seen[key] = day\n            nxt = [0] * 8\n            for i in range(1, 7):\n                nxt[i] = 1 if cur[i - 1] == cur[i + 1] else 0\n            cur = nxt\n            day += 1\n        return cur\n```\n", "starter": {"go": "package main\n\nfunc PrisonAfterNDays(cells []int, n int) []int {\n    return nil\n}", "python": "from typing import List\nclass Solution:\n    def prisonAfterNDays(self, cells: List[int], n: int) -> List[int]:\n        return []", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<int> prisonAfterNDays(vector<int>& cells, int n) {\n        return {};\n    }\n};"}, "fn": "prisonAfterNDays", "params": [{"name": "cells", "type": "int_array"}, {"name": "n", "type": "int"}], "outputType": "int_array", "tests": [["[0,1,0,1,1,0,0,1]", "7"], ["[1,0,0,1,0,0,1,0]", "1"], ["[1,1,1,0,1,1,1,1]", "2"], ["[0,1,0,1,1,0,0,1]", "14"], ["[0,0,0,0,0,0,0,0]", "5"], ["[1,1,1,1,1,1,1,1]", "3"], ["[1,0,1,0,1,0,1,0]", "10"], ["[0,1,0,1,1,0,0,1]", "1000000000"], ["[1,0,0,1,0,0,0,1]", "14"], ["[1,0,0,1,0,0,0,1]", "15"], ["[1,0,0,1,0,0,0,1]", "16"], ["[0,0,1,1,1,0,1,0]", "20"], ["[1,1,0,0,1,0,1,1]", "100"], ["[0,1,1,0,0,1,0,1]", "1000000000"], ["[1,0,1,1,0,1,0,0]", "6"], ["[0,0,0,1,1,1,0,0]", "9"], ["[1,1,0,1,0,0,0,1]", "13"], ["[0,1,1,1,0,0,1,0]", "21"], ["[1,0,1,0,0,0,1,1]", "28"], ["[0,0,1,0,1,1,1,0]", "30"], ["[1,1,1,0,0,0,1,1]", "4"], ["[0,1,0,0,1,0,1,0]", "11"], ["[1,0,0,0,1,1,0,1]", "17"], ["[0,0,1,1,0,1,1,0]", "25"], ["[1,1,0,1,1,0,0,0]", "8"], ["[0,1,1,0,1,0,0,1]", "12"], ["[1,0,1,1,1,0,1,0]", "19"], ["[0,0,0,1,0,1,0,1]", "26"]], "expected": [[0, 0, 1, 1, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 1, 0], [0, 1, 1, 1, 1, 0, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0], [0, 1, 0, 1, 1, 0, 1, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 0, 0], [0, 0, 1, 0, 1, 1, 0, 0], [0, 1, 1, 0, 1, 1, 1, 0], [0, 0, 0, 1, 0, 1, 0, 0], [0, 1, 0, 1, 1, 1, 0, 0], [0, 0, 0, 1, 0, 1, 0, 0], [0, 1, 1, 0, 0, 0, 0, 0], [0, 0, 1, 1, 0, 1, 0, 0], [0, 1, 0, 1, 0, 1, 1, 0], [0, 1, 0, 1, 0, 0, 1, 0], [0, 0, 1, 0, 0, 0, 0, 0], [0, 1, 0, 0, 1, 1, 1, 0], [0, 1, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 0], [0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 1, 1, 0], [0, 0, 1, 1, 0, 0, 1, 0], [0, 1, 0, 0, 0, 1, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 1, 1, 0, 1, 0], [0, 0, 0, 1, 1, 1, 1, 0]], "loose": false}