npm - offcode - Versions diffs - 0.0.0-stage → 0.1.1 - Mend

offcode 0.0.0-stage → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1038) hide show

package/data/problems/find-smallest-letter-greater-than-target.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "748", "slug": "find-smallest-letter-greater-than-target", "id": 748, "title": "Find Smallest Letter Greater Than Target", "difficulty": "Easy", "category": "binary-search", "link": "https://leetcode.com/problems/find-smallest-letter-greater-than-target/", "examples": [{"input": "letters = [\"c\",\"f\",\"j\"], target = \"a\"", "output": "\"c\"", "explanation": "The smallest entry after \"a\" is \"c\"."}, {"input": "letters = [\"c\",\"f\",\"j\"], target = \"c\"", "output": "\"f\"", "explanation": "The smallest entry after \"c\" is \"f\"."}, {"input": "letters = [\"x\",\"x\",\"y\",\"y\"], target = \"z\"", "output": "\"x\"", "explanation": "Nothing exceeds \"z\", so wrap to the front."}], "hints": ["Because the list is sorted, a binary search for the first entry above the target runs in logarithmic time.", "Remember the wrap rule: when the target is at or past the last distinct entry, the answer is letters[0].", "Compare only the first character of each one-letter string."], "statement": "You are handed a list of lowercase letters sorted from smallest to largest, holding at least two different letters, plus a single target letter.\n\nScan the list and pick the smallest entry that comes strictly after the target in alphabetical order. If every entry is at or before the target, wrap around and return the first entry of the list.\n\nAdaptation for this judge: the original statement uses a character array and single characters; here each letter is a one-character string, so `letters` is a string array and both `target` and the answer are strings.\n\n**Constraints:**\n- `2 <= letters.length <= 10^4`\n- Each entry of `letters` is a lowercase English letter.\n- `letters` is sorted in non-decreasing order.\n- `letters` holds at least two distinct letters.\n- `target` is a lowercase English letter.\n", "solution": "## Approach\n\nWalk the sorted list from left to right and return the first entry whose single character exceeds the target character. If the scan finishes without a hit, every entry is at or below the target, so the wrap rule gives the front entry. A binary search for the insertion point works too, but the linear pass is already fast enough for the limits.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of letters. Each entry is inspected at most once.\n- **Space Complexity:** O(1) besides the input and output.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def nextGreatestLetter(self, letters: List[str], target: str) -> str:\n for ch in letters:\n if ch > target:\n return ch\n return letters[0]\n```\n", "starter": {"go": "package main\n\nfunc NextGreatestLetter(letters []string, target string) string {\n return \"\"\n}", "python": "from typing import List\nclass Solution:\n def nextGreatestLetter(self, letters: List[str], target: str) -> str:\n pass", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n string nextGreatestLetter(vector<string>& letters, string target) {\n return \"\";\n }\n};"}, "fn": "nextGreatestLetter", "params": [{"name": "letters", "type": "string_array"}, {"name": "target", "type": "string"}], "outputType": "string", "tests": [["['c', 'f', 'j']", "a"], ["['c', 'f', 'j']", "c"], ["['x', 'x', 'y', 'y']", "z"], ["['a', 'b']", "a"], ["['a', 'b']", "b"], ["['a', 'b', 'c']", "b"], ["['a', 'a', 'b', 'b']", "a"], ["['e', 'e', 'e', 'n', 'n']", "e"], ["['c', 'f', 'j']", "d"], ["['c', 'f', 'j']", "g"], ["['c', 'f', 'j']", "j"], ["['a', 'c', 'f', 'j']", "b"], ["['m', 'm', 'm', 'z']", "m"], ["['a', 'z']", "y"], ["['a', 'z']", "z"], ["['b', 'd', 'f', 'h']", "a"], ["['b', 'd', 'f', 'h']", "e"], ["['k', 'k', 'k', 'k', 'p']", "k"], ["['c', 'd', 'e']", "a"], ["['a', 'b', 'c', 'd']", "d"], ["['j', 'j', 'k']", "j"], ["['a', 'e', 'i', 'o', 'u']", "b"], ["['a', 'e', 'i', 'o', 'u']", "u"], ["['f', 'm', 't']", "s"], ["['a', 'b']", "z"], ["['d', 'h', 'z']", "c"], ["['p', 'q', 'r']", "p"], ["['w', 'x', 'y', 'z']", "v"]], "expected": null, "loose": false}

package/data/problems/find-the-celebrity.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "277", "slug": "find-the-celebrity", "id": 277, "title": "Find the Celebrity", "difficulty": "Medium", "category": "graph", "link": "https://leetcode.com/problems/find-the-celebrity/", "examples": [{"input": "graph = [[1,1,0],[0,1,0],[1,1,1]]", "output": "1", "explanation": "Person 1 is known by 0 and 2 while knowing nobody else."}, {"input": "graph = [[1,0,1],[1,1,0],[0,1,1]]", "output": "-1", "explanation": "No person satisfies both celebrity conditions."}, {"input": "graph = [[1,0],[1,1]]", "output": "0", "explanation": "Person 0 knows nobody else and person 1 knows 0."}], "hints": ["The judge never reveals the matrix; only relation.knows(a, b) is available (at most 10 + 5*n calls).", "Eliminate non-candidates: if candidate knows i, candidate cannot be the celebrity so move to i.", "Verify the survivor knows nobody else and is known by everybody; else return -1."], "statement": "There are `n` people labeled `0` to `n - 1`. A celebrity knows nobody but is known by everybody else. Interact with the judge object `relation` \u2014 your code never receives the adjacency matrix:\n\n- `knows(a, b)` returns whether person `a` knows person `b`.\n\nImplement `findCelebrity(n, relation)` returning the celebrity label, or `-1` when none exists. First eliminate candidates in `O(n)` calls (if the candidate knows `i`, it cannot be the celebrity, so move to `i`), then verify the survivor knows nobody and is known by everybody. The judge counts your `knows` calls and reports Wrong Answer if you exceed **10 + 5*n** calls on a test case (an `O(n)` solution uses about `3n`).\n\nMethod names per language: Java `relation.knows(a, b)`, Python `relation.knows(a, b)`, C++ `relation.knows(a, b)`, C# `relation.Knows(a, b)`, Rust `relation.knows(a, b)`, Go `relation.Knows(a, b)`, TypeScript `relation.knows(a, b)`, PHP `$relation->knows($a, $b)`.\n\n**Constraints:**\n\n- `1 <= n <= 100`\n- The hidden matrix is `n x n` with entries `0` or `1` (diagonal entries are ignored).\n- At most `10 + 5*n` `knows` calls per test case.\n", "solution": "## Approach\n\nPick a candidate by scanning people: whenever the current candidate knows i, discard the candidate and take i. Then verify the survivor is known by all others and knows none of them; otherwise no celebrity exists.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n)\n- **Space Complexity:** O(1)\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def findCelebrity(self, graph: List[List[int]]) -> int:\n n = len(graph)\n if n == 0:\n return -1\n cand = 0\n for i in range(1, n):\n if graph[cand][i] == 1:\n cand = i\n for i in range(n):\n if i == cand:\n continue\n if graph[cand][i] == 1:\n return -1\n if graph[i][cand] == 0:\n return -1\n return cand\n```\n", "starter": {"go": "package main\n\n// This is the knows API interface.\n// You should not implement it, or speculate about its implementation\n// type Relation struct { }\n// func (r *Relation) Knows(a int, b int) bool\n// Knows(a, b) tells whether person a knows person b; n is the party size.\n// Eliminate in O(n) calls, then verify the survivor.\n// The judge counts your calls: at most 10 + 5*n per test case.\nfunc FindCelebrity(n int, relation *Relation) int {\n return -1\n}", "python": "# The knows API is provided by the judge as `relation`.\n# You should not implement it, or speculate about its implementation\n# class Relation:\n# def knows(self, a: int, b: int) -> bool:\n# ...\n# knows(a, b) tells whether person a knows person b; n is the party size.\n# Eliminate in O(n) calls, then verify the survivor.\n# The judge counts your calls: at most 10 + 5*n per test case.\nfrom typing import List\nclass Solution:\n def findCelebrity(self, n: int, relation: 'Relation') -> int:\n return -1", "cpp": "/**\n * // This is the knows API interface.\n * // You should not implement it, or speculate about its implementation\n * class Relation {\n * public:\n * bool knows(int a, int b);\n * };\n * // knows(a, b) tells whether person a knows person b; n is the party size.\n * // Eliminate in O(n) calls, then verify the survivor.\n * // The judge counts your calls: at most 10 + 5*n per test case.\n */\nclass Solution {\npublic:\n int findCelebrity(int n, Relation& relation) {\n return -1;\n }\n};"}, "fn": "findCelebrity", "params": [{"name": "graph", "type": "int_array_2d"}], "outputType": "int", "tests": [["[[1,1,0],[0,1,0],[1,1,1]]"], ["[[1,0,1],[1,1,0],[0,1,1]]"], ["[[1,0],[1,1]]"], ["[[1,1],[0,1]]"], ["[[1]]"], ["[[1,1,1],[1,1,1],[1,1,1]]"], ["[[1,0,0],[0,1,0],[0,0,1]]"], ["[[1,0,0,0],[1,1,0,0],[1,1,1,0],[1,1,1,1]]"], ["[[1,1,1,0],[0,1,1,0],[0,0,1,0],[1,1,1,1]]"], ["[[1,0],[0,1]]"], ["[[1,1,0,0],[0,1,0,0],[1,1,1,0],[1,1,1,1]]"], ["[[1,0,1],[0,1,1],[0,0,1]]"], ["[[1,1],[1,1]]"], ["[[1,0,0],[1,1,1],[0,0,1]]"], ["[[1,0,0,0,0],[1,1,1,1,1],[1,0,1,0,0],[1,1,1,1,0],[1,1,0,0,1]]"], ["[[1,0,0],[1,1,0],[1,1,1]]"], ["[[1,1,1],[0,1,0],[0,1,1]]"], ["[[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]]"], ["[[1,1,1,1],[0,1,0,0],[0,0,1,0],[0,0,0,1]]"], ["[[1,0,0],[1,1,0],[1,0,1]]"], ["[[1,0,0,0,1],[0,1,0,0,1],[0,0,1,0,1],[0,0,0,1,1],[0,0,0,0,1]]"], ["[[1,1,0],[0,1,1],[0,0,1]]"], ["[[1,0,1,0],[0,1,1,0],[0,0,1,0],[0,0,1,1]]"], ["[[1,0,1,0],[1,1,0,1],[1,0,1,1],[1,1,0,1]]"], ["[[1,0,0],[0,1,1],[1,1,1]]"], ["[[1,1,0,0,0],[0,1,0,0,0],[0,1,1,0,0],[0,1,1,1,0],[0,1,1,1,1]]"], ["[[1,0,0,0],[1,1,1,1],[1,0,1,0],[1,0,0,1]]"], ["[[1,0,1],[1,1,1],[0,0,1]]"], ["@javascript:(()=>{const n=100,c=73;const g=Array.from({length:n},(_,i)=>Array.from({length:n},(_,j)=>i===j?1:(j===c?1:(i===c?0:(((i*31+j*17)%3===0)?1:0)))));return JSON.stringify(g);})()"], ["@javascript:JSON.stringify(Array.from({length:100},(_,i)=>Array.from({length:100},(_,j)=>i===j?1:0)))"]], "expected": null, "loose": false}

package/data/problems/find-the-closest-palindrome.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "619", "slug": "find-the-closest-palindrome", "id": 619, "title": "Find the Closest Palindrome", "difficulty": "Hard", "category": "math", "link": "https://leetcode.com/problems/find-the-closest-palindrome/", "examples": [{"input": "n = \"123\"", "output": "\"121\"", "explanation": "121 and 131 tie at distance 2; the smaller wins."}, {"input": "n = \"1\"", "output": "\"0\"", "explanation": "The nearest palindrome besides 1 itself is 0."}, {"input": "n = \"99\"", "output": "\"101\"", "explanation": "101 (gap 2) beats 88 (gap 11)."}], "hints": ["Mirror the first half onto the second half; also try the prefix plus and minus one before mirroring.", "Add the length-change candidates 10^k + 1 and 10^(k-1) - 1 for inputs like 1000 or 999.", "Drop the input itself from the candidates, then keep the smallest gap, preferring the smaller value on ties."], "statement": "Given a decimal string `n` (no leading zeros except `\"0\"` itself), return the closest palindromic integer different from `n` itself, as a string. Closeness is measured by absolute numeric difference; when two palindromes tie, pick the smaller one.\n\nOnly the value matters, not the spelling: candidates are built by mirroring a prefix. Also consider the powers-of-ten neighbors (`99..9` and `100..01`), which cover length changes the mirroring may miss.\n\n**Constraints:**\n- `1 <= n.length <= 18`\n- `n` has no leading zeros.\n- `n` fits in a signed 64-bit integer.\n", "solution": "## Approach\n\nBuild a small candidate set: mirror the leading half for the prefixes `p-1`, `p`, and `p+1`, and add the two length-change neighbors `10^len + 1` and `10^(len-1) - 1`. Mirroring copies the first `len // 2` characters of the prefix string in reverse, which naturally handles prefixes that grew or shrank. Remove the input itself, then choose the candidate with the smallest absolute gap, breaking ties toward the smaller value.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(len), proportional to the digit count (at most 18).\n- **Space Complexity:** O(len) for the candidate strings.\n\n## Implementation\n\n```python\nclass Solution:\n def nearestPalindromic(self, n: str) -> str:\n ln = len(n)\n self_val = int(n)\n cands = set()\n cands.add(10 ** ln + 1)\n cands.add(10 ** (ln - 1) - 1 if ln > 1 else 0)\n half = (ln + 1) // 2\n prefix = int(n[:half])\n for p in (prefix - 1, prefix, prefix + 1):\n if p < 0:\n continue\n s = str(p)\n cands.add(int(s + s[:ln // 2][::-1]))\n cands.discard(self_val)\n return str(min(cands, key=lambda c: (abs(c - self_val), c)))\n```\n", "starter": {"go": "package main\n\nfunc NearestPalindromic(n string) string {\n return \"\"\n}", "python": "class Solution:\n def nearestPalindromic(self, n: str) -> str:\n return \"\"\n", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n string nearestPalindromic(string n) {\n return \"\";\n }\n};"}, "fn": "nearestPalindromic", "params": [{"name": "n", "type": "string"}], "outputType": "string", "tests": [["123"], ["1"], ["9"], ["10"], ["99"], ["100"], ["1000"], ["999"], ["12321"], ["1221"], ["10001"], ["15"], ["19"], ["10010"], ["101"], ["110"], ["1001"], ["9999"], ["1234"], ["99999"], ["100000"], ["54321"], ["12932"], ["99800"], ["11"], ["22"], ["191"], ["1283"]], "expected": ["121", "0", "8", "9", "101", "99", "999", "1001", "12221", "1111", "9999", "11", "22", "10001", "99", "111", "999", "10001", "1221", "100001", "99999", "54345", "12921", "99799", "9", "11", "181", "1331"], "loose": false}

package/data/problems/find-the-derangement-of-an-array.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "656", "slug": "find-the-derangement-of-an-array", "id": 656, "title": "Find the Derangement of An Array", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/find-the-derangement-of-an-array/", "examples": [{"input": "n = 3", "output": "2", "explanation": "The derangements of [1,2,3] are [2,3,1] and [3,1,2]."}, {"input": "n = 2", "output": "1", "explanation": "Only [2,1] avoids every original slot."}, {"input": "n = 1", "output": "0", "explanation": "One element cannot escape its own position."}], "hints": ["Let f[i] count derangements of i items with f[0] = 1 and f[1] = 0.", "Placing item 1 into slot j (i-1 choices) splits on where item j goes, giving f[i] = (i-1) * (f[i-1] + f[i-2]).", "Iterate bottom-up with two rolling values, reducing modulo 1000000007 each step."], "statement": "Start from the sorted array `[1, 2, ..., n]`. A derangement is a rearrangement where no value stays in its original slot (so 1 is not first, 2 is not second, and so on).\n\nCount how many derangements exist, returning the total modulo 1000000007.\n\n**Constraints:**\n- `1 <= n <= 10^6`\n", "solution": "## Approach\n\nUse the classic recurrence for derangements: with f[0]=1 and f[1]=0, each larger size satisfies f[i]=(i-1)*(f[i-1]+f[i-2]) because element 1 has i-1 destination choices and the displaced element either swaps back or joins a smaller derangement. Iterate upward keeping only the last two values under the modulus.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n).\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nclass Solution:\n def findDerangement(self, n: int) -> int:\n MOD = 10 ** 9 + 7\n if n == 1:\n return 0\n a, b = 1, 0\n for i in range(2, n + 1):\n a, b = b, ((i - 1) * (a + b)) % MOD\n return b\n```\n", "starter": {"go": "package main\n\nfunc FindDerangement(n int) int {\n \n}", "python": "class Solution:\n def findDerangement(self, n: int) -> int:\n pass", "cpp": "class Solution {\npublic:\n int findDerangement(int n) {\n return 0;\n }\n};"}, "fn": "findDerangement", "params": [{"name": "n", "type": "int"}], "outputType": "int", "tests": [["3"], ["2"], ["1"], ["4"], ["5"], ["6"], ["7"], ["8"], ["9"], ["10"], ["11"], ["12"], ["20"], ["50"], ["100"], ["1000"], ["10000"], ["100000"], ["1000000"], ["13"], ["14"], ["15"], ["16"], ["17"], ["18"], ["19"], ["21"], ["30"]], "expected": [2, 1, 0, 9, 44, 265, 1854, 14833, 133496, 1334961, 14684570, 176214841, 927799753, 77829876, 944828409, 37043040, 381587473, 183389504, 102701088, 290792918, 71100825, 66512367, 64197866, 91363714, 644546846, 246389989, 483794679, 568643488], "loose": false}

package/data/problems/find-the-difference.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "465", "slug": "find-the-difference", "id": 465, "title": "Find the Difference", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/find-the-difference/", "examples": [{"explanation": "Reordering \"abcd\" can produce \"abcd\"; the surplus letter is \"e\".", "input": "s = \"abcd\", t = \"abcde\"", "output": "\"e\""}, {"explanation": "The first string is empty, so the only letter of \"t\" is the extra one.", "input": "s = \"\", t = \"y\"", "output": "\"y\""}, {"explanation": "Three 'a' letters pair up; one 'a' is left over.", "input": "s = \"aaab\", t = \"aaaba\"", "output": "\"a\""}], "hints": ["Adding up character codes of both strings leaves a difference equal to the extra letter.", "XOR-ing all codes cancels paired letters and reveals the surplus one.", "A 26-slot frequency table also works: the letter whose count differs is the answer."], "statement": "Two lowercase strings are given. The second string is formed by shuffling the characters of the first one and then inserting exactly one additional lowercase letter at some position. Identify which letter was inserted.\n\n*Interface note:* the original statement returns a single character. In this repo every language models that answer as a one-character `string`, so return e.g. `\"e\"` rather than `'e'`.\n\n**Constraints:**\n- `0 <= s.length <= 1000`\n- `t.length == s.length + 1`\n- `s` and `t` contain only lowercase English letters.\n", "solution": "## Approach\n\nPairing each letter of the shorter string with an equal letter of the longer one leaves exactly one unpaired letter. XOR-ing all character codes cancels the pairs and exposes the leftover code, which is converted to a one-character string. (Summing codes and subtracting works equally well.)\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the length of `t`.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nclass Solution:\n def findTheDifference(self, s: str, t: str) -> str:\n x = 0\n for c in s:\n x ^= ord(c)\n for c in t:\n x ^= ord(c)\n return chr(x)\n```\n", "starter": {"go": "package main\n\nfunc FindTheDifference(s string, t string) string {\n return \"\"\n}", "python": "class Solution:\n def findTheDifference(self, s: str, t: str) -> str:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n string findTheDifference(string s, string t) {\n return \"\";\n }\n};"}, "fn": "findTheDifference", "params": [{"name": "s", "type": "string"}, {"name": "t", "type": "string"}], "outputType": "string", "tests": [["abcd", "abcde"], ["", "y"], ["aaab", "aaaba"], ["a", "aa"], ["a", "ab"], ["ae", "aea"], ["xyz", "xyzz"], ["hello", "hellol"], ["abc", "cabd"], ["q", "qq"], ["qq", "qqq"], ["abcd", "abecd"], ["aabbcc", "aabbccd"], ["z", "zz"], ["m", "nm"], ["mn", "mnm"], ["aaaa", "aaaaa"], ["abcdefg", "abcdefgh"], ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz"], ["zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzz", "zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzyz"], ["abcde", "edcbaf"], ["xxyy", "xxyyx"], ["", "a"], ["", "z"], ["ab", "aab"], ["ab", "abb"], ["code", "coded"], ["test", "testt"], ["u", "vu"], ["pqrs", "pqrst"]], "expected": ["e", "y", "a", "a", "b", "a", "z", "l", "d", "q", "q", "e", "d", "z", "n", "m", "a", "h", "z", "y", "f", "x", "a", "z", "a", "b", "d", "t", "v", "t"], "loose": false}

package/data/problems/find-the-duplicate-number.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "94", "slug": "find-the-duplicate-number", "id": 94, "title": "Find the Duplicate Number", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/find-the-duplicate-number/", "examples": [{"input": "nums = [1,3,4,2,2]", "output": "2", "explanation": "The repeated number in [1, 3, 4, 2, 2] is 2."}, {"input": "nums = [3,1,3,4,2]", "output": "3", "explanation": "The repeated number in [3, 1, 3, 4, 2] is 3."}, {"input": "nums = [3,3,3,3,3]", "output": "3", "explanation": "The number 3 is the duplicate, appearing 5 times."}], "hints": ["Interpret each array value as the next index in a linked structure; a duplicate creates a cycle.", "Use slow and fast pointers to find a meeting point inside that cycle.", "Reset one pointer to `nums[0]` and advance both one step at a time; their next meeting point is the duplicate."], "statement": "You receive an integer array `nums` holding `n + 1` entries, each drawn from the interval `[1, n]`. One value occurs repeatedly; identify and return it.\n\nA single distinct value is duplicated, though it may show up more than twice. Leave `nums` untouched and rely on only a constant amount of additional memory.\n\n**Constraints:**\n\n- `2 <= nums.length <= 100001`\n- `1 <= nums[i] < nums.length`\n- Precisely one distinct integer in `nums` shows up more than once.\n- That duplicated integer may occur more than twice.\n\n**Follow-up:** Is an `O(n)`-time approach achievable while keeping the input read-only and the extra memory at `O(1)`?\n", "solution": "## Approach\n\nTreat each value as a pointer to another index. Because there are `n + 1` entries whose values are in `[1, n]`, this pointer graph contains a cycle, and the cycle entrance is the duplicate value. First use slow and fast pointers to meet inside the cycle, then reset one pointer to `nums[0]` and advance both one step until they meet at the entrance.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n).\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def findDuplicate(self, nums: List[int]) -> int:\n slow = nums[0]\n fast = nums[0]\n\n while True:\n slow = nums[slow]\n fast = nums[nums[fast]]\n if slow == fast:\n break\n\n slow = nums[0]\n while slow != fast:\n slow = nums[slow]\n fast = nums[fast]\n return slow\n```\n", "starter": {"go": "package main\n\nfunc FindDuplicate(nums []int) int {\n return 0\n}", "python": "from typing import List\n\nclass Solution:\n def findDuplicate(self, nums: List[int]) -> int:\n pass\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n int findDuplicate(vector<int>& nums) {\n return 0;\n }\n};"}, "fn": "findDuplicate", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[1,1]"], ["[1,3,4,2,2]"], ["[3,1,3,4,2]"], ["[3,3,3,3,3]"], ["[2,1,2]"], ["[1,2,1]"], ["[2,2,1]"], ["[1,2,2]"], ["[1,1,2]"], ["[2,1,1]"], ["[1,2,3,1]"], ["[1,2,3,2]"], ["[1,2,3,3]"], ["[3,2,1,3]"], ["[2,3,2,1]"], ["[1,1,1,2]"], ["[2,2,3,2]"], ["[3,1,3,3]"], ["[4,1,2,3,4]"], ["[1,4,2,3,1]"], ["[2,4,2,1,3]"], ["[3,4,1,3,2]"], ["[4,2,1,3,2]"], ["[2,2,2,1,3]"], ["[4,4,1,4,2]"], ["[1,5,3,4,2,5]"], ["[6,1,2,3,4,5,6]"], ["[2,1,4,3,2,5]"], ["[3,5,1,4,2,3]"], ["[4,2,5,1,3,4]"], ["[1,1,1,1,2,3]"], ["[5,5,2,5,3,1]"], ["[1,6,2,5,3,4,6]"], ["[7,1,2,3,4,5,6,7]"], ["[2,6,4,1,3,5,2]"], ["[3,1,6,4,2,5,3]"], ["[4,2,6,1,5,3,4]"], ["[5,3,1,6,2,4,5]"], ["[6,4,2,5,3,1,6]"], ["[2,2,2,2,1,3,4]"], ["[7,7,1,7,2,3,4,5]"], ["[8,1,2,3,4,5,6,7,8]"], ["[1,7,3,5,2,8,4,6,7]"], ["[4,1,8,3,6,2,7,5,4]"], ["[2,8,6,4,1,7,3,5,2]"], ["[6,3,8,1,5,2,7,4,6]"], ["[1,1,1,1,1,2,3,4,5]"], ["[8,8,8,1,2,3,4,5,6]"], ["[9,1,2,3,4,5,6,7,8,9]"], ["[5,9,1,8,2,7,3,6,4,5]"], ["[2,4,6,8,1,3,5,7,9,2]"], ["[10,1,2,3,4,5,6,7,8,9,10]"], ["[7,2,10,4,1,9,3,8,5,6,7]"], ["[11,1,2,3,4,5,6,7,8,9,10,11]"], ["[6,11,2,10,3,9,4,8,5,7,1,6]"], ["@javascript:JSON.stringify(Array.from({length:19998},(_,i)=>19998-i).concat(1))"], ["@javascript:JSON.stringify(Array.from({length:19999},(_,i)=>i+1).concat(5432))"]], "expected": [1, 2, 3, 3, 2, 1, 2, 2, 1, 1, 1, 2, 3, 3, 2, 1, 2, 3, 4, 1, 2, 3, 2, 2, 4, 5, 6, 2, 3, 4, 1, 5, 6, 7, 2, 3, 4, 5, 6, 2, 7, 8, 7, 4, 2, 6, 1, 8, 9, 5, 2, 10, 7, 11, 6, 1, 5432], "loose": false}

package/data/problems/find-the-index-of-the-first-occurrence-in-a-string.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "257", "slug": "find-the-index-of-the-first-occurrence-in-a-string", "id": 257, "title": "Find the Index of the First Occurrence in a String", "difficulty": "Easy", "category": "two-pointers", "link": "https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string/", "examples": [{"input": "haystack = \"sadbutsad\", needle = \"sad\"", "output": "0", "explanation": "The pattern appears at index 0 and again at 6; the first occurrence wins."}, {"input": "haystack = \"leetcode\", needle = \"leeto\"", "output": "-1", "explanation": "No substring of the text equals the pattern."}], "hints": ["Try every start position from 0 up to len(haystack) - len(needle) and compare character by character.", "For a faster scan, precompute the longest-prefix-suffix table (KMP) so a mismatch never re-examines text characters."], "statement": "You are given two strings: a longer text `haystack` and a shorter pattern `needle`. Locate the first position in `haystack` where the whole `needle` appears as a contiguous block, and return that starting index.\n\nReturn `-1` when `needle` never occurs inside `haystack`.\n\n**Constraints:**\n- `1 <= haystack.length, needle.length <= 10^4`\n- Both strings consist of lowercase English letters.\n", "solution": "## Approach\n\nSlide a window over the text: for each start position that still leaves room for the pattern, compare the pattern character by character. The first position with a full match is the answer, and exhausting all starts without success yields -1.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * m) in the worst case, where n and m are the lengths of the text and pattern.\n- **Space Complexity:** O(1) extra space.\n\n## Implementation\n\n```python\nclass Solution:\n def strStr(self, haystack: str, needle: str) -> int:\n n, m = len(haystack), len(needle)\n for i in range(n - m + 1):\n if haystack[i:i + m] == needle:\n return i\n return -1\n```\n", "starter": {"go": "package main\n\nfunc StrStr(haystack string, needle string) int {\n \n}", "python": "class Solution:\n def strStr(self, haystack: str, needle: str) -> int:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int strStr(string haystack, string needle) {\n return 0;\n }\n};"}, "fn": "strStr", "params": [{"name": "haystack", "type": "string"}, {"name": "needle", "type": "string"}], "outputType": "int", "tests": [["sadbutsad", "sad"], ["leetcode", "leeto"], ["hello", "ll"], ["aaaaa", "bba"], ["mississippi", "issip"], ["a", "a"], ["a", "b"], ["abc", "c"], ["abc", "abc"], ["abc", "abcd"], ["aaa", "aaaa"], ["mississippi", "pi"], ["abababab", "abab"], ["bacbababa", "baba"], ["aaaab", "aaab"], ["abcdef", "def"], ["abcdef", "abc"], ["xyzxyzxyz", "yzx"], ["aaaaaaaaaab", "aaab"], ["ab", "b"], ["ba", "a"], ["qwerty", "y"], ["qwerty", "q"], ["abcabcabc", "cab"], ["aaaaaa", "aaa"], ["z", "zz"], ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab"], ["thequickbrownfox", "brown"]], "expected": [0, -1, 2, -1, 4, 0, -1, 2, 0, -1, -1, 9, 0, 3, 1, 3, 0, 1, 7, 1, 1, 5, 0, 2, 0, -1, 150, 8], "loose": false}

package/data/problems/find-the-shortest-superstring.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "930", "slug": "find-the-shortest-superstring", "id": 930, "title": "Find the Shortest Superstring", "difficulty": "Hard", "category": "array", "link": "https://leetcode.com/problems/find-the-shortest-superstring/", "examples": [{"input": "words = [\"alex\",\"loves\",\"leetcode\"]", "output": "\"alexlovesleetcode\"", "explanation": "No overlaps, so concatenation in any order is best."}, {"input": "words = [\"catg\",\"ctaagt\",\"gcta\",\"ttca\",\"atgcatc\"]", "output": "\"gctaagttcatgcatc\"", "explanation": "Best overlaps chain all words into 16 characters."}], "hints": ["Precompute for every ordered pair how many trailing characters of the first equal the leading characters of the second.", "Run a travelling-salesman style dynamic program over subsets: the state is (used set, last word) holding the best string so far.", "Extend each state with every unused word using the precomputed overlap, keeping the shortest candidate (ties broken arbitrarily)."], "statement": "Stitch every word into one short string that holds each of them as a contiguous block.\n\nGiven distinct words, arrange them in some order and glue neighbours together with the largest possible overlap (the tail of one matching the head of the next). The result must contain every word somewhere inside it. Among all shortest results, any one is accepted. Assume no word appears inside another word.\n\n**Constraints:**\n- `1 <= words.length <= 12`\n- `1 <= words[i].length <= 20`\n- Words hold lowercase English letters and are pairwise different.\n- No word is a substring of another word.\n", "solution": "## Approach\n\nFirst measure every ordered overlap: the longest tail of word `i` that equals the head of word `j`. Then run dynamic programming over subsets where each state stores the best superstring covering a given set of words and ending with a given word. Extending a state appends an unused word trimmed by the overlap, keeping the shortest candidate. The answer is the best full-set state.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2 * 2^n * L) for n words of length up to L (n <= 12).\n- **Space Complexity:** O(n * 2^n * L) for the table of partial superstrings.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def shortestSuperstring(self, words: List[str]) -> str:\n n = len(words)\n if n == 1:\n return words[0]\n ov = [[0] * n for _ in range(n)]\n for i in range(n):\n for j in range(n):\n if i == j:\n continue\n m = min(len(words[i]), len(words[j]))\n for k in range(m, 0, -1):\n if words[i][-k:] == words[j][:k]:\n ov[i][j] = k\n break\n size = 1 << n\n dp = [[None] * n for _ in range(size)]\n for i in range(n):\n dp[1 << i][i] = words[i]\n for mask in range(size):\n for last in range(n):\n if not (mask & (1 << last)) or dp[mask][last] is None:\n continue\n for nxt in range(n):\n if mask & (1 << nxt):\n continue\n cand = dp[mask][last] + words[nxt][ov[last][nxt]:]\n nm = mask | (1 << nxt)\n cur = dp[nm][nxt]\n if cur is None or len(cand) < len(cur) or (len(cand) == len(cur) and cand < cur):\n dp[nm][nxt] = cand\n full = size - 1\n best = None\n for i in range(n):\n cur = dp[full][i]\n if cur is None:\n continue\n if best is None or len(cur) < len(best) or (len(cur) == len(best) and cur < best):\n best = cur\n return best\n```\n", "starter": {"go": "package main\n\nfunc ShortestSuperstring(words []string) string {\n return \"\"\n}", "python": "from typing import List\nclass Solution:\n def shortestSuperstring(self, words: List[str]) -> str:\n pass", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n string shortestSuperstring(vector<string>& words) {\n return \"\";\n }\n};"}, "fn": "shortestSuperstring", "params": [{"name": "words", "type": "string_array"}], "outputType": "string", "tests": [["['alex', 'loves', 'leetcode']"], ["['catg', 'ctaagt', 'gcta', 'ttca', 'atgcatc']"], ["['abc', 'bcd', 'cde']"], ["['abcd', 'cdef', 'efgh']"], ["['a', 'b', 'c']"], ["['abc', 'def', 'ghi']"], ["['ab', 'bc', 'cd', 'de']"], ["['gta', 'agt', 'tag']"], ["['cat', 'atc', 'tca']"], ["['abcde', 'cdefg', 'efghi']"], ["['word', 'ordw', 'rdwo']"], ["['ab', 'cd', 'ef', 'gh']"], ["['abc', 'cde', 'efg', 'ghi']"], ["['aab', 'abb', 'bba', 'baa']"], ["['xyz', 'yzx', 'zxy']"], ["['qwe', 'wer', 'ert', 'rty']"], ["['abcd', 'bcde', 'cdef', 'defg', 'efgh']"], ["['hello', 'llohe', 'ohell']"], ["['abca', 'bcab', 'cabc']"], ["['taco', 'acot', 'cota']"], ["['abcdef', 'defghi', 'ghijkl']"], ["['ab', 'ba']"], ["['abc', 'bca', 'cab']"], ["['mno', 'nop', 'opq', 'pqr']"], ["['aaaaab', 'aaaaba', 'aaabaa']"], ["['cat', 'dog', 'bird']"], ["['abca', 'cabc', 'bcab', 'cabb']"], ["['ef', 'fg', 'gh', 'he']"]], "expected": null, "loose": false}

package/data/problems/find-the-town-judge.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "217", "slug": "find-the-town-judge", "id": 217, "title": "Find the Town Judge", "difficulty": "Easy", "category": "graph", "link": "https://leetcode.com/problems/find-the-town-judge/", "examples": [{"input": "n = 2, trust = [[1,2]]", "output": "2"}, {"input": "n = 3, trust = [[1,3],[2,3]]", "output": "3"}, {"input": "n = 3, trust = [[1,3],[2,3],[3,1]]", "output": "-1"}], "hints": ["The judge is trusted by everyone else and trusts nobody. Track in/out degree."], "statement": "A settlement holds `n` residents numbered `1` through `n`. Rumor says one of them covertly serves as the town judge.\n\nWhenever a judge is present, the following all hold:\n\n1. The town judge places trust in no one.\n2. Every other resident places trust in the town judge.\n3. Exactly one resident meets both conditions above.\n\nYou receive a list `trust` in which `trust[i] = [ai, bi]` means resident `ai` trusts resident `bi`. Any pair missing from `trust` indicates no trust flows there.\n\nIdentify the judge by number when such a uniquely determinable person exists; otherwise return `-1`.\n\n**Constraints:**\n- `1 <= n <= 1000`\n- `0 <= trust.length <= 10^4`\n- `trust[i].length == 2`\n- Every trust pair is different from the others.\n- `ai != bi`\n- `1 <= ai, bi <= n`\n", "solution": "## Approach\n\nMaintain a score for each person: +1 when trusted, -1 when trusting. The judge ends with score `n-1`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + trust.length)\n- **Space Complexity:** O(n)\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def findJudge(self, n: int, trust: List[List[int]]) -> int:\n score = [0] * (n + 1)\n for a, b in trust:\n score[a] -= 1\n score[b] += 1\n for i in range(1, n + 1):\n if score[i] == n - 1:\n return i\n return -1\n```\n", "starter": {"go": "package main\n\nfunc FindJudge(n int, trust [][]int) int {\n \n}", "python": "from typing import List\nclass Solution:\n def findJudge(self, n: int, trust: List[List[int]]) -> int:\n ", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n int findJudge(int n, vector<vector<int>>& trust) {\n \n }\n};"}, "fn": "findJudge", "params": [{"name": "n", "type": "int"}, {"name": "trust", "type": "int_array_2d"}], "outputType": "int", "tests": [["2", "[[1,2]]"], ["3", "[[1,3],[2,3]]"], ["3", "[[1,3],[2,3],[3,1]]"], ["1", "[]"], ["4", "[[1,3],[1,4],[2,3],[2,4],[4,3]]"], ["3", "[[1,2],[2,3]]"], ["4", "[[1,2],[2,3],[3,4],[4,1]]"], ["2", "[]"], ["3", "[[1,2],[2,1]]"], ["5", "[[1,5],[2,5],[3,5],[4,5]]"], ["4", "[[1,4],[2,4],[3,4]]"], ["4", "[[1,3],[2,3],[4,3],[3,1]]"], ["5", "[[1,2],[2,3],[3,4],[4,5]]"], ["5", "[]"], ["6", "[[1,6],[2,6],[3,6],[4,6],[5,6]]"], ["6", "[[1,6],[2,6],[3,6],[4,6]]"], ["3", "[[1,2],[1,3],[2,1],[2,3],[3,1],[3,2]]"], ["4", "[[2,1],[3,1],[4,1]]"], ["4", "[[2,1],[3,1],[4,1],[1,2]]"], ["5", "[[1,3],[2,3],[4,3],[5,3]]"], ["5", "[[2,1],[3,1],[4,1],[5,1],[1,3]]"], ["2", "[[2,1]]"], ["2", "[[1,2],[2,1]]"], ["7", "[[1,7],[2,7],[3,7],[4,7],[5,7],[6,7]]"], ["7", "[[1,2],[2,3],[3,1]]"], ["3", "[[1,3]]"], ["4", "[[1,2],[3,2],[4,2]]"], ["8", "[[1,5],[2,5],[3,5],[4,5],[6,5],[7,5],[8,5]]"], ["8", "[[1,5],[2,5],[3,5],[4,5],[6,5],[7,5],[8,5],[5,1]]"], ["10", "[[1,10],[2,10],[3,10],[4,10],[5,10],[6,10],[7,10],[8,10],[9,10]]"], ["3", "[[2,3],[3,2]]"], ["6", "[[1,2],[1,3],[2,4],[3,4],[4,5],[5,6]]"]], "expected": [2, 3, -1, 1, 3, -1, -1, -1, -1, 5, 4, -1, -1, -1, 6, -1, -1, 1, -1, 3, -1, 1, -1, 7, -1, -1, 2, 5, -1, 10, -1, -1], "loose": false}

package/data/problems/first-bad-version.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "278", "slug": "first-bad-version", "id": 278, "title": "First Bad Version", "difficulty": "Easy", "category": "binary-search", "link": "https://leetcode.com/problems/first-bad-version/", "examples": [{"input": "n = 5, bad = 4", "output": "4", "explanation": "Versions 4 and 5 are bad; 4 is first."}, {"input": "n = 1, bad = 1", "output": "1", "explanation": "The only version is bad."}, {"input": "n = 10, bad = 7", "output": "7", "explanation": "Versions 7..10 are bad; 7 is first."}], "hints": ["The judge never reveals bad; call the isBadVersion API to test a version, and minimize the number of calls.", "Binary-search [1, n] for the first v with v >= bad.", "Use mid = left + (right - left) / 2 to avoid overflow."], "statement": "Versions `1..n` turn bad starting at some hidden threshold: every version from the first bad one onward is bad. Interact with the judge object `vc` \u2014 your code never receives `bad` directly:\n\n- `isBadVersion(version)` returns whether that version is bad.\n\nImplement `firstBadVersion(n, vc)` returning the first bad version while minimizing the number of API calls. Binary search needs `O(log n)` calls; the judge counts your calls and reports Wrong Answer if you exceed **100** calls on a test case.\n\nMethod names per language: Java `vc.isBadVersion(version)`, Python `vc.is_bad_version(version)`, C++ `vc.isBadVersion(version)`, C# `vc.IsBadVersion(version)`, Rust `vc.is_bad_version(version)`, Go `vc.IsBadVersion(version)`, TypeScript `vc.isBadVersion(version)`, PHP `$vc->isBadVersion($version)`.\n\n**Constraints:**\n\n- `1 <= bad <= n <= 2^31 - 1`\n- At most 100 API calls per test case.\n", "solution": "## Approach\n\nTreat isBadVersion(v) as v >= bad and binary-search the inclusive range [1, n]. When mid is bad, record it and search left; otherwise search right.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(log n)\n- **Space Complexity:** O(1)\n\n## Implementation\n\n```python\nclass Solution:\n def firstBadVersion(self, n: int, bad: int) -> int:\n def isBad(v: int) -> bool:\n return v >= bad\n lo, hi, ans = 1, n, n\n while lo <= hi:\n mid = lo + (hi - lo) // 2\n if isBad(mid):\n ans = mid\n hi = mid - 1\n else:\n lo = mid + 1\n return ans\n```\n", "starter": {"go": "package main\n\n// This is the version-control API interface.\n// You should not implement it, or speculate about its implementation\n// type VersionControl struct { }\n// func (v *VersionControl) IsBadVersion(version int) bool\n// The judge counts your calls: at most 100 per test case.\nfunc FirstBadVersion(n int, vc *VersionControl) int {\n return 0\n}", "python": "# The version-control API is provided by the judge as `vc`.\n# You should not implement it, or speculate about its implementation\n# class VersionControl:\n# def is_bad_version(self, version: int) -> bool:\n# ...\n# The judge counts your calls: at most 100 per test case.\nclass Solution:\n def firstBadVersion(self, n: int, vc: 'VersionControl') -> int:\n return 0", "cpp": "// This is the version-control API interface.\n// You should not implement it, or speculate about its implementation\n// class VersionControl {\n// public:\n// bool isBadVersion(int version);\n// };\n// The judge counts your calls: at most 100 per test case.\nclass Solution {\npublic:\n int firstBadVersion(int n, VersionControl& vc) {\n return 0;\n }\n};"}, "fn": "firstBadVersion", "params": [{"name": "n", "type": "int"}, {"name": "bad", "type": "int"}], "outputType": "int", "tests": [["5", "4"], ["1", "1"], ["10", "1"], ["10", "10"], ["100", "50"], ["1000", "1"], ["1000", "1000"], ["2147483647", "1"], ["2147483647", "2147483647"], ["100", "42"], ["2", "1"], ["2", "2"], ["3", "2"], ["7", "4"], ["50", "25"], ["100", "99"], ["500", "1"], ["500", "500"], ["8", "8"], ["9", "5"], ["100", "100"], ["100", "1"], ["1000", "500"], ["10000", "9999"], ["10000", "5000"], ["3", "3"], ["3", "1"], ["2147483647", "1073741823"]], "expected": null, "loose": false}

package/data/problems/first-missing-positive.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "164", "slug": "first-missing-positive", "id": 164, "title": "First Missing Positive", "difficulty": "Hard", "category": "array", "link": "https://leetcode.com/problems/first-missing-positive/", "examples": [{"input": "nums = [1,2,0]", "output": "3", "explanation": "The numbers in the range [1,2] are all in the array."}, {"input": "nums = [3,4,-1,1]", "output": "2", "explanation": "1 is in the array but 2 is missing."}, {"input": "nums = [7,8,9,11,12]", "output": "1", "explanation": "The smallest positive integer 1 is missing."}], "hints": ["Place each value v with 1 <= v <= n at index v-1 by swapping (cyclic sort), ignoring others.", "Then the first index i with nums[i] != i+1 gives answer i+1; otherwise n+1."], "statement": "You receive an integer array `nums` with no particular order. Report the least positive integer (1, 2, 3, ...) absent from `nums`.\n\nYour method should complete in `O(n)` time while consuming only `O(1)` extra memory.\n\n**Constraints:**\n\n- `1 <= nums.length <= 10^5`\n- `-2^31 <= nums[i] <= 2^31 - 1`\n", "solution": "## Approach\n\nUse cyclic sort in place: for each index `i`, while `nums[i]` is in `[1, n]` and not already at its target `nums[v-1]`, swap it to position `v-1`. After this pass, every placeable value sits at its correct index. Scan for the first `i` with `nums[i] != i+1` and return `i+1`; if all match, return `n+1`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), each element is swapped at most once into place plus one scan.\n- **Space Complexity:** O(1) extra.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def firstMissingPositive(self, nums: List[int]) -> int:\n n = len(nums)\n i = 0\n while i < n:\n v = nums[i]\n if 1 <= v <= n and nums[v - 1] != v:\n nums[i], nums[v - 1] = nums[v - 1], nums[i]\n else:\n i += 1\n for i, v in enumerate(nums):\n if v != i + 1:\n return i + 1\n return n + 1\n```\n", "starter": {"go": "package main\n\nfunc FirstMissingPositive(nums []int) int {\n return 0\n}", "python": "from typing import List\nclass Solution:\n def firstMissingPositive(self, nums: List[int]) -> int:\n ", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int firstMissingPositive(vector<int>& nums) {\n return 0;\n }\n};"}, "fn": "firstMissingPositive", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[1,2,0]"], ["[3,4,-1,1]"], ["[7,8,9,11,12]"], ["[1]"], ["[0]"], ["[2]"], ["[1,2,3,4,5]"], ["[2,2,2]"], ["[-5,-1,0]"], ["[1,1000000]"], ["[2,1]"], ["@javascript:JSON.stringify(Array.from({length:100000},(_,i)=>i+1))"], ["[1,2,3]"], ["[2,3,4]"], ["[0,0,0]"], ["[-1,-2,-3]"], ["[1,1,1]"], ["[5,4,3,2,1]"], ["[1,3,5,7]"], ["[2,4,6,8]"], ["[0,2,2,1,1]"], ["[100,101,102]"], ["[-10,0,1,2]"], ["[2147483647,-2147483648]"], ["[3,1,2]"], ["[4,3,2,1]"], ["[1,2,4]"], ["[0,1]"], ["[2,0,1]"], ["[5,3,1,2,4]"], ["[1,2,3,5,6]"], ["[0,-1,3,1]"]], "expected": [3, 2, 1, 2, 1, 1, 6, 1, 1, 2, 3, 100001, 4, 1, 1, 1, 2, 6, 2, 1, 3, 1, 3, 1, 4, 5, 3, 2, 3, 6, 4, 2], "loose": false}

package/data/problems/first-unique-character-in-a-string.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "463", "slug": "first-unique-character-in-a-string", "id": 463, "title": "First Unique Character in a String", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/first-unique-character-in-a-string/", "examples": [{"explanation": "'l' occurs once at index 0; 'e' repeats.", "input": "s = \"leetcode\"", "output": "0"}, {"explanation": "'l', 'o' and 'e' repeat; the first singleton is 'v' at index 2.", "input": "s = \"loveleetcode\"", "output": "2"}, {"explanation": "Both letters appear twice, so there is no singleton.", "input": "s = \"aabb\"", "output": "-1"}], "hints": ["Count how many times each of the 26 letters occurs in one pass.", "Make a second left-to-right pass and stop at the first letter whose count is 1.", "Two linear passes beat checking every pair of positions."], "statement": "Scan a lowercase word and locate the earliest position whose letter appears nowhere else in the word. Return that zero-based position. When every letter repeats, return `-1`.\n\nThe scan must distinguish the *first* singleton by its left-to-right order, not the smallest letter alphabetically.\n\n**Constraints:**\n- `1 <= s.length <= 10^5`\n- `s` contains only lowercase English letters.\n", "solution": "## Approach\n\nCount occurrences of each letter in a first pass over the string, then walk the string a second time and return the first index whose letter has count one. If the second walk finishes without a hit, no letter is unique. Two linear scans with a 26-slot table keep the work proportional to the string length.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the length of `s`.\n- **Space Complexity:** O(1), a fixed 26-entry frequency table.\n\n## Implementation\n\n```python\nclass Solution:\n def firstUniqChar(self, s: str) -> int:\n cnt = [0] * 26\n for c in s:\n cnt[ord(c) - ord('a')] += 1\n for i, c in enumerate(s):\n if cnt[ord(c) - ord('a')] == 1:\n return i\n return -1\n```\n", "starter": {"go": "package main\n\nfunc FirstUniqChar(s string) int {\n return 0\n}", "python": "class Solution:\n def firstUniqChar(self, s: str) -> int:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int firstUniqChar(string s) {\n return 0;\n }\n};"}, "fn": "firstUniqChar", "params": [{"name": "s", "type": "string"}], "outputType": "int", "tests": [["leetcode"], ["loveleetcode"], ["aabb"], ["a"], ["z"], ["ab"], ["aa"], ["abcabc"], ["dddccdbba"], ["aadadaad"], ["abcdefghijklmnopqrstuvwxyz"], ["zyxwvutsrqponmlkjihgfedcba"], ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"], ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab"], ["abacabad"], ["aabbcdd"], ["xxyyzzabc"], ["aabbccddeeffg"], ["leetcodeleetcode"], ["oontt"], ["abcddcbaef"], ["aabbcceeddffg"], ["qwertyuiopasdfghjklzxcvbnm"], ["mmnnooppqq"], ["abcdabcdabce"], ["zzzzzzzzzzzzzzzzzzzzzzzzzy"], ["aab"], ["abb"], ["abc"], ["aabcbc"]], "expected": [0, 2, -1, 0, 0, 0, -1, -1, 8, -1, 0, 0, -1, 50, 3, 4, 6, 12, -1, 2, 8, 12, 0, -1, 11, 25, 2, 0, 0, -1], "loose": false}

package/data/problems/fizz-buzz.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "485", "slug": "fizz-buzz", "id": 485, "title": "Fizz Buzz", "difficulty": "Easy", "category": "math", "link": "https://leetcode.com/problems/fizz-buzz/", "examples": [{"input": "n = 3", "output": "[\"1\",\"2\",\"Fizz\"]", "explanation": "Multiples of 3 become Fizz."}, {"input": "n = 5", "output": "[\"1\",\"2\",\"Fizz\",\"4\",\"Buzz\"]", "explanation": "Multiples of 5 become Buzz."}, {"input": "n = 15", "output": "[\"1\",\"2\",\"Fizz\",\"4\",\"Buzz\",\"Fizz\",\"7\",\"8\",\"Fizz\",\"Buzz\",\"11\",\"Fizz\",\"13\",\"14\",\"FizzBuzz\"]", "explanation": "Multiples of both 3 and 5 become FizzBuzz."}], "hints": ["Check divisibility by 3 and 5 first for the combined case.", "Otherwise emit Fizz for multiples of 3 and Buzz for multiples of 5.", "All other positions hold the decimal form of the index."], "statement": "Count from `1` to `n`, writing a label for each position. Positions divisible by both `3` and `5` become `\"FizzBuzz\"`, those divisible only by `3` become `\"Fizz\"`, those divisible only by `5` become `\"Buzz\"`, and every other position becomes its own number as a string.\n\nReturn the labels in order as a list.\n\n**Constraints:**\n- `1 <= n <= 10^4`\n\n**Adaptation note:** The original return type is a list of strings; here it maps to `string_list` with identical contents.\n", "solution": "## Approach\n\nWalk i from 1 through n and pick the label by divisibility: the both-divisible case first, then the single-divisor cases, then the numeric fallback. Collecting labels in order directly yields the required list.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n).\n- **Space Complexity:** O(n) for the answer.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def fizzBuzz(self, n: int) -> List[str]:\n ans = []\n for i in range(1, n + 1):\n if i % 15 == 0:\n ans.append(\"FizzBuzz\")\n elif i % 3 == 0:\n ans.append(\"Fizz\")\n elif i % 5 == 0:\n ans.append(\"Buzz\")\n else:\n ans.append(str(i))\n return ans\n```\n", "starter": {"go": "package main\n\nfunc FizzBuzz(n int) []string {\n return []string{}\n}", "python": "from typing import List\n\nclass Solution:\n def fizzBuzz(self, n: int) -> List[str]:\n return []\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<string> fizzBuzz(int n) {\n return {};\n }\n};"}, "fn": "fizzBuzz", "params": [{"name": "n", "type": "int"}], "outputType": "string_list", "tests": [["3"], ["5"], ["15"], ["1"], ["2"], ["4"], ["6"], ["7"], ["8"], ["9"], ["10"], ["11"], ["12"], ["13"], ["14"], ["16"], ["20"], ["30"], ["50"], ["100"], ["25"], ["45"], ["60"], ["75"], ["90"], ["33"], ["99"], ["17"], ["19"], ["21"]], "expected": [["1", "2", "Fizz"], ["1", "2", "Fizz", "4", "Buzz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz"], ["1"], ["1", "2"], ["1", "2", "Fizz", "4"], ["1", "2", "Fizz", "4", "Buzz", "Fizz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", "Buzz", "26", "Fizz", "28", "29", "FizzBuzz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", "Buzz", "26", "Fizz", "28", "29", "FizzBuzz", "31", "32", "Fizz", "34", "Buzz", "Fizz", "37", "38", "Fizz", "Buzz", "41", "Fizz", "43", "44", "FizzBuzz", "46", "47", "Fizz", "49", "Buzz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", "Buzz", "26", "Fizz", "28", "29", "FizzBuzz", "31", "32", "Fizz", "34", "Buzz", "Fizz", "37", "38", "Fizz", "Buzz", "41", "Fizz", "43", "44", "FizzBuzz", "46", "47", "Fizz", "49", "Buzz", "Fizz", "52", "53", "Fizz", "Buzz", "56", "Fizz", "58", "59", "FizzBuzz", "61", "62", "Fizz", "64", "Buzz", "Fizz", "67", "68", "Fizz", "Buzz", "71", "Fizz", "73", "74", "FizzBuzz", "76", "77", "Fizz", "79", "Buzz", "Fizz", "82", "83", "Fizz", "Buzz", "86", "Fizz", "88", "89", "FizzBuzz", "91", "92", "Fizz", "94", "Buzz", "Fizz", "97", "98", "Fizz", "Buzz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", "Buzz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", "Buzz", "26", "Fizz", "28", "29", "FizzBuzz", "31", "32", "Fizz", "34", "Buzz", "Fizz", "37", "38", "Fizz", "Buzz", "41", "Fizz", "43", "44", "FizzBuzz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", "Buzz", "26", "Fizz", "28", "29", "FizzBuzz", "31", "32", "Fizz", "34", "Buzz", "Fizz", "37", "38", "Fizz", "Buzz", "41", "Fizz", "43", "44", "FizzBuzz", "46", "47", "Fizz", "49", "Buzz", "Fizz", "52", "53", "Fizz", "Buzz", "56", "Fizz", "58", "59", "FizzBuzz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", "Buzz", "26", "Fizz", "28", "29", "FizzBuzz", "31", "32", "Fizz", "34", "Buzz", "Fizz", "37", "38", "Fizz", "Buzz", "41", "Fizz", "43", "44", "FizzBuzz", "46", "47", "Fizz", "49", "Buzz", "Fizz", "52", "53", "Fizz", "Buzz", "56", "Fizz", "58", "59", "FizzBuzz", "61", "62", "Fizz", "64", "Buzz", "Fizz", "67", "68", "Fizz", "Buzz", "71", "Fizz", "73", "74", "FizzBuzz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", "Buzz", "26", "Fizz", "28", "29", "FizzBuzz", "31", "32", "Fizz", "34", "Buzz", "Fizz", "37", "38", "Fizz", "Buzz", "41", "Fizz", "43", "44", "FizzBuzz", "46", "47", "Fizz", "49", "Buzz", "Fizz", "52", "53", "Fizz", "Buzz", "56", "Fizz", "58", "59", "FizzBuzz", "61", "62", "Fizz", "64", "Buzz", "Fizz", "67", "68", "Fizz", "Buzz", "71", "Fizz", "73", "74", "FizzBuzz", "76", "77", "Fizz", "79", "Buzz", "Fizz", "82", "83", "Fizz", "Buzz", "86", "Fizz", "88", "89", "FizzBuzz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", "Buzz", "26", "Fizz", "28", "29", "FizzBuzz", "31", "32", "Fizz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz", "22", "23", "Fizz", "Buzz", "26", "Fizz", "28", "29", "FizzBuzz", "31", "32", "Fizz", "34", "Buzz", "Fizz", "37", "38", "Fizz", "Buzz", "41", "Fizz", "43", "44", "FizzBuzz", "46", "47", "Fizz", "49", "Buzz", "Fizz", "52", "53", "Fizz", "Buzz", "56", "Fizz", "58", "59", "FizzBuzz", "61", "62", "Fizz", "64", "Buzz", "Fizz", "67", "68", "Fizz", "Buzz", "71", "Fizz", "73", "74", "FizzBuzz", "76", "77", "Fizz", "79", "Buzz", "Fizz", "82", "83", "Fizz", "Buzz", "86", "Fizz", "88", "89", "FizzBuzz", "91", "92", "Fizz", "94", "Buzz", "Fizz", "97", "98", "Fizz"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19"], ["1", "2", "Fizz", "4", "Buzz", "Fizz", "7", "8", "Fizz", "Buzz", "11", "Fizz", "13", "14", "FizzBuzz", "16", "17", "Fizz", "19", "Buzz", "Fizz"]], "loose": false}

package/data/problems/flatten-2d-vector.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "357", "slug": "flatten-2d-vector", "id": 357, "title": "Flatten 2D Vector", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/flatten-2d-vector/", "examples": [{"input": "vec = [[1,2],[3],[4]], operations = [\"next\",\"next\",\"next\",\"hasNext\",\"hasNext\",\"next\",\"hasNext\"]", "output": "[1,2,3,1,1,4,0]", "explanation": "Flattened order is [1,2,3,4]. The first three calls give 1, 2 and 3; values remain so both checks are 1; the next call gives 4; nothing remains so the last check is 0."}, {"input": "vec = [[],[1],[],[2,3]], operations = [\"hasNext\",\"next\",\"next\",\"next\",\"hasNext\"]", "output": "[1,1,2,3,0]", "explanation": "Empty rows are skipped, so flattened order is [1,2,3]."}, {"input": "vec = [[],[]], operations = [\"hasNext\",\"hasNext\"]", "output": "[0,0]", "explanation": "Both rows are empty, so no value ever becomes available."}], "hints": ["Flatten the input once into a single list, skipping empty rows, then serve operations with an index pointer.", "Alternatively keep a row and column cursor and advance it past empty rows before answering each operation."], "statement": "This is an offline adaptation of a design task. Instead of writing a class, you write one function that replays a whole session:\n\n```\nrunVector2D(vec, operations)\n```\n\n`vec` is a 2D integer array such as `[[1,2],[3],[4]]`, and `operations` holds only `\"next\"` or `\"hasNext\"`, in the order they are called. The flattened view visits every integer row by row from left to right, skipping empty rows:\n\n- `\"next\"` returns the next integer in flattened order and moves forward.\n- `\"hasNext\"` returns `1` when integers remain and `0` otherwise.\n\nReturn the answers for every operation in order, encoding `\"hasNext\"` as `1` or `0`.\n\n**Constraints:**\n- `0 <= vec.length <= 100`\n- `0 <= vec[i].length <= 100`\n- `-10^4 <= vec[i][j] <= 10^4`\n- `1 <= operations.length <= 10^4`\n- Each operation is `\"next\"` or `\"hasNext\"`.\n- `\"next\"` is only called when `\"hasNext\"` would be true.\n", "solution": "## Approach\n\nFlatten the 2D input once into a single list, skipping empty rows. Keep an index pointing at the next unconsumed value. A `next` operation returns the value at the index and advances it, while a `hasNext` operation reports whether the index is still inside the list. This replays the iterator behavior without storing per-row cursors.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m + q), where m is the total number of integers and q is the number of operations.\n- **Space Complexity:** O(m) for the flattened list and the output.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def runVector2D(self, vec: List[List[int]], operations: List[str]) -> List[int]:\n flat = [v for row in vec for v in row]\n ans = []\n idx = 0\n for op in operations:\n if op == \"next\":\n ans.append(flat[idx])\n idx += 1\n else:\n ans.append(1 if idx < len(flat) else 0)\n return ans\n```\n", "starter": {"go": "package main\n\nfunc RunVector2D(vec [][]int, operations []string) []int {\n return []int{}\n}", "python": "from typing import List\n\nclass Solution:\n def runVector2D(self, vec: List[List[int]], operations: List[str]) -> List[int]:\n return []\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n vector<int> runVector2D(vector<vector<int>>& vec, vector<string>& operations) {\n return {};\n }\n};"}, "fn": "runVector2D", "params": [{"name": "vec", "type": "int_array_2d"}, {"name": "operations", "type": "string_array"}], "outputType": "int_array", "tests": [["[[1,2],[3],[4]]", "[\"next\",\"next\",\"next\",\"hasNext\",\"hasNext\",\"next\",\"hasNext\"]"], ["[[],[1],[],[2,3]]", "[\"hasNext\",\"next\",\"next\",\"next\",\"hasNext\"]"], ["[[],[]]", "[\"hasNext\",\"hasNext\"]"], ["[[5]]", "[\"hasNext\",\"next\",\"hasNext\"]"], ["[[1]]", "[\"next\",\"hasNext\"]"], ["[[1,2,3]]", "[\"next\",\"hasNext\",\"next\",\"hasNext\",\"next\",\"hasNext\"]"], ["[[1],[2],[3],[4],[5]]", "[\"next\",\"next\",\"next\",\"next\",\"next\",\"hasNext\"]"], ["[[],[],[7,8]]", "[\"hasNext\",\"next\",\"hasNext\",\"next\",\"hasNext\"]"], ["[[0,-1],[100]]", "[\"next\",\"next\",\"next\",\"hasNext\"]"], ["[]", "[\"hasNext\"]"], ["[[1,2],[3,4],[5,6]]", "[\"next\",\"next\",\"hasNext\",\"next\",\"next\",\"hasNext\",\"next\",\"next\",\"hasNext\"]"], ["[[10,20,30,40]]", "[\"hasNext\",\"next\",\"next\",\"next\",\"next\",\"hasNext\"]"], ["[[1],[],[2]]", "[\"next\",\"next\",\"hasNext\"]"], ["[[-5,0,5],[],[-10,10]]", "[\"next\",\"next\",\"next\",\"next\",\"next\",\"hasNext\"]"], ["[[3,3,3],[3]]", "[\"hasNext\",\"hasNext\",\"next\",\"next\",\"next\",\"next\",\"hasNext\"]"], ["[[10000],[-10000]]", "[\"next\",\"hasNext\",\"next\",\"hasNext\"]"], ["[[1,2],[],[],[3]]", "[\"next\",\"next\",\"hasNext\",\"next\",\"hasNext\"]"], ["[[9]]", "[\"hasNext\"]"], ["[[1,2,3,4,5,6,7,8,9,10]]", "[\"next\",\"next\",\"next\",\"next\",\"next\",\"next\",\"next\",\"next\",\"next\",\"next\",\"hasNext\"]"], ["[[1],[2,3,4],[5]]", "[\"hasNext\",\"next\",\"hasNext\",\"next\",\"hasNext\",\"next\",\"hasNext\",\"next\",\"hasNext\",\"next\",\"hasNext\"]"], ["[[0],[0],[0]]", "[\"next\",\"next\",\"next\",\"hasNext\"]"], ["[[42,43],[44]]", "[\"next\",\"hasNext\",\"next\",\"hasNext\",\"next\",\"hasNext\"]"], ["[[],[],[],[]]", "[\"hasNext\",\"hasNext\",\"hasNext\"]"], ["[[-10000,10000]]", "[\"next\",\"hasNext\",\"next\",\"hasNext\"]"], ["[[1,2,3],[],[]]", "[\"next\",\"next\",\"next\",\"hasNext\"]"], ["[[],[0],[]]", "[\"hasNext\",\"hasNext\",\"next\",\"hasNext\",\"hasNext\"]"], ["[[6],[7],[8],[9]]", "[\"hasNext\",\"next\",\"next\",\"next\",\"next\",\"hasNext\"]"], ["[[-1,0],[],[1],[],[2,-2]]", "[\"next\",\"hasNext\",\"next\",\"next\",\"hasNext\",\"next\",\"next\",\"hasNext\"]"]], "expected": [[1, 2, 3, 1, 1, 4, 0], [1, 1, 2, 3, 0], [0, 0], [1, 5, 0], [1, 0], [1, 1, 2, 1, 3, 0], [1, 2, 3, 4, 5, 0], [1, 7, 1, 8, 0], [0, -1, 100, 0], [0], [1, 2, 1, 3, 4, 1, 5, 6, 0], [1, 10, 20, 30, 40, 0], [1, 2, 0], [-5, 0, 5, -10, 10, 0], [1, 1, 3, 3, 3, 3, 0], [10000, 1, -10000, 0], [1, 2, 1, 3, 0], [1], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 0], [1, 1, 1, 2, 1, 3, 1, 4, 1, 5, 0], [0, 0, 0, 0], [42, 1, 43, 1, 44, 0], [0, 0, 0], [-10000, 1, 10000, 0], [1, 2, 3, 0], [1, 1, 0, 0, 0], [1, 6, 7, 8, 9, 0], [-1, 1, 0, 1, 1, 2, -2, 0]], "loose": false}

package/data/problems/flatten-a-multilevel-doubly-linked-list.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "499", "slug": "flatten-a-multilevel-doubly-linked-list", "id": 499, "title": "Flatten a Multilevel Doubly Linked List", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/flatten-a-multilevel-doubly-linked-list/", "examples": [{"input": "head = [1,2,3,4,5,6]", "output": "[1,2,3,4,5,6]", "explanation": "A single-level list is already flat."}, {"input": "head = [1,2,3]", "output": "[1,2,3]", "explanation": "Nothing to unfold; order is preserved."}, {"input": "head = []", "output": "[]", "explanation": "Empty input gives empty output."}], "hints": ["Walk the chain once and collect values, then rebuild a fresh chain in that order.", "Adaptation: child and prev links are omitted, so flattening keeps the value order.", "An empty input returns null."], "statement": "You receive the head of a linked list and must return the head of its flattened form: the same values in the same order, with every node linked through `next`.\n\n**Constraints:**\n- Node count lies in `[0, 1000]`.\n- `1 <= Node.val <= 10^5`.\n\nAdaptation: the source uses a multilevel doubly node with `prev`, `next` and `child` links, which this judge cannot express (only singly `list_node` exists). Child and previous links are therefore omitted: input is a single-level chain modeled as `list_node`, and flattening preserves its order. Implement a faithful copy that keeps the value sequence.\n", "solution": "## Approach\n\nBecause the adapted input has no child levels, flattening means preserving the value order. Traverse once to gather values, then stitch a new singly chain from them. The fresh chain matches the input sequence exactly.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the list length. One pass to read plus one to rebuild.\n- **Space Complexity:** O(n) for the new nodes.\n\n## Implementation\n\n```python\nclass Solution:\n def flatten(self, head):\n if not head:\n return None\n dummy = ListNode(0)\n tail = dummy\n cur = head\n while cur:\n tail.next = ListNode(cur.val)\n tail = tail.next\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 Flatten(head *ListNode) *ListNode {\n \n}", "python": "# Definition for singly-linked list.\n# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def flatten(self, 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* flatten(ListNode* head) {\n \n }\n};"}, "fn": "flatten", "params": [{"name": "head", "type": "list_node"}], "outputType": "list_node", "tests": [["[1,2,3,4,5,6]"], ["[1,2,3]"], ["[]"], ["[1]"], ["[1,2]"], ["[7,8,9,10]"], ["[5]"], ["[1,2,3,4,5]"], ["[10,20,30]"], ["[4,4,4]"], ["[100,200]"], ["[1,2,3,4,5,6,7,8,9,10]"], ["[2]"], ["[3]"], ["[1,1,1]"], ["[9,8,7,6,5]"], ["[100]"], ["[1,3,5,7,9]"], ["[2,4,6,8,10]"], ["[11,22,33]"], ["[5,5,5,5,5]"], ["[42]"], ["[999,1000]"], ["[1,2,3,4,5,6,7]"], ["[50,40,30,20,10]"], ["[6,6,6,6]"], ["[123]"], ["[7,7,8,8,9,9]"], ["[100000]"], ["[1,100000]"]], "expected": [[1, 2, 3, 4, 5, 6], [1, 2, 3], null, [1], [1, 2], [7, 8, 9, 10], [5], [1, 2, 3, 4, 5], [10, 20, 30], [4, 4, 4], [100, 200], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], [2], [3], [1, 1, 1], [9, 8, 7, 6, 5], [100], [1, 3, 5, 7, 9], [2, 4, 6, 8, 10], [11, 22, 33], [5, 5, 5, 5, 5], [42], [999, 1000], [1, 2, 3, 4, 5, 6, 7], [50, 40, 30, 20, 10], [6, 6, 6, 6], [123], [7, 7, 8, 8, 9, 9], [100000], [1, 100000]], "loose": false}

package/data/problems/flatten-binary-tree-to-linked-list.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "292", "slug": "flatten-binary-tree-to-linked-list", "id": 292, "title": "Flatten Binary Tree to Linked List", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/flatten-binary-tree-to-linked-list/", "examples": [{"input": "root = [1,2,5,3,4,null,6]", "output": "[1,null,2,null,3,null,4,null,5,null,6]", "explanation": "Preorder visits 1,2,3,4,5,6; the flattened chain links them via right pointers with all left pointers empty."}, {"input": "root = []", "output": "[]", "explanation": "Nothing to flatten."}, {"input": "root = [0]", "output": "[0]", "explanation": "A lone node is already flat."}], "hints": ["The final right-leaning chain follows preorder: root, left subtree, then right subtree.", "One simple route gathers preorder values first, then rebuilds a chain of right-only nodes.", "An in-place alternative rewires each node by splicing its left subtree between itself and its right subtree.", "Adaptation: the original edits in place with no return; here return the flattened root for checking."], "statement": "Reshape a binary tree into a right-leaning chain that follows preorder visiting order.\n\nAfter flattening, every node's left pointer must be empty and each right pointer must lead to the next node in a preorder walk (root, then left subtree, then right subtree). The node values stay the same; only the links change.\n\nReturn the root of the reshaped tree.\n\n**Constraints:**\n- `0 <= number of nodes <= 2000`\n- `-100 <= Node.val <= 100`\n\n**Adaptation note:** The classic task rewrites the tree in place and returns nothing. This version returns the flattened root so the result can be serialized and graded.\n", "solution": "## Approach\n\nA preorder walk lists the exact order the final chain must follow. Rebuilding a chain of right-only nodes from that list is straightforward: each new node takes the next preorder value with an empty left pointer. This uses extra nodes but keeps the logic clear; an in-place splice achieves the same order without allocation.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), one preorder pass plus one chain build.\n- **Space Complexity:** O(n) for the value list (O(h) with an in-place splice).\n\n## Implementation\n\n```python\nclass Solution:\n def flatten(self, root):\n if not root:\n return None\n vals = []\n def pre(n):\n if not n:\n return\n vals.append(n.val)\n pre(n.left)\n pre(n.right)\n pre(root)\n root.val = vals[0]\n root.left = None\n cur = root\n for v in vals[1:]:\n cur.right = TreeNode(v)\n cur = cur.right\n cur.left = None\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 Flatten(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 flatten(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* flatten(TreeNode* root) {\n \n }\n};"}, "fn": "flatten", "params": [{"name": "root", "type": "tree_node", "visualizeType": "tree_node"}], "outputType": "tree_node", "tests": [["[1,2,5,3,4,null,6]"], ["[]"], ["[0]"], ["[1,2,3]"], ["[1,null,2,3,4]"], ["[1,2,null,3]"], ["[1,2,3,4,5]"], ["[2,1,3]"], ["[3,1,4,null,2]"], ["[1,2,3,4,5,6,7]"], ["[5,4,6,3,null,null,7]"], ["[10,5,15,2,7]"], ["[1,null,2,null,3,null,4]"], ["[4,2,6,1,3,5,7]"], ["[0,0,0]"], ["[-5,-10,0]"], ["[100,50,150,25,75]"], ["[1,2,3,null,4,5,6]"], ["[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]"], ["[9,5,12,3,7,10,15]"], ["[15,10,20,8,12,17,25]"]], "expected": null, "loose": false}

package/data/problems/flatten-nested-list-iterator.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "424", "slug": "flatten-nested-list-iterator", "id": 424, "title": "Flatten Nested List Iterator", "difficulty": "Medium", "category": "stack", "link": "https://leetcode.com/problems/flatten-nested-list-iterator/", "examples": [{"input": "nestedList = \"[[1,1],2,[1,1]]\"", "output": "[1,1,2,1,1]", "explanation": "Left-to-right depth-first reading yields 1,1,2,1,1."}, {"input": "nestedList = \"[1,[4,[6]]]\"", "output": "[1,4,6]", "explanation": "Descending level by level gives 1, then 4, then 6."}, {"input": "nestedList = \"[]\"", "output": "[]", "explanation": "Nothing is stored, so the result is empty."}], "hints": ["Adaptation: simulate what repeated next calls would produce and return it as one array.", "Parse recursively (a list) or iteratively with a stack, appending integers in encounter order."], "statement": "This is an offline adaptation of an iterator task. Instead of writing a class with `next` and `hasNext`, you write one function that returns the whole flattened order at once:\n\n```\nflattenNestedList(nestedList)\n```\n\n`nestedList` arrives serialized as text, e.g. `\"[[1,1],2,[1,1]]\"`: brackets delimit lists, bare numbers (possibly negative) are integers, commas separate elements. Flattening means reading all integers in left-to-right order, descending into every nested list. Return them as an array in that order.\n\n**Constraints:**\n- `1 <= nestedList.length <= 500`\n- Integers lie in `[-10^6, 10^6]`.\n- The text is always a valid nested list.\n\n**Adaptation note:** The classic version exposes a `NestedIterator` class over `NestedInteger` objects. Here the structure is passed as a serialized `string` and you return the full flattened `int_array`.\n", "solution": "## Approach\n\nParse the serialization with a small recursive reader: on `[` consume elements until the matching `]`, skipping commas; on a digit or minus sign read the full integer and append it. Because elements are visited strictly left to right and sublists are expanded in place, appended integers already appear in flattened order, matching exactly what successive iterator steps would emit.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the text length. Each character is consumed once.\n- **Space Complexity:** O(d + m), with d nesting depth for recursion and m integers of output.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def flattenNestedList(self, nestedList: str) -> List[int]:\n self.s = nestedList\n self.i = 0\n out = []\n def parse():\n if self.i >= len(self.s):\n return\n if self.s[self.i] == '[':\n self.i += 1\n while self.i < len(self.s) and self.s[self.i] != ']':\n if self.s[self.i] == ',':\n self.i += 1\n else:\n parse()\n self.i += 1\n else:\n sign = 1\n if self.s[self.i] == '-':\n sign = -1\n self.i += 1\n num = 0\n while self.i < len(self.s) and self.s[self.i].isdigit():\n num = num * 10 + int(self.s[self.i])\n self.i += 1\n out.append(sign * num)\n parse()\n return out\n```\n", "starter": {"go": "package main\n\nfunc FlattenNestedList(nestedList string) []int {\n return []int{}\n}", "python": "from typing import List\nclass Solution:\n def flattenNestedList(self, nestedList: str) -> List[int]:\n return []\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n vector<int> flattenNestedList(string nestedList) {\n return {};\n }\n};"}, "fn": "flattenNestedList", "params": [{"name": "nestedList", "type": "string"}], "outputType": "int_array", "tests": [["[[1,1],2,[1,1]]"], ["[1,[4,[6]]]"], ["[]"], ["[1]"], ["[1,2,3]"], ["[[1],[2],[3]]"], ["[[1,2],[3,4]]"], ["[[-1],[-2]]"], ["[[[1]]]"], ["[[[]]]"], ["[[],[1],[],[2,3]]"], ["[10,20,30]"], ["[[10,20],30]"], ["[1,[2,[3,[4]]]]"], ["[[0,0],0]"], ["[5]"], ["[-5]"], ["[[1],[2,[3]]]"], ["[[100]]"], ["[1,[1,[1,[1]]]]"], ["[[2],3,[4,[5]]]"], ["[[-1,2],[-3,4]]"], ["[[1,1],2,[1,1],3]"], ["[7,[7,[7,[7]]]]"], ["[[1,2,3],[4,5]]"], ["[0]"], ["[[1,1],[1,1]]"]], "expected": [[1, 1, 2, 1, 1], [1, 4, 6], [], [1], [1, 2, 3], [1, 2, 3], [1, 2, 3, 4], [-1, -2], [1], [], [1, 2, 3], [10, 20, 30], [10, 20, 30], [1, 2, 3, 4], [0, 0, 0], [5], [-5], [1, 2, 3], [100], [1, 1, 1, 1], [2, 3, 4, 5], [-1, 2, -3, 4], [1, 1, 2, 1, 1, 3], [7, 7, 7, 7], [1, 2, 3, 4, 5], [0], [1, 1, 1, 1]], "loose": false}

package/data/problems/flip-binary-tree-to-match-preorder-traversal.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "957", "slug": "flip-binary-tree-to-match-preorder-traversal", "id": 957, "title": "Flip Binary Tree To Match Preorder Traversal", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/flip-binary-tree-to-match-preorder-traversal/", "examples": [{"input": "root = [1,2], voyage = [2,1]", "output": "[-1]", "explanation": "Flipping never changes the root value, so a voyage starting with 2 cannot be produced from a tree rooted at 1."}, {"input": "root = [1,2,3], voyage = [1,3,2]", "output": "[1]", "explanation": "Swapping the two children of node 1 makes the preorder visit 1, then 3, then 2."}, {"input": "root = [1,2,3], voyage = [1,2,3]", "output": "[]", "explanation": "The tree already visits nodes in the requested order, so nothing is flipped."}], "hints": ["Walk the tree in preorder while consuming the voyage array with a shared index pointer.", "When a node has a left child whose value is not the next voyage entry, you must flip that node (if possible) and visit the right subtree first.", "If any node value mismatches the expected voyage entry, or a needed child is missing, the answer is [-1]."], "statement": "You are given the root of a binary tree and an integer array `voyage` that lists node values in some desired preorder order.\n\nA flip operation swaps the left and right child of a chosen node. Performing any number of flips (each node flipped at most once conceptually) changes the preorder visit order of the tree.\n\nReturn the values of the flipped nodes in the order they are flipped. When several answers exist the preorder walk described below yields the canonical one. When the voyage cannot be achieved, return `[-1]`. When no flip is needed, return an empty list.\n\nTo determine the flips, traverse the tree in preorder while reading `voyage` from left to right with a single position pointer:\n\n- Each visited node must equal the current voyage entry; otherwise the task is impossible.\n- If the node has a left child and that child does not equal the next voyage entry, flip the node (record its value) and traverse the right child before the left child.\n- Otherwise traverse left before right as usual.\n\n**Constraints:**\n- `1 <= number of nodes <= 100`\n- `1 <= node values, voyage[i] <= 100`\n- `voyage.length == number of nodes`\n- Values in the tree are unique.\n", "solution": "## Approach\n\nKeep a position pointer into the voyage array and walk the tree in preorder. Each visited node must match the current voyage entry, otherwise the voyage is unreachable. When the left child exists but its value differs from the next voyage entry, record a flip at the current node and visit the right subtree first; otherwise visit left first. A single depth-first pass implements this rule.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of nodes. Each node is visited once.\n- **Space Complexity:** O(h) for recursion depth, where h is the tree height, plus O(n) for the flip list in the worst case.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def flipMatchVoyage(self, root, voyage: List[int]) -> List[int]:\n self.i = 0\n self.flips = []\n def dfs(node):\n if not node:\n return True\n if self.i >= len(voyage) or node.val != voyage[self.i]:\n return False\n self.i += 1\n left = node.left\n if left is not None and self.i < len(voyage) and left.val != voyage[self.i]:\n self.flips.append(node.val)\n if not dfs(node.right):\n return False\n if not dfs(node.left):\n return False\n else:\n if not dfs(node.left):\n return False\n if not dfs(node.right):\n return False\n return True\n if not dfs(root):\n return [-1]\n return self.flips\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 FlipMatchVoyage(root *TreeNode, voyage []int) []int {\n \n}", "python": "# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nfrom typing import List\nclass Solution:\n def flipMatchVoyage(self, root, voyage: List[int]) -> List[int]:\n pass", "cpp": "/*\nDefinition for a binary tree node.\nstruct TreeNode {\n int val;\n TreeNode *left;\n TreeNode *right;\n TreeNode(): val(0), left(nullptr), right(nullptr) {}\n TreeNode(int x): val(x), left(nullptr), right(nullptr) {}\n TreeNode(int x, TreeNode* left, TreeNode* right): val(x), left(left), right(right) {}\n};\n*/\n#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<int> flipMatchVoyage(TreeNode* root, vector<int>& voyage) {\n return {};\n }\n};"}, "fn": "flipMatchVoyage", "params": [{"name": "root", "type": "tree_node"}, {"name": "voyage", "type": "int_array"}], "outputType": "int_list", "tests": [["[1,2]", "[2,1]"], ["[1,2,3]", "[1,3,2]"], ["[1,2,3]", "[1,2,3]"], ["[1,null,2]", "[1,2]"], ["[1,null,2]", "[1,2]"], ["[1,2,null,3]", "[1,2,3]"], ["[1,2,null,3]", "[1,3,2]"], ["[1,2,3,4,5,6,7]", "[1,2,4,5,3,6,7]"], ["[1,2,3,4,5,6,7]", "[1,3,7,6,2,5,4]"], ["[1,2,3,4,5,6,7]", "[1,2,4,5,3,7,6]"], ["[1,2,3]", "[1,3,4]"], ["[1]", "[1]"], ["[1]", "[2]"], ["[2,1,3]", "[2,3,1]"], ["[4,2,7,1,3,6,9]", "[4,2,1,3,7,6,9]"], ["[4,2,7,1,3,6,9]", "[4,7,9,6,2,3,1]"], ["[1,2,3,null,null,4,5]", "[1,2,3,4,5]"], ["[1,2,3,null,null,4,5]", "[1,3,5,4,2]"], ["[1,2,3,4,null,null,5]", "[1,2,4,3,5]"], ["[1,2,3,4,null,null,5]", "[1,3,5,2,4]"], ["[1,2,null,3,null,4]", "[1,2,3,4]"], ["[1,null,2,null,3]", "[1,2,3]"], ["[1,null,2,null,3]", "[1,3,2]"], ["[3,1,4,null,2]", "[3,1,2,4]"], ["[3,1,4,null,2]", "[3,4,1,2]"], ["[5,3,8,1,4,7,9]", "[5,3,1,4,8,7,9]"], ["[5,3,8,1,4,7,9]", "[5,8,9,7,3,4,1]"], ["[1,2,3,4,5]", "[1,2,5,4,3]"]], "expected": [[-1], [1], [], [], [], [], [-1], [], [1, 3, 2], [3], [-1], [], [-1], [2], [], [4, 7, 2], [], [1, 3], [], [1], [], [], [-1], [], [3], [], [5, 8, 3], [2]], "loose": false}

package/data/problems/flip-equivalent-binary-trees.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "938", "slug": "flip-equivalent-binary-trees", "id": 938, "title": "Flip Equivalent Binary Trees", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/flip-equivalent-binary-trees/", "examples": [{"input": "root1 = [1,2,3,4,5,6,null,null,null,7,8], root2 = [1,3,2,null,6,4,5,null,null,null,null,8,7]", "output": "true", "explanation": "Flips at a few nodes align both trees."}, {"input": "root1 = [], root2 = []", "output": "true", "explanation": "Empty trees match."}, {"input": "root1 = [], root2 = [1]", "output": "false", "explanation": "A missing node cannot appear."}], "hints": ["Matching roots must hold equal values; empty trees match only each other.", "For non-empty roots, try both alignments: straight (left-left, right-right) and crossed (left-right, right-left); one of them must fully match."], "statement": "Test whether two binary trees can be made identical by swapping child pairs.\n\nOne flip picks any node and exchanges its left and right subtrees. Applying flips anywhere, any number of times, reshapes a tree without changing its values.\n\nGiven the roots `root1` and `root2`, return `true` when the first tree can be turned into the second through flips, else `false`. An empty tree is written `[]`.\n\n**Constraints:**\n- Each tree holds between 0 and 100 nodes.\n- Node values lie in `0..99` and are unique within a tree.\n", "solution": "## Approach\n\nCompare the two trees recursively. Empty pairs match, half-empty pairs fail, and differing root values fail. Otherwise the answer is true when either the straight pairing (left with left, right with right) or the crossed pairing (left with right, right with left) fully matches, which models using or skipping a flip at the current node.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) in practice for these sizes; each node pair is examined a small number of times.\n- **Space Complexity:** O(h) call stack for trees of height h.\n\n## Implementation\n\n```python\nclass Solution:\n def flipEquiv(self, root1, root2) -> bool:\n if root1 is None and root2 is None:\n return True\n if root1 is None or root2 is None:\n return False\n if root1.val != root2.val:\n return False\n straight = self.flipEquiv(root1.left, root2.left) and self.flipEquiv(root1.right, root2.right)\n crossed = self.flipEquiv(root1.left, root2.right) and self.flipEquiv(root1.right, root2.left)\n return straight or crossed\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 FlipEquiv(root1 *TreeNode, root2 *TreeNode) bool {\n return false\n}", "python": "# Definition for a binary tree node.\n# class TreeNode:\n# def __init__(self, val=0, left=None, right=None):\n# self.val = val\n# self.left = left\n# self.right = right\nclass Solution:\n def flipEquiv(self, root1, root2) -> bool:\n pass", "cpp": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n * int val;\n * TreeNode *left;\n * TreeNode *right;\n * TreeNode() : val(0), left(nullptr), right(nullptr) {}\n * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n * TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}\n * };\n */\nclass Solution {\npublic:\n bool flipEquiv(TreeNode* root1, TreeNode* root2) {\n return false;\n }\n};"}, "fn": "flipEquiv", "params": [{"name": "root1", "type": "tree_node"}, {"name": "root2", "type": "tree_node"}], "outputType": "boolean", "tests": [["[1,2,3,4,5,6,null,null,null,7,8]", "[1,3,2,null,6,4,5,null,null,null,null,8,7]"], ["[]", "[]"], ["[]", "[1]"], ["[1]", "[1]"], ["[1]", "[2]"], ["[1,2,3]", "[1,3,2]"], ["[1,2,3]", "[1,2,3]"], ["[0,1,2]", "[0,2,1]"], ["[1,2]", "[1,null,2]"], ["[1,2,null,3]", "[1,2,null,null,3]"], ["[1,2,3,4]", "[1,2,3,4]"], ["[1,2,3,4,5]", "[1,2,3,4,6]"], ["[5,3,8,1,4,7,9]", "[5,8,3,9,7,4,1]"], ["[1,2,3,null,4]", "[1,3,2,4]"], ["[2,1,3]", "[2,3,1]"], ["[0]", "[0]"], ["[0]", "[1]"], ["[1,2,3,4,5,6,7]", "[1,3,2,7,6,5,4]"], ["[1,2,3,4,5,6,7]", "[1,2,3,4,5,6,8]"], ["[4,2,7,1,3,6,9]", "[4,7,2,9,6,3,1]"], ["[1,null,2,null,3]", "[1,2,null,3]"], ["[1,2,3,null,null,4,5]", "[1,3,2,5,4]"], ["[10,5,15]", "[10,15,5]"], ["[10,5,15]", "[10,5,15]"], ["[3,1,4,null,2]", "[3,4,1,2]"], ["[8,3,10,1,6,null,14,null,null,4,7,13]", "[8,3,10,1,6,null,14,null,null,4,7,13]"], ["[8,3,10,1,6,null,14,null,null,4,7,13]", "[8,10,3,14,null,6,1,13,null,7,4]"], ["[1,2,3]", "[4,5,6]"]], "expected": [true, true, false, true, false, true, true, true, true, true, true, false, true, false, true, true, false, true, false, true, true, true, true, true, false, true, true, false], "loose": false}

package/data/problems/flip-game-ii.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "390", "slug": "flip-game-ii", "id": 390, "title": "Flip Game II", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/flip-game-ii/", "examples": [{"input": "currentState = \"++++\"", "output": "true", "explanation": "Flipping the middle pair leaves \"+--+\" with no reply."}, {"input": "currentState = \"+\"", "output": "false", "explanation": "No move exists for the first player."}, {"input": "currentState = \"+++++\"", "output": "false", "explanation": "Each possible first flip hands the opponent a winning board."}], "hints": ["A board is winning when some legal flip leads to a board that is losing for the player to move.", "Boards with no flippable pair are losing; build up from there with memoised search.", "Flipping splits the board into independent left and right parts, so identical substrings share results through memoisation."], "statement": "Consider the same board and move as in Flip Game: a move flips one occurrence of `\"++\"`\ninto `\"--\"`. Two players now alternate moves, and the player that cannot move loses. Both\nplay perfectly. Given the starting board `currentState`, decide whether the player to move\nhas a forced win.\n\n**Constraints:**\n- `1 <= currentState.length <= 60`\n- `currentState` contains only `'+'` and `'-'`.\n", "solution": "## Approach\n\nDepth-first game search with memoisation: try every flip, and win if any reply position is losing for the opponent. Boards without moves lose.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(2^n)\n- **Space Complexity:** O(2^n)\n\n## Implementation\n\n```python\nclass Solution:\n def canWin(self, currentState: str) -> bool:\n from functools import lru_cache\n @lru_cache(maxsize=None)\n def win(s: str) -> bool:\n c = list(s)\n for i in range(len(c) - 1):\n if c[i] == '+' and c[i + 1] == '+':\n c[i] = c[i + 1] = '-'\n nxt = ''.join(c)\n c[i] = c[i + 1] = '+'\n if not win(nxt):\n return True\n return False\n return win(currentState)\n```\n", "starter": {"go": "package main\n\nfunc CanWin(currentState string) bool {\n return false\n}", "python": "class Solution:\n def canWin(self, currentState: str) -> bool:\n ", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n bool canWin(string currentState) {\n return false;\n }\n};"}, "fn": "canWin", "params": [{"name": "currentState", "type": "string"}], "outputType": "boolean", "tests": [["++++"], ["+"], ["+++++"], ["-"], ["--"], ["++"], ["---"], ["+++"], ["------"], ["++++++"], ["+++++++"], ["++++++++"], ["+-"], ["-+"], ["+--+"], ["++--"], ["--++"], ["-++-"], ["++-++"], ["+-++-"], ["--++--"], ["++--++"], ["+-+-+-"], ["++++++++++++"], ["+++-+++"], ["-++-++-"], ["++-----++"], ["+++++++++"]], "expected": [true, false, false, false, false, true, false, true, false, true, true, true, false, false, false, true, true, true, false, true, true, false, false, true, false, false, false, false], "loose": false}

package/data/problems/flip-game.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "389", "slug": "flip-game", "id": 389, "title": "Flip Game", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/flip-game/", "examples": [{"input": "currentState = \"++++\"", "output": "[\"--++\",\"+--+\",\"++--\"]", "explanation": "Each of the three adjacent pairs flips once."}, {"input": "currentState = \"--++\"", "output": "[\"----\"]", "explanation": "Only the trailing pair can flip."}, {"input": "currentState = \"-+-\"", "output": "[]", "explanation": "No \"++\" exists, so no move is possible."}], "hints": ["Scan every adjacent pair of positions once and test whether both hold '+'..., hide the literal: say both hold a plus sign.", "Build each answer by copying the board and flipping just the chosen pair.", "Boards with no flippable pair produce an empty result list."], "statement": "You are given a string holding only `'+'` and `'-'` characters. A single move picks an\noccurrence of `\"++\"` and flips both characters to `\"--\"`. Return every distinct board that\ncan be reached with exactly one move. The order of the returned boards does not matter.\n\n**Constraints:**\n- `1 <= currentState.length <= 100`\n- `currentState` contains only `'+'` and `'-'`.\n", "solution": "## Approach\n\nSlide a window of width two across the board; whenever both cells show '+', emit a copy with that pair flipped to '-'.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2)\n- **Space Complexity:** O(n)\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def generatePossibleNextMoves(self, currentState: str) -> List[str]:\n res = []\n for i in range(len(currentState) - 1):\n if currentState[i] == '+' and currentState[i + 1] == '+':\n res.append(currentState[:i] + '--' + currentState[i + 2:])\n return res\n```\n", "starter": {"go": "package main\n\nfunc GeneratePossibleNextMoves(currentState string) []string {\n return nil\n}", "python": "from typing import List\nclass Solution:\n def generatePossibleNextMoves(self, currentState: str) -> List[str]:\n ", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n vector<string> generatePossibleNextMoves(string currentState) {\n return {};\n }\n};"}, "fn": "generatePossibleNextMoves", "params": [{"name": "currentState", "type": "string"}], "outputType": "string_list", "tests": [["++++"], ["--++"], ["-+-"], ["+"], ["-"], ["++"], ["--"], ["+-"], ["-+"], ["+++"], ["---"], ["+--+"], ["++--"], ["--++"], ["-++-"], ["+++++"], ["-----"], ["++-++"], ["+-+-"], ["-+-+"], ["+++-++"], ["-++"], ["++-"], ["+-++-+"], ["++++++++"], ["--+--+"], ["+-+++"], ["++--++"]], "expected": [["--++", "+--+", "++--"], ["----"], [], [], [], ["--"], [], [], [], ["--+", "+--"], [], [], ["----"], ["----"], ["----"], ["--+++", "+--++", "++--+", "+++--"], [], ["---++", "++---"], [], [], ["--+-++", "+---++", "+++---"], ["---"], ["---"], ["+----+"], ["--++++++", "+--+++++", "++--++++", "+++--+++", "++++--++", "+++++--+", "++++++--"], [], ["+---+", "+-+--"], ["----++", "++----"]], "loose": true}

package/data/problems/flip-string-to-monotone-increasing.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "913", "slug": "flip-string-to-monotone-increasing", "id": 913, "title": "Flip String to Monotone Increasing", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/flip-string-to-monotone-increasing/", "examples": [{"input": "s = \"00110\"", "output": "1", "explanation": "Flip the last '0' to '1'."}, {"input": "s = \"010110\"", "output": "2", "explanation": "Two flips reach a block of zeros then ones."}, {"input": "s = \"00011000\"", "output": "2", "explanation": "Clearing the two ones leaves all zeros."}], "hints": ["Every monotone string is zeros then ones, so the split point is the only choice.", "While scanning, remember how many ones have appeared; they are the cost of forcing all zeros.", "For each zero, compare flipping it versus flipping all prior ones."], "statement": "You are given a binary string `s` containing only `'0'` and `'1'`. In one move you may flip any single character (`'0'` to `'1'` or `'1'` to `'0'`).\n\nA string is monotone increasing when it consists of some number of `'0'`s followed by some number of `'1'`s (either part may be empty). Return the smallest number of flips needed to make `s` monotone increasing.\n\n**Constraints:**\n- `1 <= s.length <= 100000`\n- `s` contains only `'0'` and `'1'`.\n", "solution": "## Approach\n\nScan once while counting how many `'1'`s have been seen. Keep `flips`, the cheapest cost for the prefix so far. On `'1'` increment the ones count; on `'0'` we either flip this zero to one (`flips + 1`) or flip all previous ones to zero (`ones`), taking the cheaper option.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the length of `s`. One left-to-right pass.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nclass Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n ones = 0\n flips = 0\n for c in s:\n if c == '1':\n ones += 1\n else:\n flips = min(flips + 1, ones)\n return flips\n```\n", "starter": {"go": "package main\n\nfunc MinFlipsMonoIncr(s string) int {\n return 0\n}", "python": "class Solution:\n def minFlipsMonoIncr(self, s: str) -> int:\n pass", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n int minFlipsMonoIncr(string s) {\n return 0;\n }\n};"}, "fn": "minFlipsMonoIncr", "params": [{"name": "s", "type": "string"}], "outputType": "int", "tests": [["00110"], ["010110"], ["00011000"], ["0"], ["1"], ["00"], ["11"], ["01"], ["10"], ["00000"], ["11111"], ["010101"], ["101010"], ["00110011"], ["11001100"], ["000111"], ["111000"], ["01000"], ["10111"], ["00100"], ["10011"], ["0110"], ["0101"], ["1010"], ["0001"], ["1110"], ["01111"], ["00001"]], "expected": [1, 2, 2, 0, 0, 0, 0, 0, 1, 0, 0, 2, 3, 2, 4, 0, 3, 1, 1, 1, 1, 1, 1, 2, 0, 1, 0, 0], "loose": false}

package/data/problems/flipping-an-image.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "830", "slug": "flipping-an-image", "id": 830, "title": "Flipping an Image", "difficulty": "Easy", "category": "matrix", "link": "https://leetcode.com/problems/flipping-an-image/", "examples": [{"input": "image = [[1,1,0],[1,0,1],[0,0,0]]", "output": "[[1,0,0],[0,1,0],[1,1,1]]", "explanation": "Mirror each row, then invert every bit."}, {"input": "image = [[1,1,0,0],[1,0,0,1],[0,1,1,1],[1,0,1,0]]", "output": "[[1,1,0,0],[0,1,1,0],[0,0,0,1],[1,0,1,0]]"}], "hints": ["Mirroring plus inverting can be done in one pass by reading each row from the far end while flipping the bit.", "Handle odd-length rows carefully so the middle cell is only inverted, not swapped with itself twice.", "XOR with 1 is a compact way to invert a binary cell."], "statement": "You are given a binary matrix `image` where each cell is `0` or `1`. Transform it in two steps: first mirror every row horizontally (the leftmost cell swaps with the rightmost, and so on), then flip every bit (`0` becomes `1` and `1` becomes `0`). Return the resulting matrix.\n\n**Constraints:**\n- `1 <= image.length <= 20`\n- `1 <= image[i].length <= 20`\n- `image[i][j]` is `0` or `1`\n", "solution": "## Approach\n\nBuild a fresh matrix where each output cell copies the horizontally mirrored input cell with its bit flipped. Reading row i from right to left while writing left to right combines the mirror and the inversion in a single pass, and XOR with 1 performs the bit flip.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n*m) for an n by m matrix.\n- **Space Complexity:** O(n*m) for the result matrix.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def flipAndInvertImage(self, image: List[List[int]]) -> List[List[int]]:\n return [[cell ^ 1 for cell in row[::-1]] for row in image]\n```\n", "starter": {"go": "package main\n\nfunc FlipAndInvertImage(image [][]int) [][]int {\n return nil\n}", "python": "from typing import List\nclass Solution:\n def flipAndInvertImage(self, image: List[List[int]]) -> List[List[int]]:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<vector<int>> flipAndInvertImage(vector<vector<int>>& image) {\n return {};\n }\n};"}, "fn": "flipAndInvertImage", "params": [{"name": "image", "type": "int_array_2d"}], "outputType": "int_array_2d", "tests": [["[[1, 1, 0], [1, 0, 1], [0, 0, 0]]"], ["[[1, 1, 0, 0], [1, 0, 0, 1], [0, 1, 1, 1], [1, 0, 1, 0]]"], ["[[0]]"], ["[[1]]"], ["[[0, 1], [1, 0]]"], ["[[1, 1], [0, 0]]"], ["[[0, 0, 0], [1, 1, 1]]"], ["[[1, 0, 1], [0, 1, 0]]"], ["[[1, 0]]"], ["[[0, 1, 0, 1, 0]]"], ["[[1, 1, 1, 1, 1]]"], ["[[0, 0, 0, 0, 0]]"], ["[[1, 0, 0], [0, 1, 0], [0, 0, 1]]"], ["[[0, 1, 1], [1, 0, 0], [1, 1, 0]]"], ["[[1, 1, 0, 1], [0, 0, 1, 0]]"], ["[[1, 0, 1, 0, 1], [0, 1, 0, 1, 0], [1, 1, 1, 0, 0]]"], ["[[0, 0], [0, 0], [1, 1]]"], ["[[1]]"], ["[[1, 1, 1], [1, 1, 1], [1, 1, 1]]"], ["[[0, 0, 0], [0, 0, 0], [0, 0, 0]]"], ["[[1, 0, 1, 0], [0, 1, 0, 1], [1, 1, 0, 0], [0, 0, 1, 1]]"], ["[[0, 1, 0], [1, 0, 1], [0, 1, 0], [1, 0, 1]]"], ["[[1, 0, 0, 0, 1]]"], ["[[0, 1, 1, 1, 0, 0]]"], ["[[1, 0, 1]]"], ["[[0, 1, 0, 1], [1, 0, 1, 0], [0, 0, 0, 0]]"], ["[[1, 1, 0, 0, 1, 1], [0, 0, 1, 1, 0, 0]]"], ["[[0, 1], [1, 1], [0, 0], [1, 0]]"]], "expected": [[[1, 0, 0], [0, 1, 0], [1, 1, 1]], [[1, 1, 0, 0], [0, 1, 1, 0], [0, 0, 0, 1], [1, 0, 1, 0]], [[1]], [[0]], [[0, 1], [1, 0]], [[0, 0], [1, 1]], [[1, 1, 1], [0, 0, 0]], [[0, 1, 0], [1, 0, 1]], [[1, 0]], [[1, 0, 1, 0, 1]], [[0, 0, 0, 0, 0]], [[1, 1, 1, 1, 1]], [[1, 1, 0], [1, 0, 1], [0, 1, 1]], [[0, 0, 1], [1, 1, 0], [1, 0, 0]], [[0, 1, 0, 0], [1, 0, 1, 1]], [[0, 1, 0, 1, 0], [1, 0, 1, 0, 1], [1, 1, 0, 0, 0]], [[1, 1], [1, 1], [0, 0]], [[0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[1, 1, 1], [1, 1, 1], [1, 1, 1]], [[1, 0, 1, 0], [0, 1, 0, 1], [1, 1, 0, 0], [0, 0, 1, 1]], [[1, 0, 1], [0, 1, 0], [1, 0, 1], [0, 1, 0]], [[0, 1, 1, 1, 0]], [[1, 1, 0, 0, 0, 1]], [[0, 1, 0]], [[0, 1, 0, 1], [1, 0, 1, 0], [1, 1, 1, 1]], [[0, 0, 1, 1, 0, 0], [1, 1, 0, 0, 1, 1]], [[0, 1], [0, 0], [1, 1], [1, 0]]], "loose": false}

package/data/problems/flood-fill.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "740", "slug": "flood-fill", "id": 740, "title": "Flood Fill", "difficulty": "Easy", "category": "matrix", "link": "https://leetcode.com/problems/flood-fill/", "examples": [{"input": "image = [[1,1,1],[1,1,0],[1,0,1]], sr = 1, sc = 1, color = 2", "output": "[[2,2,2],[2,2,0],[2,0,1]]", "explanation": "The 4-connected block of 1s is repainted to 2."}, {"input": "image = [[0,0,0],[0,0,0]], sr = 0, sc = 0, color = 0", "output": "[[0,0,0],[0,0,0]]"}, {"input": "image = [[1,2,1],[2,1,2],[1,2,1]], sr = 1, sc = 1, color = 9", "output": "[[1,2,1],[2,9,2],[1,2,1]]"}], "hints": ["Remember the starting cell's original color first; if it already equals the new color, return immediately.", "Explore with depth-first or breadth-first search, stepping only to in-bounds neighbours holding the original color.", "Recolor on visit so cells are never processed twice."], "statement": "You are given a picture as a grid of color numbers, a starting cell `(sr, sc)`, and a new color value. Recolor the starting cell plus every cell connected to it through shared sides (up, down, left, right) that currently holds the same original color, painting all of them with the new color.\n\nCells joined only diagonally do not count as connected. When the new color already equals the starting cell's color, the picture stays unchanged.\n\nReturn the picture after the recoloring.\n\n**Constraints:**\n- `1 <= image.length, image[i].length <= 50`\n- `0 <= image[i][j], color < 65536`\n- `0 <= sr < image.length`, `0 <= sc < image[i].length`\n", "solution": "## Approach\n\nSnapshot the color of the start cell. If it already matches the target, there is nothing to do. Otherwise run an explicit stack (depth-first search) from the start: pop a cell, paint its four orthogonal neighbours when they still hold the old color, and push them. Painting on discovery guarantees each cell is handled once.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n) for an m-by-n picture, each cell visited at most once.\n- **Space Complexity:** O(m * n) worst case for the stack.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def floodFill(self, image: List[List[int]], sr: int, sc: int, color: int) -> List[List[int]]:\n old = image[sr][sc]\n if old == color:\n return image\n m, n = len(image), len(image[0])\n stack = [(sr, sc)]\n image[sr][sc] = color\n while stack:\n r, c = stack.pop()\n for dr, dc in ((1, 0), (-1, 0), (0, 1), (0, -1)):\n nr, nc = r + dr, c + dc\n if 0 <= nr < m and 0 <= nc < n and image[nr][nc] == old:\n image[nr][nc] = color\n stack.append((nr, nc))\n return image\n```\n", "starter": {"go": "package main\n\nfunc FloodFill(image [][]int, sr int, sc int, color int) [][]int {\n return image\n}", "python": "from typing import List\nclass Solution:\n def floodFill(self, image: List[List[int]], sr: int, sc: int, color: int) -> List[List[int]]:\n return image\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<vector<int>> floodFill(vector<vector<int>>& image, int sr, int sc, int color) {\n return image;\n }\n};"}, "fn": "floodFill", "params": [{"name": "image", "type": "int_array_2d"}, {"name": "sr", "type": "int"}, {"name": "sc", "type": "int"}, {"name": "color", "type": "int"}], "outputType": "int_array_2d", "tests": [["[[1,1,1],[1,1,0],[1,0,1]]", "1", "1", "2"], ["[[0,0,0],[0,0,0]]", "0", "0", "0"], ["[[1,2,1],[2,1,2],[1,2,1]]", "1", "1", "9"], ["[[0]]", "0", "0", "1"], ["[[1]]", "0", "0", "1"], ["[[1,1],[1,1]]", "0", "0", "2"], ["[[1,2],[3,4]]", "0", "0", "9"], ["[[1,2],[3,4]]", "1", "1", "0"], ["[[3,3,3],[3,3,3],[3,3,3]]", "1", "1", "5"], ["[[1,1,2],[1,0,2],[0,0,2]]", "0", "0", "3"], ["[[5,5,5,5],[5,4,4,5],[5,4,4,5],[5,5,5,5]]", "1", "1", "7"], ["[[1,2,3],[4,5,6],[7,8,9]]", "2", "2", "0"], ["[[0,1,0],[1,1,1],[0,1,0]]", "1", "1", "2"], ["[[2,2,2],[2,0,2],[2,2,2]]", "1", "1", "1"], ["[[1,0,1],[0,1,0],[1,0,1]]", "0", "0", "8"], ["[[4,4],[4,4],[4,4]]", "2", "1", "4"], ["[[1,2,1,2],[2,1,2,1]]", "0", "1", "3"], ["[[0,0,1],[0,1,1],[1,1,0]]", "2", "2", "5"], ["[[7]]", "0", "0", "7"], ["[[1,1,1,1],[1,0,0,1],[1,0,0,1],[1,1,1,1]]", "1", "1", "2"], ["[[9,9],[9,8]]", "0", "0", "8"], ["[[1,3,1],[1,1,1],[3,1,3]]", "1", "0", "6"], ["[[0,2,0,2],[2,0,2,0],[0,2,0,2]]", "0", "0", "1"], ["[[5,1,5],[1,1,1],[5,1,5]]", "1", "1", "5"], ["[[100,100],[100,200]]", "0", "1", "300"], ["[[1,2,3,4],[5,1,1,4],[9,1,1,4]]", "1", "1", "0"], ["[[6,6,6],[6,1,6],[6,6,6]]", "1", "1", "2"], ["[[0,0,0,0],[0,1,1,0],[0,1,1,0],[0,0,0,0]]", "0", "0", "9"]], "expected": [[[2, 2, 2], [2, 2, 0], [2, 0, 1]], [[0, 0, 0], [0, 0, 0]], [[1, 2, 1], [2, 9, 2], [1, 2, 1]], [[1]], [[1]], [[2, 2], [2, 2]], [[9, 2], [3, 4]], [[1, 2], [3, 0]], [[5, 5, 5], [5, 5, 5], [5, 5, 5]], [[3, 3, 2], [3, 0, 2], [0, 0, 2]], [[5, 5, 5, 5], [5, 7, 7, 5], [5, 7, 7, 5], [5, 5, 5, 5]], [[1, 2, 3], [4, 5, 6], [7, 8, 0]], [[0, 2, 0], [2, 2, 2], [0, 2, 0]], [[2, 2, 2], [2, 1, 2], [2, 2, 2]], [[8, 0, 1], [0, 1, 0], [1, 0, 1]], [[4, 4], [4, 4], [4, 4]], [[1, 3, 1, 2], [2, 1, 2, 1]], [[0, 0, 1], [0, 1, 1], [1, 1, 5]], [[7]], [[1, 1, 1, 1], [1, 2, 2, 1], [1, 2, 2, 1], [1, 1, 1, 1]], [[8, 8], [8, 8]], [[6, 3, 6], [6, 6, 6], [3, 6, 3]], [[1, 2, 0, 2], [2, 0, 2, 0], [0, 2, 0, 2]], [[5, 5, 5], [5, 5, 5], [5, 5, 5]], [[300, 300], [300, 200]], [[1, 2, 3, 4], [5, 0, 0, 4], [9, 0, 0, 4]], [[6, 6, 6], [6, 2, 6], [6, 6, 6]], [[9, 9, 9, 9], [9, 1, 1, 9], [9, 1, 1, 9], [9, 9, 9, 9]]], "loose": false}

package/data/problems/fraction-addition-and-subtraction.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "634", "slug": "fraction-addition-and-subtraction", "id": 634, "title": "Fraction Addition and Subtraction", "difficulty": "Medium", "category": "math", "link": "https://leetcode.com/problems/fraction-addition-and-subtraction/", "examples": [{"input": "expression = \"-1/2+1/2\"", "output": "\"0/1\"", "explanation": "Opposites cancel to zero."}, {"input": "expression = \"-1/2+1/2+1/3\"", "output": "\"1/3\"", "explanation": "The first two cancel, leaving one third."}, {"input": "expression = \"1/3-1/2\"", "output": "\"-1/6\"", "explanation": "A common denominator of 6 gives 2/6 - 3/6."}], "hints": ["Parse optional sign, numerator, slash, denominator repeatedly.", "Keep a running total as numerator/denominator and reduce by gcd after each step.", "Return zero as 0/1 with a positive denominator."], "statement": "An expression strings together fractions with `+` and `-`, for example `\"-1/2+1/2+1/3\"`. Each fraction has a possibly signed numerator and a positive denominator. Evaluate the sum and return it as one reduced fraction `\"num/den\"` with a positive denominator and greatest-common-divisor 1; zero is written `\"0/1\"`.\n\n**Constraints:**\n- Length is at most 500; numerators and denominators are small positive integers.\n- The first fraction may carry a leading sign.\n", "solution": "## Approach\n\nWalk the string pulling optional signs and numerator/denominator pairs. Merge each term into a running total with cross multiplication and divide by the gcd each time so numbers stay small.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(k log C) for k fractions.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nimport math\nclass Solution:\n def fractionAddition(self, expression: str) -> str:\n rn, rd, i, n = 0, 1, 0, len(expression)\n while i < n:\n sign = 1\n if expression[i] in '+-':\n sign = -1 if expression[i] == '-' else 1\n i += 1\n j = i\n while j < n and expression[j].isdigit():\n j += 1\n a = int(expression[i:j]) * sign\n i = j + 1\n j = i\n while j < n and expression[j].isdigit():\n j += 1\n b = int(expression[i:j])\n i = j\n rn = rn * b + a * rd\n rd = rd * b\n g = math.gcd(abs(rn), rd)\n rn //= g; rd //= g\n return f\"{rn}/{rd}\"\n```\n", "starter": {"go": "package main\n\nfunc FractionAddition(expression string) string {\n return \"\"\n}", "python": "class Solution:\n def fractionAddition(self, expression: str) -> str:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n string fractionAddition(string expression) {\n return \"\";\n }\n};"}, "fn": "fractionAddition", "params": [{"name": "expression", "type": "string"}], "outputType": "string", "tests": [["-1/2+1/2"], ["-1/2+1/2+1/3"], ["1/3-1/2"], ["5/3+1/3"], ["1/2-1/2"], ["1/10+2/10"], ["7/2+2/3-3/4"], ["-5/2+10/3+7/9"], ["1/1+1/1"], ["2/4"], ["4/6-1/6"], ["1/6+1/6"], ["3/7-2/7+1/7"], ["10/3-5/3+1/3"], ["1/2+1/3+1/6"], ["1/2-1/3-1/6"], ["-1/3-1/3"], ["0/5+0/7"], ["9/10-1/10-2/10"], ["100/200+100/200"], ["1/7+1/7+1/7+1/7"], ["5/6-1/6-1/6"], ["11/12-1/12"], ["2/3-1/3"], ["-3/4+1/4"], ["7/8-3/8+1/8"], ["1/5+2/5+2/5"], ["12/8-4/8"]], "expected": ["0/1", "1/3", "-1/6", "2/1", "0/1", "3/10", "41/12", "29/18", "2/1", "1/2", "1/2", "1/3", "2/7", "2/1", "1/1", "0/1", "-2/3", "0/1", "3/5", "1/1", "4/7", "1/2", "5/6", "1/3", "-1/2", "5/8", "1/1", "1/1"], "loose": false}

package/data/problems/fraction-to-recurring-decimal.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "319", "slug": "fraction-to-recurring-decimal", "id": 319, "title": "Fraction to Recurring Decimal", "difficulty": "Medium", "category": "math", "link": "https://leetcode.com/problems/fraction-to-recurring-decimal/", "examples": [{"explanation": "One half is exactly 0.5.", "input": "numerator = 1, denominator = 2", "output": "\"0.5\""}, {"explanation": "The division is exact, so no decimal point appears.", "input": "numerator = 2, denominator = 1", "output": "\"2\""}, {"explanation": "The digits 012 repeat forever.", "input": "numerator = 4, denominator = 333", "output": "\"0.(012)\""}], "hints": ["Track each remainder in a map from remainder value to its position in the output.", "When a remainder repeats, the digits since its first visit form the repeating block."], "statement": "Divide `numerator` by `denominator` and write the result as a decimal string. When the fractional part repeats forever, wrap the repeating block in parentheses.\n\nFor example, `1 / 2` is `\"0.5\"`, while `4 / 333` repeats `\"012\"` and becomes `\"0.(012)\"`. A negative result carries a single leading minus sign, and an exact division shows no decimal point.\n\n**Constraints:**\n- `-2^31 <= numerator, denominator <= 2^31 - 1`\n- `denominator != 0`\n", "solution": "## Approach\n\nSeparate the sign, then do long division digit by digit. Remember where each remainder first appeared: when a remainder repeats, everything produced since its first visit repeats forever, so wrap that block in parentheses. A zero remainder ends the decimal. Wide integers protect the edge case of the smallest 32-bit value.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(d), where d is the number of digits before the decimal terminates or repeats (bounded by the denominator).\n- **Space Complexity:** O(d) for the remainder positions and the output.\n\n## Implementation\n\n```python\nclass Solution:\n def fractionToDecimal(self, numerator: int, denominator: int) -> str:\n if numerator == 0:\n return \"0\"\n res = []\n if (numerator < 0) ^ (denominator < 0):\n res.append(\"-\")\n num, den = abs(numerator), abs(denominator)\n res.append(str(num // den))\n rem = num % den\n if rem == 0:\n return \"\".join(res)\n res.append(\".\")\n pos = {}\n while rem != 0:\n if rem in pos:\n at = pos[rem]\n res.insert(at, \"(\")\n res.append(\")\")\n break\n pos[rem] = len(res)\n rem *= 10\n res.append(str(rem // den))\n rem %= den\n return \"\".join(res)\n```\n", "starter": {"go": "package main\n\nfunc FractionToDecimal(numerator int, denominator int) string {\n return \"\"\n}", "python": "class Solution:\n def fractionToDecimal(self, numerator: int, denominator: int) -> str:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n string fractionToDecimal(int numerator, int denominator) {\n return \"\";\n }\n};"}, "fn": "fractionToDecimal", "params": [{"name": "numerator", "type": "int"}, {"name": "denominator", "type": "int"}], "outputType": "string", "tests": [["1", "2"], ["2", "1"], ["4", "333"], ["1", "3"], ["1", "6"], ["-50", "8"], ["0", "3"], ["-1", "2"], ["1", "-2"], ["7", "4"], ["1", "9"], ["2", "7"], ["1", "11"], ["-1", "6"], ["0", "1"], ["3", "5"], ["22", "90"], ["1", "12"], ["1", "200"], ["-22", "4"], ["-7", "7"], ["5", "2"], ["5", "13"], ["1", "81"], ["1", "7"], ["-2147483648", "-1"]], "expected": ["0.5", "2", "0.(012)", "0.(3)", "0.1(6)", "-6.25", "0", "-0.5", "-0.5", "1.75", "0.(1)", "0.(285714)", "0.(09)", "-0.1(6)", "0", "0.6", "0.2(4)", "0.08(3)", "0.005", "-5.5", "-1", "2.5", "0.(384615)", "0.(012345679)", "0.(142857)", "2147483648"], "loose": false}

package/data/problems/freedom-trail.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "574", "slug": "freedom-trail", "id": 574, "title": "Freedom Trail", "difficulty": "Hard", "category": "dp", "link": "https://leetcode.com/problems/freedom-trail/", "examples": [{"input": "ring = \"godding\", key = \"gd\"", "output": "4", "explanation": "Keep the dial still and press 'g' (1), rotate two places to a 'd' (2), then press it (1), for 4 total."}, {"input": "ring = \"godding\", key = \"godding\"", "output": "13", "explanation": "Spelling the full word in order needs 6 rotations plus 7 presses."}, {"input": "ring = \"ab\", key = \"b\"", "output": "2", "explanation": "Rotate one step to 'b' (1) and press it (1)."}], "hints": ["Precompute, for each letter, the list of dial positions holding it so transitions only consider relevant stops.", "Memoize over (key index, dial position): try every occurrence of the next character and add the circular distance plus one press.", "Circular distance between i and j on a dial of length m is min(|i-j|, m-|i-j|)."], "statement": "A circular dial carries the characters of `ring` around its rim, with position 0 initially pointing at 12 o'clock. One step rotates the dial a single place clockwise or counterclockwise, and pressing a button spells the character currently at the top (costing one extra move per character). The dial starts aligned so `ring[0]` is at the top.\n\nGiven the dial layout `ring` and a word `key` to spell in order, compute the smallest total number of moves (rotations plus one press per character) that spells the whole word. Every character of `key` appears somewhere in `ring`.\n\n**Constraints:**\n- `1 <= ring.length, key.length <= 100`\n- `ring` and `key` contain only lowercase English letters\n- Every character of `key` occurs in `ring`\n", "solution": "## Approach\n\nGroup dial positions by their letter so each key character only considers stops that can actually spell it. Then run a memoized search over states `(key index, current dial position)`: for the next needed letter, try every matching stop, pay the shorter circular walk plus one press, and continue from there. Taking the minimum over those choices yields the optimal total.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(k * m^2) in the worst case, where k is the key length and m the ring length (each state scans matching stops).\n- **Space Complexity:** O(k * m) for the memo table plus the position groups.\n\n## Implementation\n\n```python\nclass Solution:\n def findRotateSteps(self, ring: str, key: str) -> int:\n from functools import lru_cache\n m = len(ring)\n pos_map = {}\n for i, c in enumerate(ring):\n pos_map.setdefault(c, []).append(i)\n\n @lru_cache(maxsize=None)\n def dp(ki, pos):\n if ki == len(key):\n return 0\n best = 10 ** 9\n for np in pos_map[key[ki]]:\n diff = abs(pos - np)\n step = min(diff, m - diff)\n best = min(best, step + 1 + dp(ki + 1, np))\n return best\n\n return dp(0, 0)\n```\n", "starter": {"go": "package main\n\nfunc FindRotateSteps(ring string, key string) int {\n \n}", "python": "class Solution:\n def findRotateSteps(self, ring: str, key: str) -> int:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int findRotateSteps(string ring, string key) {\n return 0;\n }\n};"}, "fn": "findRotateSteps", "params": [{"name": "ring", "type": "string"}, {"name": "key", "type": "string"}], "outputType": "int", "tests": [["godding", "gd"], ["godding", "godding"], ["ab", "b"], ["abcde", "ade"], ["a", "a"], ["a", "aaaa"], ["ab", "a"], ["ab", "aba"], ["abc", "abc"], ["abc", "cba"], ["aaaaa", "aaa"], ["abcdef", "fedcba"], ["godding", "g"], ["godding", "ding"], ["xyz", "zyx"], ["abacaba", "abc"], ["caotmcaataijjxi", "oatjiioicitatajtijciocjcaaxaaatmctxamacaamjjx"], ["abcdefghij", "jihgfedcba"], ["abccba", "abcba"], ["zzzzzz", "zzzz"], ["pqrst", "qqqq"], ["helloworld", "hold"], ["ab", "bbbb"], ["abcde", "edcba"], ["aabbaa", "aba"], ["abcdefghijklmnopqrst", "tsrqponmlkjihgfedcba"], ["niwaxk", "kankin"], ["abcabc", "cbaabc"]], "expected": [4, 13, 2, 6, 1, 4, 1, 5, 5, 6, 3, 12, 1, 10, 6, 6, 137, 20, 9, 4, 5, 11, 5, 10, 6, 40, 16, 11], "loose": false}

package/data/problems/friends-of-appropriate-ages.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "823", "slug": "friends-of-appropriate-ages", "id": 823, "title": "Friends Of Appropriate Ages", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/friends-of-appropriate-ages/", "examples": [{"input": "ages = [16,16]", "output": "2", "explanation": "Both ordered pairs pass every rule."}, {"input": "ages = [16,17,18]", "output": "2", "explanation": "Only the pairs (17,16) and (18,17) survive."}, {"input": "ages = [20,30,100,110,120]", "output": "3"}], "hints": ["Ages are bounded by 120, so count how many people have each age and evaluate pairs of distinct age values once.", "For equal ages, multiply the count by one less than itself since nobody sends to themselves.", "Check the three blocking rules in order and skip the pair as soon as any rule fires."], "statement": "You are given an array `ages` where each entry is one person's age. Person `x` sends a request to a different person `y` exactly when all of the following hold:\n\n- `y`'s age is more than half of `x`'s age plus seven (that is, the request is blocked when `ages[y] <= ages[x] / 2 + 7` using real division).\n- `y`'s age is not greater than `x`'s age.\n- It is not the case that `y` is over 100 while `x` is under 100.\n\nEvery ordered pair of distinct people is considered. Return the total number of requests sent.\n\n**Constraints:**\n- `1 <= ages.length <= 20000`\n- `1 <= ages[i] <= 120`\n", "solution": "## Approach\n\nBecause ages only range from 1 to 120, tally the frequency of each age instead of comparing every pair of people. For each ordered pair of distinct age values with nonzero counts, test the three blocking rules directly and add the product of the frequencies (subtracting the self-pair for equal ages). Summing over at most 120 by 120 age pairs is easily fast enough.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + A^2) where n is the number of people and A = 120 is the age range.\n- **Space Complexity:** O(A) for the frequency table.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def numFriendRequests(self, ages: List[int]) -> int:\n cnt = [0] * 121\n for a in ages:\n cnt[a] += 1\n ans = 0\n for a in range(1, 121):\n if cnt[a] == 0:\n continue\n for b in range(1, 121):\n if cnt[b] == 0:\n continue\n if b <= a // 2 + 7:\n continue\n if b > a:\n continue\n if b > 100 and a < 100:\n continue\n ans += cnt[a] * (cnt[b] - (1 if a == b else 0))\n return ans\n```\n", "starter": {"go": "package main\n\nfunc NumFriendRequests(ages []int) int {\n return 0\n}", "python": "from typing import List\nclass Solution:\n def numFriendRequests(self, ages: List[int]) -> int:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int numFriendRequests(vector<int>& ages) {\n return 0;\n }\n};"}, "fn": "numFriendRequests", "params": [{"name": "ages", "type": "int_array"}], "outputType": "int", "tests": [["[16, 16]"], ["[16, 17, 18]"], ["[20, 30, 100, 110, 120]"], ["[1]"], ["[120]"], ["[1, 1, 1, 1]"], ["[120, 120, 120]"], ["[100, 100, 100]"], ["[99, 100, 101]"], ["[100, 99]"], ["[99, 100]"], ["[14, 15, 16]"], ["[15, 15, 15, 15]"], ["[16, 16, 16, 16]"], ["[18, 18, 18]"], ["[20, 20, 20, 20, 20]"], ["[8, 8, 8, 8]"], ["[73, 80, 84, 100, 101, 115]"], ["[54, 23, 102, 102, 44, 16, 88, 11, 24, 23]"], ["[110, 110, 110, 99, 99]"], ["[101, 99, 101, 99]"], ["[1, 120]"], ["[120, 1]"], ["[30, 30, 30, 30, 30, 30]"], ["[17, 18, 19, 20, 21, 22]"], ["[50, 60, 70, 80, 90, 100, 110, 120]"], ["[40, 40, 60, 60, 60]"], ["[109, 98, 91, 3, 39, 92, 113, 102, 56, 66, 60, 34, 63, 97, 30, 57, 68, 29, 44, 78]"]], "expected": [2, 2, 3, 0, 0, 0, 6, 6, 3, 1, 1, 0, 12, 12, 6, 20, 0, 15, 10, 14, 8, 0, 0, 30, 11, 22, 14, 100], "loose": false}

package/data/problems/frog-jump.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "477", "slug": "frog-jump", "id": 477, "title": "Frog Jump", "difficulty": "Hard", "category": "dp", "link": "https://leetcode.com/problems/frog-jump/", "examples": [{"input": "stones = [0,1,3,5,6,8,12,17]", "output": "true", "explanation": "Hop sizes 1,2,2,3,4,5 walk the frog from the first stone to the last."}, {"input": "stones = [0,1,2,3,4,8,9,11]", "output": "false", "explanation": "The wide water gap after stone 4 cannot be crossed with any allowed step."}, {"input": "stones = [0,1]", "output": "true", "explanation": "A single hop of length 1 reaches the final stone."}], "hints": ["Track, for each stone, the set of jump lengths that can land on it; the first hop must be 1.", "From a stone reached with step k, only k-1, k and k+1 (when positive) can continue forward.", "Stop early when a gap exceeds the largest reachable step, and memoize visited (index, step) pairs."], "statement": "A frog sits on stones placed at distinct positions along a river, starting at position `0`. The positions are given in strictly increasing order in `stones`, and the frog wants to finish on the final stone.\n\nThe opening hop must cover exactly `1` unit. Suppose the previous hop covered `k` units; the next hop may cover `k - 1`, `k`, or `k + 1` units, and it must land on a stone ahead (jumps are always forward, and a hop of length zero or less is never allowed).\n\nDecide whether the last stone is reachable under these rules.\n\n**Constraints:**\n- `2 <= stones.length <= 2000`\n- `0 <= stones[i] <= 2^31 - 1`\n- `stones[0] == 0`\n- Positions are strictly increasing.\n", "solution": "## Approach\n\nKeep, for every stone, the collection of hop sizes that can arrive there. The start stone holds hop size 0, and the second stone must be at distance 1 or the answer is immediately false. Each reachable state (stone, k) tries onward hops of k-1, k and k+1 to later stones recorded in a position map. The final stone is reachable exactly when its set is non-empty.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2) in the worst case, where n is the stone count.\n- **Space Complexity:** O(n^2) for the stored hop sets in the worst case.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def canCross(self, stones: List[int]) -> bool:\n n = len(stones)\n if n <= 1:\n return True\n if stones[1] != 1:\n return False\n index_of = {x: i for i, x in enumerate(stones)}\n reach = [set() for _ in range(n)]\n reach[0].add(0)\n for i in range(n):\n for k in list(reach[i]):\n for nk in (k - 1, k, k + 1):\n if nk <= 0:\n continue\n j = index_of.get(stones[i] + nk)\n if j is not None:\n reach[j].add(nk)\n return len(reach[n - 1]) > 0\n```\n", "starter": {"go": "package main\n\nfunc CanCross(stones []int) bool {\n \n}", "python": "from typing import List\n\nclass Solution:\n def canCross(self, stones: List[int]) -> bool:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n bool canCross(vector<int>& stones) {\n return false;\n }\n};"}, "fn": "canCross", "params": [{"name": "stones", "type": "int_array"}], "outputType": "boolean", "tests": [["[0,1,3,5,6,8,12,17]"], ["[0,1,2,3,4,8,9,11]"], ["[0,1]"], ["[0,2]"], ["[0,1,3,6]"], ["[0,1,3,6,10,15,21]"], ["[0,1,3,6,10,15,21,28]"], ["[0,1,2,3,4,5,6,7,8,9,10,11,12]"], ["[0,1,3,5,6,8,12,17,20]"], ["[0,1,3,5,6,8,12,17,22]"], ["[0,1,2,4,7,11,16,22]"], ["[0,1,2,4,7,11,16,22,29]"], ["[0,1,3,6,10,14,19,25]"], ["[0,2,3,5,8,12,17]"], ["[0,1,4,9,16,25]"], ["[0,1,2,3,4,5,100]"], ["[0,1,3,4,5,7,9,10,12]"], ["[0,1,3,6,9,13,18,24]"], ["[0,1,3,6,9,13,18,24,31]"], ["[0,1,2,5,9,14,20,27]"], ["[0,1,3,7,12,18,25,33]"], ["[0,1,2,3,5,8,12,17,23]"], ["[0,1,3,5,8,12,17,23,30]"], ["[0,1,2,3,4,6,9,13,18]"], ["[0,1,3,5,7,10,14,19,25]"], ["[0,1,2,4,8,13,19,26,34]"], ["[0,1,3,6,11,17,24,32,41]"], ["[0,1,2,6,11,17,24,32]"], ["[0,1,3,4,6,9,13,18,24,31]"], ["[0,1,2,3,4,5,6,7,8,9,10,20]"], ["[0,1,3,6,10,15,16,21]"]], "expected": [true, false, true, false, true, true, true, true, false, true, true, true, true, false, false, false, true, true, true, false, false, true, true, true, true, false, false, false, true, false, true], "loose": false}

package/data/problems/fruit-into-baskets.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "893", "slug": "fruit-into-baskets", "id": 893, "title": "Fruit Into Baskets", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/fruit-into-baskets/", "examples": [{"input": "fruits = [1,2,1]", "output": "3", "explanation": "Whole row uses two kinds."}, {"input": "fruits = [0,1,2,2]", "output": "3", "explanation": "Best stretch is [1,2,2]."}, {"input": "fruits = [1,2,3,2,2]", "output": "4", "explanation": "Best stretch is [2,3,2,2]."}], "hints": ["Slide a window with left and right ends, keeping counts of each kind inside.", "When a third distinct kind enters, move the left end forward until only two kinds remain; record the largest window seen."], "statement": "A row of trees holds fruit kinds recorded in `fruits`, where each entry names the kind on that tree. You carry two baskets, each dedicated to a single kind (the two kinds may end up the same only if you never use the second basket). Starting at any tree and stepping rightward, you must take exactly one fruit per tree while the kinds fit into your two baskets, and you halt before the first tree whose kind would demand a third basket.\n\nFind the greatest number of fruits obtainable under those rules \u2014 equivalently, the length of the longest contiguous segment using at most two distinct values.\n\n**Constraints:**\n- `1 <= fruits.length <= 10^5`\n- `0 <= fruits[i] < fruits.length`\n", "solution": "## Approach\n\nMaintain a sliding window that never holds more than two fruit kinds. Expand the right edge one tree at a time while tallying kinds in a map; whenever a third kind appears, shift the left edge forward, decrementing counts until the window is legal again. The maximum window length encountered is the answer.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) since each index moves at most once.\n- **Space Complexity:** O(1) for the at-most-two-entry map.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def totalFruit(self, fruits: List[int]) -> int:\n cnt = {}\n left = best = 0\n for right, v in enumerate(fruits):\n cnt[v] = cnt.get(v, 0) + 1\n while len(cnt) > 2:\n u = fruits[left]\n cnt[u] -= 1\n if cnt[u] == 0:\n del cnt[u]\n left += 1\n best = max(best, right - left + 1)\n return best\n```\n", "starter": {"go": "package main\n\nfunc TotalFruit(fruits []int) int {\n \n}", "python": "from typing import List\nclass Solution:\n def totalFruit(self, fruits: List[int]) -> int:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int totalFruit(vector<int>& fruits) {\n return 0;\n }\n};"}, "fn": "totalFruit", "params": [{"name": "fruits", "type": "int_array"}], "outputType": "int", "tests": [["[1,2,1]"], ["[0,1,2,2]"], ["[1,2,3,2,2]"], ["[1]"], ["[0,0,0]"], ["[1,2,3,4,5]"], ["[1,1,1,2,2]"], ["[3,3,3,1,2,1,1,2,3,3,4]"], ["[0,1,1,1,2,3,4]"], ["[1,2,1,2,1,2]"], ["[5,5,5,5]"], ["[1,0,1,4,1,4,1,2,3]"], ["[2,2,2,2,2]"], ["[0,1,0,1,0,1]"], ["[1,2,3,2,2,3,3,1]"], ["[0]"], ["[1,2]"], ["[1,2,3]"], ["[4,4,1,2,1]"], ["[0,0,1,1]"], ["[1,1,2,3,2,1]"], ["[2,1,2,3,2,1,1]"], ["[0,1,6,6,4,4,6]"], ["[1,2,3,4,3,2,1]"], ["[9,9,9,9,8]"], ["[1,0,3,3,3,3]"], ["[2,3,1,2,3,2,2]"], ["[0,2,1,2,2,0,1]"]], "expected": [3, 3, 4, 1, 3, 2, 5, 5, 4, 6, 4, 5, 5, 6, 6, 1, 2, 2, 3, 4, 3, 3, 5, 3, 5, 5, 4, 4], "loose": false}

package/data/problems/game-of-life.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "385", "slug": "game-of-life", "id": 385, "title": "Game of Life", "difficulty": "Medium", "category": "matrix", "link": "https://leetcode.com/problems/game-of-life/", "examples": [{"input": "board = [[0,1,0],[0,0,1],[1,1,1],[0,0,0]]", "output": "[[0,0,0],[1,0,1],[0,1,1],[0,1,0]]", "explanation": "Standard glider step computed simultaneously from live-neighbor counts."}, {"input": "board = [[1,1],[1,0]]", "output": "[[1,1],[1,1]]", "explanation": "Three live cells around the dead corner bring it to life."}, {"input": "board = [[0]]", "output": "[[0]]", "explanation": "A lone dead cell stays dead."}], "hints": ["Adaptation: the original updates in place with void; here return the next board.", "Count the eight neighbors for each cell from a snapshot before writing any change.", "Live survives with 2-3 neighbors; dead becomes live with exactly 3."], "statement": "Compute one step of Conway's Game of Life.\n\nEach cell is live (`1`) or dead (`0`). Count its eight neighbors, then apply\nsimultaneously: a live cell with fewer than two or more than three live\nneighbors dies; a live cell with two or three lives on; a dead cell with\nexactly three becomes live.\n\n**Adaptation:** instead of a void in-place update, implement\n`gameOfLife(board)` returning the next-state board.\n\n**Constraints:**\n- `1 <= m, n <= 25`\n- `board[i][j]` is `0` or `1`.\n", "solution": "## Approach\n\nCopy neighbor counts from the original board, then decide each cell's next state with the four rules. Reading from the snapshot guarantees simultaneity.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n) with constant neighbor work.\n- **Space Complexity:** O(m * n) for the next board.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def gameOfLife(self, board: List[List[int]]) -> List[List[int]]:\n m, n = len(board), len(board[0])\n nxt = [[0] * n for _ in range(m)]\n for r in range(m):\n for c in range(n):\n live = 0\n for dr in (-1, 0, 1):\n for dc in (-1, 0, 1):\n if dr == 0 and dc == 0:\n continue\n nr, nc = r + dr, c + dc\n if 0 <= nr < m and 0 <= nc < n and board[nr][nc] == 1:\n live += 1\n if board[r][c] == 1:\n nxt[r][c] = 1 if live in (2, 3) else 0\n else:\n nxt[r][c] = 1 if live == 3 else 0\n return nxt\n```\n", "starter": {"go": "package main\n\nfunc GameOfLife(board [][]int) [][]int {\n \n}", "python": "from typing import List\nclass Solution:\n def gameOfLife(self, board: List[List[int]]) -> List[List[int]]:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<vector<int>> gameOfLife(vector<vector<int>>& board) {\n return {};\n }\n};"}, "fn": "gameOfLife", "params": [{"name": "board", "type": "int_array_2d"}], "outputType": "int_array_2d", "tests": [["[[0,1,0],[0,0,1],[1,1,1],[0,0,0]]"], ["[[1,1],[1,0]]"], ["[[0]]"], ["[[1]]"], ["[[0,0],[0,0]]"], ["[[1,1],[1,1]]"], ["[[0,1,0],[0,1,0],[0,1,0]]"], ["[[1,0,1],[0,1,0],[1,0,1]]"], ["[[0,0,0],[0,1,0],[0,0,0]]"], ["[[1,1,1],[1,1,1],[1,1,1]]"], ["[[0,1,0,0],[1,0,1,0],[0,1,0,0],[0,0,0,0]]"], ["[[1,0],[0,1]]"], ["[[1,0,0],[0,0,0],[0,0,1]]"], ["[[0,1],[1,1]]"], ["[[1,1,0],[1,0,1],[0,1,0]]"], ["[[1,1,1,1],[1,1,1,1],[1,1,1,1]]"], ["[[0,0,0],[0,0,0],[0,0,0]]"], ["[[0,0,0,0],[0,0,0,0]]"], ["[[1,0,1,0],[0,1,0,1],[1,0,1,0],[0,1,0,1]]"], ["[[1,1,0,0],[1,1,0,0],[0,0,1,1],[0,0,1,1]]"], ["[[0,1,0],[1,1,1],[0,1,0]]"], ["[[1,0,0,0,1],[0,0,0,0,0],[0,0,1,0,0],[0,0,0,0,0],[1,0,0,0,1]]"], ["[[1,1,1,1,1]]"], ["[[1],[0],[1],[0],[1]]"], ["[[0,1],[0,1],[0,1]]"], ["[[1,0,0],[1,0,0],[1,0,0]]"], ["[[1,1],[0,0]]"], ["[[0,0],[1,1]]"]], "expected": [[[0, 0, 0], [1, 0, 1], [0, 1, 1], [0, 1, 0]], [[1, 1], [1, 1]], [[0]], [[0]], [[0, 0], [0, 0]], [[1, 1], [1, 1]], [[0, 0, 0], [1, 1, 1], [0, 0, 0]], [[0, 1, 0], [1, 0, 1], [0, 1, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[1, 0, 1], [0, 0, 0], [1, 0, 1]], [[0, 1, 0, 0], [1, 0, 1, 0], [0, 1, 0, 0], [0, 0, 0, 0]], [[0, 0], [0, 0]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[1, 1], [1, 1]], [[1, 1, 0], [1, 0, 1], [0, 1, 0]], [[1, 0, 0, 1], [0, 0, 0, 0], [1, 0, 0, 1]], [[0, 0, 0], [0, 0, 0], [0, 0, 0]], [[0, 0, 0, 0], [0, 0, 0, 0]], [[0, 1, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 1, 0]], [[1, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 1]], [[1, 1, 1], [1, 0, 1], [1, 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, 1, 1, 1, 0]], [[0], [0], [0], [0], [0]], [[0, 0], [1, 1], [0, 0]], [[0, 0, 0], [1, 1, 0], [0, 0, 0]], [[0, 0], [0, 0]], [[0, 0], [0, 0]]], "loose": false}

package/data/problems/gas-station.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "140", "slug": "gas-station", "id": 140, "title": "Gas Station", "difficulty": "Medium", "category": "greedy", "link": "https://leetcode.com/problems/gas-station/", "examples": [{"input": "gas = [1,2,3,4,5], cost = [3,4,5,1,2]", "output": "3", "explanation": "Starting at station 3 allows a complete circuit without running out of fuel."}, {"input": "gas = [2,3,4], cost = [3,4,3]", "output": "-1", "explanation": "No starting station can complete the circuit (total gas < total cost)."}, {"input": "gas = [5], cost = [4]", "output": "0", "explanation": "Starting at station 0, there is enough gas (5) to cover the cost (4) and complete the circuit."}], "hints": ["A circuit is impossible when total gas is less than total cost.", "Track the running fuel balance from a candidate start while scanning the stations once.", "If the balance becomes negative at station i, no station from the current candidate through i can be a valid start, so try i + 1."], "statement": "There are `n` gas stations arranged in a circle. `gas[i]` is the fuel available at station `i`, and `cost[i]` is the fuel needed to drive from station `i` to station `(i + 1) mod n`.\n\nYou begin with an empty tank. Return the index from which you can complete one clockwise circuit without the tank becoming negative. If no such station exists, return `-1`. If a valid starting station exists, it is guaranteed to be unique.\n\n**Constraints:**\n\n- `gas.length == cost.length`\n- `1 <= gas.length <= 100000`\n- `0 <= gas[i], cost[i] <= 10000`\n- If a valid starting station exists, it is unique.\n", "solution": "## Approach\n\nTrack both the total fuel balance and the balance from the current candidate start. If the candidate balance becomes negative at station `i`, no station from the current candidate through `i` can be a valid start, so reset the candidate to `i + 1`. A negative total means no circuit exists; otherwise, the final candidate completes the circuit.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), with one pass over the stations.\n- **Space Complexity:** O(1) auxiliary space.\n\n## Implementation\n\n```python\nfrom typing import List\n\n\nclass Solution:\n def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:\n total = 0\n tank = 0\n start = 0\n for index, (available, required) in enumerate(zip(gas, cost)):\n difference = available - required\n total += difference\n tank += difference\n if tank < 0:\n start = index + 1\n tank = 0\n return -1 if total < 0 else start % len(gas)\n```\n", "starter": {"go": "package main\n\nfunc CanCompleteCircuit(gas []int, cost []int) int {\n \n}", "python": "from typing import List\nclass Solution:\n def canCompleteCircuit(self, gas: List[int], cost: List[int]) -> int:\n pass\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n int canCompleteCircuit(vector<int>& gas, vector<int>& cost) {\n return -1;\n }\n};"}, "fn": "canCompleteCircuit", "params": [{"name": "gas", "type": "int_array"}, {"name": "cost", "type": "int_array"}], "outputType": "int", "tests": [["[1,2,3,4,5]", "[3,4,5,1,2]"], ["[2,3,4]", "[3,4,3]"], ["[5]", "[4]"], ["[4]", "[5]"], ["[0]", "[0]"], ["[1,2]", "[2,1]"], ["[2,1]", "[1,2]"], ["[0,1]", "[1,0]"], ["[1,0]", "[0,1]"], ["[3,3,4]", "[3,4,4]"], ["[4,6,7,4]", "[6,5,5,5]"], ["[5,1,2,3,4]", "[4,4,1,5,1]"], ["[2,0,1]", "[1,2,0]"], ["[0,2,0]", "[1,0,1]"], ["[10,0,0]", "[3,3,3]"], ["[0,0,10]", "[3,3,3]"], ["[3,1,1]", "[1,2,2]"], ["[1,1,3]", "[2,2,1]"], ["[2,2,2]", "[1,2,3]"], ["[1,2,3]", "[2,3,1]"], ["[6,1,4,3,5]", "[3,8,2,4,2]"], ["[1,5,3,3,5,3,1,3,4,5]", "[5,2,2,8,2,4,2,5,1,2]"], ["[1,1,1,1]", "[2,2,2,2]"], ["[5,5,5,5]", "[6,6,6,2]"], ["[1,2,3,4]", "[4,3,2,1]"], ["[0,0,1,0]", "[0,1,0,0]"], ["[7,0,0,0]", "[2,2,2,1]"], ["[0,0,0,7]", "[2,2,1,2]"], ["[2,4,1,3]", "[3,1,2,4]"], ["[8,1,1,1,1]", "[2,2,2,2,4]"], ["[1,1,1,1,8]", "[2,2,2,4,2]"], ["[3,4,5,1,2]", "[4,5,1,2,3]"], ["[2,3,1,4]", "[3,1,4,2]"], ["[9,0,2,0,1]", "[3,3,3,1,2]"], ["[0,2,0,9,1]", "[3,1,3,2,3]"], ["[4,0,4,0]", "[2,3,1,2]"], ["[2,0,2,0]", "[1,2,0,1]"], ["[100,0,0]", "[30,30,40]"], ["[0,0,100]", "[30,40,30]"], ["[5,2,1,4,3]", "[4,3,2,3,3]"], ["[2,7,1,0,5]", "[3,2,4,1,5]"], ["[0,5,0,5,0]", "[2,1,3,1,3]"], ["[6,0,1,2]", "[2,3,3,1]"], ["[1,2,0,6]", "[2,2,3,1]"], ["[3,0,0,3]", "[1,2,1,2]"], ["[1,0,3,0]", "[2,1,0,1]"], ["[4,1,0,2,5]", "[3,2,1,4,2]"], ["[2,5,0,1,4]", "[3,1,3,1,4]"], ["[1,4,2,0,6]", "[2,2,3,3,3]"], ["[3,3,0,0,4]", "[2,4,1,2,1]"], ["[1,10,1]", "[5,1,6]"], ["[10,1,1]", "[1,6,5]"], ["[1,1,10]", "[6,5,1]"], ["[2,8,2,8]", "[5,3,8,4]"], ["[8,2,8,2]", "[3,8,2,7]"], ["[10000]", "[10000]"], ["@javascript:Array.from({length:50000},(_,i)=>i<5?10000:0)", "@javascript:Array.from({length:50000},(_,i)=>i<5?0:1)"]], "expected": [3, -1, 0, -1, 0, 1, 0, 1, 0, -1, 1, 4, 2, 1, 0, 2, 0, 2, 0, 2, 2, 8, -1, 3, 2, 2, 0, 3, 1, 0, 4, 2, 3, 0, 3, 2, 2, 0, 2, 3, 1, 1, 3, 3, 3, 2, 4, 1, 4, 4, 1, 0, 2, 3, 2, 0, 0], "loose": false}