offcode 0.0.0-stage → 0.1.1

package/data/problems/remove-boxes.json

@@ -0,0 +1 @@
+{"basic": false, "label": "603", "slug": "remove-boxes", "id": 603, "title": "Remove Boxes", "difficulty": "Hard", "category": "dp", "link": "https://leetcode.com/problems/remove-boxes/", "examples": [{"input": "boxes = [1,3,2,2,2,3,4,3,1]", "output": "23", "explanation": "Clear 2s first, then merge 3s for the optimum."}, {"input": "boxes = [1,1,1]", "output": "9", "explanation": "Remove together for 9."}, {"input": "boxes = [1]", "output": "1"}], "hints": ["Add a third dimension k counting extra boxes of the same colour attached to the left interval.", "Compress leading equal colours, then either delete them now or merge them with a later equal colour after clearing the middle.", "Memoise on (l, r, k) to avoid exponential recomputation."], "statement": "You are given a row of boxes, each coloured with a positive integer. In one move you may pick any maximal run of consecutive boxes sharing one colour: if the run has length `k` you score `k*k` points and the run disappears, letting the left and right remainders join together.\n\nRepeat until no box remains. Plan the removal order to earn the largest total score and return that maximum.\n\n**Constraints:**\n- `1 <= boxes.length <= 100`\n- `1 <= boxes[i] <= 100`\n", "solution": "## Approach\n\nInterval DP with an extra count k of same-coloured boxes fused to the left end. Collapse the leading run, score it immediately, or keep it and merge with a later matching box after the gap is cleared. Memoisation over (l, r, k) explores all merge orders.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^4) worst case with n <= 100.\n- **Space Complexity:** O(n^3) memo table.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def removeBoxes(self, boxes: List[int]) -> int:\n        from functools import lru_cache\n        n = len(boxes)\n        @lru_cache(None)\n        def dfs(l: int, r: int, k: int) -> int:\n            if l > r:\n                return 0\n            while l + 1 <= r and boxes[l + 1] == boxes[l]:\n                l += 1\n                k += 1\n            best = (k + 1) * (k + 1) + dfs(l + 1, r, 0)\n            for m in range(l + 1, r + 1):\n                if boxes[m] == boxes[l]:\n                    best = max(best, dfs(l + 1, m - 1, 0) + dfs(m, r, k + 1))\n            return best\n        return dfs(0, n - 1, 0)\n```\n", "starter": {"go": "package main\n\nfunc RemoveBoxes(boxes []int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def removeBoxes(self, boxes: List[int]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int removeBoxes(vector<int>& boxes) {\n        return 0;\n    }\n};"}, "fn": "removeBoxes", "params": [{"name": "boxes", "type": "int_array"}], "outputType": "int", "tests": [["[1,3,2,2,2,3,4,3,1]"], ["[1,1,1]"], ["[1]"], ["[1,2]"], ["[2,2]"], ["[1,2,1]"], ["[1,1,2,2]"], ["[2,1,1,2]"], ["[1,3,2,2,2,3,4,3,1,1]"], ["[3,2,1,2,3]"], ["[1,2,3,4,5]"], ["[5,5,5,5,5]"], ["[1,1,1,2,2,2,3,3,3]"], ["[1,2,1,2,1,2]"], ["[2,2,1,1,2,2]"], ["[1,3,3,3,2,2,2,1]"], ["[4,4,4,1,1,4,4]"], ["[1,2,3,1,2,3]"], ["[2]"], ["[1,1]"], ["[1,2,3,4,1]"], ["[3,3,2,2,1,1]"], ["[1,1,2,1,1]"], ["[2,3,2,3,2]"], ["[1,1,1,1]"], ["[2,2,2,1,1]"], ["[1,2,2,1,2,2,1]"], ["[3,1,2,3,1,2,3]"]], "expected": [23, 9, 1, 2, 4, 5, 8, 8, 28, 9, 5, 25, 27, 12, 20, 22, 29, 8, 1, 4, 7, 12, 17, 11, 16, 13, 21, 13], "loose": false}

package/data/problems/remove-comments.json

@@ -0,0 +1 @@
+{"basic": false, "label": "729", "slug": "remove-comments", "id": 729, "title": "Remove Comments", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/remove-comments/", "examples": [{"input": "source = [\"/*Test program */\", \"int main()\", \"{ \", \"  // variable declaration \", \"int a, b, c;\", \"/* This is a test\", \"   multiline  \", \"   comment for \", \"   testing */\", \"a = b + c;\", \"}\"]", "output": "[\"int main()\",\"{ \",\"  \",\"int a, b, c;\",\"a = b + c;\",\"}\"]", "explanation": "Block and line comments are stripped; the declaration line keeps its two leading spaces."}, {"input": "source = [\"a/*comment\", \"line\", \"more_comment*/b\"]", "output": "[\"ab\"]", "explanation": "A block spanning three lines joins the outer fragments into ab."}, {"input": "source = [\"void f(){\", \"// do nothing\", \"}\"]", "output": "[\"void f(){\",\"}\"]", "explanation": "The whole middle line is a line comment and disappears."}], "hints": ["Scan line by line keeping an in-block flag; // ends the line only when outside a block.", "When /* opens outside a block, skip until its matching */ which may sit many lines later.", "Buffer the surviving characters per logical line and emit the buffer only when nonempty and outside a block at line end. Adaptation: input is a string_array and output is a string_list."], "statement": "Strip comments from a program given as one string per line. Two comment forms exist:\n\n- `//` discards the rest of its line when seen outside a block comment.\n- `/*` opens a block that discards everything until its matching `*/`, possibly across many lines. Blocks do not nest.\n\nCode outside comments is kept verbatim (including spaces). After processing a source line, if the current output buffer is nonempty and no block is open, it becomes one answer line and the buffer resets only at that point \u2014 so fragments before and after a multi-line block join together.\n\nReturn the surviving lines in order.\n\n*Adaptation note:* input type is `string_array` and output type is `string_list`.\n\n**Constraints:**\n- `1 <= source.length <= 100`\n- `0 <= source[i].length <= 80`\n- Each line consists of printable ASCII without quote characters.\n", "solution": "## Approach\n\nWalk each line with an index and an `in_block` flag. Outside a block, `//` stops the line and `/*` opens a block; inside, only `*/` matters and everything else is skipped. Surviving characters accumulate in a buffer that is flushed as one answer line whenever a source line ends outside a block with content.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(T), where T is the total character count.\n- **Space Complexity:** O(T) for the buffer and answers.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def removeComments(self, source: List[str]) -> List[str]:\n        ans = []\n        buf = []\n        in_block = False\n        for line in source:\n            i = 0\n            n = len(line)\n            while i < n:\n                if not in_block and i + 1 < n and line[i:i+2] == \"//\":\n                    break\n                elif not in_block and i + 1 < n and line[i:i+2] == \"/*\":\n                    in_block = True\n                    i += 2\n                elif in_block and i + 1 < n and line[i:i+2] == \"*/\":\n                    in_block = False\n                    i += 2\n                elif in_block:\n                    i += 1\n                else:\n                    buf.append(line[i])\n                    i += 1\n            if not in_block and buf:\n                ans.append(''.join(buf))\n                buf = []\n        return ans\n```\n", "starter": {"go": "package main\n\nfunc RemoveComments(source []string) []string {\n    return []string{}\n}", "python": "from typing import List\nclass Solution:\n    def removeComments(self, source: List[str]) -> List[str]:\n        return []", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    vector<string> removeComments(vector<string>& source) {\n        return {};\n    }\n};"}, "fn": "removeComments", "params": [{"name": "source", "type": "string_array"}], "outputType": "string_list", "tests": [["[\"/*Test program */\", \"int main()\", \"{ \", \"  // variable declaration \", \"int a, b, c;\", \"/* This is a test\", \"   multiline  \", \"   comment for \", \"   testing */\", \"a = b + c;\", \"}\"]"], ["[\"a/*comment\", \"line\", \"more_comment*/b\"]"], ["[\"void f(){\", \"// do nothing\", \"}\"]"], ["[\"a//b\", \"c\"]"], ["[\"a/*b*/c\"]"], ["[\"/*a*/int x = 1;\"]"], ["[\"int x = 1;/*comment\"]"], ["[\"// whole line\"]"], ["[\"code\"]"], ["[\"a/*b\", \"c*/d\", \"e\"]"], ["[\"/*\", \"*/a\"]"], ["[\"a\", \"b\", \"c\"]"], ["[\"/*/\", \"x\"]"], ["[\"ab//cd\", \"ef/*gh\", \"ij*/kl\"]"], ["[\"int a = 0; // init\", \"int b = 1;\"]"], ["[\"/*a\", \"b\", \"c*/\"]"], ["[\"x/*y*/z/*w*/v\"]"], ["[\"  // indented\", \"keep\"]"], ["[\"a/*b*c*/d\"]"], ["[\"one\", \"two/*three\", \"four*/five\", \"six\"]"], ["[\"/*start\", \"middle//not-code\", \"end*/done\"]"], ["[\"a/b\", \"c/*d\", \"e//f\", \"g*/h\"]"], ["[\"void f() { /*call*/ return; }\"]"], ["[\"a/*/*b*/c\"]"], ["[\"line1\", \"line2//comment\", \"line3/*block\", \"still block\", \"end*/line4\"]"], ["[\"/*a*/*\", \"b\"]"], ["[\"x\", \"y/*z\"]"], ["[\"p/*q*/\", \"r\"]"]], "expected": [["int main()", "{ ", "  ", "int a, b, c;", "a = b + c;", "}"], ["ab"], ["void f(){", "}"], ["a", "c"], ["ac"], ["int x = 1;"], [], [], ["code"], ["ad", "e"], ["a"], ["a", "b", "c"], [], ["ab", "efkl"], ["int a = 0; ", "int b = 1;"], [], ["xzv"], ["  ", "keep"], ["ad"], ["one", "twofive", "six"], ["done"], ["a/b", "ch"], ["void f() {  return; }"], ["ac"], ["line1", "line2", "line3line4"], ["*", "b"], ["x"], ["p", "r"]], "loose": false}

package/data/problems/remove-duplicate-letters.json

@@ -0,0 +1 @@
+{"basic": false, "label": "405", "slug": "remove-duplicate-letters", "id": 405, "title": "Remove Duplicate Letters", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/remove-duplicate-letters/", "examples": [{"explanation": "Keeping one of each of 'a', 'b' and 'c' allows \"abc\", \"bac\" or \"bca\"; \"abc\" is the smallest of these.", "input": "s = \"bcabc\"", "output": "\"abc\""}, {"explanation": "The distinct letters are 'a', 'b', 'c' and 'd', and \"acdb\" is the smallest ordering obtainable as a subsequence.", "input": "s = \"cbacdcbc\"", "output": "\"acdb\""}, {"explanation": "\"abc\" can be formed (for instance from positions 0, 1 and 4) and no smaller arrangement of 'a', 'b', 'c' is a subsequence.", "input": "s = \"abacb\"", "output": "\"abc\""}], "hints": ["Record the last position of every letter so you know whether a stacked character can still appear later.", "Scan once with a monotonic stack: pop a larger top character that is still unused and occurs again ahead before pushing the current one.", "Track which letters are already in the stack to skip repeats."], "statement": "You are given a string `s` built from lowercase English letters. Delete some characters so that each distinct letter occurring in `s` shows up exactly once in what remains, while the surviving characters keep their original relative order.\n\nAmong every string achievable this way, pick the one that comes first in dictionary (lexicographical) order and return it.\n\n**Constraints:**\n- `1 <= s.length <= 10^4`\n- `s` consists of lowercase English letters.\n", "solution": "## Approach\n\nPrecompute each letter's final position, then scan the string while maintaining a stack of chosen letters. Before pushing a new letter, discard any larger letter on the stack top that still appears later and has not been fixed yet. Skipping letters already present guarantees uniqueness, and the greedy pops guarantee the smallest possible ordering.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the length of `s`. Each character is pushed and popped at most once.\n- **Space Complexity:** O(1) besides the output, since the stack holds at most 26 letters.\n\n## Implementation\n\n```python\nclass Solution:\n    def removeDuplicateLetters(self, s: str) -> str:\n        last = {c: i for i, c in enumerate(s)}\n        in_stack = set()\n        st = []\n        for i, c in enumerate(s):\n            if c in in_stack:\n                continue\n            while st and st[-1] > c and last[st[-1]] > i:\n                in_stack.remove(st.pop())\n            st.append(c)\n            in_stack.add(c)\n        return \"\".join(st)\n```\n", "starter": {"go": "package main\n\nfunc RemoveDuplicateLetters(s string) string {\n    \n}", "python": "class Solution:\n    def removeDuplicateLetters(self, s: str) -> str:\n        pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    string removeDuplicateLetters(string s) {\n        return \"\";\n    }\n};"}, "fn": "removeDuplicateLetters", "params": [{"name": "s", "type": "string"}], "outputType": "string", "tests": [["bcabc"], ["cbacdcbc"], ["abacb"], ["a"], ["aa"], ["ab"], ["ba"], ["abc"], ["cba"], ["abacaba"], ["bbcaac"], ["leetcode"], ["acbac"], ["abccba"], ["zyxwvutsrqponmlkjihgfedcba"], ["abcdefghijklmnopqrstuvwxyz"], ["aaaaabbbbbccccc"], ["cbadabac"], ["theskyisblue"], ["abbbcccaaa"], ["dcadcbc"], ["ecbacba"], ["bbbacddceee"], ["zzazbzc"], ["mnopmnop"], ["qwertyqwerty"], ["bbbbbaaaaa"], ["cdadabcc"], ["axbyczaxbycz"], ["fedcbafedcba"]], "expected": ["abc", "acdb", "abc", "a", "a", "ab", "ba", "abc", "cba", "abc", "bac", "letcod", "abc", "abc", "zyxwvutsrqponmlkjihgfedcba", "abcdefghijklmnopqrstuvwxyz", "abc", "adbc", "thekyisblu", "abc", "adbc", "eacb", "bacde", "abzc", "mnop", "eqwrty", "ba", "adbc", "abcxyz", "afedcb"], "loose": false}

package/data/problems/remove-duplicates-from-sorted-array-ii.json

@@ -0,0 +1 @@
+{"basic": false, "label": "272", "slug": "remove-duplicates-from-sorted-array-ii", "id": 272, "title": "Remove Duplicates from Sorted Array II", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/", "examples": [{"input": "nums = [1,1,1,2,2,3]", "output": "5", "explanation": "The first 5 entries become [1,1,2,2,3]; one extra 1 is dropped."}, {"input": "nums = [0,0,1,1,1,1,2,3,3]", "output": "7", "explanation": "The first 7 entries become [0,0,1,1,2,3,3]; two extra 1s are dropped."}], "hints": ["Because the array is sorted, compare each candidate with the element two positions before the write pointer.", "Keep nums[i] when it differs from nums[k-2]; otherwise it would be a third copy.", "Short arrays (length <= 2) are already valid and need no changes."], "statement": "Given a non-decreasing integer array, keep at most two copies of each distinct value while preserving the relative order. Rearrange the front of the array so the first `k` entries hold the kept values, and return `k`.\n\nOnly the returned length is graded; the contents beyond position `k` are ignored. The update must reuse the input array without allocating another large array.\n\n**Constraints:**\n- `1 <= nums.length <= 30000`\n- `-10000 <= nums[i] <= 10000`\n- `nums` is sorted in non-decreasing order.\n", "solution": "## Approach\n\nScan from the third element onward with a write pointer starting at index 2. Copy the current value forward only when it differs from the value two slots behind the write position, which guarantees no value appears more than twice. Arrays shorter than three elements are already valid.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), a single pass.\n- **Space Complexity:** O(1), in-place writes.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def removeDuplicates(self, nums: List[int]) -> int:\n        if len(nums) <= 2:\n            return len(nums)\n        k = 2\n        for i in range(2, len(nums)):\n            if nums[i] != nums[k - 2]:\n                nums[k] = nums[i]\n                k += 1\n        return k\n```\n", "starter": {"go": "package main\n\nfunc RemoveDuplicates(nums []int) int {\n    return 0\n}", "python": "from typing import List\nclass Solution:\n    def removeDuplicates(self, nums: List[int]) -> int:\n        return 0\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int removeDuplicates(vector<int>& nums) {\n        return 0;\n    }\n};"}, "fn": "removeDuplicates", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[1,1,1,2,2,3]"], ["[0,0,1,1,1,1,2,3,3]"], ["[1,1,2,2,3,3]"], ["[1]"], ["[1,1]"], ["[1,1,1]"], ["[1,1,1,1]"], ["[1,2,3]"], ["[0,0,0,0,0]"], ["[-3,-3,-2,-1,-1,0,0,0,1]"], ["[1,1,2,2,3,3,4,4,5,5]"], ["[-100,-100,-100,100,100,100]"], ["[1,2,2,3,3,3,4,4,4,4]"], ["[0,1,2,3,4,4,4,5,5,5]"], ["[-1,-1,-1,0,0,0,1,1,1]"], ["[2]"], ["[1,1,1,2,2,2,3,3,3]"], ["[0,0,1,1,2,2,3,3,4,4,5,5]"], ["[-5,-5,-5,-5,0,0,0,5,5,5,5]"], ["[1,1,1,1,1,1,1]"], ["[1,2,3,4,5,6,7]"], ["[5,5,6,6,6,7,7,7,7,8]"], ["[-10,-10,0,0,10,10,10]"], ["[3,3,3,3,3,4,4,5]"], ["[0,0,0,1,1,1,2,2,2,3,3,3]"], ["[100,100,100,100]"], ["[-1,0,0,0,1,1,1,1,2]"], ["[7,7,8,8,8,9,9,9,9,10,10]"], ["[1,1,2]"], ["[0,0,1,1,1,2,2,3,3,4]"]], "expected": [5, 7, 6, 1, 2, 2, 2, 3, 2, 8, 10, 4, 7, 8, 6, 1, 6, 12, 6, 2, 7, 7, 6, 5, 8, 2, 6, 8, 3, 9], "loose": false}

package/data/problems/remove-duplicates-from-sorted-array.json

@@ -0,0 +1 @@
+{"basic": false, "label": "169", "slug": "remove-duplicates-from-sorted-array", "id": 169, "title": "Remove Duplicates from Sorted Array", "difficulty": "Easy", "category": "two-pointer", "link": "https://leetcode.com/problems/remove-duplicates-from-sorted-array/", "examples": [{"input": "nums = [1,1,2]", "output": "2", "explanation": "Return k = 2, with the first two elements of nums being 1 and 2."}, {"input": "nums = [0,0,1,1,1,2,2,3,3,4]", "output": "5", "explanation": "Return k = 5, with the first five elements of nums being 0, 1, 2, 3, and 4."}], "hints": ["The array is sorted, so duplicates are adjacent. Use a slow pointer for the next unique position.", "Iterate with a fast pointer; when a new value is found, write it to the slow position and advance."], "statement": "You are given an integer array `nums` arranged in non-decreasing order. Squeeze out the repeats directly inside the array so that every distinct value survives exactly once, leaving the survivors in their original relative order.\n\nCall the count of distinct values `k`. Hand back `k`. The first `k` slots of `nums` must then hold those distinct values from smallest to largest.\n\n**Constraints:**\n\n- 1 \u2264 nums.length \u2264 3 * 10^4\n- -100 \u2264 nums[i] \u2264 100\n- nums is sorted in non-decreasing order.\n", "solution": "## Approach\n\nBecause the array is sorted, duplicates are adjacent. Keep a slow pointer `k` for the position of the next unique element. Scan with a fast pointer `i`; whenever `nums[i]` differs from `nums[k-1]`, copy it to `nums[k]` and increment `k`. Return `k`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the length of the array. Each element is visited once.\n- **Space Complexity:** O(1). Only two pointers are used.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def removeDuplicates(self, nums: List[int]) -> int:\n        if not nums:\n            return 0\n        k = 1\n        for i in range(1, len(nums)):\n            if nums[i] != nums[k - 1]:\n                nums[k] = nums[i]\n                k += 1\n        return k\n```\n", "starter": {"go": "package main\n\nfunc RemoveDuplicates(nums []int) int {\n    return 0\n}", "python": "from typing import List\nclass Solution:\n    def removeDuplicates(self, nums: List[int]) -> int:\n        return 0\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int removeDuplicates(vector<int>& nums) {\n        return 0;\n    }\n};"}, "fn": "removeDuplicates", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[1,1,2]"], ["[0,0,1,1,1,2,2,3,3,4]"], ["[1,2,3]"], ["[1,1]"], ["[1]"], ["[0,0,0,0,0]"], ["[-3,-3,-2,-1,-1,0,0,0,1]"], ["[1,1,2,2,3,3,4,4,5]"], ["[-100,-100,100]"], ["[1,2,2,3,3,3,4]"], ["[0,1,2,3,4,4,4,5]"], ["[-1,-1,-1,0,0,1,1]"], ["[2]"], ["[1,1,1]"], ["[2,2,2,2]"], ["[-5,-4,-3,-2,-1]"], ["[0]"], ["[-100]"], ["[100]"], ["[-100,-99,-98]"], ["[5,5,5,6,6,7]"], ["[-2,-2,0,0,2,2]"], ["[1,2,3,4,5]"], ["[0,0,1]"], ["[-1,0,0,0,1]"], ["[10,10,20,20,30]"], ["[-50,-50,-40,-30,-30]"], ["[3,3,3,3,4]"], ["[8,9,9,9,10,10]"], ["[-100,-100,-100,100,100]"]], "expected": [2, 5, 3, 1, 1, 1, 5, 5, 2, 4, 6, 3, 1, 1, 1, 5, 1, 1, 1, 3, 3, 3, 5, 2, 3, 3, 3, 2, 3, 2], "loose": false}

package/data/problems/remove-duplicates-from-sorted-list-ii.json

@@ -0,0 +1 @@
+{"basic": false, "label": "273", "slug": "remove-duplicates-from-sorted-list-ii", "id": 273, "title": "Remove Duplicates from Sorted List II", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/", "examples": [{"input": "head = [1,2,3,3,4,4,5]", "output": "[1,2,5]", "explanation": "Values 3 and 4 repeat, so all their nodes are removed."}, {"input": "head = [1,1,1,2,3]", "output": "[2,3]", "explanation": "The three leading 1s are all dropped."}, {"input": "head = [1,1,2,2]", "output": "[]", "explanation": "Every value repeats, so nothing remains."}], "hints": ["Use a dummy head so removals at the front need no special case.", "When the next two values match, advance past the entire run of equal values before linking.", "Only advance the predecessor when the next node is confirmed unique."], "statement": "Given the head of a sorted linked list, delete every node whose value occurs more than once, keeping only nodes with fully unique values. The remaining nodes stay in their original relative order.\n\nFor instance, a run like `2 -> 2 -> 2` disappears entirely, while an isolated value is preserved. Return the head of the trimmed list.\n\n**Constraints:**\n- `0 <= number of nodes <= 300`\n- `-100 <= node value <= 100`\n- The list is sorted in non-decreasing order.\n", "solution": "## Approach\n\nAnchor a dummy node before the head and keep a predecessor pointer. Whenever the next two values agree, skip the whole run of that value without moving the predecessor; otherwise the next node is unique and the predecessor advances. The dummy handles deletions at the front uniformly.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), each node visited a constant number of times.\n- **Space Complexity:** O(1), only pointer rewiring.\n\n## Implementation\n\n```python\nclass Solution:\n    def deleteDuplicates(self, head):\n        dummy = ListNode(0, head)\n        prev = dummy\n        while prev.next and prev.next.next:\n            if prev.next.val == prev.next.next.val:\n                dup = prev.next.val\n                while prev.next and prev.next.val == dup:\n                    prev.next = prev.next.next\n            else:\n                prev = prev.next\n        return dummy.next\n```\n", "starter": {"go": "package main\n\n/*\nDefinition for singly-linked list.\ntype ListNode struct {\n    Val int\n    Next *ListNode\n}\n*/\n\nfunc DeleteDuplicates(head *ListNode) *ListNode {\n    \n}", "python": "# class ListNode:\n#     def __init__(self, val=0, next=None):\n#         self.val = val\n#         self.next = next\n\nclass Solution:\n    def deleteDuplicates(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* deleteDuplicates(ListNode* head) {\n        return nullptr;\n    }\n};"}, "fn": "deleteDuplicates", "params": [{"name": "head", "type": "list_node"}], "outputType": "list_node", "tests": [["[1,2,3,3,4,4,5]"], ["[1,1,1,2,3]"], ["[1,1,2,2]"], ["[]"], ["[1]"], ["[1,1]"], ["[1,2,2]"], ["[1,1,2]"], ["[1,2,3]"], ["[1,1,1]"], ["[1,2,3,3]"], ["[1,1,2,3,3]"], ["[0,0,0,0,0]"], ["[-3,-3,-2,-1,-1,0]"], ["[1,2,2,3,3,4,4,5]"], ["[1,1,2,2,3,3]"], ["[1,2,3,4,5,5]"], ["[5,5,5,5,6,7,8,8]"], ["[-100,-100,0,100,100]"], ["[1,1,2,3,4,4,5,5,6]"], ["[0,1,2,3,4,5]"], ["[1,1,1,2,2,3,3,4]"], ["[2,2,3,4,5]"], ["[1,2,3,4,4,4]"], ["[1,1,1,1]"], ["[1,2,2,2,3]"], ["[10,10,20,20,30,40,40]"], ["[-2,-2,-1,0,0,1,1,2]"], ["[3,3,4,4,5,5,6,6,7]"], ["[100]"]], "expected": [[1, 2, 5], [2, 3], null, null, [1], null, [1], [2], [1, 2, 3], null, [1, 2], [2], null, [-2, 0], [1, 5], null, [1, 2, 3, 4], [6, 7], [0], [2, 3, 6], [0, 1, 2, 3, 4, 5], [4], [3, 4, 5], [1, 2, 3], null, [1, 3], [30], [-1, 2], [7], [100]], "loose": false}

package/data/problems/remove-duplicates-from-sorted-list.json

@@ -0,0 +1 @@
+{"basic": false, "label": "274", "slug": "remove-duplicates-from-sorted-list", "id": 274, "title": "Remove Duplicates from Sorted List", "difficulty": "Easy", "category": "linked-list", "link": "https://leetcode.com/problems/remove-duplicates-from-sorted-list/", "examples": [{"input": "head = [1,1,2]", "output": "[1,2]", "explanation": "One of the two 1s is removed."}, {"input": "head = [1,1,2,3,3]", "output": "[1,2,3]", "explanation": "Extra copies of 1 and 3 are removed."}, {"input": "head = []", "output": "[]", "explanation": "An empty list stays empty."}], "hints": ["Walk the list with a single pointer and compare each node with its successor.", "When values match, bypass the next node; otherwise advance.", "No dummy node is needed because the head value is always kept."], "statement": "Given the head of a sorted linked list, collapse each run of equal values into a single node. The first occurrence of every value is kept and all consecutive duplicates are removed, preserving the sorted order.\n\nFor example, `1 -> 1 -> 2` becomes `1 -> 2`. Return the head of the deduplicated list.\n\n**Constraints:**\n- `0 <= number of nodes <= 300`\n- `-100 <= node value <= 100`\n- The list is sorted in non-decreasing order.\n", "solution": "## Approach\n\nTraverse with one pointer, always comparing the current node to its successor. Equal values mean the next node is a duplicate and gets bypassed; different values mean the run ended and the pointer moves on. The head never changes since its first copy survives.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), a single linear walk.\n- **Space Complexity:** O(1), only pointer updates.\n\n## Implementation\n\n```python\nclass Solution:\n    def deleteDuplicates(self, head):\n        cur = head\n        while cur and cur.next:\n            if cur.val == cur.next.val:\n                cur.next = cur.next.next\n            else:\n                cur = cur.next\n        return head\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 DeleteDuplicates(head *ListNode) *ListNode {\n    \n}", "python": "# class ListNode:\n#     def __init__(self, val=0, next=None):\n#         self.val = val\n#         self.next = next\n\nclass Solution:\n    def deleteDuplicates(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* deleteDuplicates(ListNode* head) {\n        return nullptr;\n    }\n};"}, "fn": "deleteDuplicates", "params": [{"name": "head", "type": "list_node"}], "outputType": "list_node", "tests": [["[1,1,2]"], ["[1,1,2,3,3]"], ["[]"], ["[1]"], ["[1,1,1]"], ["[1,2,3]"], ["[1,1]"], ["[0,0,0,0]"], ["[-3,-3,-2,-1,-1]"], ["[1,1,2,2,3,3]"], ["[1,2,2,3,3,3,4]"], ["[5,5,5,5,5]"], ["[-100,-100,100,100]"], ["[1,2,3,3,4,4,5]"], ["[0,1,1,2,2,3]"], ["[1,1,1,2,2,3,3,3]"], ["[2,2,2,2,3]"], ["[1,2,3,4,4,4,4]"], ["[7,7,8,9,9,10]"], ["[-5,-5,0,0,5,5]"], ["[1,1,2,2,2,3]"], ["[10,10,10,20,30,30]"], ["[0,0,1,2,2,2,3]"], ["[42,42,42]"], ["[1,2,2]"], ["[3,3,3,4,5,5]"], ["[-1,-1,0,0,1,1]"], ["[100,100]"], ["[1,1,1,1,2]"], ["[7,8,8,9,9]"]], "expected": [[1, 2], [1, 2, 3], null, [1], [1], [1, 2, 3], [1], [0], [-3, -2, -1], [1, 2, 3], [1, 2, 3, 4], [5], [-100, 100], [1, 2, 3, 4, 5], [0, 1, 2, 3], [1, 2, 3], [2, 3], [1, 2, 3, 4], [7, 8, 9, 10], [-5, 0, 5], [1, 2, 3], [10, 20, 30], [0, 1, 2, 3], [42], [1, 2], [3, 4, 5], [-1, 0, 1], [100], [1, 2], [7, 8, 9]], "loose": false}

package/data/problems/remove-element.json

@@ -0,0 +1 @@
+{"basic": false, "label": "154", "slug": "remove-element", "id": 154, "title": "Remove Element", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/remove-element/", "examples": [{"input": "nums = [3,2,2,3], val = 3", "output": "2", "explanation": "Your function should return k = 2, with the first two elements of nums being 2 and 2."}, {"input": "nums = [0,1,2,2,3,0,4,2], val = 2", "output": "5", "explanation": "Your function should return k = 5, with the first five elements containing 0, 0, 1, 3, and 4 in any order."}], "hints": ["Use two pointers: overwrite kept elements in a single pass by copying every element not equal to val to the front.", "The elements beyond the returned length k can be anything; only k and the multiset of the first k matter."], "statement": "You receive an integer array `nums` together with an integer `val`. Erase every occurrence of `val` directly inside `nums`; the surviving entries may finish in any order. Then report how many entries of `nums` differ from `val`.\n\nDenote that survivor count by `k`. For acceptance, rearrange `nums` so its first `k` slots store exactly the entries that differ from `val`, and return `k`. Whatever sits past position `k` is irrelevant.\n\n**Constraints:**\n\n- 0 \u2264 nums.length \u2264 100\n- 0 \u2264 nums[i] \u2264 50\n- 0 \u2264 val \u2264 100\n", "solution": "## Approach\n\nUse two pointers with a write index `k` starting at 0. Scan each element; whenever `nums[i] != val`, copy it to `nums[k]` and increment `k`. At the end `k` is the count of kept elements and the first `k` positions hold them in order. This overwrites removed elements in place in a single pass.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the length of `nums`. Each element is visited once.\n- **Space Complexity:** O(1) extra.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def removeElement(self, nums: List[int], val: int) -> int:\n        k = 0\n        for x in nums:\n            if x != val:\n                nums[k] = x\n                k += 1\n        return k\n```\n", "starter": {"go": "package main\n\nfunc RemoveElement(nums []int, val int) int {\n    return 0\n}", "python": "from typing import List\nclass Solution:\n    def removeElement(self, nums: List[int], val: int) -> int:\n        ", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int removeElement(vector<int>& nums, int val) {\n        return 0;\n    }\n};"}, "fn": "removeElement", "params": [{"name": "nums", "type": "int_array"}, {"name": "val", "type": "int"}], "outputType": "int", "tests": [["[3,2,2,3]", "3"], ["[0,1,2,2,3,0,4,2]", "2"], ["[]", "0"], ["[1]", "1"], ["[1]", "2"], ["[4,5]", "4"], ["[2,2,2]", "2"], ["[1,2,3,4]", "5"], ["[0,0,0,0]", "0"], ["[50,0,50,0]", "50"], ["[1,2,3,4,5,6,7,8,9,10]", "5"], ["@javascript:JSON.stringify(Array.from({length:100},(_,i)=>i%2))", "0"], ["[]", "100"], ["[0]", "0"], ["[0]", "100"], ["[50]", "50"], ["[50]", "100"], ["[1,2,1,2,1]", "1"], ["[1,2,1,2,1]", "2"], ["[3,3,4,3,5,3]", "3"], ["[3,3,4,3,5,3]", "4"], ["[0,50,25,50,0]", "25"], ["[0,50,25,50,0]", "51"], ["[7,7,7,8,7,7]", "8"], ["[9,8,7,6,5,4,3,2,1,0]", "9"], ["[9,8,7,6,5,4,3,2,1,0]", "0"], ["[10,20,30,40,50]", "30"], ["[10,20,30,40,50]", "100"], ["[2,3,2,3,2,3,2,3]", "2"], ["[49,50,49,50,49]", "50"]], "expected": [2, 5, 0, 0, 1, 1, 0, 4, 0, 2, 9, 50, 0, 0, 1, 0, 1, 2, 3, 2, 5, 4, 5, 5, 9, 9, 4, 5, 4, 3], "loose": false}

package/data/problems/remove-invalid-parentheses.json

@@ -0,0 +1 @@
+{"basic": false, "label": "394", "slug": "remove-invalid-parentheses", "id": 394, "title": "Remove Invalid Parentheses", "difficulty": "Hard", "category": "string", "link": "https://leetcode.com/problems/remove-invalid-parentheses/", "examples": [{"input": "s = \"()())()\"", "output": "[\"(())()\",\"()()()\"]", "explanation": "Removing one bracket yields two balanced variants."}, {"input": "s = \"(a)())()\"", "output": "[\"(a())()\",\"(a)()()\"]", "explanation": "The letter is fixed; one bracket is dropped two ways."}, {"input": "s = \")(\"", "output": "[\"\"]", "explanation": "Nothing balanced remains except the empty string."}], "hints": ["Breadth-first removal level by level guarantees the first balanced strings found use the fewest deletions.", "Only ever delete bracket characters; letters are part of every candidate.", "Skip deleting a bracket identical to its left neighbour to avoid repeat candidates."], "statement": "Given a string mixing parentheses with other characters, delete the fewest parentheses\npossible so that what remains is balanced (every opening bracket is closed in order).\nReturn every distinct result achievable with that minimum deletion count; the order of the\nresults does not matter. Non-parenthesis characters are never removed.\n\n**Constraints:**\n- `1 <= s.length <= 25`\n- `s` holds lowercase letters plus `'('` and `')'`.\n", "solution": "## Approach\n\nBreadth-first search over strings formed by deleting one bracket at a time; the first level containing any balanced string holds exactly the minimum-deletion answers.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(2^n)\n- **Space Complexity:** O(2^n)\n\n## Implementation\n\n```python\nfrom typing import List\nfrom collections import deque\nclass Solution:\n    def removeInvalidParentheses(self, s: str) -> List[str]:\n        def valid(t: str) -> bool:\n            bal = 0\n            for c in t:\n                if c == '(':\n                    bal += 1\n                elif c == ')':\n                    bal -= 1\n                    if bal < 0:\n                        return False\n            return bal == 0\n        seen, q, res = {s}, deque([s]), []\n        while q:\n            for _ in range(len(q)):\n                cur = q.popleft()\n                if valid(cur):\n                    res.append(cur)\n                elif not res:\n                    for i, c in enumerate(cur):\n                        if c not in '()':\n                            continue\n                        if i and cur[i] == cur[i - 1]:\n                            continue\n                        nxt = cur[:i] + cur[i + 1:]\n                        if nxt not in seen:\n                            seen.add(nxt)\n                            q.append(nxt)\n            if res:\n                break\n        return res\n```\n", "starter": {"go": "package main\n\nfunc RemoveInvalidParentheses(s string) []string {\n    return nil\n}", "python": "from typing import List\nclass Solution:\n    def removeInvalidParentheses(self, s: str) -> List[str]:\n        ", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<string> removeInvalidParentheses(string s) {\n        return {};\n    }\n};"}, "fn": "removeInvalidParentheses", "params": [{"name": "s", "type": "string"}], "outputType": "string_list", "tests": [["()())()"], ["(a)())()"], [")("], ["(a"], [")a"], ["a"], ["abc"], ["()"], ["(())"], ["()()"], [")()("], ["(()"], ["())"], ["((("], [")))"], ["()(()"], ["(a(b(c)d"], ["x(y)z)"], ["(a)b(c)"], ["(()())"], ["()()()"], ["(()))(()"], ["a(b)c)d("], ["(a)b)c(d"], ["())(()"], ["((a))"], ["a)b(c(d)e"], [")a(b)c("], ["(a)a(a"], ["(()()"], ["(())(()"]], "expected": [["(())()", "()()()"], ["(a())()", "(a)()()"], [""], ["a"], ["a"], ["a"], ["abc"], ["()"], ["(())"], ["()()"], ["()"], ["()"], ["()"], [""], [""], ["()()"], ["ab(c)d", "a(bc)d", "(abc)d"], ["x(yz)", "x(y)z"], ["(a)b(c)"], ["(()())"], ["()()()"], ["(())()"], ["a(bc)d", "a(b)cd"], ["(ab)cd", "(a)bcd"], ["()()"], ["((a))"], ["abc(d)e", "ab(cd)e"], ["a(b)c"], ["(a)aa"], ["()()", "(())"], ["(())()"]], "loose": true}

package/data/problems/remove-k-digits.json

@@ -0,0 +1 @@
+{"basic": false, "label": "476", "slug": "remove-k-digits", "id": 476, "title": "Remove K Digits", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/remove-k-digits/", "examples": [{"explanation": "Dropping '4', '3' and one '2' leaves \"1219\".", "input": "num = \"1432219\", k = 3", "output": "\"1219\""}, {"explanation": "Removing the leading '1' gives \"0200\", normalized to \"200\".", "input": "num = \"10200\", k = 1", "output": "\"200\""}, {"explanation": "Deleting everything leaves nothing, reported as \"0\".", "input": "num = \"10\", k = 2", "output": "\"0\""}], "hints": ["Build the answer left to right, discarding a previous larger digit whenever a smaller one arrives and deletions remain.", "If deletions remain after the scan, drop from the right end.", "Strip leading zeros at the end; an empty result means \"0\"."], "statement": "A non-negative integer arrives as its decimal text `num` (no leading zeros unless the value itself is zero). Delete exactly `k` of its digits, keeping the relative order of the survivors, so that the remaining text denotes the smallest achievable value. Strip any leading zeros from the result; when every digit is deleted or only zeros remain, answer `\"0\"`.\n\n**Constraints:**\n- `1 <= k <= num.length <= 10^5`\n- `num` holds only digits and has no leading zeros except for `\"0\"` itself.\n", "solution": "## Approach\n\nGrow a monotonic stack of kept digits: while the last kept digit exceeds the incoming digit and deletions remain, pop it \u2014 removing a larger earlier digit always improves the outcome. Append the current digit, and after the scan drop any leftover deletions from the right. Finally strip leading zeros, returning `\"0\"` when nothing significant remains.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), each digit pushed and popped at most once.\n- **Space Complexity:** O(n) for the stack.\n\n## Implementation\n\n```python\nclass Solution:\n    def removeKdigits(self, num: str, k: int) -> str:\n        st = []\n        for c in num:\n            while st and k > 0 and st[-1] > c:\n                st.pop()\n                k -= 1\n            st.append(c)\n        while k > 0 and st:\n            st.pop()\n            k -= 1\n        res = ''.join(st).lstrip('0')\n        return res if res else '0'\n```\n", "starter": {"go": "package main\n\nfunc RemoveKdigits(num string, k int) string {\n    return \"\"\n}", "python": "class Solution:\n    def removeKdigits(self, num: str, k: int) -> str:\n        pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    string removeKdigits(string num, int k) {\n        return \"\";\n    }\n};"}, "fn": "removeKdigits", "params": [{"name": "num", "type": "string"}, {"name": "k", "type": "int"}], "outputType": "string", "tests": [["1432219", "3"], ["10200", "1"], ["10", "2"], ["9", "1"], ["112", "1"], ["12345", "2"], ["54321", "2"], ["10001", "1"], ["10001", "4"], ["111111", "3"], ["1234567890", "9"], ["10", "1"], ["100", "1"], ["1000", "2"], ["123456789", "3"], ["987654321", "3"], ["1122334455", "5"], ["10203", "2"], ["100200", "1"], ["9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999", "50"], ["123123123", "4"], ["456789", "3"], ["1000000", "3"], ["22134", "2"], ["99991", "2"], ["1112", "1"], ["10010", "2"], ["765028321", "5"], ["12345", "5"], ["0", "1"]], "expected": ["1219", "200", "0", "0", "11", "123", "321", "1", "0", "111", "0", "0", "0", "0", "123456", "654321", "11223", "3", "200", "99999999999999999999999999999999999999999999999999", "11123", "456", "0", "134", "991", "111", "0", "221", "0", "0"], "loose": false}

package/data/problems/remove-linked-list-elements.json

@@ -0,0 +1 @@
+{"basic": false, "label": "329", "slug": "remove-linked-list-elements", "id": 329, "title": "Remove Linked List Elements", "difficulty": "Easy", "category": "linked-list", "link": "https://leetcode.com/problems/remove-linked-list-elements/", "examples": [{"explanation": "Both nodes holding 6 are skipped; the rest keep their order.", "input": "head = [1,2,6,3,4,5,6], val = 6", "output": "[1,2,3,4,5]"}, {"explanation": "There is nothing to filter.", "input": "head = [], val = 1", "output": "[]"}, {"explanation": "Every node matches, so nothing remains.", "input": "head = [7,7,7,7], val = 7", "output": "[]"}], "hints": ["Place a dummy node before the head so removals at the front need no special case.", "Walk with a cursor: if cursor.next holds val, bypass it; otherwise advance.", "Only move forward past kept nodes so consecutive matches are all skipped."], "statement": "You are given the head of a singly linked list and an integer `val`. Unlink every node whose value equals `val` and return the head of what remains. If every node is removed, return an empty list.\n\nThe list is supplied in the form `[v0,v1,...]` and an answer is expected in the same form.\n\n**Constraints:**\n- The list holds between 0 and `10^4` nodes.\n- `0 <= node value <= 50`\n- `0 <= val <= 50`\n", "solution": "## Approach\n\nAnchor a dummy node before the head so deletions at the front look like any other deletion. Sweep a cursor forward: whenever the next node carries `val`, bypass it, otherwise step past it. Bypassing without advancing handles runs of matching values, and the dummy's successor is the filtered head.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), a single pass over the list.\n- **Space Complexity:** O(1) besides the output linkage.\n\n## Implementation\n\n```python\nclass Solution:\n    def removeElements(self, head, val):\n        dummy = ListNode(0, head)\n        cur = dummy\n        while cur.next is not None:\n            if cur.next.val == val:\n                cur.next = cur.next.next\n            else:\n                cur = cur.next\n        return dummy.next\n```\n", "starter": {"go": "package main\n\n/*\nDefinition for singly-linked list.\ntype ListNode struct {\n    Val int\n    Next *ListNode\n}\n*/\n\nfunc RemoveElements(head *ListNode, val int) *ListNode {\n    \n}", "python": "# Definition for singly-linked list.\n# class ListNode:\n#     def __init__(self, val=0, next=None):\n#         self.val = val\n#         self.next = next\n\nclass Solution:\n    def removeElements(self, head, val):\n        # TODO: unlink every node holding val and return the new head\n        pass\n", "cpp": "/*\nDefinition for singly-linked list.\nstruct ListNode {\n    int val;\n    ListNode *next;\n    ListNode(): val(0), next(nullptr) {}\n    ListNode(int x): val(x), next(nullptr) {}\n    ListNode(int x, ListNode* next): val(x), next(next) {}\n};\n*/\nclass Solution {\npublic:\n    ListNode* removeElements(ListNode* head, int val) {\n        \n    }\n};"}, "fn": "removeElements", "params": [{"name": "head", "type": "list_node"}, {"name": "val", "type": "int"}], "outputType": "list_node", "tests": [["[1,2,6,3,4,5,6]", "6"], ["[]", "1"], ["[7,7,7,7]", "7"], ["[1]", "1"], ["[1]", "2"], ["[1,2,3,4,5]", "1"], ["[1,2,3,4,5]", "5"], ["[1,2,3,4,5]", "9"], ["[6,1,2,6,3,6,4,6,5,6]", "6"], ["[0,0,1,0,2,0,3]", "0"], ["[50,50,50,1,50]", "50"], ["[1,1,1,1,1]", "2"], ["[2,2,2,2,2]", "2"], ["[1,2,1,2,1,2]", "1"], ["[1,2,1,2,1,2]", "2"], ["[3,1,3,1,3]", "3"], ["[10,20,30,40,50]", "30"], ["[5,4,3,2,1]", "5"], ["[5,4,3,2,1]", "1"], ["[0]", "0"], ["[0]", "1"], ["[1,2,3,1,2,3,1,2,3]", "3"], ["[9,8,7,6,5,4,3,2,1,0]", "0"], ["[9,8,7,6,5,4,3,2,1,0]", "9"], ["[4,4,5,4,4,6,4]", "4"], ["[1,3,5,7,9,2,4,6,8,10]", "7"], ["[25,25,10,25,20,25,30]", "25"], ["[1,2,3,4,5,6,7,8,9,10,11,12]", "6"]], "expected": [[1, 2, 3, 4, 5], null, null, null, [1], [2, 3, 4, 5], [1, 2, 3, 4], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3], [1], [1, 1, 1, 1, 1], null, [2, 2, 2], [1, 1, 1], [1, 1], [10, 20, 40, 50], [4, 3, 2, 1], [5, 4, 3, 2], null, [0], [1, 2, 1, 2, 1, 2], [9, 8, 7, 6, 5, 4, 3, 2, 1], [8, 7, 6, 5, 4, 3, 2, 1, 0], [5, 6], [1, 3, 5, 9, 2, 4, 6, 8, 10], [10, 20, 30], [1, 2, 3, 4, 5, 7, 8, 9, 10, 11, 12]], "loose": false}

package/data/problems/remove-nth-node-from-end-of-list.json

@@ -0,0 +1 @@
+{"basic": false, "label": "44", "slug": "remove-nth-node-from-end-of-list", "id": 44, "title": "Remove Nth Node From End Of List", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/remove-nth-node-from-end-of-list/", "examples": [{"input": "head = [1,2,3,4,5], n = 2", "output": "[1,2,3,5]", "explanation": "The 2nd node from the end of [1,2,3,4,5] is 4, so removing it yields [1,2,3,5]."}, {"input": "head = [1], n = 1", "output": "[]", "explanation": "The 1st node from the end of [1] is the only node, so removing it yields []."}, {"input": "head = [1,2], n = 1", "output": "[1]", "explanation": "The 1st node from the end of [1,2] is 2, so removing it yields [1]."}], "hints": ["Given the head of a linked list, remove the nth node from the end of the list and return its head."], "statement": "Take a singly linked list, drop its nth node counting back from the tail, and hand back the head of the resulting list.\n\n**Constraints:**\n\n- The number of nodes in the list is sz.\n- 1 \u2264 sz \u2264 30\n- 0 \u2264 Node.val \u2264 100\n- 1 \u2264 n \u2264 sz\n", "solution": "## Approach\n\nUse a dummy node and two pointers. Move the fast pointer n+1 steps ahead, then advance both until fast reaches the end. The slow pointer is now just before the node to remove.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n)\n- **Space Complexity:** O(1)\n\n## Implementation\n\n```python\nfrom typing import Optional\nclass Solution:\n    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:\n        dummy = ListNode(0, head)\n        fast = slow = dummy\n        for _ in range(n + 1):\n            fast = fast.next\n        while fast:\n            slow = slow.next\n            fast = fast.next\n        slow.next = slow.next.next\n        return dummy.next\n```\n", "starter": {"go": "package main\n\n/*\nDefinition for singly-linked list.\ntype ListNode struct {\n    Val int\n    Next *ListNode\n}\n*/\n\nfunc RemoveNthFromEnd(head *ListNode, n int) *ListNode {\n    \n}", "python": "# class ListNode:\n#     def __init__(self, val=0, next=None):\n#         self.val = val\n#         self.next = next\n\nclass Solution:\n    def removeNthFromEnd(self, head, n: int):\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* removeNthFromEnd(ListNode* head, int n) {\n        return nullptr;\n    }\n};\n"}, "fn": "removeNthFromEnd", "params": [{"name": "head", "type": "list_node"}, {"name": "n", "type": "int"}], "outputType": "list_node", "tests": [["[1,2,3,4,5]", "2"], ["[1]", "1"], ["[1,2]", "1"], ["[1,2]", "2"], ["[1,1,1,1,1]", "3"], ["[0]", "1"], ["[100]", "1"], ["[0,100]", "1"], ["[0,100]", "2"], ["[1,2,3]", "1"], ["[1,2,3]", "2"], ["[1,2,3]", "3"], ["[5,4,3,2,1]", "1"], ["[5,4,3,2,1]", "5"], ["[10,20,30,40]", "2"], ["[10,20,30,40]", "3"], ["[0,0,0,0]", "1"], ["[0,0,0,0]", "4"], ["[100,0,100,0,100]", "2"], ["[7,8,9,10,11,12]", "3"], ["[1,2,3,4,5,6,7]", "4"], ["[2,4,6,8,10,12,14,16]", "8"], ["[9,8,7,6,5,4,3,2,1]", "5"], ["[1,3,5,7,9,11,13,15,17,19]", "1"], ["[1,3,5,7,9,11,13,15,17,19]", "10"], ["[42,42,42,42,42,42]", "4"], ["[0,1,0,1,0,1,0]", "6"], ["[100,99,98,97,96,95,94,93]", "2"], ["[3,1,4,1,5,9,2,6,5]", "7"], ["[0,10,20,30,40,50,60,70,80,90,100]", "6"]], "expected": [[1, 2, 3, 5], null, [1], [2], [1, 1, 1, 1], null, null, [0], [100], [1, 2], [1, 3], [2, 3], [5, 4, 3, 2], [4, 3, 2, 1], [10, 20, 40], [10, 30, 40], [0, 0, 0], [0, 0, 0], [100, 0, 100, 100], [7, 8, 9, 11, 12], [1, 2, 3, 5, 6, 7], [4, 6, 8, 10, 12, 14, 16], [9, 8, 7, 6, 4, 3, 2, 1], [1, 3, 5, 7, 9, 11, 13, 15, 17], [3, 5, 7, 9, 11, 13, 15, 17, 19], [42, 42, 42, 42, 42], [0, 0, 1, 0, 1, 0], [100, 99, 98, 97, 96, 95, 93], [3, 1, 1, 5, 9, 2, 6, 5], [0, 10, 20, 30, 40, 60, 70, 80, 90, 100]], "loose": false}

package/data/problems/reorder-data-in-log-files.json

@@ -0,0 +1 @@
+{"basic": false, "label": "924", "slug": "reorder-data-in-log-files", "id": 924, "title": "Reorder Data in Log Files", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/reorder-data-in-log-files/", "examples": [{"input": "logs = [\"dig1 8 1 5 1\",\"let1 art can\",\"dig2 3 6\",\"let2 own kit dig\",\"let3 art zero\"]", "output": "[\"let1 art can\",\"let3 art zero\",\"let2 own kit dig\",\"dig1 8 1 5 1\",\"dig2 3 6\"]", "explanation": "Letter-logs sort by content; digits stay behind in order."}, {"input": "logs = [\"a1 9 2 3 1\",\"g1 act car\",\"zo4 4 7\",\"ab1 off key dog\",\"a8 act zoo\"]", "output": "[\"g1 act car\",\"a8 act zoo\",\"ab1 off key dog\",\"a1 9 2 3 1\",\"zo4 4 7\"]"}, {"input": "logs = [\"t1 1 2\",\"t2 3 4\"]", "output": "[\"t1 1 2\",\"t2 3 4\"]", "explanation": "With only digits, the order is unchanged."}], "hints": ["A log is a digit-log when the first character after the identifier is a digit; otherwise it is a letter-log.", "Sort letter-logs by the tuple (content, identifier); keep digit-logs in input order.", "Concatenate sorted letters followed by the untouched digits."], "statement": "Each log is a string starting with an identifier, followed by either words (a letter-log) or numbers (a digit-log). Reorder all logs so that letter-logs come first, sorted by their content and then by identifier when contents tie, while digit-logs keep their original relative order at the end.\n\nReturn the reordered logs as a list. The judge stores string arrays as native lists and expects a string list back.\n\n**Constraints:**\n- `1 <= logs.length <= 100`\n- Each log has an identifier plus at least one word or number, separated by single spaces.\n\nAdaptation: input logs use `string_array` while the ordered result uses `string_list`.\n", "solution": "## Approach\n\nSplit logs by looking at the first character after the identifier: digits go to a stable tail, words go to a sortable head. Sort the head by content first and identifier second, then concatenate the untouched digit tail.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m log m * L), where m is the number of letter-logs and L the content length for comparisons.\n- **Space Complexity:** O(n) for the two partitions and the answer.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def reorderLogFiles(self, logs: List[str]) -> List[str]:\n        letter = []\n        digit = []\n        for log in logs:\n            _id, _, rest = log.partition(' ')\n            if rest[0].isdigit():\n                digit.append(log)\n            else:\n                letter.append(log)\n        letter.sort(key=lambda x: (x.split(' ', 1)[1], x.split(' ', 1)[0]))\n        return letter + digit\n```\n", "starter": {"go": "package main\n\nfunc ReorderLogFiles(logs []string) []string {\n    return nil\n}", "python": "from typing import List\nclass Solution:\n    def reorderLogFiles(self, logs: List[str]) -> List[str]:\n        pass", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<string> reorderLogFiles(vector<string>& logs) {\n        return {};\n    }\n};"}, "fn": "reorderLogFiles", "params": [{"name": "logs", "type": "string_array"}], "outputType": "string_list", "tests": [["['dig1 8 1 5 1', 'let1 art can', 'dig2 3 6', 'let2 own kit dig', 'let3 art zero']"], ["['a1 9 2 3 1', 'g1 act car', 'zo4 4 7', 'ab1 off key dog', 'a8 act zoo']"], ["['t1 1 2', 't2 3 4']"], ["['a1 act car', 'a2 act car']"], ["['a1 act car', 'a1 act car']"], ["['let1 art can']"], ["['dig1 1 2 3']"], ["['l1 hello world', 'l2 hello world']"], ["['b2 xyz', 'a1 xyz']"], ["['d1 9 8', 'l1 abc', 'd2 7 6', 'l2 abd']"], ["['x1 b', 'x2 a', 'x3 c']"], ["['id1 a a a', 'id2 a a b', 'id3 a a a']"], ["['a1 0', 'b1 a', 'c1 1', 'd1 b']"], ["['k1 keep calm', 'k2 keep calm and go', 'k3 keep']"], ["['z1 1', 'z2 2', 'a1 hello']"], ["['m1 mix 123 abc', 'm2 123 456']"], ["['p1 art zero', 'p2 art can', 'p3 art can']"], ["['q1 the quick brown', 'q2 the quick']"], ["['r1 a', 'r2 1', 'r3 b', 'r4 2']"], ["['s1 code review', 's2 code']"], ["['t1 a b c', 't2 a b']"], ["['u1 zzz', 'u2 aaa', 'd1 5 5 5']"], ["['v1 hello', 'v2 hello world']"], ["['w1 10 20', 'w2 alpha beta']"], ["['a1 off key dog', 'g1 act car', 'a8 act zoo']"], ["['f1 a', 'f2 a', 'f3 a', 'd1 1']"], ["['g1 2 3', 'g2 1 2', 'l1 x y']"], ["['h1 data science', 'h2 data']"]], "expected": null, "loose": false}