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

offcode 0.0.0-stage → 0.1.0

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/lfu-cache.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "193", "slug": "lfu-cache", "id": 193, "title": "LFU Cache", "difficulty": "Hard", "category": "linked-list", "link": "https://leetcode.com/problems/lfu-cache/", "examples": [{"input": "operations = [\"LFUCache\",\"put\",\"put\",\"get\",\"put\",\"get\",\"get\",\"put\",\"get\",\"get\",\"get\"], args = [[2],[1,1],[2,2],[1],[3,3],[2],[3],[4,4],[1],[3],[4]]", "output": "[1,-1,3,-1,3,4]", "explanation": "Capacity 2. get(1) returns 1; put(3,3) evicts key 2; get(2) returns -1 and get(3) returns 3. put(4,4) evicts key 1; get(1) returns -1 while get(3) returns 3 and get(4) returns 4."}, {"input": "operations = [\"LFUCache\",\"put\",\"get\",\"put\",\"get\",\"get\"], args = [[1],[2,1],[2],[3,2],[2],[3]]", "output": "[1,-1,2]", "explanation": "Capacity 1. get(2) returns 1; put(3,2) evicts key 2; get(2) returns -1 and get(3) returns 2."}, {"input": "operations = [\"LFUCache\",\"put\",\"put\",\"get\",\"get\"], args = [[2],[1,1],[1,9],[1],[2]]", "output": "[9,-1]", "explanation": "Capacity 2. put(1,9) updates key 1; get(1) returns 9 and get(2) returns -1."}], "hints": ["Keep key-to-value and key-to-frequency maps plus frequency-to-ordered-keys groups.", "Track the minimum frequency; on eviction remove the least recently used key from the minimum group, and update min frequency after each get/put."], "statement": "Design a Least Frequently Used (LFU) cache.\n\n`operations[0]` is always `LFUCache` and `args[0]` holds the capacity.\nFor `i >= 1`, `operations[i]` is `get` with `args[i] = [key]` or `put` with\n`args[i] = [key, value]`. Return an array with one entry per `get` operation,\nin order; `put` produces no output. A missing key returns `-1`. When the cache\nis full, evict the least frequently used key, breaking ties by least recently\nused. A new key starts with frequency `1`; every `get` or updating `put`\nincrements its frequency.\n\n**Constraints:**\n\n- `1 <= capacity <= 10^4`\n- `0 <= key <= 10^5`\n- `0 <= value <= 10^9`\n", "solution": "## Approach\n\nMaintain `key -> value`, `key -> frequency`, and `frequency -> ordered keys`\n(`LinkedHashSet` preserves LRU order within a frequency). Track `minFreq`.\nOn `get`, bump the key's frequency and move it between groups, fixing `minFreq`\nwhen its group empties. On `put`, update existing keys the same way; for new\nkeys evict the oldest key of the `minFreq` group when full, insert with\nfrequency `1`, and reset `minFreq` to `1`.\n\n## Complexity Analysis\n\n- **Time Complexity:** `O(1)` average per `get`/`put`.\n- **Space Complexity:** `O(capacity)` for the maps and groups.\n\n## Implementation\n\n```python\nfrom collections import OrderedDict, defaultdict\nfrom typing import List\n\n\nclass Solution:\n def runLfuCache(self, operations: List[str], args: List[List[int]]) -> List[int]:\n capacity = args[0][0]\n values: dict[int, int] = {}\n freqs: dict[int, int] = {}\n groups: dict[int, OrderedDict[int, None]] = defaultdict(OrderedDict)\n min_freq = 0\n results: List[int] = []\n for operation, arg in zip(operations[1:], args[1:]):\n if operation == \"get\":\n key = arg[0]\n if key not in values:\n results.append(-1)\n else:\n f = freqs[key]\n del groups[f][key]\n if f == min_freq and not groups[f]:\n min_freq += 1\n freqs[key] = f + 1\n groups[f + 1][key] = None\n results.append(values[key])\n else:\n key, value = arg[0], arg[1]\n if capacity == 0:\n continue\n if key in values:\n values[key] = value\n f = freqs[key]\n del groups[f][key]\n if f == min_freq and not groups[f]:\n min_freq += 1\n freqs[key] = f + 1\n groups[f + 1][key] = None\n else:\n if len(values) == capacity:\n evict, _ = groups[min_freq].popitem(last=False)\n del values[evict]\n del freqs[evict]\n values[key] = value\n freqs[key] = 1\n groups[1][key] = None\n min_freq = 1\n return results\n```\n", "starter": {"go": "package main\n\nfunc RunLfuCache(operations []string, args [][]int) []int {\n return nil\n}", "python": "from typing import List\n\nclass Solution:\n def runLfuCache(self, operations: List[str], args: List[List[int]]) -> List[int]:\n return []\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n vector<int> runLfuCache(vector<string>& operations, vector<vector<int>>& args) {\n return {};\n }\n};"}, "fn": "runLfuCache", "params": [{"name": "operations", "type": "string_array"}, {"name": "args", "type": "int_array_2d"}], "outputType": "int_array", "tests": [["[\"LFUCache\",\"put\",\"put\",\"get\",\"put\",\"get\",\"get\",\"put\",\"get\",\"get\",\"get\"]", "[[2],[1,1],[2,2],[1],[3,3],[2],[3],[4,4],[1],[3],[4]]"], ["[\"LFUCache\",\"put\",\"get\",\"put\",\"get\",\"get\"]", "[[1],[2,1],[2],[3,2],[2],[3]]"], ["[\"LFUCache\",\"put\",\"put\",\"get\",\"get\"]", "[[2],[1,1],[1,9],[1],[2]]"], ["[\"LFUCache\",\"get\"]", "[[3],[7]]"], ["[\"LFUCache\",\"put\",\"get\"]", "[[1],[0,0],[0]]"], ["[\"LFUCache\",\"put\",\"put\",\"get\",\"get\"]", "[[1],[1,10],[2,20],[1],[2]]"], ["[\"LFUCache\",\"put\",\"put\",\"put\",\"get\",\"get\",\"get\"]", "[[2],[1,10],[2,20],[3,30],[1],[2],[3]]"], ["[\"LFUCache\",\"put\",\"put\",\"get\",\"put\",\"get\",\"get\"]", "[[2],[1,10],[2,20],[1],[3,30],[2],[3]]"], ["[\"LFUCache\",\"put\",\"put\",\"put\",\"get\",\"put\",\"get\",\"get\",\"get\",\"get\"]", "[[3],[1,1],[2,2],[3,3],[1],[4,4],[1],[2],[3],[4]]"], ["[\"LFUCache\",\"put\",\"get\",\"put\",\"get\",\"put\",\"get\"]", "[[1],[5,50],[5],[5,55],[5],[6,60],[5]]"], ["[\"LFUCache\",\"put\",\"put\",\"get\",\"get\",\"get\"]", "[[2],[0,100],[10000,200],[0],[10000],[5000]]"], ["[\"LFUCache\",\"put\",\"put\",\"put\",\"get\",\"get\",\"put\",\"get\",\"get\"]", "[[2],[1,1],[2,2],[2,22],[1],[2],[3,3],[1],[3]]"], ["[\"LFUCache\",\"put\",\"put\",\"put\",\"put\",\"get\",\"get\",\"get\",\"get\"]", "[[2],[1,1],[2,2],[3,3],[2,20],[1],[2],[3],[4]]"], ["[\"LFUCache\",\"put\",\"get\",\"get\",\"get\"]", "[[2],[1,5],[2],[1],[1]]"], ["[\"LFUCache\",\"put\",\"get\"]", "[[1],[1,1],[1]]"], ["[\"LFUCache\",\"put\",\"get\"]", "[[10000],[100000,1000000000],[100000]]"], ["[\"LFUCache\",\"put\",\"put\",\"put\",\"put\",\"get\",\"get\",\"get\",\"get\"]", "[[3],[1,1],[2,2],[3,3],[4,4],[1],[2],[3],[4]]"], ["[\"LFUCache\",\"put\",\"get\",\"get\",\"put\",\"get\"]", "[[2],[5,5],[5],[5],[6,6],[5]]"], ["[\"LFUCache\",\"put\",\"put\",\"get\",\"put\",\"get\"]", "[[1],[1,1],[2,2],[1],[3,3],[3]]"], ["[\"LFUCache\",\"get\",\"get\"]", "[[2],[1],[2]]"], ["[\"LFUCache\",\"put\",\"put\",\"put\",\"get\"]", "[[5],[1,1],[2,2],[3,3],[1]]"], ["[\"LFUCache\",\"put\",\"put\",\"put\",\"get\"]", "[[1],[1,1],[1,2],[1,3],[1]]"], ["[\"LFUCache\",\"put\",\"put\",\"get\",\"get\"]", "[[10],[0,0],[100000,1000000000],[0],[100000]]"], ["[\"LFUCache\",\"put\",\"put\",\"get\"]", "[[2],[7,0],[8,0],[7]]"], ["[\"LFUCache\",\"put\",\"get\",\"put\",\"get\"]", "[[1],[9,90],[9],[9,91],[9]]"], ["[\"LFUCache\",\"put\",\"get\",\"put\",\"get\",\"get\",\"put\",\"get\"]", "[[2],[1,10],[1],[2,20],[1],[2],[3,30],[3]]"], ["[\"LFUCache\",\"put\",\"put\",\"put\",\"put\",\"get\",\"get\"]", "[[4],[1,1],[2,2],[3,3],[4,4],[2],[4]]"], ["[\"LFUCache\",\"put\",\"put\",\"put\",\"get\"]", "[[2],[1,1],[2,2],[3,3],[2]]"], ["[\"LFUCache\",\"put\",\"get\",\"put\",\"get\",\"get\"]", "[[3],[4,40],[5],[6,60],[4],[6]]"], ["[\"LFUCache\",\"put\",\"put\",\"get\",\"get\",\"get\",\"put\",\"get\",\"get\"]", "[[2],[1,1],[2,2],[1],[1],[1],[3,3],[1],[3]]"], ["@javascript:(()=>{const ops=['LFUCache'];const args=[[100]];for(let i=0;i<3000;i++){if(i%3===2){ops.push('get');args.push([i%150]);}else{ops.push('put');args.push([i%150,(i*13)%100000]);}}return JSON.stringify(ops)})()", "@javascript:(()=>{const args=[[100]];for(let i=0;i<3000;i++){if(i%3===2){args.push([i%150]);}else{args.push([i%150,(i*13)%100000]);}}return JSON.stringify(args)})()"]], "expected": [[1, -1, 3, -1, 3, 4], [1, -1, 2], [9, -1], [-1], [0], [-1, 20], [-1, 20, 30], [10, -1, 30], [1, 1, -1, 3, 4], [50, 55, -1], [100, 200, -1], [1, 22, -1, 3], [-1, 20, 3, -1], [-1, 5, 5], [1], [1000000000], [-1, 2, 3, 4], [5, 5, 5], [-1, 3], [-1, -1], [1], [3], [0, 1000000000], [0], [90, 91], [10, 10, 20, 30], [2, 4], [2], [-1, 40, 60], [1, 1, 1, 1, 3], [-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1]], "loose": false}

package/data/problems/license-key-formatting.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "546", "slug": "license-key-formatting", "id": 546, "title": "License Key Formatting", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/license-key-formatting/", "examples": [{"input": "s = \"5F3Z-2e-9-w\", k = 4", "output": "\"5F3Z-2E9W\"", "explanation": "Cleaned 5F3Z2E9W splits into two groups of 4."}, {"input": "s = \"2-5g-3-J\", k = 2", "output": "\"2-5G-3J\"", "explanation": "Cleaned 25G3J groups from the right into 2-5G-3J."}, {"input": "s = \"---a-a-a-\", k = 1", "output": "\"A-A-A\"", "explanation": "Each character stands alone."}], "hints": ["Strip dashes and uppercase in one pass.", "Build the result backwards so full k-sized groups form naturally.", "The first group is whatever remains; it must hold at least one character."], "statement": "A license key is written as letters, digits, and dashes. Reformat it in this way: drop every dash, turn lowercase letters into uppercase, then re-insert dashes so that each chunk holds exactly `k` characters, except the leading chunk which may be shorter but must not be empty. Dashes separate chunks and never appear at the ends.\n\nReturn the reformatted key.\n\n**Constraints:**\n\n- `1 <= s.length <= 10^5`\n- `s` holds English letters, digits, and `-`.\n- `1 <= k <= 10^4`\n", "solution": "## Approach\n\nRemove all dashes while uppercasing letters, leaving a plain alphanumeric run. If nothing remains, return empty. Otherwise walk that run from the end, emitting `k` characters at a time and inserting a dash between groups; building backwards guarantees every group except the first is full. Reverse the built buffer to obtain the final key.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) where n is the length of `s`.\n- **Space Complexity:** O(n) for the cleaned and output buffers.\n\n## Implementation\n\n```python\nclass Solution:\n def licenseKeyFormatting(self, s: str, k: int) -> str:\n clean = [c.upper() for c in s if c != \"-\"]\n if not clean:\n return \"\"\n parts = []\n count = 0\n for i in range(len(clean) - 1, -1, -1):\n parts.append(clean[i])\n count += 1\n if count == k and i != 0:\n parts.append(\"-\")\n count = 0\n return \"\".join(reversed(parts))\n```\n", "starter": {"go": "package main\n\nfunc LicenseKeyFormatting(s string, k int) string {\n return \"\"\n}", "python": "class Solution:\n def licenseKeyFormatting(self, s: str, k: int) -> str:\n return \"\"\n", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n string licenseKeyFormatting(string s, int k) {\n return \"\";\n }\n};"}, "fn": "licenseKeyFormatting", "params": [{"name": "s", "type": "string"}, {"name": "k", "type": "int"}], "outputType": "string", "tests": [["5F3Z-2e-9-w", "4"], ["2-5g-3-J", "2"], ["---a-a-a-", "1"], ["a", "1"], ["ab", "2"], ["abcdef", "2"], ["a-b-c-d-e", "2"], ["2-4A0r7-4k", "4"], ["----", "2"], ["z", "5"], ["abc-def-ghi", "3"], ["0123456789", "3"], ["a-a-a-a-a-a", "3"], ["Aa-Bb-Cc", "2"], ["x", "4"], ["12-34-56-78", "2"], ["m-n-o-p-q-r", "5"], ["AB-CD-EF-GH", "4"], ["a1b2c3d4", "4"], ["---HELLO---WORLD---", "5"], ["abcd", "2"], ["a-b-c", "3"], ["2-5G-3J-ABC", "3"], ["hello-world", "4"], ["a", "2"], ["--ab--cd--", "1"], ["ABC123DEF456", "6"], ["k-9-8-7", "2"], ["test-case-123", "5"], ["Z", "1"]], "expected": ["5F3Z-2E9W", "2-5G-3J", "A-A-A", "A", "AB", "AB-CD-EF", "A-BC-DE", "24A0-R74K", "", "Z", "ABC-DEF-GHI", "0-123-456-789", "AAA-AAA", "AA-BB-CC", "X", "12-34-56-78", "M-NOPQR", "ABCD-EFGH", "A1B2-C3D4", "HELLO-WORLD", "AB-CD", "ABC", "25-G3J-ABC", "HE-LLOW-ORLD", "A", "A-B-C-D", "ABC123-DEF456", "K9-87", "T-ESTCA-SE123", "Z"], "loose": false}

package/data/problems/line-reflection.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "435", "slug": "line-reflection", "id": 435, "title": "Line Reflection", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/line-reflection/", "examples": [{"input": "points = [[1,1],[-1,1]]", "output": "true", "explanation": "The line x = 0 reflects each point onto the other."}, {"input": "points = [[1,1],[-1,-1]]", "output": "false", "explanation": "The mirror of (1,1) across any vertical line through these x values would be (-1,1), which is absent."}], "hints": ["If a mirror exists, it must sit halfway between the smallest and largest x values.", "Store all points in a hash set, then check the mirror partner of each point.", "Use the sum minX + maxX to avoid fractions: the partner of x is (minX + maxX - x)."], "statement": "You are given points on a 2D grid. Decide whether some vertical line mirrors\nthe whole set onto itself: reflecting every point across the line must land on\nanother point of the set (possibly itself). The mirror line may pass halfway\nbetween integer coordinates.\n\nFor instance, `[[1,1],[-1,1]]` is symmetric around the vertical axis, while\n`[[1,1],[-1,-1]]` is not, because the mirror of `(1,1)` would be `(-1,1)`,\nwhich is missing.\n\n**Constraints:**\n- `0 <= points.length <= 10000`\n- `points[i].length == 2`\n- `-10^8 <= points[i][j] <= 10^8`\n", "solution": "## Approach\n\nThe extreme x values pin down the only possible mirror: it must lie halfway\nbetween the minimum and maximum x. Collect every point in a hash set, then\nverify that each point's partner at `minX + maxX - x` with the same y is also\npresent.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of points.\n- **Space Complexity:** O(n) for the point set.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def isReflected(self, points: List[List[int]]) -> bool:\n if not points:\n return True\n mn = min(p[0] for p in points)\n mx = max(p[0] for p in points)\n seen = {(x, y) for x, y in points}\n total = mn + mx\n return all((total - x, y) in seen for x, y in points)\n```\n", "starter": {"go": "package main\n\nfunc IsReflected(points [][]int) bool {\n \n}", "python": "from typing import List\nclass Solution:\n def isReflected(self, points: List[List[int]]) -> bool:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n bool isReflected(vector<vector<int>>& points) {\n return false;\n }\n};"}, "fn": "isReflected", "params": [{"name": "points", "type": "int_array_2d"}], "outputType": "boolean", "tests": [["[[1, 1], [-1, 1]]"], ["[[1, 1], [-1, -1]]"], ["[[0, 0]]"], ["[[1, 1], [2, 1], [0, 1]]"], ["[[1, 1], [1, 1], [1, 1]]"], ["[[2, 2], [2, 2]]"], ["[[0, 0], [1, 0], [2, 0], [3, 0]]"], ["[[0, 0], [1, 0], [3, 0]]"], ["[[1, 2], [2, 3], [3, 2], [2, 1]]"], ["[[1, 2], [2, 3], [3, 2]]"], ["[[-100000000, 5], [100000000, 5]]"], ["[[5, 1], [5, 2], [5, 3]]"], ["[[1, 1], [3, 1], [2, 1]]"], ["[[0, 1], [0, 2], [4, 1], [4, 2]]"], ["[[0, 1], [0, 2], [4, 1]]"], ["[[1, 0], [2, 0], [3, 0], [4, 0]]"], ["[[1, 1], [2, 2], [3, 3], [0, 0]]"], ["[[2, 1], [2, -1], [4, 1], [4, -1]]"], ["[[2, 1], [2, -1], [4, 1]]"], ["[[0, 0], [0, 1], [0, 2]]"], ["[[1, 5], [3, 5], [5, 5], [7, 5]]"], ["[[1, 5], [3, 5], [5, 5]]"], ["[[-1, -1], [0, 0], [1, 1]]"], ["[[1, 2], [5, 2], [3, 4], [3, 0]]"], ["[[1, 2], [5, 2], [3, 4]]"], ["[[10, 10], [12, 10], [11, 11], [11, 9]]"], ["[[10, 10], [12, 10], [11, 11]]"]], "expected": [true, false, true, true, true, true, true, false, true, true, true, true, true, true, false, true, false, true, false, true, true, true, false, true, true, true, true], "loose": false}

package/data/problems/linked-list-components.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "815", "slug": "linked-list-components", "id": 815, "title": "Linked List Components", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/linked-list-components/", "examples": [{"input": "head = [0,1,2,3], nums = [0,1,3]", "output": "2", "explanation": "Nodes 0-1 form one connected block and node 3 forms another; node 2 breaks the chain."}, {"input": "head = [0,1,2,3,4], nums = [0,3,1,4]", "output": "2", "explanation": "Blocks 0-1 and 3-4 are each contiguous in the list."}, {"input": "head = [1,2,0,4], nums = [0]", "output": "1", "explanation": "A single matching node is one component."}], "hints": ["Store nums in a hash set for O(1) membership checks while walking the list.", "A new component starts at each matching node whose predecessor is missing or unmatched."], "statement": "You are given the head of a singly linked list holding distinct values and an array `nums` containing a subset of those values. A component is a maximal run of consecutive list nodes whose values all appear in `nums`.\n\nWalk the list from head to tail and count how many such blocks occur. For example, with list `[0,1,2,3]` and `nums = [0,1,3]`, the blocks are `[0,1]` and `[3]`, so the answer is 2.\n\n**Constraints:**\n- The list has between 1 and 10000 nodes.\n- Values are distinct and in range `[0, 10000]`.\n- `1 <= nums.length <= list length`.\n- Every value of `nums` appears in the list.\n", "solution": "## Approach\n\nPut all of `nums` into a hash set. Then sweep the linked list once, tracking whether the previous node was part of the set. Each time a matching node appears right after a non-matching stretch (or the start), a new component begins and the counter grows. This counts maximal runs in one pass.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + m) for a list of n nodes and m query values.\n- **Space Complexity:** O(m) for the lookup set.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def numComponents(self, head, nums: List[int]) -> int:\n wanted = set(nums)\n ans = 0\n in_run = False\n cur = head\n while cur is not None:\n if cur.val in wanted:\n if not in_run:\n ans += 1\n in_run = True\n else:\n in_run = False\n cur = cur.next\n return ans\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 NumComponents(head *ListNode, nums []int) int {\n return 0\n}", "python": "# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nfrom typing import List\nclass Solution:\n def numComponents(self, head, nums: List[int]) -> int:\n return 0\n", "cpp": "/*\nstruct ListNode {\n int val;\n ListNode *next;\n ListNode(): val(0), next(nullptr) {}\n ListNode(int x): val(x), next(nullptr) {}\n ListNode(int x, ListNode* next): val(x), next(next) {}\n};\n*/\nclass Solution {\npublic:\n int numComponents(ListNode* head, vector<int>& nums) {\n return 0;\n }\n};"}, "fn": "numComponents", "params": [{"name": "head", "type": "list_node"}, {"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[0,1,2,3]", "[0,1,3]"], ["[0,1,2,3,4]", "[0,3,1,4]"], ["[1,2,0,4]", "[0]"], ["[0]", "[0]"], ["[0,1]", "[0]"], ["[0,1]", "[1]"], ["[0,1]", "[0,1]"], ["[0,1,2]", "[2]"], ["[0,1,2]", "[0,2]"], ["[0,1,2,3,4,5]", "[0,2,4]"], ["[0,1,2,3,4,5]", "[0,1,2,3,4,5]"], ["[3,2,1]", "[1,2]"], ["[5,4,3,2,1]", "[1,3,5]"], ["[0,1,2,3]", "[3]"], ["[0,1,2,3]", "[0]"], ["[1,2,3,4,5]", "[2,4]"], ["[10,20,30,40]", "[20,30]"], ["[7,8,9,10,11]", "[7,11]"], ["[0,1,2,3,4,5,6,7]", "[1,3,5,7]"], ["[0,1,2,3,4,5,6,7]", "[0,1,6,7]"], ["[100,200,300]", "[100,200,300]"], ["[4,3,2,1]", "[2]"], ["[1,3,5,7,9]", "[3,5,7]"], ["[0,2,4,6,8]", "[0,8]"], ["[9,8,7,6,5]", "[9,8,7,6,5]"], ["[1,2]", "[2,1]"], ["[5,6,7,8,9,10]", "[6,7,8]"], ["[0,1,2,3,4]", "[1,2,3]"]], "expected": [2, 2, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 3, 1, 1, 2, 1, 2, 4, 2, 1, 1, 1, 2, 1, 1, 1, 1], "loose": false}

package/data/problems/linked-list-cycle-ii.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "303", "slug": "linked-list-cycle-ii", "id": 303, "title": "Linked List Cycle II", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/linked-list-cycle-ii/", "examples": [{"input": "head = [3,2,0,-4], pos = 1", "output": "1", "explanation": "The tail (-4) links to index 1 (value 2), so the cycle starts at index 1."}, {"input": "head = [1,2], pos = 0", "output": "0", "explanation": "The tail links to the head, so the cycle starts at index 0."}, {"input": "head = [1], pos = -1", "output": "-1", "explanation": "There is no cycle."}], "hints": ["Floyd's tortoise and hare finds a meeting point inside the loop, if any.", "Restart one pointer at the head; both advance one step until they meet at the entry.", "Count nodes to translate the entry node into its index; return -1 when there is no meeting."], "statement": "A linked list may contain a loop: the last node can point back to some earlier node. You are given the list values `head` and a loop descriptor `pos`, where `pos` is the index the tail links to (`-1` means no loop).\n\nFind where the loop starts and return its index. Return `-1` when there is no loop. Do not change the list.\n\n**Constraints:**\n- `0 <= number of nodes <= 10^4`\n- `-10^5 <= Node.val <= 10^5`\n- `pos` is `-1` or a valid list index.\n\n**Adaptation note:** The original LeetCode task returns the cycle-entry node (or null). Because a cyclic list cannot be serialized as an output value, this version returns the entry index (`-1` when absent). The `pos` field is test harness metadata used to build the loop and is not a function parameter.\n", "solution": "## Approach\n\nUse Floyd's two-pointer race: a slow pointer moves one node per step while a fast pointer moves two. If they ever coincide, a cycle exists. To locate its start, place one pointer back at the head and advance both singly; their next meeting is the entry node, whose index is counted from the head.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of nodes. Each pointer traverses at most a few passes.\n- **Space Complexity:** O(1), using two pointers.\n\n## Implementation\n\n```python\nclass Solution:\n def detectCycle(self, head) -> int:\n slow = fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow is fast:\n break\n else:\n return -1\n entry = head\n while entry is not slow:\n entry = entry.next\n slow = slow.next\n # count index of entry from head\n cur = head\n pos = 0\n while cur is not entry:\n cur = cur.next\n pos += 1\n return pos\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 DetectCycle(head *ListNode) int {\n return -1\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 detectCycle(self, head) -> int:\n return -1", "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 int detectCycle(ListNode* head) {\n return -1;\n }\n};"}, "fn": "detectCycle", "params": [{"name": "head", "type": "list_node"}], "outputType": "int", "tests": [["[3,2,0,-4]"], ["[1,2]"], ["[1]"], ["[]"], ["[1]"], ["[1,2]"], ["[1,2]"], ["[1,2,3]"], ["[1,2,3]"], ["[1,2,3]"], ["[1,2,3,4]"], ["[1,2,3,4]"], ["[1,2,3,4,5]"], ["[1,2,3,4,5]"], ["[1,2,3,4,5]"], ["[1,2,3,4,5]"], ["[1,1,1,1]"], ["[1,1,1,1]"], ["[2,2,2]"], ["[10,-5,3]"], ["[10,-5,3]"], ["[5,4,3,2,1]"], ["[5,4,3,2,1]"], ["[1,2,3,4,5,6]"], ["[1,2,3,4,5,6]"], ["[1,2,3,4,5,6]"], ["[7,8,9,10,11,12,13]"], ["[0,0,0,0]"]], "expected": null, "loose": false}

package/data/problems/linked-list-cycle.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "41", "slug": "linked-list-cycle", "id": 41, "title": "Detect Cycle in a Linked List", "difficulty": "Easy", "category": "linked-list", "link": "https://leetcode.com/problems/linked-list-cycle/", "examples": [{"input": "head = [3,2,0,-4], pos = 1", "output": "true", "explanation": "The linked list has a cycle (tail connects to a previous node), so the output is true.\n\n![Linked list with cycle at index 1](/api/problems/linked-list-cycle/asset/tc01.png)"}, {"input": "head = [1,2], pos = 0", "output": "true", "explanation": "The linked list has a cycle (tail connects to a previous node), so the output is true.\n\n![Linked list with cycle at head](/api/problems/linked-list-cycle/asset/tc02.png)"}, {"input": "head = [1], pos = -1", "output": "false", "explanation": "The linked list [1] has no cycle (pos=-1 means no connection), so the output is false.\n\n![Single node with no cycle](/api/problems/linked-list-cycle/asset/tc03.png)"}], "hints": ["Use Floyd's Tortoise and Hare algorithm to detect if a cycle exists in a singly linked list."], "statement": "You receive `head`, the first node of a singly linked list. Decide whether following `next` links from that node can ever revisit a node: return true when such a loop exists, and false when the chain ends.\n\nA loop means some node in the chain is reachable a second time by continuing along `next` pointers. For describing tests, `pos` records the index that the tail's `next` link points back to. Take note that `pos` is only a description of the test data and is not handed to your code.\n\n**Constraints:**\n\n- The number of the nodes in the list is in the range [0, 10^4].\n- -10^5 \u2264 Node.val \u2264 10^5\n- pos is -1 or a valid index in the linked-list.\n", "solution": "## Approach\n\nFloyd's cycle detection (tortoise and hare) using two pointers moving at different speeds. If they meet, a cycle exists; if the fast pointer reaches the end, there is no cycle.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of nodes.\n- **Space Complexity:** O(1), using only two pointers.\n\n## Implementation\n\n```python\nfrom typing import Optional\nclass Solution:\n def hasCycle(self, head: Optional[ListNode]) -> bool:\n slow = fast = head\n while fast and fast.next:\n slow = slow.next\n fast = fast.next.next\n if slow == fast:\n return True\n return False\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 HasCycle(head *ListNode) bool {\n \n}", "python": "# class ListNode:\n# def __init__(self, val=0, next=None):\n# self.val = val\n# self.next = next\n\nclass Solution:\n def hasCycle(self, head) -> bool:\n pass\n", "cpp": "/*\nstruct ListNode {\n int val;\n ListNode *next;\n ListNode(): val(0), next(nullptr) {}\n ListNode(int x): val(x), next(nullptr) {}\n ListNode(int x, ListNode* next): val(x), next(next) {}\n};\n*/\nclass Solution {\npublic:\n bool hasCycle(ListNode* head) {\n return false;\n }\n};\n"}, "fn": "hasCycle", "params": [{"name": "head", "type": "list_node"}], "outputType": "boolean", "tests": [["[]"], ["[1]"], ["[1]"], ["[1,2]"], ["[1,2]"], ["[1,2]"], ["[3,2,0,-4]"], ["[1,2,3,4,5]"], ["[1,2,3,4,5]"], ["[1,2,3,4,5]"], ["[1,1,1,1,1]"], ["[1,1,1,1,1]"], ["[1,2,3]"], ["[1,2,3]"], ["[1,2,3]"], ["[1,2,3,4]"], ["[1,2,3,4]"], ["[1,2,3,4]"], ["[2,2,2]"], ["[2,2,2]"], ["[10,-5,3]"], ["[10,-5,3]"], ["[100000,-100000]"], ["[100000,-100000]"], ["[1,2,3,4,5,6]"], ["[1,2,3,4,5,6]"], ["[1,2,3,4,5,6]"], ["[7]"], ["[9]"], ["[5,4,3,2,1]"], ["[5,4,3,2,1]"]], "expected": null, "loose": false}

package/data/problems/linked-list-random-node.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "458", "slug": "linked-list-random-node", "id": 458, "title": "Linked List Random Node", "difficulty": "Medium", "category": "linked-list", "link": "https://leetcode.com/problems/linked-list-random-node/", "examples": [{"input": "head = [1,2,3]", "output": "2", "explanation": "Any of 1, 2, or 3 is valid."}, {"input": "head = [5]", "output": "5", "explanation": "Only value available."}, {"input": "head = [1,2,2,3]", "output": "2", "explanation": "Returned value appears in the list."}], "hints": ["Collecting the values into an array and picking one index works for a single call.", "Reservoir sampling (keep candidate i with probability 1/i) handles unknown lengths in one pass.", "The judge only checks membership, not uniformity."], "statement": "Return any value stored in a linked list, standing in for a uniform random pick.\n\nYou receive the head of a singly linked list with at least one node. Implement `getRandomNode(head)`, which returns the value of one node from the chain. The classic task additionally requires every node to be equally likely (usually via reservoir sampling) across repeated calls; this portable version calls the function once per test and accepts any value present in the list, so sampling fairness is not verified. Just make sure the returned integer actually occurs in the input chain.\n\n**Constraints:**\n- `1 <= number of nodes <= 10^4`\n- `-10^4 <= Node.val <= 10^4`\n", "solution": "## Approach\n\nWalk the chain once, keeping a candidate that is replaced with diminishing probability (reservoir sampling), or simply store every value and pick one slot. Either way a single call returns a member of the list; the judge accepts any member rather than verifying uniformity.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of nodes.\n- **Space Complexity:** O(1) with reservoir sampling, O(n) when buffering all values.\n\n## Implementation\n\n```python\nimport random\nclass Solution:\n def getRandomNode(self, head) -> int:\n vals = []\n p = head\n while p is not None:\n vals.append(p.val)\n p = p.next\n return random.choice(vals)\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 GetRandomNode(head *ListNode) int {\n return 0\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 getRandomNode(self, head) -> int:\n return 0\n", "cpp": "/*\nstruct ListNode {\n int val;\n ListNode *next;\n ListNode(): val(0), next(nullptr) {}\n ListNode(int x): val(x), next(nullptr) {}\n ListNode(int x, ListNode* next): val(x), next(next) {}\n};\n*/\nclass Solution {\npublic:\n int getRandomNode(ListNode* head) {\n return 0;\n }\n};"}, "fn": "getRandomNode", "params": [{"name": "head", "type": "list_node"}], "outputType": "int", "tests": [["[1,2,3]"], ["[5]"], ["[1,2,2,3]"], ["[10,20,30,40,50]"], ["[1]"], ["[0]"], ["[-10000,10000]"], ["[1,1,1,1]"], ["[7,7,8,8,9]"], ["[100,200]"], ["[3,1,4,1,5,9,2,6]"], ["[-5,-4,-3,-2,-1]"], ["[42]"], ["[1,2]"], ["[9,8,7,6,5,4,3,2,1]"], ["[0,0,0,1]"], ["[5,5,6,6,6]"], ["[10000]"], ["[-10000]"], ["[1,3,5,7,9,11]"], ["[2,4,6,8,10,12,14]"], ["[15,15,15]"], ["[1,2,3,4,5,6,7,8,9,10]"], ["[-1,0,1]"], ["[999,1000]"], ["[4,2]"], ["[6,1,6,1,6]"], ["[8,6,7,5,3,0,9]"], ["[1234]"], ["[5,4,3,2,1,0,-1,-2]"]], "expected": [1, 5, 1, 10, 1, 0, -10000, 1, 7, 100, 3, -5, 42, 1, 9, 0, 5, 10000, -10000, 1, 2, 15, 1, -1, 999, 4, 6, 8, 1234, 5], "loose": false}

package/data/problems/logger-rate-limiter.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "438", "slug": "logger-rate-limiter", "id": 438, "title": "Logger Rate Limiter", "difficulty": "Easy", "category": "hash-table", "link": "https://leetcode.com/problems/logger-rate-limiter/", "examples": [{"input": "timestamps = [1,2,3,8,10,11], messages = [\"foo\",\"bar\",\"foo\",\"bar\",\"foo\",\"foo\"]", "output": "[1,1,0,0,0,1]", "explanation": "A message prints only when 10 seconds have passed since its last printing."}, {"input": "timestamps = [0,10,20], messages = [\"a\",\"a\",\"a\"]", "output": "[1,1,1]", "explanation": "Each request lands exactly on the 10-second boundary."}], "hints": ["Remember only the latest printed timestamp per distinct message.", "A request prints exactly when the gap since that stored time is 10 or more.", "Update the stored time on every printed request, never on rejected ones."], "statement": "A logger receives print requests, each carrying a timestamp (in seconds) and a\nmessage. A message may be printed when it has never appeared before, or when at\nleast 10 seconds have passed since it was last printed. Otherwise the request\nis rejected.\n\nTimestamps arrive in non-decreasing order.\n\n**Adaptation note:** instead of a stateful class, implement\n`runLogger(timestamps, messages)`, which replays one request per index and\nreturns an array using `1` for \"printed\" and `0` for \"rejected\".\n\n**Constraints:**\n- `1 <= timestamps.length == messages.length <= 500`\n- `0 <= timestamps[i] <= 10^9`, non-decreasing\n- `1 <= messages[i].length <= 100`, lowercase letters and spaces\n", "solution": "## Approach\n\nTrack the most recent printed timestamp for each distinct message in a hash\nmap. A request prints when the message is new or the gap since its stored\ntime reaches 10 seconds; only printed requests refresh the stored time.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the number of requests.\n- **Space Complexity:** O(m) for m distinct messages.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def runLogger(self, timestamps: List[int], messages: List[str]) -> List[int]:\n last = {}\n ans = []\n for t, m in zip(timestamps, messages):\n if m not in last or t - last[m] >= 10:\n ans.append(1)\n last[m] = t\n else:\n ans.append(0)\n return ans\n```\n", "starter": {"go": "package main\n\nfunc RunLogger(timestamps []int, messages []string) []int {\n \n}", "python": "from typing import List\nclass Solution:\n def runLogger(self, timestamps: List[int], messages: List[str]) -> List[int]:\n pass", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<int> runLogger(vector<int>& timestamps, vector<string>& messages) {\n return {};\n }\n};"}, "fn": "runLogger", "params": [{"name": "timestamps", "type": "int_array"}, {"name": "messages", "type": "string_array"}], "outputType": "int_array", "tests": [["[1,2,3,8,10,11]", "[\"foo\",\"bar\",\"foo\",\"bar\",\"foo\",\"foo\"]"], ["[0,10,20]", "[\"a\",\"a\",\"a\"]"], ["[0,1,2]", "[\"a\",\"a\",\"a\"]"], ["[5]", "[\"solo\"]"], ["[0,0,0]", "[\"a\",\"a\",\"b\"]"], ["[1,1,11,11,21]", "[\"m\",\"m\",\"m\",\"m\",\"m\"]"], ["[0,5,10,15,20]", "[\"x\",\"y\",\"x\",\"y\",\"x\"]"], ["[3,3,3,13]", "[\"a b\",\"a b\",\"c\",\"a b\"]"], ["[100,109,110,119,120]", "[\"t\",\"t\",\"t\",\"t\",\"t\"]"], ["[0,9,10,19,20]", "[\"k\",\"k\",\"k\",\"k\",\"k\"]"], ["[1,2,3,4,5]", "[\"a\",\"b\",\"c\",\"d\",\"e\"]"], ["[7,7,7,7]", "[\"same\",\"same\",\"same\",\"same\"]"], ["[0,10,10,20,20,30]", "[\"p\",\"p\",\"q\",\"p\",\"q\",\"p\"]"], ["[2,4,6,8,10,12]", "[\"n\",\"n\",\"n\",\"n\",\"n\",\"n\"]"], ["[0,1,10,11,20,21]", "[\"a\",\"b\",\"a\",\"b\",\"a\",\"b\"]"], ["[50]", "[\"edge\"]"], ["[0,1000000000]", "[\"big\",\"big\"]"], ["[1,10,11,20,21,30]", "[\"z\",\"z\",\"z\",\"z\",\"z\",\"z\"]"], ["[5,5,15,15,25]", "[\"a\",\"b\",\"a\",\"b\",\"a\"]"], ["[0,2,12,14,24]", "[\"hello world\",\"hello world\",\"hello world\",\"hello world\",\"hello world\"]"], ["[8,9,18,19,28,29]", "[\"m1\",\"m2\",\"m1\",\"m2\",\"m1\",\"m2\"]"], ["[0,10]", "[\"a\",\"b\"]"], ["[4,14,15,24,25]", "[\"c\",\"c\",\"c\",\"c\",\"c\"]"], ["[6,16,16,26]", "[\"d\",\"d\",\"d\",\"d\"]"], ["[1,2,11,12,22]", "[\"e\",\"f\",\"e\",\"f\",\"e\"]"], ["[9,10,11,20]", "[\"g\",\"g\",\"g\",\"g\"]"]], "expected": [[1, 1, 0, 0, 0, 1], [1, 1, 1], [1, 0, 0], [1], [1, 0, 1], [1, 0, 1, 0, 1], [1, 1, 1, 1, 1], [1, 0, 1, 1], [1, 0, 1, 0, 1], [1, 0, 1, 0, 1], [1, 1, 1, 1, 1], [1, 0, 0, 0], [1, 1, 1, 1, 1, 1], [1, 0, 0, 0, 0, 1], [1, 1, 1, 1, 1, 1], [1], [1, 1], [1, 0, 1, 0, 1, 0], [1, 1, 1, 1, 1], [1, 0, 1, 0, 1], [1, 1, 1, 1, 1, 1], [1, 1], [1, 1, 0, 1, 0], [1, 1, 0, 1], [1, 1, 1, 1, 1], [1, 0, 0, 1]], "loose": false}

package/data/problems/logical-or-of-two-binary-grids-represented-as-quad-trees.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "614", "slug": "logical-or-of-two-binary-grids-represented-as-quad-trees", "id": 614, "title": "Logical OR of Two Binary Grids Represented as Quad-Trees", "difficulty": "Medium", "category": "tree", "link": "https://leetcode.com/problems/logical-or-of-two-binary-grids-represented-as-quad-trees/", "examples": [{"input": "quadTree1 = [[1,1]], quadTree2 = [[1,0]]", "output": "[[1,1]]", "explanation": "True OR False is True."}, {"input": "quadTree1 = [[0,1],[1,0],[1,1],[1,1],[1,0]], quadTree2 = [[1,0]]", "output": "[[0,1],[1,0],[1,1],[1,1],[1,0]]", "explanation": "OR with all-False keeps the first grid."}, {"input": "quadTree1 = [[0,1],[1,0],[1,1],[1,1],[1,0]], quadTree2 = [[1,1]]", "output": "[[1,1]]", "explanation": "OR with all-True gives all-True."}], "hints": ["Rebuild both node trees from the BFS lists: leaves stop, internal nodes take the next four entries as children.", "A leaf True dominates (result leaf True); a leaf False defers to the other subtree.", "When both sides are internal, merge the four child pairs, then collapse uniform leaf children into one leaf."], "statement": "Two binary grids of equal size are each given as a quad tree. Combine them with a cell-wise logical OR and return the quad tree of the resulting grid.\n\nRepresentation used here (matching the Construct Quad Tree problem): each tree is serialized as a breadth-first list of `[isLeaf, val]` pairs with `1/0` integers. Leaves carry the cell value and have no entries for children; every internal node is followed by its four children in topLeft, topRight, bottomLeft, bottomRight order. Internal nodes always store `val` 1 in outputs.\n\nMerging follows two simplifications: OR-ing anything with a leaf `1` gives a leaf `1`, and OR-ing anything with a leaf `0` gives the other side unchanged. After merging children, an internal node whose four children are all leaves holding the same value collapses into a single leaf.\n\n**Constraints:**\n- Each input is a valid minimal quad-tree serialization with at most a few hundred nodes.\n- Both trees describe the same grid size (a power-of-two square).\n", "solution": "## Approach\n\nDecode each BFS list back into a quad tree with a queue: the first pair is the root, and every internal node dequeued claims its four children from the next entries while leaves claim none. Merge recursively \u2014 a True leaf wins outright, a False leaf yields to the opposite subtree, and two internal nodes merge child by child with a final collapse when all four results are equal leaves. The merged tree is then re-encoded with the same breadth-first layout.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the total number of serialized nodes.\n- **Space Complexity:** O(n) for the rebuilt trees and the output list.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def intersect(self, quadTree1: List[List[int]], quadTree2: List[List[int]]) -> List[List[int]]:\n class Node:\n __slots__ = (\"val\", \"leaf\", \"kids\")\n def __init__(self, val, leaf):\n self.val = val\n self.leaf = leaf\n self.kids = []\n\n def decode(a):\n root = Node(a[0][1] == 1, a[0][0] == 1)\n q = [root]\n idx = 1\n i = 0\n while i < len(q) and idx < len(a):\n n = q[i]\n i += 1\n if n.leaf:\n continue\n for _ in range(4):\n c = Node(a[idx][1] == 1, a[idx][0] == 1)\n idx += 1\n n.kids.append(c)\n q.append(c)\n return root\n\n def clone(n):\n c = Node(n.val, n.leaf)\n c.kids = [clone(k) for k in n.kids]\n return c\n\n def merge(a, b):\n if a.leaf:\n return Node(True, True) if a.val else clone(b)\n if b.leaf:\n return Node(True, True) if b.val else clone(a)\n kids = [merge(x, y) for x, y in zip(a.kids, b.kids)]\n if all(k.leaf for k in kids) and all(k.val == kids[0].val for k in kids):\n return Node(kids[0].val, True)\n n = Node(True, False)\n n.kids = kids\n return n\n\n def encode(root):\n out = []\n q = [root]\n i = 0\n while i < len(q):\n n = q[i]\n i += 1\n out.append([1 if n.leaf else 0, 1 if n.val else 0])\n if not n.leaf:\n q.extend(n.kids)\n return out\n\n return encode(merge(decode(quadTree1), decode(quadTree2)))\n```\n", "starter": {"go": "package main\n\nfunc Intersect(quadTree1 [][]int, quadTree2 [][]int) [][]int {\n return nil\n}", "python": "from typing import List\nclass Solution:\n def intersect(self, quadTree1: List[List[int]], quadTree2: List[List[int]]) -> List[List[int]]:\n return []\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<vector<int>> intersect(vector<vector<int>>& quadTree1, vector<vector<int>>& quadTree2) {\n return {};\n }\n};"}, "fn": "intersect", "params": [{"name": "quadTree1", "type": "int_array_2d"}, {"name": "quadTree2", "type": "int_array_2d"}], "outputType": "int_array_2d", "tests": [["[[1,1]]", "[[1,1]]"], ["[[1,1]]", "[[1,0]]"], ["[[1,0]]", "[[1,0]]"], ["[[1,0]]", "[[1,1]]"], ["[[0,1],[1,0],[1,1],[1,1],[1,0]]", "[[1,0]]"], ["[[0,1],[1,0],[1,1],[1,1],[1,0]]", "[[1,1]]"], ["[[1,0]]", "[[0,1],[1,0],[1,1],[1,1],[1,0]]"], ["[[1,1]]", "[[0,1],[1,0],[1,1],[1,1],[1,0]]"], ["[[0,1],[1,1],[1,0],[1,0],[1,0]]", "[[1,0]]"], ["[[0,1],[1,1],[1,0],[1,0],[1,0]]", "[[1,1]]"], ["[[0,1],[1,1],[1,1],[1,0],[1,0]]", "[[1,0]]"], ["[[0,1],[1,1],[1,1],[1,0],[1,0]]", "[[1,1]]"], ["[[0,1],[1,0],[1,1],[1,1],[1,0]]", "[[0,1],[1,0],[1,1],[1,1],[1,0]]"], ["[[0,1],[1,0],[1,1],[1,1],[1,0]]", "[[0,1],[1,1],[1,0],[1,0],[1,0]]"], ["[[0,1],[1,1],[1,0],[1,0],[1,0]]", "[[0,1],[1,1],[1,1],[1,0],[1,0]]"], ["[[0,1],[1,1],[1,1],[1,0],[1,0]]", "[[0,1],[1,1],[1,1],[1,0],[1,0]]"], ["[[0,1],[0,1],[1,0],[1,1],[1,0],[1,0],[1,1],[1,1],[1,0]]", "[[1,0]]"], ["[[0,1],[0,1],[1,0],[1,1],[1,0],[1,0],[1,1],[1,1],[1,0]]", "[[1,1]]"], ["[[1,0]]", "[[0,1],[0,1],[1,0],[1,1],[1,0],[1,0],[1,1],[1,1],[1,0]]"], ["[[0,1],[0,1],[1,0],[1,1],[1,0],[1,0],[1,1],[1,1],[1,0]]", "[[0,1],[1,0],[1,1],[1,1],[1,0]]"], ["[[0,1],[1,1],[0,1],[1,0],[1,0],[1,1],[1,0],[1,1],[1,0]]", "[[1,0]]"], ["[[0,1],[1,1],[0,1],[1,0],[1,0],[1,1],[1,0],[1,1],[1,0]]", "[[1,1]]"], ["[[0,1],[0,1],[1,0],[1,1],[1,0],[1,0],[1,1],[1,1],[1,0]]", "[[0,1],[1,1],[0,1],[1,0],[1,0],[1,1],[1,0],[1,1],[1,0]]"], ["[[0,1],[1,1],[0,1],[1,0],[1,0],[1,1],[1,0],[1,1],[1,0]]", "[[0,1],[1,1],[0,1],[1,0],[1,0],[1,1],[1,0],[1,1],[1,0]]"], ["[[0,1],[1,0],[1,1],[1,1],[1,0]]", "[[0,1],[0,1],[1,0],[1,1],[1,0],[1,0],[1,1],[1,1],[1,0]]"], ["[[0,1],[1,1],[1,0],[1,0],[1,0]]", "[[0,1],[0,1],[1,0],[1,1],[1,0],[1,0],[1,1],[1,1],[1,0]]"], ["[[0,1],[1,1],[1,1],[1,0],[1,0]]", "[[0,1],[1,1],[0,1],[1,0],[1,0],[1,1],[1,0],[1,1],[1,0]]"], ["[[1,1]]", "[[0,1],[0,1],[1,0],[1,1],[1,0],[1,0],[1,1],[1,1],[1,0]]"]], "expected": [[[1, 1]], [[1, 1]], [[1, 0]], [[1, 1]], [[0, 1], [1, 0], [1, 1], [1, 1], [1, 0]], [[1, 1]], [[0, 1], [1, 0], [1, 1], [1, 1], [1, 0]], [[1, 1]], [[0, 1], [1, 1], [1, 0], [1, 0], [1, 0]], [[1, 1]], [[0, 1], [1, 1], [1, 1], [1, 0], [1, 0]], [[1, 1]], [[0, 1], [1, 0], [1, 1], [1, 1], [1, 0]], [[0, 1], [1, 1], [1, 1], [1, 1], [1, 0]], [[0, 1], [1, 1], [1, 1], [1, 0], [1, 0]], [[0, 1], [1, 1], [1, 1], [1, 0], [1, 0]], [[0, 1], [0, 1], [1, 0], [1, 1], [1, 0], [1, 0], [1, 1], [1, 1], [1, 0]], [[1, 1]], [[0, 1], [0, 1], [1, 0], [1, 1], [1, 0], [1, 0], [1, 1], [1, 1], [1, 0]], [[0, 1], [0, 1], [1, 1], [1, 1], [1, 0], [1, 0], [1, 1], [1, 1], [1, 0]], [[0, 1], [1, 1], [0, 1], [1, 0], [1, 0], [1, 1], [1, 0], [1, 1], [1, 0]], [[1, 1]], [[0, 1], [1, 1], [0, 1], [1, 1], [1, 0], [1, 1], [1, 0], [1, 1], [1, 0]], [[0, 1], [1, 1], [0, 1], [1, 0], [1, 0], [1, 1], [1, 0], [1, 1], [1, 0]], [[0, 1], [0, 1], [1, 1], [1, 1], [1, 0], [1, 0], [1, 1], [1, 1], [1, 0]], [[0, 1], [1, 1], [1, 0], [1, 1], [1, 0]], [[0, 1], [1, 1], [1, 1], [1, 0], [1, 0]], [[1, 1]]], "loose": false}

package/data/problems/lonely-pixel-i.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "590", "slug": "lonely-pixel-i", "id": 590, "title": "Lonely Pixel I", "difficulty": "Medium", "category": "matrix", "link": "https://leetcode.com/problems/lonely-pixel-i/", "examples": [{"input": "picture = [[\"W\",\"W\",\"B\"],[\"W\",\"B\",\"W\"],[\"B\",\"W\",\"W\"]]", "output": "3", "explanation": "Each black pixel sits alone in its row and column."}, {"input": "picture = [[\"B\",\"B\"],[\"B\",\"W\"]]", "output": "0", "explanation": "Every black pixel shares its row or column with another black pixel."}, {"input": "picture = [[\"W\",\"B\",\"W\"]]", "output": "1", "explanation": "The single black pixel has no company in its row or column."}], "hints": ["Count the black pixels in each row and each column first.", "A black pixel is lonely exactly when its row count and its column count are both 1.", "Rust note: the picture arrives as its encoded string; parse it before counting."], "statement": "You are given a picture as a grid of characters where `B` marks a black pixel and `W` marks a white pixel. A black pixel is called *lonely* when its entire row and its entire column contain no other black pixels (it is the only `B` in both).\n\nReturn the number of lonely black pixels in the picture.\n\n**Constraints:**\n- `1 <= picture.length, picture[i].length <= 500`\n- The grid is rectangular and holds only `B` and `W`.\n", "solution": "## Approach\n\nFirst tally the black pixels in every row and every column with two counting arrays. Then revisit each black pixel and keep it only when both its row tally and its column tally equal exactly one. This two-pass scan captures precisely the lonely pixels.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n), where m and n are the picture dimensions.\n- **Space Complexity:** O(m + n) for the row and column tallies.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def findLonelyPixel(self, picture: List[List[str]]) -> int:\n m, n = len(picture), len(picture[0])\n rows = [0] * m\n cols = [0] * n\n for i in range(m):\n for j in range(n):\n if picture[i][j] == 'B':\n rows[i] += 1\n cols[j] += 1\n ans = 0\n for i in range(m):\n for j in range(n):\n if picture[i][j] == 'B' and rows[i] == 1 and cols[j] == 1:\n ans += 1\n return ans\n```\n", "starter": {"go": "package main\n\nfunc FindLonelyPixel(picture [][]byte) int {\n return 0\n}", "python": "from typing import List\nclass Solution:\n def findLonelyPixel(self, picture: List[List[str]]) -> int:\n return 0\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int findLonelyPixel(vector<vector<char>>& picture) {\n return 0;\n }\n};"}, "fn": "findLonelyPixel", "params": [{"name": "picture", "type": "char_array_2d"}], "outputType": "int", "tests": [["[[\"W\",\"W\",\"B\"],[\"W\",\"B\",\"W\"],[\"B\",\"W\",\"W\"]]"], ["[[\"B\",\"B\"],[\"B\",\"W\"]]"], ["[[\"W\",\"B\",\"W\"]]"], ["[[\"B\"]]"], ["[[\"W\"]]"], ["[[\"B\",\"W\"],[\"W\",\"W\"]]"], ["[[\"B\",\"W\"],[\"W\",\"B\"]]"], ["[[\"B\",\"B\"],[\"B\",\"B\"]]"], ["[[\"W\",\"W\",\"W\"],[\"W\",\"W\",\"W\"]]"], ["[[\"B\",\"B\",\"B\"]]"], ["[[\"B\"],[\"B\"],[\"B\"]]"], ["[[\"B\"],[\"W\"],[\"B\"]]"], ["[[\"W\",\"B\"],[\"B\",\"W\"],[\"W\",\"W\"]]"], ["[[\"B\",\"W\",\"B\",\"W\"],[\"W\",\"W\",\"W\",\"W\"],[\"B\",\"W\",\"B\",\"W\"]]"], ["[[\"W\",\"W\",\"W\",\"B\"],[\"W\",\"W\",\"W\",\"W\"],[\"W\",\"W\",\"W\",\"W\"],[\"B\",\"W\",\"W\",\"W\"]]"], ["[[\"B\",\"W\",\"W\"],[\"W\",\"W\",\"W\"],[\"W\",\"W\",\"B\"]]"], ["[[\"B\",\"W\",\"W\"],[\"W\",\"B\",\"W\"],[\"W\",\"W\",\"W\"]]"], ["[[\"W\",\"B\",\"W\",\"B\",\"W\"]]"], ["[[\"B\"],[\"W\"],[\"W\"],[\"B\"],[\"W\"]]"], ["[[\"W\",\"W\",\"B\",\"W\"],[\"W\",\"W\",\"W\",\"W\"],[\"B\",\"W\",\"W\",\"W\"],[\"W\",\"W\",\"W\",\"B\"]]"], ["[[\"B\",\"W\",\"B\"],[\"W\",\"W\",\"W\"],[\"B\",\"W\",\"B\"]]"], ["[[\"W\",\"W\",\"W\",\"W\",\"B\"]]"], ["[[\"B\",\"W\",\"W\",\"W\",\"W\",\"B\"]]"], ["[[\"W\",\"B\",\"W\"],[\"W\",\"B\",\"W\"],[\"W\",\"W\",\"W\"]]"], ["[[\"B\",\"W\",\"W\",\"B\"],[\"W\",\"W\",\"W\",\"W\"],[\"W\",\"B\",\"W\",\"W\"]]"], ["[[\"W\",\"W\",\"B\",\"W\",\"W\"],[\"W\",\"W\",\"B\",\"W\",\"W\"],[\"B\",\"B\",\"W\",\"B\",\"B\"]]"], ["[[\"B\",\"W\",\"W\",\"W\"],[\"W\",\"B\",\"W\",\"W\"],[\"W\",\"W\",\"B\",\"W\"],[\"W\",\"W\",\"W\",\"B\"]]"], ["[[\"W\",\"W\",\"W\"],[\"W\",\"B\",\"B\"],[\"W\",\"W\",\"W\"]]"]], "expected": [3, 0, 1, 1, 0, 1, 2, 0, 0, 0, 0, 0, 2, 0, 2, 2, 2, 0, 0, 3, 0, 1, 0, 0, 1, 0, 4, 0], "loose": false}

package/data/problems/lonely-pixel-ii.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "592", "slug": "lonely-pixel-ii", "id": 592, "title": "Lonely Pixel II", "difficulty": "Medium", "category": "matrix", "link": "https://leetcode.com/problems/lonely-pixel-ii/", "examples": [{"input": "picture = [[\"W\",\"B\",\"W\",\"B\",\"B\",\"W\"],[\"W\",\"B\",\"W\",\"B\",\"B\",\"W\"],[\"W\",\"B\",\"W\",\"B\",\"B\",\"W\"],[\"W\",\"W\",\"B\",\"W\",\"B\",\"W\"]], N = 3", "output": "6", "explanation": "Columns 1 and 3 each hold exactly 3 black pixels in identical rows, giving 3 times 2 = 6."}, {"input": "picture = [[\"W\",\"B\",\"W\"],[\"B\",\"W\",\"W\"]], N = 1", "output": "2", "explanation": "Both black pixels sit in rows and columns that each hold exactly one black pixel."}], "hints": ["Precompute each row's black-pixel count and each column's black-pixel count.", "For a candidate pixel, confirm the counts equal N, then scan the column checking row equality.", "Compare rows with a helper or by joining each row into a string key. Rust note: the picture arrives as its encoded string; parse it before counting."], "statement": "You are given a picture as a grid of `B` (black) and `W` (white) pixels, plus a positive integer `N`. A black pixel at position `(r, c)` is counted when all three of these hold:\n1. Row `r` contains exactly `N` black pixels.\n2. Column `c` contains exactly `N` black pixels.\n3. Every row that has a black pixel in column `c` looks exactly like row `r` (same pattern of black and white cells).\n\nReturn the total number of black pixels satisfying all three conditions.\n\n**Constraints:**\n- `1 <= picture.length, picture[i].length <= 500`\n- The grid is rectangular and holds only `B` and `W`.\n- `1 <= N <= picture.length`\n", "solution": "## Approach\n\nCount black pixels per row and per column up front. A pixel can only qualify when its row count and column count both equal `N`, which already rules out most cells. For each surviving candidate, walk down its column: every row holding a black pixel there must match the candidate's whole row, compared with an array equality test. Candidates passing all three filters are tallied.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m^2 * n), where the picture is m by n: each candidate may scan a full column with row comparisons.\n- **Space Complexity:** O(m + n) for the two count arrays.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def findBlackPixel(self, picture: List[List[str]], n: int) -> int:\n m, cols = len(picture), len(picture[0])\n row_count = [row.count('B') for row in picture]\n col_count = [sum(1 for i in range(m) if picture[i][j] == 'B') for j in range(cols)]\n ans = 0\n for i in range(m):\n if row_count[i] != n:\n continue\n for j in range(cols):\n if picture[i][j] != 'B' or col_count[j] != n:\n continue\n ok = True\n for r in range(m):\n if picture[r][j] == 'B' and picture[r] != picture[i]:\n ok = False\n break\n if ok:\n ans += 1\n return ans\n```\n", "starter": {"go": "package main\n\nfunc FindBlackPixel(picture [][]byte, n int) int {\n return 0\n}", "python": "from typing import List\nclass Solution:\n def findBlackPixel(self, picture: List[List[str]], n: int) -> int:\n return 0\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int findBlackPixel(vector<vector<char>>& picture, int n) {\n return 0;\n }\n};"}, "fn": "findBlackPixel", "params": [{"name": "picture", "type": "char_array_2d"}, {"name": "n", "type": "int"}], "outputType": "int", "tests": [["[[\"W\",\"B\",\"W\",\"B\",\"B\",\"W\"],[\"W\",\"B\",\"W\",\"B\",\"B\",\"W\"],[\"W\",\"B\",\"W\",\"B\",\"B\",\"W\"],[\"W\",\"W\",\"B\",\"W\",\"B\",\"W\"]]", "3"], ["[[\"W\",\"B\",\"W\"],[\"B\",\"W\",\"W\"]]", "1"], ["[[\"B\",\"B\"],[\"B\",\"W\"]]", "2"], ["[[\"B\"]]", "1"], ["[[\"W\"]]", "1"], ["[[\"B\",\"W\",\"B\"]]", "2"], ["[[\"B\",\"W\",\"B\"]]", "1"], ["[[\"B\",\"B\"],[\"B\",\"B\"]]", "2"], ["[[\"B\",\"B\"],[\"B\",\"B\"]]", "1"], ["[[\"B\",\"W\",\"W\"],[\"W\",\"B\",\"W\"],[\"W\",\"W\",\"B\"]]", "1"], ["[[\"B\",\"B\",\"W\"],[\"B\",\"B\",\"W\"],[\"W\",\"W\",\"W\"]]", "2"], ["[[\"B\",\"B\",\"W\"],[\"B\",\"W\",\"B\"],[\"W\",\"W\",\"W\"]]", "2"], ["[[\"W\",\"W\",\"W\"],[\"W\",\"W\",\"W\"]]", "1"], ["[[\"B\",\"B\",\"B\",\"B\"]]", "4"], ["[[\"B\",\"B\",\"B\",\"B\"]]", "1"], ["[[\"B\"],[\"W\"],[\"B\"],[\"W\"]]", "1"], ["[[\"B\",\"W\",\"W\",\"W\"],[\"W\",\"W\",\"W\",\"W\"],[\"W\",\"W\",\"W\",\"W\"],[\"W\",\"W\",\"W\",\"W\"]]", "1"], ["[[\"B\",\"B\",\"W\",\"W\"],[\"B\",\"B\",\"W\",\"W\"],[\"W\",\"W\",\"W\",\"W\"]]", "2"], ["[[\"B\",\"B\",\"W\",\"W\"],[\"B\",\"B\",\"W\",\"W\"],[\"W\",\"W\",\"W\",\"W\"]]", "3"], ["[[\"B\",\"W\",\"W\",\"W\",\"W\"],[\"W\",\"B\",\"W\",\"W\",\"W\"],[\"W\",\"W\",\"B\",\"W\",\"W\"],[\"W\",\"W\",\"W\",\"B\",\"W\"],[\"W\",\"W\",\"W\",\"W\",\"B\"]]", "1"], ["[[\"B\",\"W\",\"W\",\"W\",\"W\"],[\"W\",\"B\",\"W\",\"W\",\"W\"],[\"W\",\"W\",\"B\",\"W\",\"W\"],[\"W\",\"W\",\"W\",\"B\",\"W\"],[\"W\",\"W\",\"W\",\"W\",\"B\"]]", "2"], ["[[\"B\",\"B\",\"B\"],[\"B\",\"B\",\"B\"],[\"B\",\"B\",\"B\"]]", "3"], ["[[\"B\",\"B\",\"B\"],[\"B\",\"B\",\"B\"],[\"B\",\"B\",\"B\"]]", "2"], ["[[\"W\",\"B\",\"W\",\"W\"],[\"W\",\"B\",\"W\",\"W\"],[\"B\",\"W\",\"W\",\"W\"]]", "2"], ["[[\"W\",\"B\",\"W\",\"W\"],[\"W\",\"B\",\"W\",\"W\"],[\"B\",\"W\",\"W\",\"W\"]]", "1"], ["[[\"B\",\"W\",\"W\"],[\"B\",\"W\",\"W\"]]", "1"], ["[[\"B\",\"W\",\"W\"],[\"W\",\"W\",\"W\"]]", "1"], ["[[\"W\",\"B\",\"W\",\"B\"],[\"W\",\"B\",\"W\",\"B\"],[\"W\",\"W\",\"W\",\"W\"]]", "2"]], "expected": [6, 2, 0, 1, 0, 0, 0, 4, 0, 3, 4, 0, 0, 0, 0, 0, 1, 4, 0, 5, 0, 9, 0, 0, 1, 0, 1, 4], "loose": false}

package/data/problems/long-pressed-name.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "912", "slug": "long-pressed-name", "id": 912, "title": "Long Pressed Name", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/long-pressed-name/", "examples": [{"input": "name = \"alex\", typed = \"aaleex\"", "output": "true", "explanation": "The letters 'a' and 'e' were held a little longer."}, {"input": "name = \"saeed\", typed = \"ssaaedd\"", "output": "false", "explanation": "The count of 'e' does not line up."}, {"input": "name = \"leelee\", typed = \"lleeelee\"", "output": "true"}], "hints": ["Track one index into the intended name while scanning the typed text from left to right.", "A typed character either consumes the next needed name character or repeats the previous typed character.", "If the scan ends with unmatched name characters left over, the answer is false."], "statement": "Your friend typed a name but some keys may have stuck, repeating characters. Given the intended `name` and the actually typed string `typed`, decide whether the typed string could have come from the intended name by holding some keys longer.\n\nIn other words, scanning from left to right, each character of `name` must appear in `typed` in order, and any extra characters in `typed` must equal the previous character of `typed` (a long press). Every character of `typed` must be explainable this way.\n\nReturn `true` when `typed` is a valid long-pressed version of `name`, otherwise `false`.\n\n**Constraints:**\n- `1 <= name.length, typed.length <= 1000`\n- Both strings contain only lowercase English letters.\n", "solution": "## Approach\n\nWalk through `typed` with two pointers. Keep an index into `name`; when the current typed character matches the current name character, advance the name pointer. Otherwise the typed character must repeat the previous typed character, or the answer is false. At the end every name character must have been consumed.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + m), where n and m are the lengths of `name` and `typed`. Each string is scanned once.\n- **Space Complexity:** O(1) besides the inputs.\n\n## Implementation\n\n```python\nclass Solution:\n def isLongPressedName(self, name: str, typed: str) -> bool:\n i = 0\n for j, c in enumerate(typed):\n if i < len(name) and c == name[i]:\n i += 1\n elif j == 0 or c != typed[j - 1]:\n return False\n return i == len(name)\n```\n", "starter": {"go": "package main\n\nfunc IsLongPressedName(name string, typed string) bool {\n return false\n}", "python": "class Solution:\n def isLongPressedName(self, name: str, typed: str) -> bool:\n pass", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n bool isLongPressedName(string name, string typed) {\n return false;\n }\n};"}, "fn": "isLongPressedName", "params": [{"name": "name", "type": "string"}, {"name": "typed", "type": "string"}], "outputType": "boolean", "tests": [["alex", "aaleex"], ["saeed", "ssaaedd"], ["leelee", "lleeelee"], ["a", "a"], ["a", "aa"], ["a", "b"], ["alex", "alex"], ["alex", "aaleexa"], ["saeed", "ssaaeed"], ["xnhtq", "xhhtq"], ["vtkgn", "vttkgnn"], ["aab", "aaab"], ["aab", "aabbb"], ["aab", "aaabb"], ["ab", "aab"], ["ab", "abb"], ["ab", "aabb"], ["ab", "aba"], ["abc", "aabbcc"], ["abc", "aabcbcc"], ["leel", "lleeeel"], ["laidez", "laidezzz"], ["pyplrz", "ppyypllr"], ["abcd", "abcdd"], ["abcd", "abccdd"], ["z", "zzzz"], ["ab", "ab"], ["aabb", "aaabbb"]], "expected": [true, false, true, true, true, false, true, false, true, false, true, true, true, true, true, true, true, false, true, false, true, true, false, true, true, true, true, true], "loose": false}

package/data/problems/longest-absolute-file-path.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "464", "slug": "longest-absolute-file-path", "id": 464, "title": "Longest Absolute File Path", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/longest-absolute-file-path/", "examples": [{"explanation": "The file lives at \"dir/subdir2/file.ext\", length 20.", "input": "input = \"dir\\n\\tsubdir1\\n\\tsubdir2\\n\\t\\tfile.ext\"", "output": "20"}, {"explanation": "Two files exist; the longer path \"dir/subdir2/subsubdir2/file2.ext\" has 32 chars.", "input": "input = \"dir\\n\\tsubdir1\\n\\t\\tfile1.ext\\n\\t\\tsubsubdir1\\n\\tsubdir2\\n\\t\\tsubsubdir2\\n\\t\\t\\tfile2.ext\"", "output": "32"}, {"explanation": "A single folder with no file yields 0.", "input": "input = \"a\"", "output": "0"}], "hints": ["Split the encoding on newlines and count leading tabs to get each entry's depth.", "Keep the cumulative path length per depth; a file candidate is parent length plus its own name length.", "Only entries containing a dot can be files; folders just update the length table for deeper entries."], "statement": "A toy file system is flattened into one string. Newline characters separate entries, and the number of leading tab characters tells how deeply an entry is nested: no tabs means the top level, one tab means a child of the previous top-level entry, and so on. Names of folders contain only letters, digits and spaces, while names of files add a dot plus an extension (so a dot marks a file).\n\nThe absolute path of an entry joins its ancestor names with `'/'` characters, for example `dir/subdir2/file.ext`. Given the flattened encoding, determine the character count of the longest absolute path that ends at a file. When the encoding holds no file at all, the answer is `0`.\n\n**Constraints:**\n- `1 <= input.length <= 10^4`\n- `input` holds letters, digits, spaces, dots, newlines (`\\n`) and tabs (`\\t`).\n- Every name is non-empty and the nesting described by the tabs is valid.\n", "solution": "## Approach\n\nSplit the encoding into lines. The count of leading tabs gives the nesting depth of each entry. Maintain an array where entry `d` holds the total length of the path down to depth `d` including separators. For a folder, record its extended length for the next level; for a name containing a dot (a file), compute the candidate path length and keep the maximum. One linear scan suffices.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the length of the encoded string.\n- **Space Complexity:** O(d) for the per-depth lengths, with d bounded by the nesting depth.\n\n## Implementation\n\n```python\nclass Solution:\n def lengthLongestPath(self, input: str) -> int:\n # '|' is accepted as a newline alias (runner-safe encoding).\n input = input.replace('|', '\\n')\n acc = [0] * (input.count('\\n') + 3)\n best = 0\n for line in input.split('\\n'):\n depth = 0\n while depth < len(line) and line[depth] == '\\t':\n depth += 1\n name = line[depth:]\n if '.' in name:\n best = max(best, acc[depth] + len(name))\n else:\n acc[depth + 1] = acc[depth] + len(name) + 1\n return best\n```\n", "starter": {"go": "package main\n\nfunc LengthLongestPath(input string) int {\n return 0\n}", "python": "class Solution:\n def lengthLongestPath(self, input: str) -> int:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int lengthLongestPath(string input) {\n return 0;\n }\n};"}, "fn": "lengthLongestPath", "params": [{"name": "input", "type": "string"}], "outputType": "int", "tests": [["dir|\tsubdir1|\tsubdir2|\t\tfile.ext"], ["dir|\tsubdir1|\t\tfile1.ext|\t\tsubsubdir1|\tsubdir2|\t\tsubsubdir2|\t\t\tfile2.ext"], ["a"], ["file.txt"], ["dir|\tfile.txt"], ["a|\tb|\t\tc.txt|\taaaa.txt"], ["dir|\tsubdir1|\t\tfile1.ext|\t\tsubsubdir1"], ["a|\tb.txt|\ta"], ["root|\ta|\t\tb|\t\t\tc.doc"], ["x|\ty"], ["my dir|\tmy subdir|\t\tmy file.ext"], ["d1|\td2|\t\td3|\t\t\tf.txt"], ["a.txt|\tb"], ["a|\tb|\tc|\t\td.txt"], ["folder|\tsub folder 1|\t\t doc.txt"], ["r|\ta.txt|\tb.txt|\tc.txt"], ["top|\tmid one|\t\tdeep file name.ext|\tmid two"], ["a|\tb|\t\tc|\t\t\td|\t\t\t\te.f"], ["dir1|\tdir2|\t\tdir3|\t\t\tverylongfilename.extension"], ["f.e"], ["ab|\tcd.txt|\tef|\t\tgh.txt"], ["one|\ttwo three|\t\tfour five six.txt"], ["d|\te.txt|\tf|\t\tg.txt|\t\t\th.txt"], ["a b c|\td e f.txt"], ["zzz|\ta|\t\tb.txt|\tc|\t\td.txt|\t\t\te.txt"], ["dir|\tsubdir1|\t\tfile with spaces.ext"], ["A1|\tB2|\t\tC3.D4"], ["longdirname123|\tshort.txt"], ["p|\tq.txt|\tr|\t\ts.txt"], ["m|\tn.txt"]], "expected": [20, 32, 0, 8, 12, 10, 21, 7, 14, 0, 28, 14, 5, 9, 28, 7, 30, 11, 41, 3, 12, 31, 9, 15, 11, 32, 11, 24, 9, 7], "loose": false}

package/data/problems/longest-common-prefix.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "153", "slug": "longest-common-prefix", "id": 153, "title": "Longest Common Prefix", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/longest-common-prefix/", "examples": [{"input": "strs = [\"flower\",\"flow\",\"flight\"]", "output": "\"fl\"", "explanation": "The strings share the prefix \"fl\"; the third character differs ('o' vs 'i')."}, {"input": "strs = [\"dog\",\"racecar\",\"car\"]", "output": "\"\"", "explanation": "There is no common prefix among the input strings."}], "hints": ["Compare characters column by column: take the first string as reference and shrink the prefix while any other string mismatches.", "Alternatively sort the array and only compare the first and last strings, since they differ the most."], "statement": "You receive a collection of strings. Identify the longest leading segment that every one of them shares.\n\nWhen the strings share no leading character at all, give back an empty string `\"\"`.\n\n**Constraints:**\n\n- 1 \u2264 strs.length \u2264 200\n- 0 \u2264 strs[i].length \u2264 200\n- strs[i] consists of only lowercase English letters if it is non-empty.\n", "solution": "## Approach\n\nUse the first string as the initial prefix. For each remaining string, shrink the prefix from the end until the string starts with it. If the prefix becomes empty, no common prefix exists. This compares characters column by column and stops early on mismatch.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(S), where S is the total number of characters across all strings. Each character comparison is done at most once per string.\n- **Space Complexity:** O(1) extra (excluding the returned prefix, which is a substring of the first string).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def longestCommonPrefix(self, strs: List[str]) -> str:\n if not strs:\n return \"\"\n prefix = strs[0]\n for s in strs[1:]:\n while not s.startswith(prefix):\n prefix = prefix[:-1]\n if not prefix:\n return \"\"\n return prefix\n```\n", "starter": {"go": "package main\n\nfunc LongestCommonPrefix(strs []string) string {\n \n}", "python": "from typing import List\nclass Solution:\n def longestCommonPrefix(self, strs: List[str]) -> str:\n ", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n string longestCommonPrefix(vector<string>& strs) {\n return \"\";\n }\n};"}, "fn": "longestCommonPrefix", "params": [{"name": "strs", "type": "string_array"}], "outputType": "string", "tests": [["[\"flower\",\"flow\",\"flight\"]"], ["[\"dog\",\"racecar\",\"car\"]"], ["[\"a\"]"], ["[\"\", \"\"]"], ["[\"ab\", \"a\"]"], ["[\"interspecies\",\"interstellar\",\"interstate\"]"], ["[\"throne\",\"throne\"]"], ["[\"throne\",\"dungeon\"]"], ["[\"a\",\"a\",\"b\"]"], ["[\"abc\",\"abc\",\"abc\"]"], ["[\"aaa\",\"aa\",\"aaa\"]"], ["[\"c\",\"acc\",\"ccc\"]"], ["[\"abc\",\"abd\",\"abe\"]"], ["[\"test\",\"testing\",\"tester\"]"], ["[\"prefix\",\"prelude\",\"prevent\"]"], ["[\"same\",\"same\",\"same\"]"], ["[\"a\",\"ab\",\"abc\"]"], ["[\"abc\",\"ab\",\"a\"]"], ["[\"z\"]"], ["[\"hello\",\"hell\",\"heaven\"]"], ["[\"abcd\",\"efgh\"]"], ["[\"aa\",\"aaa\",\"aaaa\"]"], ["[\"foo\",\"foobar\",\"foobaz\"]"], ["[\"x\",\"y\",\"z\"]"], ["[\"single\"]"], ["[\"abcde\",\"abcdf\",\"abcdg\",\"abcdh\"]"], ["[\"\",\"a\"]"], ["[\"ab\",\"abc\",\"abcd\",\"abcde\"]"], ["[\"qwerty\",\"qwertyuiop\",\"qwer\"]"], ["[\"mango\",\"mangrove\",\"mango\"]"], ["[\"bc\",\"bcd\",\"bcde\"]"], ["@javascript:JSON.stringify([...Array(200).fill(\"a\".repeat(200))])"]], "expected": ["fl", "", "a", "", "a", "inters", "throne", "", "", "abc", "aa", "", "ab", "test", "pre", "same", "a", "a", "z", "he", "", "aa", "foo", "", "single", "abcd", "", "ab", "qwer", "mang", "bc", "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"], "loose": false}

package/data/problems/longest-common-subsequence.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "19", "slug": "longest-common-subsequence", "id": 19, "title": "Longest Common Subsequence", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/longest-common-subsequence/", "examples": [{"input": "text1 = \"abcde\", text2 = \"ace\"", "output": "3", "explanation": "The longest subsequence common to both \"abcde\" and \"ace\" is \"ace\", which has length 3."}, {"input": "text1 = \"abc\", text2 = \"abc\"", "output": "3", "explanation": "The strings \"abc\" and \"abc\" are identical, so the longest common subsequence is \"abc\" with length 3."}], "hints": ["Standard 2D DP: dp[i][j] is the LCS length of prefixes text1[0..i-1], text2[0..j-1]."], "statement": "You receive two strings, text1 and text2. Count how long the longest shared subsequence of the pair can be \u2014 that is, the most characters that appear in both strings in the same relative order, though not necessarily side by side. When the pair shares no character in order, give back 0.\n\n**Constraints:**\n\n- 1 \u2264 text1.length, text2.length \u2264 1000\n- text1 and text2 consist of only lowercase English characters.\n", "solution": "## Approach\n\n2D dynamic programming where dp[i][j] stores the LCS length of prefixes text1[:i] and text2[:j]. If characters match, extend the LCS by 1; otherwise, take the maximum of excluding either character.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * m), where n and m are the lengths of the two strings.\n- **Space Complexity:** O(n * m) for the DP table.\n\n## Implementation\n\n```python\nclass Solution:\n def longestCommonSubsequence(self, text1: str, text2: str) -> int:\n n, m = len(text1), len(text2)\n dp = [[0] * (m + 1) for _ in range(n + 1)]\n for i in range(1, n + 1):\n for j in range(1, m + 1):\n if text1[i - 1] == text2[j - 1]:\n dp[i][j] = dp[i - 1][j - 1] + 1\n else:\n dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])\n return dp[n][m]\n```\n", "starter": {"go": "package main\n\nfunc LongestCommonSubsequence(text1 string, text2 string) int {\n \n}", "python": "class Solution:\n def longestCommonSubsequence(self, text1: str, text2: str) -> int:\n pass\n", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int longestCommonSubsequence(string text1, string text2) {\n return 0;\n }\n};"}, "fn": "longestCommonSubsequence", "params": [{"name": "text1", "type": "string"}, {"name": "text2", "type": "string"}], "outputType": "int", "tests": [["abcde", "ace"], ["abc", "abc"], ["abc", "def"], ["bl", "yby"], ["@javascript: 'a'.repeat(1000)", "@javascript: 'a'.repeat(1000)"], ["a", "a"], ["a", "b"], ["aaaaa", "aaa"], ["abcdefghij", "klmnopqrst"], ["abcdef", "abcdef"], ["abcxyz", "xyzabc"], ["horse", "ros"], ["abcdgh", "aedfhr"], ["aggtab", "gxtxayb"], ["abcbdab", "bdcaba"], ["aaaa", "aa"], ["abc", "cba"], ["algorithm", "logarithm"], ["pmjghexybyrgzczy", "hafcdqbgncrcbihkd"], ["abcba", "abcbcba"], ["aaaaaa", "bbbbbb"], ["abcdef", "fedcba"], ["longest", "stone"], ["abcd", "efgh"], ["aab", "aba"], ["abcde", "edcba"], ["xyz", "xyz"], ["qwerty", "qwerty"], ["ab", "ba"], ["aaabbb", "ab"], ["programming", "gaming"], ["abcdefgh", "aceg"]], "expected": [3, 3, 0, 1, 1000, 1, 0, 3, 0, 6, 3, 2, 3, 4, 4, 2, 1, 7, 4, 5, 0, 1, 3, 0, 2, 1, 3, 6, 1, 2, 6, 4], "loose": false}

package/data/problems/longest-consecutive-sequence.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "31", "slug": "longest-consecutive-sequence", "id": 31, "title": "Longest Consecutive Sequence", "difficulty": "Medium", "category": "graph", "link": "https://leetcode.com/problems/longest-consecutive-sequence/", "examples": [{"input": "nums = [100,4,200,1,3,2]", "output": "4", "explanation": "The longest consecutive sequence in [100, 4, 200, 1, 3, 2] is 1, 2, 3, 4, which has length 4."}, {"input": "nums = [0,3,7,2,5,8,4,6,0,1]", "output": "9", "explanation": "The longest consecutive sequence in [0, 3, 7, 2, 5, 8, 4, 6, 0, 1] is 0, 1, 2, 3, 4, 5, 6, 7, 8, which has length 9."}], "hints": ["Use a hash set: start counting from numbers that have no predecessor (x-1 not in set)."], "statement": "You receive a jumbled integer array nums. Measure how long the longest run of back-to-back integers that all occur in the array can be, regardless of where they sit in the input. Your method must take O(n) time.\n\n**Constraints:**\n\n- 0 \u2264 nums.length \u2264 10^5\n- -10^9 \u2264 nums[i] \u2264 10^9\n", "solution": "## Approach\nPlace all numbers in a set, then iterate through them. For each number, only start counting a consecutive sequence if it is the smallest element of that sequence (i.e., `x - 1` is not in the set). Expand upward from that starting point and track the maximum length found.\n\n## Complexity Analysis\n- **Time Complexity:** O(n)\n- **Space Complexity:** O(n)\n\n## Implementation\n```python\nfrom typing import List\nclass Solution:\n def longestConsecutive(self, nums: List[int]) -> int:\n s = set(nums)\n res = 0\n for x in s:\n if x - 1 not in s:\n y = x + 1\n while y in s:\n y += 1\n res = max(res, y - x)\n return res\n```\n", "starter": {"go": "package main\n\nfunc LongestConsecutive(nums []int) int {\n \n}", "python": "from typing import List\nclass Solution:\n def longestConsecutive(self, nums: List[int]) -> int:\n pass\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int longestConsecutive(vector<int>& nums) {\n return 0;\n }\n};"}, "fn": "longestConsecutive", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[100,4,200,1,3,2]"], ["[0,3,7,2,5,8,4,6,0,1]"], ["[]"], ["[1,2,0,1]"], ["[9,1,4,7,3,-1,0,5,8,-1,6]"], ["[1]"], ["[5,5,5]"], ["[1,2,3,4,5]"], ["[5,4,3,2,1]"], ["[1,3,5,7,9]"], ["[-3,-2,-1,0,1]"], ["[-1000000000,1000000000]"], ["[0]"], ["[2,2,2,1,1,0]"], ["[10,5,12,3,55,30,4,11,2]"], ["[1,2,3,10,11,12,13]"], ["[-1]"], ["[100,101,102,104,105]"], ["[7]"], ["[3,1,2]"], ["[0,1,2,3,4,5,6,7,8,9]"], ["[9,8,7,6,5,4,3,2,1,0]"], ["[1,100,2,200,3,300]"], ["[-5,-4,-3,10,11]"], ["[999999999,1000000000]"], ["[-1000000000,-999999999]"], ["[4,0,-4,-2,-3,-1,0,4,2,-1]"], ["[1,2,0]"], ["[5]"], ["[6,7,8,1,2,3]"]], "expected": [4, 9, 0, 3, 7, 1, 1, 5, 5, 1, 5, 1, 1, 3, 4, 4, 1, 3, 1, 3, 10, 10, 3, 3, 2, 2, 5, 3, 1, 3], "loose": false}

package/data/problems/longest-continuous-increasing-subsequence.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "693", "slug": "longest-continuous-increasing-subsequence", "id": 693, "title": "Longest Continuous Increasing Subsequence", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/longest-continuous-increasing-subsequence/", "examples": [{"input": "nums = [1,3,5,4,7]", "output": "3", "explanation": "The run [1,3,5] has length 3; the later run [4,7] has length 2."}, {"input": "nums = [2,2,2,2,2]", "output": "1", "explanation": "No adjacent pair increases, so the best is a single element."}, {"input": "nums = [1,3,5,7]", "output": "4", "explanation": "The whole array is strictly increasing."}], "hints": ["Only neighbors matter: extend the current run when nums[i] > nums[i-1], else restart at 1.", "Keep the maximum run seen so far.", "An empty array yields 0."], "statement": "Given an integer array `nums`, find the length of the longest subarray in which every adjacent pair strictly increases (each element is larger than the one before it).\n\n**Constraints:**\n- `0 <= nums.length <= 10^4`\n- `-10^9 <= nums[i] <= 10^9`\n", "solution": "## Approach\n\nSweep once while tracking the current increasing run. If the new value exceeds its predecessor, grow the run; otherwise restart it at length one. Record the largest run observed. Empty input gives zero.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), single pass.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def findLengthOfLCIS(self, nums: List[int]) -> int:\n if not nums:\n return 0\n best = cur = 1\n for i in range(1, len(nums)):\n if nums[i] > nums[i - 1]:\n cur += 1\n else:\n cur = 1\n best = max(best, cur)\n return best\n```\n", "starter": {"go": "package main\n\nfunc FindLengthOfLCIS(nums []int) int {\n return 0\n}", "python": "from typing import List\nclass Solution:\n def findLengthOfLCIS(self, nums: List[int]) -> int:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int findLengthOfLCIS(vector<int>& nums) {\n return 0;\n }\n};"}, "fn": "findLengthOfLCIS", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[1,3,5,4,7]"], ["[2,2,2,2,2]"], ["[1,3,5,7]"], ["[1]"], ["[]"], ["[1,2]"], ["[2,1]"], ["[1,2,3,4,5]"], ["[5,4,3,2,1]"], ["[1,3,2,4,5,6]"], ["[1,2,2,3]"], ["[1,2,3,2,3,4,5]"], ["[-1,0,1,2]"], ["[100,10,20,30]"], ["[1,3,5,4,2,3,4,5]"], ["[2,4,6,1,2]"], ["[1,2,3,1,2,3,4]"], ["[7,7,8,9]"], ["[3,2,1,2,3]"], ["[1,2,3,4,3,4,5,6,7]"], ["[0]"], ["[5,6,1,2,3]"], ["[1,1,1,2,2,3]"], ["[4,5,6,7,1]"], ["[2,3,1,4,5,1,2,3]"], ["[10,20,30,5,6,7,8,1]"], ["[1,2,3,4,5,4,5,6]"], ["[9,8,7,6,7,8]"]], "expected": [3, 1, 4, 1, 0, 2, 1, 5, 1, 4, 2, 4, 4, 3, 4, 3, 4, 3, 3, 5, 1, 3, 2, 4, 3, 4, 5, 3], "loose": false}

package/data/problems/longest-happy-string.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "204", "slug": "longest-happy-string", "id": 204, "title": "Longest Happy String", "difficulty": "Medium", "category": "heap", "link": "https://leetcode.com/problems/longest-happy-string/", "examples": [{"input": "a = 1, b = 1, c = 7", "output": "\"ccaccbcc\"", "explanation": "\"ccbccacc\" would also be a correct answer."}, {"input": "a = 7, b = 1, c = 0", "output": "\"aabaa\"", "explanation": "It is the only correct answer in this case."}], "hints": ["Use a greedy approach.", "Use the letter with the maximum current limit that can be added without breaking the condition.", "Track the last two appended characters so you never build \"aaa\", \"bbb\", or \"ccc\"."], "statement": "Call a string `s` **happy** when each of these holds:\n\n- every character of `s` is one of `'a'`, `'b'`, or `'c'`.\n- neither `\"aaa\"`, `\"bbb\"`, nor `\"ccc\"` occurs anywhere inside `s`.\n- the count of `'a'` inside `s` is **no more than** `a`.\n- the count of `'b'` inside `s` is **no more than** `b`.\n- the count of `'c'` inside `s` is **no more than** `c`.\n\nYou receive three integers `a`, `b`, and `c`. Build the lengthiest happy string achievable. When several answers tie for greatest length, any of them is accepted. When no non-empty happy string exists, give back the empty string `\"\"`.\n\nHere, a substring means a block of characters standing next to each other in the string.\n\n**Constraints:**\n\n- `0 <= a, b, c <= 100`\n- `a + b + c > 0`\n", "solution": "## Approach\n\nTrack the remaining counts of `a`, `b`, and `c` along with the last two characters that were appended. Greedily append the letter with the largest remaining count that is not forbidden by the \"last two\" rule (a letter equal to both of the last two cannot be appended). Repeat until no letter can be added; the produced string is the longest possible happy string.\n\n## Complexity Analysis\n\n- **Time Complexity:** O((a + b + c) \\* 3) = O(a + b + c).\n- **Space Complexity:** O(1), excluding the output string.\n\n## Implementation\n\n```python\nclass Solution:\n def longestDiverseString(self, a: int, b: int, c: int) -> str:\n count = [a, b, c]\n result = []\n last = second_last = -1\n\n while True:\n best = -1\n for ch in range(3):\n if count[ch] == 0:\n continue\n if ch == last and ch == second_last:\n continue\n if best == -1 or count[ch] > count[best]:\n best = ch\n if best == -1:\n break\n result.append(chr(ord(\"a\") + best))\n count[best] -= 1\n second_last = last\n last = best\n return \"\".join(result)\n```", "starter": {"go": "package main\n\nfunc LongestDiverseString(a int, b int, c int) string {\n \n}", "python": "class Solution:\n def longestDiverseString(self, a: int, b: int, c: int) -> str:\n ", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n string longestDiverseString(int a, int b, int c) {\n \n }\n};"}, "fn": "longestDiverseString", "params": [{"name": "a", "type": "int"}, {"name": "b", "type": "int"}, {"name": "c", "type": "int"}], "outputType": "string", "tests": [["1", "1", "7"], ["7", "1", "0"], ["0", "0", "3"], ["3", "3", "3"], ["0", "0", "1"], ["1", "0", "0"], ["2", "2", "2"], ["0", "0", "100"], ["100", "0", "0"], ["0", "8", "8"], ["2", "8", "0"], ["5", "5", "0"], ["10", "1", "1"], ["7", "1", "1"], ["33", "33", "34"], ["0", "1", "1"], ["5", "10", "5"], ["1", "3", "1"], ["4", "4", "4"], ["0", "2", "0"], ["0", "0", "2"], ["0", "1", "0"], ["0", "0", "4"], ["1", "1", "1"], ["2", "0", "0"], ["6", "1", "1"], ["1", "2", "3"], ["8", "8", "8"], ["50", "50", "0"], ["100", "100", "100"], ["0", "5", "5"], ["1", "6", "1"]], "expected": ["ccaccbcc", "aabaa", "cc", "abcabcabc", "c", "a", "abcabc", "cc", "aa", "bcbcbcbcbcbcbcbc", "bbabbabb", "ababababab", "aabaacaa", "aabaacaa", "cabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc", "bc", "bbabbcbbabcabcabcabc", "bbabc", "abcabcabcabc", "bb", "cc", "b", "cc", "abc", "aa", "aabaacaa", "cbcabc", "abcabcabcabcabcabcabcabc", "abababababababababababababababababababababababababababababababababababababababababababababababababab", "abcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabcabc", "bcbcbcbcbc", "bbabbcbb"], "loose": false}

package/data/problems/longest-harmonious-subsequence.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "636", "slug": "longest-harmonious-subsequence", "id": 636, "title": "Longest Harmonious Subsequence", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/longest-harmonious-subsequence/", "examples": [{"input": "nums = [1,3,2,2,5,2,3,7]", "output": "5", "explanation": "Values 2 and 3 differ by one and appear five times together."}, {"input": "nums = [1,2,3,4]", "output": "2", "explanation": "Any neighboring pair such as 1 and 2 works."}, {"input": "nums = [1,1,1,1]", "output": "0", "explanation": "Only one distinct value exists."}], "hints": ["Count each value first.", "A harmonious group uses exactly two neighboring values x and x+1.", "Sum the counts for each such pair and keep the maximum."], "statement": "A subsequence is harmonious when its largest and smallest values differ by exactly one. Given `nums`, return the length of the longest harmonious subsequence; return 0 when none exists. Order inside the subsequence does not matter, only values.\n\n**Constraints:**\n- `1 <= nums.length <= 20000`\n- Values fit in 32-bit integers.\n", "solution": "## Approach\n\nTally frequencies, then check every value against its successor. The best pair sum is the answer because any harmonious group can only contain two neighboring values.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n).\n- **Space Complexity:** O(n) for counts.\n\n## Implementation\n\n```python\nfrom typing import List\nfrom collections import Counter\nclass Solution:\n def findLHS(self, nums: List[int]) -> int:\n c = Counter(nums)\n return max([c[x] + c[x+1] for x in c if x+1 in c] or [0])\n```\n", "starter": {"go": "package main\n\nfunc FindLHS(nums []int) int {\n return 0\n}", "python": "from typing import List\nclass Solution:\n def findLHS(self, nums: List[int]) -> int:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int findLHS(vector<int>& nums) {\n return 0;\n }\n};"}, "fn": "findLHS", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[1,3,2,2,5,2,3,7]"], ["[1,2,3,4]"], ["[1,1,1,1]"], ["[1,4,1,3,1,4,1,4]"], ["[1,2]"], ["[2,1]"], ["[1,3,5,7]"], ["[1,2,2,1]"], ["[1,2,2,2,3]"], ["[5,5,5,6,6]"], ["[-1,0,1,2,3]"], ["[0,0,1,1,1]"], ["[3,3,3,4,4,4]"], ["[10]"], ["[1,1,2,2,3,3]"], ["[2,2,2,2,2,3,3]"], ["[1,2,3,3,3,4,4,5]"], ["[100,101]"], ["[-5,-4,-4,-3]"], ["[8,7,6,5,4]"], ["[1,2,3,4,5,6]"], ["[4,4,4,4,5,5]"], ["[9,9,10,10,10,11]"], ["[0,1,1,0]"], ["[2,4,6,8,10]"], ["[1,3,2,2,2,3]"], ["[7,7,7,8]"], ["[1,2,1,2,1,2]"]], "expected": [5, 2, 0, 4, 2, 2, 0, 4, 4, 5, 2, 5, 6, 0, 4, 7, 5, 2, 3, 2, 2, 6, 5, 4, 0, 5, 4, 6], "loose": false}

package/data/problems/longest-increasing-path-in-a-matrix.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "133", "slug": "longest-increasing-path-in-a-matrix", "id": 133, "title": "Longest Increasing Path in a Matrix", "difficulty": "Hard", "category": "matrix", "link": "https://leetcode.com/problems/longest-increasing-path-in-a-matrix/", "examples": [{"input": "matrix = [[9,9,4],[6,6,8],[2,1,1]]", "output": "4", "explanation": "One longest path is 1 -> 2 -> 6 -> 9."}, {"input": "matrix = [[3,4,5],[3,2,6],[2,2,1]]", "output": "4", "explanation": "One longest increasing path is 3 -> 4 -> 5 -> 6, which has length 4."}, {"input": "matrix = [[1]]", "output": "1", "explanation": "The only cell is 1, so the longest increasing path length is 1."}], "hints": ["Treat each move from a lower value to a higher value as an edge in a directed acyclic graph.", "Memoized DFS or a layer-by-layer topological traversal visits each cell only a constant number of times."], "statement": "Given a nonempty rectangular integer matrix, return the length of its longest strictly\nincreasing path.\n\nFrom a cell, you may move up, down, left, or right. You may not move diagonally or wrap\nacross an edge.\n\n**Constraints:**\n- `1 <= matrix.length, matrix[i].length <= 200`\n- Every row has the same length.\n- `0 <= matrix[i][j] <= 2^31 - 1`\n", "solution": "## Approach\n\nView every cell as a node with directed edges to its strictly larger neighbors. These\nedges form a directed acyclic graph. Count each cell's outgoing edges, start from local\nmaxima, and remove one topological layer at a time while moving toward smaller cells.\nThe number of layers is the longest increasing path length.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(rows * columns).\n- **Space Complexity:** O(rows * columns).\n\n## Implementation\n\n```python\nfrom collections import deque\nfrom typing import List\n\n\nclass Solution:\n def longestIncreasingPath(self, matrix: List[List[int]]) -> int:\n rows, columns = len(matrix), len(matrix[0])\n directions = ((1, 0), (-1, 0), (0, 1), (0, -1))\n outdegree = [[0] * columns for _ in range(rows)]\n queue = deque()\n\n for row in range(rows):\n for column in range(columns):\n for row_step, column_step in directions:\n next_row = row + row_step\n next_column = column + column_step\n if (\n 0 <= next_row < rows\n and 0 <= next_column < columns\n and matrix[next_row][next_column] > matrix[row][column]\n ):\n outdegree[row][column] += 1\n if outdegree[row][column] == 0:\n queue.append((row, column))\n\n length = 0\n while queue:\n length += 1\n for _ in range(len(queue)):\n row, column = queue.popleft()\n for row_step, column_step in directions:\n previous_row = row + row_step\n previous_column = column + column_step\n if (\n 0 <= previous_row < rows\n and 0 <= previous_column < columns\n and matrix[previous_row][previous_column] < matrix[row][column]\n ):\n outdegree[previous_row][previous_column] -= 1\n if outdegree[previous_row][previous_column] == 0:\n queue.append((previous_row, previous_column))\n return length\n```\n", "starter": {"go": "package main\n\nfunc LongestIncreasingPath(matrix [][]int) int {\n return 0\n}", "python": "from typing import List\n\nclass Solution:\n def longestIncreasingPath(self, matrix: List[List[int]]) -> int:\n return 0\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n int longestIncreasingPath(vector<vector<int>>& matrix) {\n return 0;\n }\n};"}, "fn": "longestIncreasingPath", "params": [{"name": "matrix", "type": "int_array_2d", "visualizeType": "matrix"}], "outputType": "int", "tests": [["[[9,9,4],[6,6,8],[2,1,1]]"], ["[[3,4,5],[3,2,6],[2,2,1]]"], ["[[1]]"], ["[[0]]"], ["[[2147483647]]"], ["[[1,2]]"], ["[[2,1]]"], ["[[1,1]]"], ["[[1,2,3,4]]"], ["[[1],[2]]"], ["[[2],[1]]"], ["[[1],[1]]"], ["[[1,2,3,4,5]]"], ["[[5,4,3,2,1]]"], ["[[1],[2],[3],[4],[5]]"], ["[[5],[4],[3],[2],[1]]"], ["[[1,2],[3,4]]"], ["[[4,3],[2,1]]"], ["[[1,1],[1,1]]"], ["[[1,2],[2,3]]"], ["[[3,2],[2,1]]"], ["[[1,2,3],[6,5,4],[7,8,9]]"], ["[[9,8,7],[4,5,6],[3,2,1]]"], ["[[1,2,3],[8,9,4],[7,6,5]]"], ["[[10,10,10],[10,10,10],[10,10,10]]"], ["[[0,1,2],[5,4,3],[6,7,8]]"], ["[[7,8,9],[6,1,2],[5,4,3]]"], ["[[5,5,5],[5,6,5],[5,5,5]]"], ["[[6,5,6],[5,4,5],[6,5,6]]"], ["[[1,100,2],[6,5,3],[7,8,4]]"], ["[[100,1,100],[1,100,1],[100,1,100]]"], ["[[1,3,5,7],[2,4,6,8]]"], ["[[8,6,4,2],[7,5,3,1]]"], ["[[1,2],[4,3],[5,6],[8,7]]"], ["[[8,7],[5,6],[4,3],[1,2]]"], ["[[3,1,2],[4,6,5],[9,7,8]]"], ["[[8,7,6],[1,2,5],[0,3,4]]"], ["[[2,2,3],[2,2,4],[1,1,5]]"], ["[[5,4,3],[6,1,2],[7,8,9]]"], ["[[1,4,7],[2,5,8],[3,6,9]]"], ["[[9,6,3],[8,5,2],[7,4,1]]"], ["[[0,2147483647],[1,2147483646]]"], ["[[2147483647,2147483646],[0,1]]"], ["[[1,10,11],[2,9,12],[3,8,13],[4,7,14],[5,6,15]]"], ["[[15,6,5],[14,7,4],[13,8,3],[12,9,2],[11,10,1]]"], ["[[4,9,1,7],[3,8,2,6],[5,10,11,12]]"], ["[[12,11,10,5],[1,2,9,4],[7,8,3,6]]"], ["[[31,41,59],[26,53,58],[97,93,23]]"], ["[[2,3,4,5],[1,16,17,6],[14,15,18,7],[13,12,11,8]]"], ["[[1,2,3,4],[12,13,14,5],[11,16,15,6],[10,9,8,7]]"], ["[[1,1,2,2],[1,2,2,3],[2,2,3,3],[2,3,3,4]]"], ["[[100,90,80,70],[10,20,30,60],[9,8,40,50]]"], ["[[0,2,4,6,8],[1,3,5,7,9]]"], ["[[9,7,5,3,1],[8,6,4,2,0]]"], ["[[1,20,3,18,5],[10,11,12,13,14],[9,8,7,6,15],[22,21,20,19,16],[23,24,25,18,17]]"], ["[[42,42,41],[39,40,41],[38,37,36]]"], ["[[5,4,3,2,1],[6,7,8,9,10],[15,14,13,12,11],[16,17,18,19,20]]"], ["@javascript:JSON.stringify(Array.from({length:100},(_,r)=>Array.from({length:200},(_,c)=>(r+c)%2===0?0:2147483647)))"], ["@javascript:JSON.stringify(Array.from({length:200},(_,r)=>[r%2===0?0:2147483647]))"]], "expected": [4, 4, 1, 1, 1, 2, 2, 1, 4, 2, 2, 1, 5, 5, 5, 5, 3, 3, 1, 3, 3, 9, 9, 9, 1, 9, 9, 2, 3, 6, 2, 5, 5, 8, 8, 6, 9, 4, 9, 5, 5, 4, 4, 15, 15, 6, 6, 6, 16, 16, 2, 12, 6, 6, 20, 6, 20, 2, 2], "loose": false}

package/data/problems/longest-increasing-subsequence.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "18", "slug": "longest-increasing-subsequence", "id": 18, "title": "Longest Increasing Subsequence", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/longest-increasing-subsequence/", "examples": [{"input": "nums = [10,9,2,5,3,7,101,18]", "output": "4", "explanation": "The longest increasing subsequence in [10, 9, 2, 5, 3, 7, 101, 18] is [2, 3, 7, 101] or [2, 3, 7, 18], both of length 4."}, {"input": "nums = [0,1,0,3,2,3]", "output": "4", "explanation": "The longest increasing subsequence in [0, 1, 0, 3, 2, 3] is [0, 1, 2, 3], of length 4."}], "hints": ["Patience sorting in O(n log n): maintain tails[i] = minimum tail of an increasing subsequence of length i+1."], "statement": "You receive an integer array nums. Measure how long the longest subsequence whose values climb strictly from left to right can be.\n\n**Constraints:**\n\n- 1 \u2264 nums.length \u2264 2500\n- -10^4 \u2264 nums[i] \u2264 10^4\n", "solution": "## Approach\nUse patience sorting by maintaining a `tails` array where `tails[i]` is the smallest possible tail of an increasing subsequence of length `i + 1`. For each number, binary search to find its position in `tails` and either append or replace.\n\n## Complexity Analysis\n- **Time Complexity:** O(n log n)\n- **Space Complexity:** O(n)\n\n## Implementation\n```python\nfrom typing import List\nclass Solution:\n def lengthOfLIS(self, nums: List[int]) -> int:\n tails = []\n for x in nums:\n l, r = 0, len(tails)\n while l < r:\n m = (l + r) // 2\n if tails[m] < x:\n l = m + 1\n else:\n r = m\n if l == len(tails):\n tails.append(x)\n else:\n tails[l] = x\n return len(tails)\n```\n", "starter": {"go": "package main\n\nfunc LengthOfLIS(nums []int) int {\n \n}", "python": "from typing import List\nclass Solution:\n def lengthOfLIS(self, nums: List[int]) -> int:\n pass\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int lengthOfLIS(vector<int>& nums) {\n return 0;\n }\n};"}, "fn": "lengthOfLIS", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[10,9,2,5,3,7,101,18]"], ["[0,1,0,3,2,3]"], ["[7,7,7,7,7,7,7]"], ["[4,10,4,3,8,9]"], ["@javascript: JSON.stringify([...Array(2500)].map((_,i)=> i%2===0? i : 2500-i))"], ["[5]"], ["[1]"], ["[1,2,3,4,5]"], ["[5,4,3,2,1]"], ["[1,1,1,1]"], ["[1,3,2,4,3,5]"], ["[2,2,2,2,2,2,2,2]"], ["[-10000,10000]"], ["[-10000,-9999,-9998]"], ["[10000,9999,9998]"], ["[3,1,2]"], ["[1,2,3,10,11,12]"], ["[10,22,9,33,21,50,41,60]"], ["[0]"], ["[-5,-4,-3,-2,-1]"], ["[-1,-2,-3,-4,-5]"], ["[5,1,6,2,7,3,8]"], ["[1,2,1,2,1,2]"], ["[1,3,5,4,7]"], ["[2,5,3,7,11,8,10,13,6]"], ["[7,1,5,2,4,3]"], ["[100,1,2,3,4]"], ["[1,100,2,3,4,5]"], ["[-7,7,-7,7,-7,7]"], ["[3,4,-1,0,6,2,3]"], ["[1,2,3,4,0]"], ["[9,8,7,1,2,3]"]], "expected": [4, 4, 1, 3, 1250, 1, 1, 5, 1, 1, 4, 1, 2, 3, 1, 2, 6, 5, 1, 5, 1, 4, 2, 4, 6, 3, 4, 5, 2, 4, 4, 3], "loose": false}

package/data/problems/longest-line-of-consecutive-one-in-matrix.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "617", "slug": "longest-line-of-consecutive-one-in-matrix", "id": 617, "title": "Longest Line of Consecutive One in Matrix", "difficulty": "Medium", "category": "matrix", "link": "https://leetcode.com/problems/longest-line-of-consecutive-one-in-matrix/", "examples": [{"input": "mat = [[0,1,1,0],[0,1,1,0],[0,0,0,1]]", "output": "3", "explanation": "Three 1s line up along the main diagonal."}, {"input": "mat = [[1,1,1],[1,0,1]]", "output": "3", "explanation": "The entire top row is filled with 1s."}, {"input": "mat = [[0,0],[0,0]]", "output": "0", "explanation": "No 1 appears at all."}], "hints": ["Track four running lengths per cell: across, down, diagonal, and anti-diagonal.", "Each direction extends the matching neighbor's count (upper, left, upper-left, upper-right).", "A single dynamic-programming pass keeps the global maximum; zeros reset all four counts."], "statement": "Given a binary matrix `mat` of `0`s and `1`s, find the length of the longest run of consecutive `1`s. Runs may extend horizontally, vertically, diagonally (top-left to bottom-right), or anti-diagonally (top-right to bottom-left).\n\nEvery cell holding a `1` starts runs of length 1 in each direction; longer runs build by extending a neighboring run that points the same way. An all-zero matrix scores 0.\n\n**Constraints:**\n- `1 <= mat.length, mat[i].length <= 10^4`, with at most `10^4` cells total.\n- Each entry is `0` or `1`.\n", "solution": "## Approach\n\nSweep the matrix once while remembering, for every `1` cell, how long the run ending there is in each of the four allowed directions. The horizontal count extends the left neighbor, the vertical count extends the upper neighbor, the diagonal count extends the upper-left neighbor, and the anti-diagonal count extends the upper-right neighbor; zeros reset everything. The largest value seen is the answer.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n) for a single pass over all cells.\n- **Space Complexity:** O(m * n) for the four direction tables (compressible to O(n)).\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def longestLine(self, mat: List[List[int]]) -> int:\n m, n = len(mat), len(mat[0])\n best = 0\n dp = [[[0] * 4 for _ in range(n)] for _ in range(m)]\n for i in range(m):\n for j in range(n):\n if mat[i][j] == 0:\n continue\n dp[i][j][0] = (dp[i][j - 1][0] if j > 0 else 0) + 1\n dp[i][j][1] = (dp[i - 1][j][1] if i > 0 else 0) + 1\n dp[i][j][2] = (dp[i - 1][j - 1][2] if i > 0 and j > 0 else 0) + 1\n dp[i][j][3] = (dp[i - 1][j + 1][3] if i > 0 and j + 1 < n else 0) + 1\n best = max(best, max(dp[i][j]))\n return best\n```\n", "starter": {"go": "package main\n\nfunc LongestLine(mat [][]int) int {\n return 0\n}", "python": "from typing import List\nclass Solution:\n def longestLine(self, mat: List[List[int]]) -> int:\n return 0\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int longestLine(vector<vector<int>>& mat) {\n return 0;\n }\n};"}, "fn": "longestLine", "params": [{"name": "mat", "type": "int_array_2d"}], "outputType": "int", "tests": [["[[0,1,1,0],[0,1,1,0],[0,0,0,1]]"], ["[[1,1,1],[1,0,1]]"], ["[[0,0],[0,0]]"], ["[[1]]"], ["[[0]]"], ["[[1,1,1],[1,1,1]]"], ["[[1,0,1],[0,1,0],[1,0,1]]"], ["[[1,1,0,0],[0,1,1,0],[0,0,1,1]]"], ["[[0,0,1,1],[1,1,0,0],[0,1,0,1]]"], ["[[1,0,0],[0,1,0],[0,0,1]]"], ["[[0,0,1],[0,1,0],[1,0,0]]"], ["[[1,1,1,1]]"], ["[[1],[1],[1],[0]]"], ["[[1,0,1,1,1]]"], ["[[0],[1],[1],[1],[0]]"], ["[[1,0],[0,1]]"], ["[[1,1,0],[1,1,0],[0,0,1]]"], ["[[0,1,0],[1,1,1],[0,1,0]]"], ["[[1,1,1,0,1]]"], ["[[1,0,0,0],[1,1,0,0],[0,1,1,0],[0,0,1,1]]"], ["[[1,1],[1,1],[1,1]]"], ["[[0,1],[1,0],[0,1],[1,0]]"], ["[[1,0,1,0,1],[0,1,0,1,0]]"], ["[[1,1,1,1,1]]"], ["[[0,0,0,0]]"], ["[[1]]"], ["[[1,0,1],[1,1,1],[0,1,0]]"], ["[[0,1,1,1,0],[1,0,0,0,1]]"]], "expected": [3, 3, 0, 1, 0, 3, 3, 3, 2, 3, 3, 4, 3, 3, 3, 2, 3, 3, 3, 4, 3, 2, 2, 5, 0, 1, 3, 3], "loose": false}

package/data/problems/longest-mountain-in-array.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "843", "slug": "longest-mountain-in-array", "id": 843, "title": "Longest Mountain in Array", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/longest-mountain-in-array/", "examples": [{"input": "arr = [2,1,4,7,3,2,5]", "output": "5", "explanation": "Run [1,4,7,3,2] is the longest mountain."}, {"input": "arr = [2,2,2]", "output": "0", "explanation": "No strict up-down run exists."}, {"input": "arr = [0,1,2,3,4,5,4,3,2,1,0]", "output": "11", "explanation": "Entire array is one mountain."}], "hints": ["Walk peaks: at each index higher than both neighbours, expand left while strictly rising and right while strictly falling.", "Alternatively do one pass tracking the current climb length and descent length, resetting on flat steps.", "Only count spans with both an upward and a downward part and total length at least three."], "statement": "Measure the longest mountain-shaped run inside an array.\n\nA mountain is a contiguous segment of length at least three that first climbs strictly upward to a single peak and then descends strictly downward, with no flat steps anywhere. Given `arr`, return the length of the longest such segment, or zero when none exists.\n\n**Constraints:**\n- `0 <= arr.length <= 10^4`\n- `0 <= arr[i] <= 10^4`\n", "solution": "## Approach\n\nScan for peaks higher than both neighbours. From each peak stretch left while values rise strictly and right while they fall strictly, measuring the full span. Keep the best span seen; positions without both sides do not count.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the array length, since each index is visited at most twice.\n- **Space Complexity:** O(1) extra.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def longestMountain(self, arr: List[int]) -> int:\n n, best, i = len(arr), 0, 1\n while i < n - 1:\n if arr[i] > arr[i-1] and arr[i] > arr[i+1]:\n l, r = i - 1, i + 1\n while l > 0 and arr[l] > arr[l-1]:\n l -= 1\n while r + 1 < n and arr[r] > arr[r+1]:\n r += 1\n best = max(best, r - l + 1)\n i = r + 1\n else:\n i += 1\n return best\n```\n", "starter": {"go": "package main\n\nfunc LongestMountain(arr []int) int {\n return 0\n}", "python": "from typing import List\nclass Solution:\n def longestMountain(self, arr: List[int]) -> int:\n return 0\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n int longestMountain(vector<int>& arr) {\n return 0;\n }\n};"}, "fn": "longestMountain", "params": [{"name": "arr", "type": "int_array"}], "outputType": "int", "tests": [["[2,1,4,7,3,2,5]"], ["[2,2,2]"], ["[0,1,2,3,4,5,4,3,2,1,0]"], ["[1,2,3,2,1]"], ["[]"], ["[1]"], ["[1,2]"], ["[1,2,3]"], ["[3,2,1]"], ["[1,3,2]"], ["[2,1,4,7,3,2,5,1,2,3,2,1]"], ["[0,2,2,2,1,0]"], ["[1,2,2,1]"], ["[9,8,7,6,5,4,5,6,7,8,9,8,7]"], ["[1,2,3,4,5]"], ["[5,4,3,2,1]"], ["[1,2,1,2,1,2,1]"], ["[0,1,0,1,0,1,0]"], ["[1,2,3,4,3,2,1,2,3,4,5,3,2]"], ["[4,4,4,4]"], ["[1,2,0,2,0,2]"], ["[2,3,3,2,0,2]"], ["[875,884,239,731,723,685]"], ["[1,2,3,2,1,0,1,2,3,2,1]"], ["[0,1,2,3,2,1,0,1,0]"], ["[1,3,5,4,2]"], ["[5,1,4,7,3,2,5,6,7,3,2]"], ["[1,2,3,4,5,4,3,2,1,0,1,2,3]"]], "expected": [5, 0, 11, 5, 0, 0, 0, 0, 0, 3, 5, 0, 0, 8, 0, 0, 3, 3, 7, 0, 3, 0, 4, 6, 7, 5, 6, 10], "loose": false}

package/data/problems/longest-palindrome.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "483", "slug": "longest-palindrome", "id": 483, "title": "Longest Palindrome", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/longest-palindrome/", "examples": [{"input": "s = \"abccccdd\"", "output": "7", "explanation": "Rearrange to dccaccd, which reads the same both ways."}, {"input": "s = \"a\"", "output": "1", "explanation": "A single letter is already a palindrome."}, {"input": "s = \"Aa\"", "output": "1", "explanation": "Upper and lower case are distinct, so only one can be used."}], "hints": ["Count how many times each letter appears; case matters.", "Pairs of equal letters can sit symmetrically on both sides.", "At most one leftover single can sit in the center."], "statement": "You are given a string `s` made of upper- and lowercase English letters. By reordering its characters (using each at most as often as it appears), build the longest possible palindrome \u2014 a string reading identically forwards and backwards.\n\nUpper- and lowercase versions of a letter are different characters. Return the length of the best palindrome, not the palindrome itself.\n\n**Constraints:**\n- `1 <= s.length <= 2000`\n- `s` contains only English letters `A-Z` and `a-z`.\n", "solution": "## Approach\n\nTally each character separately since case is significant. Every pair of identical letters contributes two to the palindrome, one on each side. If any character has an odd remainder, a single leftover can occupy the middle. Summing the paired slots plus at most one center gives the optimum.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the string length.\n- **Space Complexity:** O(1), only a fixed alphabet table.\n\n## Implementation\n\n```python\nclass Solution:\n def longestPalindrome(self, s: str) -> int:\n cnt = [0] * 128\n for ch in s:\n cnt[ord(ch)] += 1\n length = 0\n odd = False\n for c in cnt:\n length += (c // 2) * 2\n if c % 2 == 1:\n odd = True\n return length + 1 if odd else length\n```\n", "starter": {"go": "package main\n\nfunc LongestPalindrome(s string) int {\n return 0\n}", "python": "class Solution:\n def longestPalindrome(self, s: str) -> int:\n return 0", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int longestPalindrome(string s) {\n return 0;\n }\n};"}, "fn": "longestPalindrome", "params": [{"name": "s", "type": "string"}], "outputType": "int", "tests": [["abccccdd"], ["a"], ["Aa"], ["abc"], ["aabb"], ["aabbc"], ["AAAA"], ["aaaa"], ["AaBbCc"], ["abccba"], ["racecar"], ["ab"], ["aa"], ["abccdd"], ["ZZZZZ"], ["z"], ["abABabAB"], ["cccccccc"], ["abcba"], ["aBcDeFg"], ["aabbccddeeffg"], ["MMMMMNNNNOOO"], ["qwertyuiopasdfghjklzxcvbnm"], ["QWERTYUIOPASDFGHJKLZXCVBNM"], ["aAabbBccCddD"], ["zzZZzzZZ"], ["abcdefg"], ["aabbcc"], ["abccccddddd"], ["tattarrattat"]], "expected": [7, 1, 1, 1, 4, 5, 4, 4, 1, 6, 7, 1, 2, 5, 5, 1, 8, 8, 5, 1, 13, 11, 1, 1, 9, 8, 1, 6, 9, 12], "loose": false}

package/data/problems/longest-palindromic-subsequence.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "576", "slug": "longest-palindromic-subsequence", "id": 576, "title": "Longest Palindromic Subsequence", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/longest-palindromic-subsequence/", "examples": [{"input": "s = \"bbbab\"", "output": "4", "explanation": "Skipping one 'a' leaves \"bbbb\", a palindrome of length 4."}, {"input": "s = \"cbbd\"", "output": "2", "explanation": "\"bb\" is the longest palindromic subsequence."}, {"input": "s = \"a\"", "output": "1", "explanation": "A single character is always a palindrome."}], "hints": ["Let dp[i][j] cover the substring s[i..j]; matching ends extend the inner answer by 2, mismatched ends take the better of the two shrunk intervals.", "Fill the table by increasing substring length so inner results are ready, keeping only one row to save memory."], "statement": "A subsequence keeps a selection of characters in their original relative order while possibly skipping others. A palindrome reads identically forward and backward.\n\nGiven a string `s`, determine the length of the longest subsequence of `s` that forms a palindrome. The subsequence itself need not be contiguous.\n\n**Constraints:**\n- `1 <= s.length <= 1000`\n- `s` consists of lowercase English letters\n", "solution": "## Approach\n\nWork over intervals: for substring `s[i..j]`, equal ends wrap the best answer of the inner interval plus two, while differing ends inherit the better of dropping the left or the right character. Processing starts from short intervals toward longer ones guarantees dependencies are solved. A single rolling row is enough because each step only needs the previous row's values and the diagonal.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2) interval states with O(1) work each.\n- **Space Complexity:** O(n) with the rolling one-dimensional table.\n\n## Implementation\n\n```python\nclass Solution:\n def longestPalindromeSubseq(self, s: str) -> int:\n n = len(s)\n dp = [0] * n\n for i in range(n - 1, -1, -1):\n dp[i] = 1\n prev = 0\n for j in range(i + 1, n):\n tmp = dp[j]\n if s[i] == s[j]:\n dp[j] = prev + 2\n else:\n dp[j] = max(dp[j], dp[j - 1])\n prev = tmp\n return dp[n - 1]\n```\n", "starter": {"go": "package main\n\nfunc LongestPalindromeSubseq(s string) int {\n \n}", "python": "class Solution:\n def longestPalindromeSubseq(self, s: str) -> int:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int longestPalindromeSubseq(string s) {\n return 0;\n }\n};"}, "fn": "longestPalindromeSubseq", "params": [{"name": "s", "type": "string"}], "outputType": "int", "tests": [["bbbab"], ["cbbd"], ["a"], ["aa"], ["ab"], ["aba"], ["abc"], ["abca"], ["abccba"], ["abcdef"], ["aaaaa"], ["abacaba"], ["racecar"], ["character"], ["bbbababbb"], ["z"], ["abcbabcba"], ["abcdefghijklmnopqrstuvwxyz"], ["aabaa"], ["abcddcba"], ["leetcode"], ["mamad"], ["abccaa"], ["xyzyx"], ["aabbcc"], ["abcbaabcba"], ["qwertytrewq"], ["abbbbbba"]], "expected": [4, 2, 1, 2, 1, 3, 1, 3, 6, 1, 5, 7, 7, 5, 9, 1, 9, 1, 5, 8, 3, 3, 4, 5, 2, 10, 11, 8], "loose": false}

package/data/problems/longest-palindromic-substring.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "57", "slug": "longest-palindromic-substring", "id": 57, "title": "Longest Palindromic Substring", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/longest-palindromic-substring/", "examples": [{"input": "s=\"babad\"", "output": "\"bab\" or \"aba\"", "explanation": "The longest palindromic substring in \"babad\" is \"bab\" or \"aba\" (both length 3)."}, {"input": "s=\"cbbd\"", "output": "\"bb\"", "explanation": "The longest palindromic substring in \"cbbd\" is \"bb\" (length 2)."}], "hints": ["Expand around centers (both odd and even) to find the longest palindromic substring in O(n^2) time and O(1) space."], "statement": "You receive a string s. Locate the longest block within it that reads identically forwards and backwards, and give that block back.\n\n**Constraints:**\n\n- 1 \u2264 s.length \u2264 1000\n- s consist of only digits and English letters.\n", "solution": "## Approach\nExpand around each character as a potential center, handling both odd-length (single center) and even-length (two adjacent centers) palindromes. Keep expanding outward while the characters match, updating the longest palindrome found.\n\n## Complexity Analysis\n- **Time Complexity:** O(n\u00b2)\n- **Space Complexity:** O(1)\n\n## Implementation\n```python\nclass Solution:\n def longestPalindrome(self, s: str) -> str:\n res = ''\n for i in range(len(s)):\n for l, r in ((i, i), (i, i + 1)):\n while l >= 0 and r < len(s) and s[l] == s[r]:\n if r - l + 1 > len(res):\n res = s[l:r+1]\n l -= 1\n r += 1\n return res\n```\n", "starter": {"go": "package main\n\nfunc LongestPalindrome(s string) string {\n \n}", "python": "class Solution:\n def longestPalindrome(self, s: str) -> str:\n pass\n", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n string longestPalindrome(string s) {\n return \"\";\n }\n};"}, "fn": "longestPalindrome", "params": [{"name": "s", "type": "string"}], "outputType": "string", "tests": [["babad"], ["cbbd"], ["a"], ["ac"], ["forgeeksskeegfor"], ["b"], ["Z"], ["5"], ["aa"], ["aba"], ["abba"], ["racecar"], ["abacdfgdcaba"], ["aaaa"], ["abcba"], ["abccba"], ["aabbaa"], ["abcdef"], ["aaaaa"], ["abacaba"], ["xababayz"], ["12321"], ["12345"], ["a1b2b1a"], ["AbA"], ["aab"], ["abb"], ["abcdedcba"], ["abcddcba"], ["z"]], "expected": ["bab", "bb", "a", "a", "geeksskeeg", "b", "Z", "5", "aa", "aba", "abba", "racecar", "aba", "aaaa", "abcba", "abccba", "aabbaa", "a", "aaaaa", "abacaba", "ababa", "12321", "1", "a1b2b1a", "AbA", "aa", "bb", "abcdedcba", "abcddcba", "z"], "loose": false}

package/data/problems/longest-repeating-character-replacement.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "51", "slug": "longest-repeating-character-replacement", "id": 51, "title": "Longest Repeating Character Replacement", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/longest-repeating-character-replacement/", "examples": [{"input": "s=\"ABAB\", k=2", "output": "4", "explanation": "Replace the two 'B's with 'A' (or the two 'A's with 'B') to get \"AAAA\" (\"BBBB\"), a substring of 4 identical characters."}, {"input": "s=\"AABABBA\", k=1", "output": "4", "explanation": "Replace the 'B' at index 3 with 'A' to get \"AAAABBA\", giving a \"AAAA\" substring of length 4. Alternatively, replace the 'A' at index 4 with 'B' to get \"AABBBBA\", giving a \"BBBB\" substring."}], "hints": ["Use a sliding window with frequency counts of letters and track the highest frequency in the window. Shrink the window when (window size - maxFreq) > k."], "statement": "You receive a string s plus an integer k. You may switch up to k positions in the string to any other capital letter. After those edits, report the greatest length of a block made up of a single repeated letter.\n\n**Constraints:**\n\n- 1 \u2264 s.length \u2264 10^5\n- s consists of only uppercase English letters.\n- 0 \u2264 k \u2264 s.length\n", "solution": "## Approach\nUse a sliding window with a frequency map tracking character counts. Maintain the maximum frequency of any single character in the current window. The window is valid when `window_size - max_freq <= k`; if invalid, shrink from the left.\n\n## Complexity Analysis\n- **Time Complexity:** O(n)\n- **Space Complexity:** O(1)\n\n## Implementation\n```python\nclass Solution:\n def characterReplacement(self, s: str, k: int) -> int:\n count = {}\n l = 0\n maxf = 0\n for r in range(len(s)):\n count[s[r]] = count.get(s[r], 0) + 1\n maxf = max(maxf, count[s[r]])\n if r - l + 1 - maxf > k:\n count[s[l]] -= 1\n l += 1\n return len(s) - l\n```\n", "starter": {"go": "package main\n\nfunc CharacterReplacement(s string, k int) int {\n \n}", "python": "class Solution:\n def characterReplacement(self, s: str, k: int) -> int:\n pass\n", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int characterReplacement(string s, int k) {\n return 0;\n }\n};"}, "fn": "characterReplacement", "params": [{"name": "s", "type": "string"}, {"name": "k", "type": "int"}], "outputType": "int", "tests": [["ABAB", "2"], ["AABABBA", "1"], ["AAAA", "2"], ["BAAAB", "2"], ["ABCDE", "1"], ["A", "0"], ["A", "1"], ["AB", "0"], ["AB", "1"], ["ABBB", "2"], ["AAAAAA", "0"], ["AAAAAA", "6"], ["ABCDEF", "3"], ["AABBBBCC", "0"], ["ABABABAB", "3"], ["AAABAA", "2"], ["ABAA", "0"], ["BAAABABB", "2"], ["KRSCDCS", "2"], ["ABCDEEDCBA", "1"], ["Z", "1"], ["AAAB", "1"], ["ABCABC", "2"], ["ZZZZZ", "0"], ["ABCDEF", "6"], ["AABBCC", "2"], ["ABABAB", "0"], ["ABCDE", "5"], ["XYZ", "1"], ["AAABBB", "3"], ["B", "0"], ["CCCCCCCC", "4"]], "expected": [4, 4, 4, 5, 2, 1, 1, 1, 2, 4, 6, 6, 4, 4, 7, 6, 2, 6, 4, 3, 1, 4, 4, 5, 6, 4, 1, 5, 2, 6, 1, 8], "loose": false}

package/data/problems/longest-substring-with-at-least-k-repeating-characters.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "470", "slug": "longest-substring-with-at-least-k-repeating-characters", "id": 470, "title": "Longest Substring with At Least K Repeating Characters", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/longest-substring-with-at-least-k-repeating-characters/", "examples": [{"explanation": "\"aaa\" is good; the full string fails since 'b' appears twice.", "input": "s = \"aaabb\", k = 3", "output": "3"}, {"explanation": "\"ababb\" is good ('a' twice, 'b' three times).", "input": "s = \"ababbc\", k = 2", "output": "5"}, {"explanation": "Every letter appears once, so no block qualifies.", "input": "s = \"abcde\", k = 2", "output": "0"}], "hints": ["Any letter occurring fewer than k times in the current range can never belong to a good block covering that range.", "Split the range at such rare letters and solve each piece independently.", "A piece with no rare letters is itself good."], "statement": "For a lowercase string `s` and a threshold `k`, consider every contiguous block of `s`. A block counts as *good* when each distinct letter inside it occurs at least `k` times within that block (letters absent from the block are ignored). Return the length of the longest good block, or `0` when no good block exists.\n\nNote that a good block need not use the whole string: rare letters can be skipped by cutting around them.\n\n**Constraints:**\n- `1 <= s.length <= 10^4`\n- `s` contains only lowercase English letters.\n- `1 <= k <= 10^5`\n", "solution": "## Approach\n\nA letter that appears fewer than `k` times in the current interval cannot be part of any good block spanning that interval, so the answer must lie in the pieces between such rare letters. Count frequencies, find the first rare letter, split there, and recurse on both sides. An interval with no rare letter is entirely good. Memo-free recursion over at most the alphabet depth keeps it simple.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * alphabet) worst case, effectively O(n) for lowercase input.\n- **Space Complexity:** O(n) recursion and counting in the worst case.\n\n## Implementation\n\n```python\nclass Solution:\n def longestSubstring(self, s: str, k: int) -> int:\n def helper(lo: int, hi: int) -> int:\n if hi - lo < k:\n return 0\n cnt = [0] * 26\n for i in range(lo, hi):\n cnt[ord(s[i]) - ord('a')] += 1\n for i in range(lo, hi):\n if cnt[ord(s[i]) - ord('a')] < k:\n j = i + 1\n while j < hi and cnt[ord(s[j]) - ord('a')] < k:\n j += 1\n return max(helper(lo, i), helper(j, hi))\n return hi - lo\n return helper(0, len(s))\n```\n", "starter": {"go": "package main\n\nfunc LongestSubstring(s string, k int) int {\n return 0\n}", "python": "class Solution:\n def longestSubstring(self, s: str, k: int) -> int:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int longestSubstring(string s, int k) {\n return 0;\n }\n};"}, "fn": "longestSubstring", "params": [{"name": "s", "type": "string"}, {"name": "k", "type": "int"}], "outputType": "int", "tests": [["aaabb", "3"], ["ababbc", "2"], ["abcde", "2"], ["a", "1"], ["a", "2"], ["aa", "2"], ["ab", "1"], ["ab", "2"], ["aaabbb", "3"], ["aaabbbccc", "3"], ["ababab", "3"], ["bbaaacbd", "3"], ["aaaaa", "5"], ["aaaaa", "6"], ["abcabcabc", "3"], ["aabbccdd", "2"], ["aabbccdde", "2"], ["abcdefghijklmnopqrstuvwxyz", "1"], ["abcdefghijklmnopqrstuvwxyz", "2"], ["aaabbbcccddeee", "3"], ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "5000"], ["abababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababababab", "5000"], ["aabbccddee", "2"], ["zzzzzzzzzz", "3"], ["abcdd", "2"], ["bcdab", "1"], ["aaabaaa", "3"], ["ababacb", "3"], ["aabcabac", "2"], ["aaabbb", "2"]], "expected": [3, 5, 0, 1, 0, 2, 2, 0, 6, 9, 6, 3, 5, 0, 9, 8, 8, 26, 0, 9, 10000, 10000, 10, 10, 2, 5, 3, 0, 8, 6], "loose": false}

package/data/problems/longest-substring-with-at-most-k-distinct-characters.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "423", "slug": "longest-substring-with-at-most-k-distinct-characters", "id": 423, "title": "Longest Substring with At Most K Distinct Characters", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/longest-substring-with-at-most-k-distinct-characters/", "examples": [{"input": "s = \"eceba\", k = 2", "output": "3", "explanation": "The block ece uses two letters and is the longest such block."}, {"input": "s = \"aa\", k = 1", "output": "2", "explanation": "One distinct letter covers the whole string."}, {"input": "s = \"abc\", k = 5", "output": "3", "explanation": "The allowance covers everything, so the full length counts."}], "hints": ["Grow a right edge and count characters inside the window.", "When distinct letters exceed k, advance the left edge until the count fits again."], "statement": "Given a string `s` and a non-negative integer `k`, find the length of the longest contiguous block that uses no more than `k` different characters.\n\nA block is any run of consecutive positions. When `k` is zero, or `s` is empty, no non-empty block qualifies and the answer is zero.\n\n**Constraints:**\n- `0 <= s.length <= 10^4`\n- `0 <= k <= 100`\n- `s` consists of printable ASCII characters.\n", "solution": "## Approach\n\nSlide a window across the string while counting how many times each character appears inside it. Expanding the right end can only add distinct letters; whenever the distinct count passes `k`, move the left end forward (dropping counts) until the window fits again. Every maximal valid window is measured, and the largest measurement is the answer.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), each character enters and leaves the window once.\n- **Space Complexity:** O(min(n, alphabet)) for the frequency table.\n\n## Implementation\n\n```python\nclass Solution:\n def lengthOfLongestSubstringKDistinct(self, s: str, k: int) -> int:\n if k == 0 or not s:\n return 0\n from collections import defaultdict\n count = defaultdict(int)\n left = best = 0\n for right, c in enumerate(s):\n count[c] += 1\n while len(count) > k:\n lc = s[left]\n count[lc] -= 1\n if count[lc] == 0:\n del count[lc]\n left += 1\n best = max(best, right - left + 1)\n return best\n```\n", "starter": {"go": "package main\n\nfunc LengthOfLongestSubstringKDistinct(s string, k int) int {\n \n}", "python": "class Solution:\n def lengthOfLongestSubstringKDistinct(self, s: str, k: int) -> int:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int lengthOfLongestSubstringKDistinct(string s, int k) {\n return 0;\n }\n};"}, "fn": "lengthOfLongestSubstringKDistinct", "params": [{"name": "s", "type": "string"}, {"name": "k", "type": "int"}], "outputType": "int", "tests": [["eceba", "2"], ["aa", "1"], ["abc", "5"], ["", "2"], ["a", "0"], ["a", "1"], ["ab", "1"], ["ab", "2"], ["ccaabbb", "2"], ["eceba", "1"], ["abaccc", "2"], ["abcdef", "3"], ["aaaa", "1"], ["abbbbccd", "2"], ["abcabcabc", "2"], ["aabbcc", "1"], ["aabbcc", "2"], ["aabbcc", "3"], ["abABab", "2"], ["a b c", "2"], ["aabacbebebe", "3"], ["aaaaaaaaaa", "0"], ["abc", "0"], ["abcc", "2"], ["mississippi", "2"], ["mississippi", "3"], ["qwerty", "6"], ["abababab", "2"]], "expected": [3, 2, 3, 0, 0, 1, 1, 2, 5, 1, 4, 3, 4, 6, 2, 2, 4, 6, 2, 3, 7, 0, 0, 3, 7, 10, 6, 8], "loose": false}

package/data/problems/longest-substring-with-at-most-two-distinct-characters.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "312", "slug": "longest-substring-with-at-most-two-distinct-characters", "id": 312, "title": "Longest Substring with At Most Two Distinct Characters", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/longest-substring-with-at-most-two-distinct-characters/", "examples": [{"explanation": "The longest piece using at most two distinct characters is \"ece\".", "input": "s = \"eceba\"", "output": "3"}, {"explanation": "The longest piece using at most two distinct characters is \"aabbb\".", "input": "s = \"ccaabbb\"", "output": "5"}, {"explanation": "A single character trivially uses one distinct character.", "input": "s = \"a\"", "output": "1"}], "hints": ["Keep a sliding window with counts of each character inside it.", "When the window holds more than two distinct characters, move the left edge forward until it holds two again."], "statement": "Given a string `s`, find the length of the longest piece that uses no more than two different characters.\n\nThink of scanning from left to right while keeping track of the characters inside the current window. When a third distinct character appears, shrink the window from the left until only two distinct characters remain. The best window size seen during this scan is the answer.\n\n**Constraints:**\n- `0 <= s.length <= 10^4`\n- `s` consists of lowercase and uppercase English letters\n", "solution": "## Approach\n\nSlide a window across the string while counting how many times each character appears inside it. Expand the right edge one step at a time; whenever a third distinct character enters, advance the left edge until only two remain. The largest window size observed is the longest piece with at most two distinct characters.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the length of `s`. Each character enters and leaves the window once.\n- **Space Complexity:** O(1), since the window holds at most three distinct characters.\n\n## Implementation\n\n```python\nclass Solution:\n def lengthOfLongestSubstringTwoDistinct(self, s: str) -> int:\n from collections import defaultdict\n count = defaultdict(int)\n left = 0\n best = 0\n for right, c in enumerate(s):\n count[c] += 1\n while len(count) > 2:\n lc = s[left]\n count[lc] -= 1\n if count[lc] == 0:\n del count[lc]\n left += 1\n best = max(best, right - left + 1)\n return best\n```\n", "starter": {"go": "package main\n\nfunc LengthOfLongestSubstringTwoDistinct(s string) int {\n \n}", "python": "class Solution:\n def lengthOfLongestSubstringTwoDistinct(self, s: str) -> int:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int lengthOfLongestSubstringTwoDistinct(string s) {\n return 0;\n }\n};"}, "fn": "lengthOfLongestSubstringTwoDistinct", "params": [{"name": "s", "type": "string"}], "outputType": "int", "tests": [["eceba"], ["ccaabbb"], ["a"], [""], ["aaaa"], ["ab"], ["abcabcabc"], ["ecebaa"], ["abaccc"], ["abcdef"], ["aabbcc"], ["aaabbb"], ["abbbbbc"], ["qwerty"], ["aA"], ["aAbB"], ["zzzzzyyyyyxxxx"], ["abc"], ["aab"], ["abb"], ["abcaaa"], ["xyxyxyxy"], ["abcdefabcdef"], ["aa"], ["ab"], ["aabbbaa"]], "expected": [3, 5, 1, 0, 4, 2, 2, 3, 4, 2, 4, 6, 6, 2, 2, 2, 10, 2, 3, 3, 4, 8, 2, 2, 2, 7], "loose": false}

package/data/problems/longest-substring-without-repeating-characters.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "50", "slug": "longest-substring-without-repeating-characters", "id": 50, "title": "Longest Substring Without Repeating Characters", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/longest-substring-without-repeating-characters/", "examples": [{"input": "s=\"abcabcbb\"", "output": "3", "explanation": "The answer is \"abc\" with length 3."}, {"input": "s=\"bbbbb\"", "output": "1", "explanation": "The answer is \"b\" with length 1."}, {"input": "s=\"pwwkew\"", "output": "3", "explanation": "The answer is \"wke\" with length 3."}], "hints": ["Use a sliding window with a character index map to track the latest position of each character. Move the left bound when you encounter a repeat to maintain a window with all unique characters."], "statement": "You receive a string s. Measure the greatest length of a continuous block inside it in which every character occurs only once.\n\n**Constraints:**\n\n- 0 \u2264 s.length \u2264 5 * 10^4\n- s consists of English letters, digits, symbols and spaces.\n", "solution": "## Approach\nUse a sliding window with a hashmap storing each character's last seen index. When a duplicate is found within the current window, move the left boundary past the previous occurrence. Track the maximum window size encountered.\n\n## Complexity Analysis\n- **Time Complexity:** O(n)\n- **Space Complexity:** O(1)\n\n## Implementation\n```python\nclass Solution:\n def lengthOfLongestSubstring(self, s: str) -> int:\n seen = {}\n l = 0\n res = 0\n for r, c in enumerate(s):\n if c in seen and seen[c] >= l:\n l = seen[c] + 1\n else:\n res = max(res, r - l + 1)\n seen[c] = r\n return res\n```\n", "starter": {"go": "package main\n\nfunc LengthOfLongestSubstring(s string) int {\n \n}", "python": "class Solution:\n def lengthOfLongestSubstring(self, s: str) -> int:\n pass\n", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int lengthOfLongestSubstring(string s) {\n return 0;\n }\n};"}, "fn": "lengthOfLongestSubstring", "params": [{"name": "s", "type": "string"}], "outputType": "int", "tests": [["abcabcbb"], ["bbbbb"], ["pwwkew"], [""], ["au"], ["dvdf"], ["abba"], ["tmmzuxt"], ["anviaj"], ["a"], ["ab"], ["aa"], ["abcdef"], ["abcdefghijklmnopqrstuvwxyz"], ["abccba"], ["bbbbba"], ["abcdabcd"], ["aab"], ["abcbdef"], ["wobble"], ["1234567890"], ["aA1! "], ["hello world"], ["mississippi"], ["abcdefgabc"], ["z"], ["aabbcc"], ["xyzzxy"], ["qwertyuiop"], ["112233"], ["abcd efgh"], ["AaAa"]], "expected": [3, 1, 3, 0, 2, 3, 2, 5, 5, 1, 2, 1, 6, 26, 3, 2, 4, 2, 5, 3, 10, 5, 6, 3, 7, 1, 2, 3, 10, 2, 9, 2], "loose": false}

package/data/problems/longest-turbulent-subarray.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "238", "slug": "longest-turbulent-subarray", "id": 238, "title": "Longest Turbulent Subarray", "difficulty": "Medium", "category": "greedy", "link": "https://leetcode.com/problems/longest-turbulent-subarray/", "examples": [{"input": "arr = [9,4,2,10,7,8,8,1,9]", "output": "5", "explanation": "arr[1] > arr[2] < arr[3] > arr[4] < arr[5]"}, {"input": "arr = [4,8,12,16]", "output": "2"}, {"input": "arr = [100]", "output": "1"}], "hints": ["Turbulence is a local alternating property; track two counters: the longest swing ending with '<' and the longest ending with '>'.", "When consecutive elements are equal, a turbulent run restarts at size 1.", "Keep a sliding window over arr while it remains turbulent."], "statement": "You receive an integer array `arr`. Report the extent of the largest **turbulent subarray** inside `arr`.\n\nCall a subarray **turbulent** when the direction of comparison reverses at every neighboring pair within it.\n\nIn precise terms, a slice `[arr[i], arr[i + 1], ..., arr[j]]` of `arr` counts as turbulent exactly when one of these patterns holds:\n\n- For `i <= k < j`:\n - `arr[k] > arr[k + 1]` when `k` is **odd**, and\n - `arr[k] < arr[k + 1]` when `k` is **even**.\n- Or, for `i <= k < j`:\n - `arr[k] > arr[k + 1]` when `k` is **even**, and\n - `arr[k] < arr[k + 1]` when `k` is **odd**.\n\n**Constraints:**\n\n- `1 <= arr.length <= 4 * 10^4`\n- `0 <= arr[i] <= 10^9`\n", "solution": "## Approach\n\nA subarray is turbulent when adjacent comparison signs alternate. Maintain two counters: `inc` (the longest turbulent subarray ending with an increasing step) and `dec` (the longest one ending with a decreasing step). For each adjacent pair, either extend the run in the opposite direction, or restart the run when the pair is equal. Track the maximum over all runs.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where `n` is `arr.length`.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n def maxTurbulenceSize(self, arr: List[int]) -> int:\n n = len(arr)\n if n < 2:\n return n\n inc = dec = 1\n best = 1\n for i in range(1, n):\n if arr[i - 1] < arr[i]:\n inc = dec + 1\n dec = 1\n elif arr[i - 1] > arr[i]:\n dec = inc + 1\n inc = 1\n else:\n inc = dec = 1\n best = max(best, inc, dec)\n return best\n```", "starter": {"go": "package main\n\nfunc MaxTurbulenceSize(arr []int) int {\n \n}", "python": "from typing import List\nclass Solution:\n def maxTurbulenceSize(self, arr: List[int]) -> int:\n ", "cpp": "#include <vector>\n#include <algorithm>\nusing namespace std;\n\nclass Solution {\npublic:\n int maxTurbulenceSize(vector<int>& arr) {\n \n }\n};"}, "fn": "maxTurbulenceSize", "params": [{"name": "arr", "type": "int_array"}], "outputType": "int", "tests": [["[9,4,2,10,7,8,8,1,9]"], ["[4,8,12,16]"], ["[100]"], ["[1,1,1]"], ["[1,3,2,4,3,5]"], ["[0]"], ["[1,2]"], ["[2,1]"], ["[2,2]"], ["[1,2,1,2,1,2,1]"], ["[7,7,7,7,8]"], ["[8,7,7,7,7]"], ["[1,3,2,2,4,3,5]"], ["[3,3,2,2,1,1,0,0]"], ["[1,2,3,2,1,2,3,2,1]"], ["[5,4,3,2,1]"], ["[2,1,2,1,2,1]"], ["[1,1,2,2,3,3]"], ["[0,1]"], ["[1,0]"], ["[5,5]"], ["[0,0,0,0]"], ["[1,2,3,4,5]"], ["[1000000000,0,1000000000,0]"], ["[1,3,2,4,3,5,4,6]"], ["[9,9,9,9,1]"], ["[1,9,9,9,9]"], ["[2,0,2,0,2]"], ["[10,10,5,5,10,10]"], ["[1,2,1,2]"], ["[3,2,5,1,4]"], ["[0,1000000000]"]], "expected": [5, 2, 1, 1, 6, 1, 2, 2, 1, 7, 2, 2, 4, 2, 3, 2, 6, 2, 2, 2, 1, 1, 2, 4, 8, 2, 2, 5, 2, 4, 5, 2], "loose": false}

package/data/problems/longest-uncommon-subsequence-i.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "580", "slug": "longest-uncommon-subsequence-i", "id": 580, "title": "Longest Uncommon Subsequence I", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/longest-uncommon-subsequence-i/", "examples": [{"input": "a = \"aba\", b = \"cdc\"", "output": "3", "explanation": "\"aba\" itself is not a subsequence of \"cdc\", so the full length 3 qualifies."}, {"input": "a = \"aaa\", b = \"bbb\"", "output": "3", "explanation": "Either whole string is absent from the other side."}, {"input": "a = \"aaa\", b = \"aaa\"", "output": "-1", "explanation": "Both strings share exactly the same subsequences."}], "hints": ["When the strings are identical, every subsequence is shared, so the answer is -1.", "Otherwise the longer whole string can never be a subsequence of the shorter one, giving max(len(a), len(b))."], "statement": "A subsequence keeps a selection of characters in their original order while possibly skipping others. A subsequence of one string is called uncommon when it never appears as a subsequence of the other string.\n\nGiven two strings `a` and `b`, return the length of the longest subsequence of one string that is not a subsequence of the other. Return `-1` when no such subsequence exists.\n\n**Constraints:**\n- `1 <= a.length, b.length <= 100`\n- `a` and `b` consist of lowercase English letters\n", "solution": "## Approach\n\nIdentical strings share every subsequence, so nothing is uncommon and the answer is `-1`. When the strings differ, the longer one in full cannot fit inside the shorter one as a subsequence, making its whole length achievable; equal-length but differing strings likewise admit the full length from either side. Hence the answer is the larger of the two lengths.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(min(len(a), len(b))) to test string equality.\n- **Space Complexity:** O(1) extra memory.\n\n## Implementation\n\n```python\nclass Solution:\n def findLUSlength(self, a: str, b: str) -> int:\n if a == b:\n return -1\n return max(len(a), len(b))\n```\n", "starter": {"go": "package main\n\nfunc FindLUSlength(a string, b string) int {\n \n}", "python": "class Solution:\n def findLUSlength(self, a: str, b: str) -> int:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int findLUSlength(string a, string b) {\n return 0;\n }\n};"}, "fn": "findLUSlength", "params": [{"name": "a", "type": "string"}, {"name": "b", "type": "string"}], "outputType": "int", "tests": [["aba", "cdc"], ["aaa", "bbb"], ["aaa", "aaa"], ["a", "b"], ["a", "a"], ["ab", "ba"], ["abc", "abc"], ["abc", "def"], ["abcd", "abc"], ["abc", "abcd"], ["horbxeemlgqpqbujbdag", "horbxeemlgqpqbujbdag"], ["horbxeemlgqpqbujbdag", "horbxeemlgqpqbujbdah"], ["a", "ab"], ["ab", "a"], ["aaaa", "aa"], ["aa", "aaaa"], ["xyz", "xy"], ["xy", "xyz"], ["longstringtest", "longstringtesu"], ["q", "qqqqqqqqqq"], ["qqqqqqqqqq", "q"], ["abcde", "abcee"], ["abcee", "abcde"], ["z", "z"], ["abcdefghij", "abcdefghik"], ["aaaaab", "aaaaac"], ["abcabc", "abcabc"], ["abcabc", "abcabd"]], "expected": [3, 3, -1, 1, -1, 2, -1, 3, 4, 4, -1, 20, 2, 2, 4, 4, 3, 3, 14, 10, 10, 5, 5, -1, 10, 6, -1, 6], "loose": false}