offcode 0.0.0-stage → 0.1.0

package/data/problems/largest-time-for-given-digits.json

@@ -0,0 +1 @@
+{"basic": false, "label": "936", "slug": "largest-time-for-given-digits", "id": 936, "title": "Largest Time for Given Digits", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/largest-time-for-given-digits/", "examples": [{"input": "arr = [1,2,3,4]", "output": "\"23:41\"", "explanation": "Latest among all valid arrangements."}, {"input": "arr = [5,5,5,5]", "output": "\"\"", "explanation": "No valid hour and minute pair."}, {"input": "arr = [0,0,0,0]", "output": "\"00:00\"", "explanation": "Midnight is the only build."}], "hints": ["Only 24 orderings exist, so trying every placement of the four digits is cheap.", "A placement is valid when its hour is below 24 and its minute below 60; keep the valid one with the most total minutes.", "Format the winner with two digits on each side, or return empty when nothing qualified."], "statement": "Assemble the latest valid clock time from four digit tiles.\n\nA 24-hour time looks like `\"HH:MM\"` with hours from `00` to `23` and minutes from `00` to `59`. You must use each of the four given digits exactly once. When several valid times exist, keep the latest one; when none exists, return the empty string.\n\nGiven `arr` of four digits, return the best time or `\"\"`.\n\n**Constraints:**\n- `arr.length == 4`\n- `0 <= arr[i] <= 9`\n", "solution": "## Approach\n\nEnumerate all 24 ways to assign the four positions to the four digits. Each assignment splits into an hour and a minute; keep it when the hour is under 24 and the minute under 60. Track the valid assignment with the most minutes since midnight and format it as HH:MM, defaulting to empty when nothing is valid.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(1), a fixed 24 checks.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def largestTimeFromDigits(self, arr: List[int]) -> str:\n        best = \"\"\n        best_min = -1\n        for i in range(4):\n            for j in range(4):\n                if j == i:\n                    continue\n                for k in range(4):\n                    if k == i or k == j:\n                        continue\n                    l = 6 - i - j - k\n                    hh = arr[i] * 10 + arr[j]\n                    mm = arr[k] * 10 + arr[l]\n                    if hh < 24 and mm < 60:\n                        tot = hh * 60 + mm\n                        if tot > best_min:\n                            best_min = tot\n                            best = \"%02d:%02d\" % (hh, mm)\n        return best\n```\n", "starter": {"go": "package main\n\nfunc LargestTimeFromDigits(arr []int) string {\n    return \"\"\n}", "python": "from typing import List\nclass Solution:\n    def largestTimeFromDigits(self, arr: List[int]) -> str:\n        pass", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n    string largestTimeFromDigits(vector<int>& arr) {\n        return \"\";\n    }\n};"}, "fn": "largestTimeFromDigits", "params": [{"name": "arr", "type": "int_array"}], "outputType": "string", "tests": [["[1, 2, 3, 4]"], ["[5, 5, 5, 5]"], ["[0, 0, 0, 0]"], ["[2, 0, 6, 6]"], ["[0, 0, 1, 0]"], ["[1, 9, 5, 0]"], ["[2, 4, 0, 0]"], ["[2, 3, 5, 9]"], ["[0, 2, 7, 9]"], ["[1, 2, 0, 0]"], ["[3, 3, 3, 3]"], ["[2, 3, 0, 0]"], ["[9, 9, 9, 9]"], ["[0, 1, 2, 3]"], ["[1, 1, 1, 2]"], ["[2, 2, 2, 3]"], ["[4, 5, 6, 6]"], ["[0, 0, 5, 9]"], ["[1, 2, 3, 9]"], ["[0, 4, 8, 9]"], ["[2, 1, 0, 5]"], ["[6, 0, 0, 0]"], ["[2, 0, 0, 0]"], ["[1, 0, 0, 0]"], ["[2, 3, 4, 5]"], ["[7, 3, 2, 0]"], ["[1, 3, 6, 7]"], ["[5, 0, 2, 0]"]], "expected": ["23:41", "", "00:00", "06:26", "10:00", "19:50", "20:40", "23:59", "09:27", "21:00", "", "23:00", "", "23:10", "21:11", "23:22", "", "09:50", "23:19", "09:48", "21:50", "06:00", "20:00", "10:00", "23:54", "23:07", "17:36", "20:50"], "loose": false}

package/data/problems/largest-triangle-area.json

@@ -0,0 +1 @@
+{"basic": false, "label": "810", "slug": "largest-triangle-area", "id": 810, "title": "Largest Triangle Area", "difficulty": "Easy", "category": "math", "link": "https://leetcode.com/problems/largest-triangle-area/", "examples": [{"input": "points = [[0,0],[0,1],[1,0],[0,2],[2,0]]", "output": "\"2.0\"", "explanation": "The triangle (0,0),(0,2),(2,0) has area 2, which is the largest achievable."}, {"input": "points = [[1,0],[0,0],[0,1]]", "output": "\"0.5\"", "explanation": "The only triangle uses the three points and covers half a unit square."}, {"input": "points = [[0,0],[1,1],[2,2]]", "output": "\"0.0\"", "explanation": "All points lie on one line, so every triangle is flat."}], "hints": ["This is a portable adaptation: return the area as a finite, double-parseable decimal string.", "Try every triple of points and keep the largest shoelace value: area = |x1(y2-y3)+x2(y3-y1)+x3(y1-y2)| / 2.", "Three points on one line give zero area and can be ignored."], "statement": "You are given a set of 2D points with integer coordinates. Pick any three distinct points as triangle corners and measure the triangle's area.\n\nReturn the largest achievable area.\n\nAdaptation note: the original task returns a floating number. Here, return the area as a decimal string (for example `\"2.0\"` or `\"0.5\"`). The judge parses your string as a double and accepts it within an absolute tolerance of 1e-9 plus a relative tolerance of 1e-5.\n\n**Constraints:**\n- `3 <= points.length <= 50`\n- `-50 <= points[i][j] <= 50`\n- All points are distinct.\n", "solution": "## Approach\n\nEnumerate every unordered triple of points and evaluate its area with the shoelace formula, keeping the maximum. With at most 50 points the cubic scan is easily fast enough. Degenerate collinear triples naturally yield zero and never beat a positive area. Format the best value as a decimal string.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^3) for n points, one constant-time area per triple.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def largestTriangleArea(self, points: List[List[int]]) -> str:\n        best = 0.0\n        n = len(points)\n        for i in range(n):\n            x1, y1 = points[i]\n            for j in range(i + 1, n):\n                x2, y2 = points[j]\n                for k in range(j + 1, n):\n                    x3, y3 = points[k]\n                    a = abs(x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2)) / 2.0\n                    if a > best:\n                        best = a\n        return str(best)\n```\n", "starter": {"go": "package main\n\nfunc LargestTriangleArea(points [][]int) string {\n    return \"0.0\"\n}", "python": "from typing import List\n\nclass Solution:\n    def largestTriangleArea(self, points: List[List[int]]) -> str:\n        return \"0.0\"\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    string largestTriangleArea(vector<vector<int>>& points) {\n        return \"0.0\";\n    }\n};"}, "fn": "largestTriangleArea", "params": [{"name": "points", "type": "int_array_2d"}], "outputType": "string", "tests": [["[[0,0],[0,1],[1,0],[0,2],[2,0]]"], ["[[1,0],[0,0],[0,1]]"], ["[[0,0],[1,1],[2,2]]"], ["[[0,0],[0,2],[2,0],[2,2]]"], ["[[0,0],[1,0],[0,1],[1,1]]"], ["[[0,0],[3,0],[0,4]]"], ["[[-1,-1],[1,1],[1,-1],[-1,1]]"], ["[[0,0],[5,0],[0,5],[1,1]]"], ["[[0,0],[0,1],[1,0]]"], ["[[2,2],[2,5],[5,2]]"], ["[[0,0],[10,0],[0,10]]"], ["[[-50,-50],[50,-50],[0,50]]"], ["[[0,0],[1,0],[2,0],[0,1]]"], ["[[1,1],[2,2],[3,3],[0,1]]"], ["[[0,0],[4,0],[2,3]]"], ["[[1,2],[3,4],[5,6],[7,8],[0,0]]"], ["[[0,0],[0,50],[50,0],[50,50]]"], ["[[-5,0],[5,0],[0,5]]"], ["[[0,0],[2,1],[1,2]]"], ["[[3,3],[3,7],[7,3],[7,7]]"], ["[[0,0],[6,0],[3,5]]"], ["[[1,1],[1,4],[4,1],[4,4],[2,2]]"], ["[[0,0],[1,1],[0,2],[2,0]]"], ["[[-10,0],[10,0],[0,1]]"], ["[[0,0],[0,3],[4,0],[1,1],[2,2]]"], ["[[5,5],[10,10],[15,5]]"], ["[[0,0],[7,0],[0,7],[3,3]]"], ["[[2,0],[0,2],[-2,0],[0,-2]]"]], "expected": ["2.0", "0.5", "0.0", "2.0", "0.5", "6.0", "2.0", "12.5", "0.5", "4.5", "50.0", "5000.0", "1.0", "1.0", "6.0", "3.0", "1250.0", "25.0", "1.5", "8.0", "15.0", "4.5", "2.0", "10.0", "6.0", "25.0", "24.5", "4.0"], "loose": false}

package/data/problems/last-stone-weight-ii.json

@@ -0,0 +1 @@
+{"basic": false, "label": "233", "slug": "last-stone-weight-ii", "id": 233, "title": "Last Stone Weight II", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/last-stone-weight-ii/", "examples": [{"input": "stones = [2,7,4,1,8,1]", "output": "1", "explanation": "We can combine 2 and 4 to get 2, so the array converts to [2,7,1,8,1] then, we can combine 7 and 8 to get 1, so the array converts to [2,1,1,1] then, we can combine 2 and 1 to get 1, so the array converts to [1,1,1] then, we can combine 1 and 1 to get 0, so the array converts to [1], then that's the optimal value."}, {"input": "stones = [31,26,33,21,40]", "output": "5", "explanation": "We can do any sequence of smashes we want, and 5 is the smallest possible."}], "hints": ["Think of the final answer as a sum of weights with + or - sign symbols in front of each weight. Actually, all sums with 1 of each sign symbol are possible.", "Use dynamic programming: for every possible sum with N stones, those sums +x or -x is possible with N+1 stones, where x is the value of the newest stone."], "statement": "An integer array `stones` lists the weight of every rock, with `stones[i]` belonging to the `i`-th rock.\n\nThe rocks take part in the following game. On every move, pick any two rocks and crash them together: call their weights `x` and `y` with `x <= y`. The crash has this outcome:\n\n- When `x == y`, both rocks vanish, and\n- When `x != y`, the rock of weight `x` vanishes, while the rock of weight `y` survives with the reduced weight `y - x`.\n\nPlay continues until no more than one rock is left.\n\nReport the lightest weight that this final rock can possibly have. When every rock can be eliminated, report `0`.\n\n**Constraints:**\n- 1 \u2264 stones.length \u2264 30\n- 1 \u2264 stones[i] \u2264 100\n", "solution": "## Approach\n\nThe smash game is equivalent to assigning each stone a `+` or `-` sign: smashing two stones keeps the difference of their signs, and the final remaining stone is `|signed sum|`. So the answer is the smallest possible non-negative value of `total - 2 * S`, where `S` is a subset sum. This is a classic 0/1 knapsack: use boolean DP to find all achievable subset sums, then pick the largest `S <= total / 2`. The answer is `total - 2 * S`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * total), where `total` is the sum of all stones (at most 3000).\n- **Space Complexity:** O(total) for the dp array.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def lastStoneWeightII(self, stones: List[int]) -> int:\n        total = sum(stones)\n        dp = [False] * (total + 1)\n        dp[0] = True\n        for s in stones:\n            for sm in range(total, s - 1, -1):\n                dp[sm] = dp[sm] or dp[sm - s]\n        for sm in range(total // 2, -1, -1):\n            if dp[sm]:\n                return total - 2 * sm\n        return total\n```", "starter": {"go": "package main\n\nfunc LastStoneWeightII(stones []int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def lastStoneWeightII(self, stones: List[int]) -> int:\n        ", "cpp": "#include <vector>\n#include <algorithm>\nusing namespace std;\n\nclass Solution {\npublic:\n    int lastStoneWeightII(vector<int>& stones) {\n        \n    }\n};"}, "fn": "lastStoneWeightII", "params": [{"name": "stones", "type": "int_array"}], "outputType": "int", "tests": [["[2,7,4,1,8,1]"], ["[31,26,33,21,40]"], ["[1]"], ["[2,2]"], ["[1,1]"], ["[1,2]"], ["[3,5]"], ["[1,1,1,1]"], ["[10]"], ["[5,5,5]"], ["[1,2,3,4,5]"], ["[100,100,100,100,100]"], ["[2,4,6,8]"], ["[1,3,5,7,9,11]"], ["[1,2,4,5]"], ["[1,1,1]"], ["[2,1]"], ["[3,3,3]"], ["[4,4,4,4]"], ["[7,7,7,7,7]"], ["[1,5,10]"], ["[2,3,5]"], ["[6,6,6]"], ["[8,4,2,1]"], ["[9,3,3]"], ["[14,7,7]"], ["[20,10,10,10]"], ["[50,50]"], ["[99,1]"], ["[5,10,15]"], ["[3,1,4,1,5]"]], "expected": [1, 5, 1, 0, 0, 1, 2, 0, 10, 5, 1, 100, 0, 0, 0, 1, 1, 3, 0, 7, 4, 0, 6, 1, 3, 0, 10, 0, 98, 0, 0], "loose": false}

package/data/problems/last-stone-weight.json

@@ -0,0 +1 @@
+{"basic": false, "label": "102", "slug": "last-stone-weight", "id": 102, "title": "Last Stone Weight", "difficulty": "Easy", "category": "heap", "link": "https://leetcode.com/problems/last-stone-weight/", "examples": [{"input": "stones = [2,7,4,1,8,1]", "output": "1", "explanation": "Repeatedly smashing the two heaviest stones leaves one stone of weight 1."}, {"input": "stones = [2,2]", "output": "0", "explanation": "Equal stones destroy each other."}], "hints": ["The next operation always needs the two largest remaining weights.", "Use a max-heap so both stones can be removed in logarithmic time.", "Insert `y - x` back into the heap only when the two weights differ."], "statement": "A pile of rocks is described by the array `stones`, where each entry `stones[i]` records how heavy the `i`-th rock is.\n\nEach round proceeds as follows: select the two remaining rocks with the greatest weights, denote them `x <= y`, and crash them into each other. When the pair matches (`x == y`), both rocks vanish. When the pair differs, the lighter rock vanishes and the heavier rock continues with its weight lowered to `y - x`.\n\nReport the weight of the single rock that survives at the end, or `0` when nothing survives.\n\n**Constraints:**\n\n- `1 <= stones.length <= 30`\n- `1 <= stones[i] <= 1000`\n", "solution": "## Approach\n\nPython's heap is a min-heap, so store every stone as a negative weight to simulate a max-heap. Repeatedly remove the two heaviest stones and insert their difference when they are unequal, then return the remaining weight or zero.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n log n), where `n` is the number of stones.\n- **Space Complexity:** O(n) for the heap.\n\n## Implementation\n\n```python\nimport heapq\nfrom typing import List\n\n\nclass Solution:\n    def lastStoneWeight(self, stones: List[int]) -> int:\n        heap = [-stone for stone in stones]\n        heapq.heapify(heap)\n        while len(heap) > 1:\n            y = -heapq.heappop(heap)\n            x = -heapq.heappop(heap)\n            if x != y:\n                heapq.heappush(heap, x - y)\n        return -heap[0] if heap else 0\n```\n", "starter": {"go": "package main\n\nfunc LastStoneWeight(stones []int) int {\n    panic(\"TODO\")\n}", "python": "from typing import List\n\nclass Solution:\n    def lastStoneWeight(self, stones: List[int]) -> int:\n        raise NotImplementedError\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    int lastStoneWeight(vector<int>& stones) {\n        return 0;\n    }\n};"}, "fn": "lastStoneWeight", "params": [{"name": "stones", "type": "int_array"}], "outputType": "int", "tests": [["[2,7,4,1,8,1]"], ["[2,2]"], ["[1]"], ["[3,7,2]"], ["[10,4,2,10]"], ["[1,1,1,1]"], ["[5,3,1]"], ["[9,3,2,10]"], ["[8,8,8]"], ["[1000,1]"], ["[4,6,4,6]"], ["[1,2,3,4,5]"], ["[10,9,8,7,6]"], ["[20,20,10]"], ["[2,3]"], ["[7,7,7,7,7]"], ["[100,50,25,25]"], ["[31,26,33,21,40]"], ["[1,3,5,7,9]"], ["[2,4,8,16]"], ["[6,6,5,5,4,4]"], ["[10,1,1,1,1]"], ["[99,98,97]"], ["[50,40,30,20,10]"], ["[3,3,3]"], ["[12,12,6,6,3,3]"], ["[1000,999,1]"], ["[17,13,11,7,5,3,2]"], ["[4,4,4,4,4,4]"], ["[1,100,1,100,1]"], ["[23,23,46]"], ["[8,1,2,3,4,5,6,7]"], ["[15,14,13,12,11,10]"], ["[200,150,100,50]"], ["[9,9,8,8,7]"], ["[2,2,2,3]"], ["[64,32,16,8,4,2,1]"], ["[5,10,15,20,25]"], ["[30,30,30,10]"], ["[14,7,7,3,3]"], ["[101,202,303]"], ["[999,500,250,125]"], ["[18,18,17,17,1]"], ["[42]"], ["[6,1,6,1,6,1]"], ["[27,18,9,6,3]"], ["[100,99,2,1]"], ["[11,22,33,44,55]"], ["[7,5,3,2,2,1]"], ["[1000,1000,1000,1000]"], ["[1000]"], ["@javascript:JSON.stringify(Array.from({length:30},(_,i)=>i%2===0?1:1000))"]], "expected": [1, 0, 1, 2, 2, 0, 1, 0, 8, 999, 0, 1, 4, 10, 1, 7, 0, 9, 1, 2, 0, 6, 96, 10, 3, 0, 0, 0, 0, 1, 0, 0, 1, 0, 7, 1, 1, 5, 20, 0, 0, 124, 1, 42, 3, 3, 0, 11, 0, 0, 1000, 985], "loose": false}

package/data/problems/leaf-similar-trees.json

@@ -0,0 +1 @@
+{"basic": false, "label": "866", "slug": "leaf-similar-trees", "id": 866, "title": "Leaf-Similar Trees", "difficulty": "Easy", "category": "tree", "link": "https://leetcode.com/problems/leaf-similar-trees/", "examples": [{"input": "root1 = [3,5,1,6,2,9,8,null,null,7,4], root2 = [3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]", "output": "true", "explanation": "Both leaf orders are 6, 7, 4, 9, 8."}, {"input": "root1 = [1,2,3], root2 = [1,3,2]", "output": "false", "explanation": "Orders are 2, 3 versus 3, 2."}, {"input": "root1 = [1], root2 = [1]", "output": "true", "explanation": "Both are a single 1."}], "hints": ["A simple depth-first walk that visits left before right naturally emits leaves in order.", "Collect each tree's leaf list separately, then compare the two lists for equality.", "Iterative stacks or recursion both work; recursion depth stays small for the given sizes."], "statement": "You are given the roots of two binary trees, `root1` and `root2`, each in level-order form.\n\nFor a tree, write down the values of its leaves (nodes with no children) in left-to-right order. This list is the leaf sequence.\n\nReturn `true` when the two trees share exactly the same leaf sequence, and `false` otherwise. Empty trees have an empty sequence.\n\n**Constraints:**\n- Each tree holds `1 <= n <= 200` nodes in these tests (empty `[]` also handled as edge).\n- `0 <= node.val <= 200`\n", "solution": "## Approach\n\nDo a left-first depth walk of each tree, recording a value whenever a node has no children. The two recorded lists are the leaf sequences; equality of the lists decides the answer.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + m), where n and m are the sizes of the two trees.\n- **Space Complexity:** O(n + m) for the leaf lists plus O(h) recursion depth.\n\n## Implementation\n\n```python\nclass Solution:\n    def leafSimilar(self, root1, root2) -> bool:\n        def leaves(n):\n            if not n:\n                return []\n            if not n.left and not n.right:\n                return [n.val]\n            return leaves(n.left) + leaves(n.right)\n        return leaves(root1) == leaves(root2)\n```\n", "starter": {"go": "// Definition for a binary tree node.\n// type TreeNode struct {\n//     Val int\n//     Left *TreeNode\n//     Right *TreeNode\n// }\npackage main\n\nfunc LeafSimilar(root1 *TreeNode, root2 *TreeNode) bool {\n    return false\n}", "python": "# Definition for a binary tree node.\n# class TreeNode:\n#     def __init__(self, val=0, left=None, right=None):\n#         self.val = val\n#         self.left = left\n#         self.right = right\nclass Solution:\n    def leafSimilar(self, root1, root2) -> bool:\n        pass", "cpp": "/**\n * Definition for a binary tree node.\n * struct TreeNode {\n *     int val;\n *     TreeNode *left;\n *     TreeNode *right;\n *     TreeNode() : val(0), left(nullptr), right(nullptr) {}\n *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}\n *     TreeNode(int x, TreeNode* left, TreeNode* right) : val(x), left(left), right(right) {}\n * };\n */\nclass Solution {\npublic:\n    bool leafSimilar(TreeNode* root1, TreeNode* root2) {\n        return false;\n    }\n};"}, "fn": "leafSimilar", "params": [{"name": "root1", "type": "tree_node"}, {"name": "root2", "type": "tree_node"}], "outputType": "boolean", "tests": [["[3,5,1,6,2,9,8,null,null,7,4]", "[3,5,1,6,7,4,2,null,null,null,null,null,null,9,8]"], ["[1,2,3]", "[1,3,2]"], ["[1]", "[1]"], ["[1]", "[2]"], ["[1,2]", "[1,null,2]"], ["[1,2,3,4]", "[1,4]"], ["[]", "[]"], ["[0]", "[]"], ["[1,2,3]", "[1,2,3]"], ["[1,null,2,3]", "[1,3]"], ["[5,1,2]", "[5,1,2]"], ["[5,1,2]", "[5,2,1]"], ["[1,2,null,3]", "[1,3]"], ["[10,5,15,3,7]", "[10,3,7]"], ["[0,1,2,3,4]", "[0,3,4]"], ["[1,2,3,4,5,6,7]", "[1,4,5,6,7]"], ["[2,1]", "[2,1]"], ["[2,1]", "[2,null,1]"], ["[3,9,20,null,null,15,7]", "[3,15,7]"], ["[1,2,3,4,null,null,5]", "[1,4,5]"], ["[0,1,null,2]", "[0,2]"], ["[7,3,9,1,5]", "[7,1,5,9]"], ["[100,50,150]", "[100,50,150]"], ["[100,50,150]", "[100,150,50]"], ["[1,2]", "[1,3]"], ["[8,3,10,1,6,null,14]", "[8,1,6,14]"], ["[0,1,2]", "[0,1,2]"], ["[1,null,2,null,3]", "[1,3]"]], "expected": [true, false, true, false, true, false, true, false, true, true, true, false, true, false, false, false, true, true, false, true, true, false, true, false, false, false, true, true], "loose": false}

package/data/problems/least-operators-to-express-number.json

@@ -0,0 +1 @@
+{"basic": false, "label": "950", "slug": "least-operators-to-express-number", "id": 950, "title": "Least Operators to Express Number", "difficulty": "Hard", "category": "dp", "link": "https://leetcode.com/problems/least-operators-to-express-number/", "examples": [{"input": "x = 3, target = 19", "output": "5", "explanation": "The flat chain 3*3+3*3+3/3 evaluates to 9+9+1 with 5 operators, and nothing shorter reaches 19."}, {"input": "x = 5, target = 501", "output": "8", "explanation": "The chain 5*5*5*5-5*5*5+5/5 evaluates to 625-125+1 with 8 operators, which is optimal."}, {"input": "x = 100, target = 100000000", "output": "3", "explanation": "The target equals 100^4, built with 3 multiplications and nothing else."}], "hints": ["Compare building up from the power below the target against overshooting the power above and subtracting.", "Powers of x cost (exponent - 1) multiplications; the value 1 costs one division (x/x).", "Memoize on the remaining value \u2014 only logarithmically many states appear."], "statement": "Write down the integer `x` several times in a row, placing one operator \u2014 `+`, `-`, `*` or `/` \u2014 between each pair of neighbours, forming one flat chain with no parentheses anywhere. The chain is scored by evaluating it with the usual precedence (multiplication and division before addition and subtraction); division produces exact rational values, and a leading minus sign is forbidden.\n\nUsing as few operators as possible, build a chain whose value equals `target`, and return that smallest operator count.\n\n**Constraints:**\n- `2 <= x <= 100`\n- `1 <= target <= 10^9`\n", "solution": "## Approach\n\nBecause the chain has no parentheses, every term glued by + or - is a product/quotient chain of x's, i.e. a power of x. Work recursively on the remaining value v: when v does not exceed x, build it from v copies of x/x (or subtract the shortfall from x). Otherwise locate the power x^k bracketing v, peel off one copy of x^(k-1) and recurse on the rest; when overshooting to x^k is close (x^k - v < v), also try reaching x^k and subtracting back. Memoization keeps the distinct states logarithmic.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(log target) states, each doing O(1) work.\n- **Space Complexity:** O(log target) for memoization and recursion depth.\n\n## Implementation\n\n```python\nfrom functools import lru_cache\n\nclass Solution:\n    def leastOpsExpressTarget(self, x: int, target: int) -> int:\n        @lru_cache(maxsize=None)\n        def dfs(v):\n            if x >= v:\n                return min(v * 2 - 1, 2 * (x - v))\n            k = 2\n            y = x * x\n            while y < v:\n                y *= x\n                k += 1\n            ans = (k - 1) + dfs(v - y // x)\n            if y - v < v:\n                ans = min(ans, k + dfs(y - v))\n            return ans\n\n        return dfs(target)\n```\n", "starter": {"go": "package main\n\nfunc LeastOpsExpressTarget(x int, target int) int {\n    return 0\n}", "python": "class Solution:\n    def leastOpsExpressTarget(self, x: int, target: int) -> int:\n        return 0", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    int leastOpsExpressTarget(int x, int target) {\n        return 0;\n    }\n};"}, "fn": "leastOpsExpressTarget", "params": [{"name": "x", "type": "int"}, {"name": "target", "type": "int"}], "outputType": "int", "tests": [["3", "19"], ["5", "501"], ["100", "100000000"], ["2", "1"], ["2", "2"], ["2", "3"], ["2", "7"], ["3", "1"], ["3", "2"], ["3", "3"], ["3", "4"], ["3", "9"], ["3", "10"], ["5", "1"], ["5", "4"], ["5", "5"], ["5", "6"], ["5", "24"], ["5", "25"], ["5", "26"], ["2", "100"], ["2", "1000"], ["10", "1"], ["10", "9"], ["10", "11"], ["10", "99"], ["7", "1000000000"], ["2", "1000000000"]], "expected": [5, 8, 3, 1, 0, 2, 4, 1, 2, 0, 2, 1, 3, 1, 2, 0, 2, 3, 1, 3, 12, 16, 1, 2, 2, 3, 127, 166], "loose": false}

package/data/problems/lemonade-change.json

@@ -0,0 +1 @@
+{"basic": false, "label": "236", "slug": "lemonade-change", "id": 236, "title": "Lemonade Change", "difficulty": "Easy", "category": "greedy", "link": "https://leetcode.com/problems/lemonade-change/", "examples": [{"input": "bills = [5,5,5,10,20]", "output": "true", "explanation": "From the first 3 customers, we collect three $5 bills. From the fourth, we collect a $10 and give back a $5. From the fifth, we give a $10 and a $5."}, {"input": "bills = [5,5,10,10,20]", "output": "false", "explanation": "From the first two customers we collect two $5. From the third and fourth we collect two $10 and give back two $5. For the fifth we cannot give $15 change."}], "hints": ["Track counts of $5 and $10 bills. Prefer giving a $10+$5 when possible for a $20."], "statement": "A drink stand sells each lemonade for $5. Patrons arrive one after another, each handing over a $5, $10, or $20 bill, and each must end up having paid exactly $5. The register begins empty, holding no bills for making change.\n\nYou receive the integer array `bills`, where `bills[i]` is what the `i`-th patron in line hands over. Decide whether change can be handed back correctly to the whole line: return `true` when every patron can be served, or `false` otherwise.\n\n**Constraints:**\n- `1 <= bills.length <= 10^5`\n- `bills[i]` is either `5`, `10`, or `20`\n", "solution": "## Approach\n\nGreedily track counts of $5 and $10 bills. For a $10 give one $5. For a $20 prefer one $10 + one $5, else three $5s.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n)\n- **Space Complexity:** O(1)\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n    def lemonadeChange(self, bills: List[int]) -> bool:\n        five = ten = 0\n        for b in bills:\n            if b == 5:\n                five += 1\n            elif b == 10:\n                if five == 0:\n                    return False\n                five -= 1\n                ten += 1\n            else:\n                if ten and five:\n                    ten -= 1\n                    five -= 1\n                elif five >= 3:\n                    five -= 3\n                else:\n                    return False\n        return True\n```\n", "starter": {"go": "package main\n\nfunc LemonadeChange(bills []int) bool {\n    \n}", "python": "from typing import List\nclass Solution:\n    def lemonadeChange(self, bills: List[int]) -> bool:\n        ", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    bool lemonadeChange(vector<int>& bills) {\n        \n    }\n};"}, "fn": "lemonadeChange", "params": [{"name": "bills", "type": "int_array"}], "outputType": "boolean", "tests": [["[5,5,5,10,20]"], ["[5,5,10,10,20]"], ["[5]"], ["[10]"], ["[20]"], ["[5,5,5,5,20,20,10]"], ["[5,5,10]"], ["[5,10,5,10,5,20]"], ["[5,5,5,10,5,5,10,20,20,20]"], ["[5,5,5,5,5,5,5,5,5,5,20,20,20,20]"], ["[5,5]"], ["[5,10]"], ["[10,10]"], ["[5,20]"], ["[5,5,5]"], ["[5,10,10]"], ["[5,5,20]"], ["[10,5,5]"], ["[5,5,5,5]"], ["[5,5,5,10]"], ["[5,5,10,20]"], ["[5,10,20]"], ["[5,5,5,5,10,10]"], ["[5,5,10,10]"], ["[5,5,5,20]"], ["[20,20,20]"], ["[5,10,5,20]"], ["[5,5,5,10,10,10]"], ["[10,20]"], ["[5,5,5,5,5,10,20]"], ["[5,20,5]"]], "expected": [true, false, true, false, false, false, true, true, false, false, true, true, false, false, true, false, false, false, true, true, true, false, true, true, true, false, true, true, false, true, false], "loose": false}

package/data/problems/length-of-last-word.json

@@ -0,0 +1 @@
+{"basic": false, "label": "266", "slug": "length-of-last-word", "id": 266, "title": "Length of Last Word", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/length-of-last-word/", "examples": [{"input": "s = \"Hello World\"", "output": "5", "explanation": "The last word is \"World\", which has 5 letters."}, {"input": "s = \"   fly me   to   the moon  \"", "output": "4", "explanation": "The last word is \"moon\" with length 4; surrounding spaces are ignored."}, {"input": "s = \"luffy is still joyboy\"", "output": "6", "explanation": "The last word is \"joyboy\", which has 6 letters."}], "hints": ["Walk in from the end: first skip trailing spaces, then count characters until the next space or the start.", "No split or extra string is needed; two indices (or one moving index plus a counter) suffice."], "statement": "You are given a string `s` built from words separated by spaces. A *word* is a maximal run of non-space characters.\n\nReturn how many characters the final word contains. The input always holds at least one word, though it may be padded with extra spaces on either side or between words.\n\n**Constraints:**\n- `1 <= s.length <= 10^4`\n- `s` consists only of English letters and spaces `' '`.\n- `s` contains at least one word.\n", "solution": "## Approach\n\nStart at the end of the string and step left past any trailing blanks to reach the final word's last letter. Then keep stepping left while the characters are non-blanks, counting them. The count is exactly the last word's length.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) in the worst case, where n is the string length.\n- **Space Complexity:** O(1) extra space.\n\n## Implementation\n\n```python\nclass Solution:\n    def lengthOfLastWord(self, s: str) -> int:\n        i = len(s) - 1\n        while i >= 0 and s[i] == ' ':\n            i -= 1\n        length = 0\n        while i >= 0 and s[i] != ' ':\n            length += 1\n            i -= 1\n        return length\n```\n", "starter": {"go": "package main\n\nfunc LengthOfLastWord(s string) int {\n    \n}", "python": "class Solution:\n    def lengthOfLastWord(self, s: str) -> int:\n        pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n    int lengthOfLastWord(string s) {\n        return 0;\n    }\n};"}, "fn": "lengthOfLastWord", "params": [{"name": "s", "type": "string"}], "outputType": "int", "tests": [["Hello World"], ["   fly me   to   the moon  "], ["luffy is still joyboy"], ["a"], [" a"], ["a "], ["   a   "], ["Hello"], ["Hello "], [" World"], ["day"], ["word word"], ["a b c d e"], ["TrailingSpace "], ["  leading"], ["multiple   spaces   between"], ["x"], ["abc def"], ["Z"], ["  Z  "], ["one two three four five"], ["ends with s "], ["s"], [" a b "], ["supercalifragilisticexpialidocious"], ["a  b"], ["  day  "]], "expected": [5, 4, 6, 1, 1, 1, 1, 5, 5, 5, 3, 4, 1, 13, 7, 7, 1, 3, 1, 1, 4, 1, 1, 1, 34, 1, 3], "loose": false}

package/data/problems/length-of-longest-fibonacci-subsequence.json

@@ -0,0 +1 @@
+{"basic": false, "label": "867", "slug": "length-of-longest-fibonacci-subsequence", "id": 867, "title": "Length of Longest Fibonacci Subsequence", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/length-of-longest-fibonacci-subsequence/", "examples": [{"input": "arr = [1,2,3,4,5,6,7,8]", "output": "5", "explanation": "One longest pick is [1,2,3,5,8] since 1 + 2 = 3, 2 + 3 = 5 and 3 + 5 = 8."}, {"input": "arr = [1,3,7,11,12,14,18]", "output": "3", "explanation": "The triples [1,11,12], [3,11,14] and [7,11,18] each follow the rule, and nothing longer does."}, {"input": "arr = [1,2,4]", "output": "0", "explanation": "The only triple is [1,2,4] and 1 + 2 is not 4."}], "hints": ["Fix the last two positions of a candidate run; the value needed just before them is their difference, which you can look up with a value-to-index map.", "Let dp[i][j] be the best run length ending with arr[i], arr[j]. If arr[j] - arr[i] appears earlier at index k, extend dp[k][i]; otherwise start a fresh pair of length 2."], "statement": "You are given a strictly increasing array of positive integers `arr`. A subsequence of `arr` is called Fibonacci-like when it contains at least three numbers and every element from the third onward equals the sum of the two elements right before it.\n\nReturn the length of the longest Fibonacci-like subsequence. When no such subsequence exists, return `0`.\n\n**Constraints:**\n- `3 <= arr.length <= 1000`\n- `1 <= arr[i] <= 10^9`\n- All values of `arr` are distinct and sorted in increasing order.\n", "solution": "## Approach\n\nBuild a map from each array value to its index. Then treat every pair of positions `(i, j)` as the tail of a candidate run: the element that must come right before them is `arr[j] - arr[i]`. When that value exists earlier in the array at index `k`, the run extends the best run ending at `(k, i)` by one; otherwise the pair starts a fresh run of length 2. The answer is the largest table entry, or 0 when nothing reaches length 3.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^2), where n is the length of `arr`. Each pair is processed once with O(1) map lookups.\n- **Space Complexity:** O(n^2) for the pair-length table plus O(n) for the index map.\n\n## Implementation\n\n```python\nfrom typing import List\n\nclass Solution:\n    def lenLongestFibSubseq(self, arr: List[int]) -> int:\n        idx = {v: i for i, v in enumerate(arr)}\n        n = len(arr)\n        dp = [[0] * n for _ in range(n)]\n        best = 0\n        for j in range(n):\n            for i in range(j):\n                k = idx.get(arr[j] - arr[i])\n                if k is not None and k < i:\n                    dp[i][j] = dp[k][i] + 1\n                else:\n                    dp[i][j] = 2\n                best = max(best, dp[i][j])\n        return best if best >= 3 else 0\n```\n", "starter": {"go": "package main\n\nfunc LenLongestFibSubseq(arr []int) int {\n    \n}", "python": "from typing import List\nclass Solution:\n    def lenLongestFibSubseq(self, arr: List[int]) -> int:\n        pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n    int lenLongestFibSubseq(vector<int>& arr) {\n        return 0;\n    }\n};"}, "fn": "lenLongestFibSubseq", "params": [{"name": "arr", "type": "int_array"}], "outputType": "int", "tests": [["[1,2,3,4,5,6,7,8]"], ["[1,3,7,11,12,14,18]"], ["[1,2,4]"], ["[1,2,3]"], ["[1,2,4,8,16,32]"], ["[1,2,3,5,8,13,21]"], ["[1,2,3,5,8,13,21,34]"], ["[3,5,8,13,21]"], ["[10,11,21,32,53,85]"], ["[1,4,5,9,14,23,37]"], ["[5,9,14,23,37,60]"], ["[7,11,18,29,47,76]"], ["[2,3,5,9,14,23]"], ["[4,6,10,16,26,42]"], ["[1,5,6,11,17,28,45]"], ["[2,5,7,12,19,31,50]"], ["[1,3,4,7,11,18,29]"], ["[6,10,16,26,42,68,110]"], ["[1,2,3,4,5]"], ["[1,4,6,7,10,13,16]"], ["[8,9,17,26,43,69]"], ["[3,4,7,11,18,29,47]"], ["[100,200,300,500,800,1300]"], ["[1,2,5,6,11,17]"], ["[2,6,8,14,22,36,58]"], ["[9,10,19,29,48,77,125]"], ["[1,7,8,15,23,38,61,99]"], ["[300000000,500000000,800000000]"]], "expected": [5, 3, 0, 3, 0, 7, 8, 5, 6, 7, 6, 6, 4, 6, 7, 7, 7, 7, 4, 4, 6, 7, 6, 5, 7, 7, 8, 3], "loose": false}

package/data/problems/letter-case-permutation.json

@@ -0,0 +1 @@
+{"basic": false, "label": "783", "slug": "letter-case-permutation", "id": 783, "title": "Letter Case Permutation", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/letter-case-permutation/", "examples": [{"input": "s = \"a1b2\"", "output": "[\"a1b2\",\"a1B2\",\"A1b2\",\"A1B2\"]", "explanation": "Two letters give four case combinations."}, {"input": "s = \"3z4\"", "output": "[\"3z4\",\"3Z4\"]", "explanation": "Only the middle letter varies."}, {"input": "s = \"123\"", "output": "[\"123\"]", "explanation": "No letters means a single result."}], "hints": ["Walk the string depth-first: digits are forced, letters branch into two cases.", "Build a mutable character buffer and backtrack after each branch.", "The total output size doubles with every additional letter."], "statement": "You receive a short string that mixes English letters with digits. For every\nletter you may independently decide to write it in lower case or in upper\ncase, while digits must stay exactly as they are. Collect every distinct\nstring that can be produced this way. The order of the collected strings\ndoes not matter.\n\nIf the input holds `m` letters, the result holds `2^m` entries.\n\n**Constraints:**\n- `1 <= s.length <= 12`\n- `s` holds only English letters (either case) and digits.\n", "solution": "## Approach\n\nTraverse the characters from left to right, keeping a mutable buffer. Digits\nhave a single continuation, while each letter forks into a lower-case branch\nand an upper-case branch. When the end of the string is reached, the buffer\nholds one complete variant. Collecting all leaves yields every case mix.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * 2^m), where m is the letter count: that many strings of that length are produced.\n- **Space Complexity:** O(m * 2^m) for the output, plus O(m) recursion depth.\n\n## Implementation\n\n```python\nfrom typing import List\n\n\nclass Solution:\n    def letterCasePermutation(self, s: str) -> List[str]:\n        result: List[str] = []\n        chars = list(s)\n\n        def backtrack(i: int) -> None:\n            if i == len(chars):\n                result.append(\"\".join(chars))\n                return\n            if chars[i].isalpha():\n                chars[i] = chars[i].lower()\n                backtrack(i + 1)\n                chars[i] = chars[i].upper()\n                backtrack(i + 1)\n            else:\n                backtrack(i + 1)\n\n        backtrack(0)\n        return result\n```\n", "starter": {"go": "package main\n\nfunc LetterCasePermutation(s string) []string {\n    return []string{}\n}", "python": "from typing import List\n\nclass Solution:\n    def letterCasePermutation(self, s: str) -> List[str]:\n        return []\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<string> letterCasePermutation(string s) {\n        return {};\n    }\n};"}, "fn": "letterCasePermutation", "params": [{"name": "s", "type": "string"}], "outputType": "string_list", "tests": [["a1b2"], ["3z4"], ["123"], ["a"], ["A"], ["1"], ["ab"], ["AB"], ["aB"], ["abc"], ["a1b"], ["12345"], ["mQ"], ["0a0"], ["Z9z9"], ["abcd"], ["ABCDE"], ["a1A1a1"], ["xYz"], ["9"], ["pQrS12"], ["00000"], ["aaaa"], ["BBBB"], ["c7d8e9"], ["HeLLo"], ["12ab34"], ["q2w3e4r5"]], "expected": [["a1b2", "a1B2", "A1b2", "A1B2"], ["3z4", "3Z4"], ["123"], ["a", "A"], ["a", "A"], ["1"], ["ab", "aB", "Ab", "AB"], ["ab", "aB", "Ab", "AB"], ["ab", "aB", "Ab", "AB"], ["abc", "abC", "aBc", "aBC", "Abc", "AbC", "ABc", "ABC"], ["a1b", "a1B", "A1b", "A1B"], ["12345"], ["mq", "mQ", "Mq", "MQ"], ["0a0", "0A0"], ["z9z9", "z9Z9", "Z9z9", "Z9Z9"], ["abcd", "abcD", "abCd", "abCD", "aBcd", "aBcD", "aBCd", "aBCD", "Abcd", "AbcD", "AbCd", "AbCD", "ABcd", "ABcD", "ABCd", "ABCD"], ["abcde", "abcdE", "abcDe", "abcDE", "abCde", "abCdE", "abCDe", "abCDE", "aBcde", "aBcdE", "aBcDe", "aBcDE", "aBCde", "aBCdE", "aBCDe", "aBCDE", "Abcde", "AbcdE", "AbcDe", "AbcDE", "AbCde", "AbCdE", "AbCDe", "AbCDE", "ABcde", "ABcdE", "ABcDe", "ABcDE", "ABCde", "ABCdE", "ABCDe", "ABCDE"], ["a1a1a1", "a1a1A1", "a1A1a1", "a1A1A1", "A1a1a1", "A1a1A1", "A1A1a1", "A1A1A1"], ["xyz", "xyZ", "xYz", "xYZ", "Xyz", "XyZ", "XYz", "XYZ"], ["9"], ["pqrs12", "pqrS12", "pqRs12", "pqRS12", "pQrs12", "pQrS12", "pQRs12", "pQRS12", "Pqrs12", "PqrS12", "PqRs12", "PqRS12", "PQrs12", "PQrS12", "PQRs12", "PQRS12"], ["00000"], ["aaaa", "aaaA", "aaAa", "aaAA", "aAaa", "aAaA", "aAAa", "aAAA", "Aaaa", "AaaA", "AaAa", "AaAA", "AAaa", "AAaA", "AAAa", "AAAA"], ["bbbb", "bbbB", "bbBb", "bbBB", "bBbb", "bBbB", "bBBb", "bBBB", "Bbbb", "BbbB", "BbBb", "BbBB", "BBbb", "BBbB", "BBBb", "BBBB"], ["c7d8e9", "c7d8E9", "c7D8e9", "c7D8E9", "C7d8e9", "C7d8E9", "C7D8e9", "C7D8E9"], ["hello", "hellO", "helLo", "helLO", "heLlo", "heLlO", "heLLo", "heLLO", "hEllo", "hEllO", "hElLo", "hElLO", "hELlo", "hELlO", "hELLo", "hELLO", "Hello", "HellO", "HelLo", "HelLO", "HeLlo", "HeLlO", "HeLLo", "HeLLO", "HEllo", "HEllO", "HElLo", "HElLO", "HELlo", "HELlO", "HELLo", "HELLO"], ["12ab34", "12aB34", "12Ab34", "12AB34"], ["q2w3e4r5", "q2w3e4R5", "q2w3E4r5", "q2w3E4R5", "q2W3e4r5", "q2W3e4R5", "q2W3E4r5", "q2W3E4R5", "Q2w3e4r5", "Q2w3e4R5", "Q2w3E4r5", "Q2w3E4R5", "Q2W3e4r5", "Q2W3e4R5", "Q2W3E4r5", "Q2W3E4R5"]], "loose": true}

package/data/problems/letter-combinations-of-a-phone-number.json

@@ -0,0 +1 @@
+{"basic": false, "label": "113", "slug": "letter-combinations-of-a-phone-number", "id": 113, "title": "Letter Combinations of a Phone Number", "difficulty": "Medium", "category": "backtracking", "link": "https://leetcode.com/problems/letter-combinations-of-a-phone-number/", "examples": [{"input": "digits = \"23\"", "output": "[\"ad\",\"ae\",\"af\",\"bd\",\"be\",\"bf\",\"cd\",\"ce\",\"cf\"]", "explanation": "Digits '2' and '3' map to ['abc', 'def'] respectively. There are 9 total letter combinations: [\"ad\",\"ae\",\"af\",\"bd\",\"be\",\"bf\",\"cd\",\"ce\",\"cf\"]."}, {"input": "digits = \"7\"", "output": "[\"p\",\"q\",\"r\",\"s\"]", "explanation": "Each digit \"7\" maps to ['pqrs']. There are 4 total letter combinations: [\"p\",\"q\",\"r\",\"s\"]."}, {"input": "digits = \"2\"", "output": "[\"a\",\"b\",\"c\"]", "explanation": "Each digit \"2\" maps to ['abc']. There are 3 total letter combinations: [\"a\",\"b\",\"c\"]."}], "hints": ["Associate each digit with its keypad letters.", "Backtrack through the digits, appending one mapped letter at each position."], "statement": "Given a string `digits`, return all letter combinations that the digits could represent on a telephone keypad.\n\nThe digit-to-letter mapping is:\n\n- `2`: `abc`\n- `3`: `def`\n- `4`: `ghi`\n- `5`: `jkl`\n- `6`: `mno`\n- `7`: `pqrs`\n- `8`: `tuv`\n- `9`: `wxyz`\n\nThe combinations may be returned in any order.\n\n**Constraints:**\n- `1 <= digits.length <= 4`\n- Every character in `digits` is between `2` and `9`.\n", "solution": "## Approach\n\nMap every digit to its keypad letters and backtrack through the digit positions. At each position, append one mapped letter and recurse to the next digit. A path that reaches the end is one complete combination.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(L * C), where `L` is the number of digits and `C` is the number of generated combinations.\n- **Space Complexity:** O(L) auxiliary recursion and path space, excluding the O(L * C) output.\n\n## Implementation\n\n```python\nfrom typing import List\n\n\nclass Solution:\n    def letterCombinations(self, digits: str) -> List[str]:\n        if not digits:\n            return []\n        letters = {\n            \"2\": \"abc\",\n            \"3\": \"def\",\n            \"4\": \"ghi\",\n            \"5\": \"jkl\",\n            \"6\": \"mno\",\n            \"7\": \"pqrs\",\n            \"8\": \"tuv\",\n            \"9\": \"wxyz\",\n        }\n        result: List[str] = []\n        current: List[str] = []\n\n        def backtrack(index: int) -> None:\n            if index == len(digits):\n                result.append(\"\".join(current))\n                return\n            for char in letters[digits[index]]:\n                current.append(char)\n                backtrack(index + 1)\n                current.pop()\n\n        backtrack(0)\n        return result\n```\n", "starter": {"go": "package main\n\nfunc LetterCombinations(digits string) []string {\n    return []string{}\n}\n", "python": "from typing import List\n\nclass Solution:\n    def letterCombinations(self, digits: str) -> List[str]:\n        return []\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n    vector<string> letterCombinations(string digits) {\n        return {};\n    }\n};"}, "fn": "letterCombinations", "params": [{"name": "digits", "type": "string"}], "outputType": "string_list", "tests": [["2999"], ["2"], ["3"], ["4"], ["5"], ["6"], ["7"], ["8"], ["9"], ["22"], ["23"], ["24"], ["25"], ["26"], ["27"], ["28"], ["29"], ["32"], ["33"], ["34"], ["35"], ["36"], ["37"], ["38"], ["39"], ["42"], ["43"], ["44"], ["45"], ["46"], ["47"], ["48"], ["49"], ["79"], ["97"], ["234"], ["279"], ["329"], ["456"], ["567"], ["789"], ["222"], ["999"], ["2345"], ["2679"], ["7329"], ["8426"], ["9999"], ["2222"], ["7777"], ["9274"], ["5683"], ["@javascript:'7979'"]], "expected": [["awww", "awwx", "awwy", "awwz", "awxw", "awxx", "awxy", "awxz", "awyw", "awyx", "awyy", "awyz", "awzw", "awzx", "awzy", "awzz", "axww", "axwx", "axwy", "axwz", "axxw", "axxx", "axxy", "axxz", "axyw", "axyx", "axyy", "axyz", "axzw", "axzx", "axzy", "axzz", "ayww", "aywx", "aywy", "aywz", "ayxw", "ayxx", "ayxy", "ayxz", "ayyw", "ayyx", "ayyy", "ayyz", "ayzw", "ayzx", "ayzy", "ayzz", "azww", "azwx", "azwy", "azwz", "azxw", "azxx", "azxy", "azxz", "azyw", "azyx", "azyy", "azyz", "azzw", "azzx", "azzy", "azzz", "bwww", "bwwx", "bwwy", "bwwz", "bwxw", "bwxx", "bwxy", "bwxz", "bwyw", "bwyx", "bwyy", "bwyz", "bwzw", "bwzx", "bwzy", "bwzz", "bxww", "bxwx", "bxwy", "bxwz", "bxxw", "bxxx", "bxxy", "bxxz", "bxyw", "bxyx", "bxyy", "bxyz", "bxzw", "bxzx", "bxzy", "bxzz", "byww", "bywx", "bywy", "bywz", "byxw", "byxx", "byxy", "byxz", "byyw", "byyx", "byyy", "byyz", "byzw", "byzx", "byzy", "byzz", "bzww", "bzwx", "bzwy", "bzwz", "bzxw", "bzxx", "bzxy", "bzxz", "bzyw", "bzyx", "bzyy", "bzyz", "bzzw", "bzzx", "bzzy", "bzzz", "cwww", "cwwx", "cwwy", "cwwz", "cwxw", "cwxx", "cwxy", "cwxz", "cwyw", "cwyx", "cwyy", "cwyz", "cwzw", "cwzx", "cwzy", "cwzz", "cxww", "cxwx", "cxwy", "cxwz", "cxxw", "cxxx", "cxxy", "cxxz", "cxyw", "cxyx", "cxyy", "cxyz", "cxzw", "cxzx", "cxzy", "cxzz", "cyww", "cywx", "cywy", "cywz", "cyxw", "cyxx", "cyxy", "cyxz", "cyyw", "cyyx", "cyyy", "cyyz", "cyzw", "cyzx", "cyzy", "cyzz", "czww", "czwx", "czwy", "czwz", "czxw", "czxx", "czxy", "czxz", "czyw", "czyx", "czyy", "czyz", "czzw", "czzx", "czzy", "czzz"], ["a", "b", "c"], ["d", "e", "f"], ["g", "h", "i"], ["j", "k", "l"], ["m", "n", "o"], ["p", "q", "r", "s"], ["t", "u", "v"], ["w", "x", "y", "z"], ["aa", "ab", "ac", "ba", "bb", "bc", "ca", "cb", "cc"], ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"], ["ag", "ah", "ai", "bg", "bh", "bi", "cg", "ch", "ci"], ["aj", "ak", "al", "bj", "bk", "bl", "cj", "ck", "cl"], ["am", "an", "ao", "bm", "bn", "bo", "cm", "cn", "co"], ["ap", "aq", "ar", "as", "bp", "bq", "br", "bs", "cp", "cq", "cr", "cs"], ["at", "au", "av", "bt", "bu", "bv", "ct", "cu", "cv"], ["aw", "ax", "ay", "az", "bw", "bx", "by", "bz", "cw", "cx", "cy", "cz"], ["da", "db", "dc", "ea", "eb", "ec", "fa", "fb", "fc"], ["dd", "de", "df", "ed", "ee", "ef", "fd", "fe", "ff"], ["dg", "dh", "di", "eg", "eh", "ei", "fg", "fh", "fi"], ["dj", "dk", "dl", "ej", "ek", "el", "fj", "fk", "fl"], ["dm", "dn", "do", "em", "en", "eo", "fm", "fn", "fo"], ["dp", "dq", "dr", "ds", "ep", "eq", "er", "es", "fp", "fq", "fr", "fs"], ["dt", "du", "dv", "et", "eu", "ev", "ft", "fu", "fv"], ["dw", "dx", "dy", "dz", "ew", "ex", "ey", "ez", "fw", "fx", "fy", "fz"], ["ga", "gb", "gc", "ha", "hb", "hc", "ia", "ib", "ic"], ["gd", "ge", "gf", "hd", "he", "hf", "id", "ie", "if"], ["gg", "gh", "gi", "hg", "hh", "hi", "ig", "ih", "ii"], ["gj", "gk", "gl", "hj", "hk", "hl", "ij", "ik", "il"], ["gm", "gn", "go", "hm", "hn", "ho", "im", "in", "io"], ["gp", "gq", "gr", "gs", "hp", "hq", "hr", "hs", "ip", "iq", "ir", "is"], ["gt", "gu", "gv", "ht", "hu", "hv", "it", "iu", "iv"], ["gw", "gx", "gy", "gz", "hw", "hx", "hy", "hz", "iw", "ix", "iy", "iz"], ["pw", "px", "py", "pz", "qw", "qx", "qy", "qz", "rw", "rx", "ry", "rz", "sw", "sx", "sy", "sz"], ["wp", "wq", "wr", "ws", "xp", "xq", "xr", "xs", "yp", "yq", "yr", "ys", "zp", "zq", "zr", "zs"], ["adg", "adh", "adi", "aeg", "aeh", "aei", "afg", "afh", "afi", "bdg", "bdh", "bdi", "beg", "beh", "bei", "bfg", "bfh", "bfi", "cdg", "cdh", "cdi", "ceg", "ceh", "cei", "cfg", "cfh", "cfi"], ["apw", "apx", "apy", "apz", "aqw", "aqx", "aqy", "aqz", "arw", "arx", "ary", "arz", "asw", "asx", "asy", "asz", "bpw", "bpx", "bpy", "bpz", "bqw", "bqx", "bqy", "bqz", "brw", "brx", "bry", "brz", "bsw", "bsx", "bsy", "bsz", "cpw", "cpx", "cpy", "cpz", "cqw", "cqx", "cqy", "cqz", "crw", "crx", "cry", "crz", "csw", "csx", "csy", "csz"], ["daw", "dax", "day", "daz", "dbw", "dbx", "dby", "dbz", "dcw", "dcx", "dcy", "dcz", "eaw", "eax", "eay", "eaz", "ebw", "ebx", "eby", "ebz", "ecw", "ecx", "ecy", "ecz", "faw", "fax", "fay", "faz", "fbw", "fbx", "fby", "fbz", "fcw", "fcx", "fcy", "fcz"], ["gjm", "gjn", "gjo", "gkm", "gkn", "gko", "glm", "gln", "glo", "hjm", "hjn", "hjo", "hkm", "hkn", "hko", "hlm", "hln", "hlo", "ijm", "ijn", "ijo", "ikm", "ikn", "iko", "ilm", "iln", "ilo"], ["jmp", "jmq", "jmr", "jms", "jnp", "jnq", "jnr", "jns", "jop", "joq", "jor", "jos", "kmp", "kmq", "kmr", "kms", "knp", "knq", "knr", "kns", "kop", "koq", "kor", "kos", "lmp", "lmq", "lmr", "lms", "lnp", "lnq", "lnr", "lns", "lop", "loq", "lor", "los"], ["ptw", "ptx", "pty", "ptz", "puw", "pux", "puy", "puz", "pvw", "pvx", "pvy", "pvz", "qtw", "qtx", "qty", "qtz", "quw", "qux", "quy", "quz", "qvw", "qvx", "qvy", "qvz", "rtw", "rtx", "rty", "rtz", "ruw", "rux", "ruy", "ruz", "rvw", "rvx", "rvy", "rvz", "stw", "stx", "sty", "stz", "suw", "sux", "suy", "suz", "svw", "svx", "svy", "svz"], ["aaa", "aab", "aac", "aba", "abb", "abc", "aca", "acb", "acc", "baa", "bab", "bac", "bba", "bbb", "bbc", "bca", "bcb", "bcc", "caa", "cab", "cac", "cba", "cbb", "cbc", "cca", "ccb", "ccc"], ["www", "wwx", "wwy", "wwz", "wxw", "wxx", "wxy", "wxz", "wyw", "wyx", "wyy", "wyz", "wzw", "wzx", "wzy", "wzz", "xww", "xwx", "xwy", "xwz", "xxw", "xxx", "xxy", "xxz", "xyw", "xyx", "xyy", "xyz", "xzw", "xzx", "xzy", "xzz", "yww", "ywx", "ywy", "ywz", "yxw", "yxx", "yxy", "yxz", "yyw", "yyx", "yyy", "yyz", "yzw", "yzx", "yzy", "yzz", "zww", "zwx", "zwy", "zwz", "zxw", "zxx", "zxy", "zxz", "zyw", "zyx", "zyy", "zyz", "zzw", "zzx", "zzy", "zzz"], ["adgj", "adgk", "adgl", "adhj", "adhk", "adhl", "adij", "adik", "adil", "aegj", "aegk", "aegl", "aehj", "aehk", "aehl", "aeij", "aeik", "aeil", "afgj", "afgk", "afgl", "afhj", "afhk", "afhl", "afij", "afik", "afil", "bdgj", "bdgk", "bdgl", "bdhj", "bdhk", "bdhl", "bdij", "bdik", "bdil", "begj", "begk", "begl", "behj", "behk", "behl", "beij", "beik", "beil", "bfgj", "bfgk", "bfgl", "bfhj", "bfhk", "bfhl", "bfij", "bfik", "bfil", "cdgj", "cdgk", "cdgl", "cdhj", "cdhk", "cdhl", "cdij", "cdik", "cdil", "cegj", "cegk", "cegl", "cehj", "cehk", "cehl", "ceij", "ceik", "ceil", "cfgj", "cfgk", "cfgl", "cfhj", "cfhk", "cfhl", "cfij", "cfik", "cfil"], ["ampw", "ampx", "ampy", "ampz", "amqw", "amqx", "amqy", "amqz", "amrw", "amrx", "amry", "amrz", "amsw", "amsx", "amsy", "amsz", "anpw", "anpx", "anpy", "anpz", "anqw", "anqx", "anqy", "anqz", "anrw", "anrx", "anry", "anrz", "answ", "ansx", "ansy", "ansz", "aopw", "aopx", "aopy", "aopz", "aoqw", "aoqx", "aoqy", "aoqz", "aorw", "aorx", "aory", "aorz", "aosw", "aosx", "aosy", "aosz", "bmpw", "bmpx", "bmpy", "bmpz", "bmqw", "bmqx", "bmqy", "bmqz", "bmrw", "bmrx", "bmry", "bmrz", "bmsw", "bmsx", "bmsy", "bmsz", "bnpw", "bnpx", "bnpy", "bnpz", "bnqw", "bnqx", "bnqy", "bnqz", "bnrw", "bnrx", "bnry", "bnrz", "bnsw", "bnsx", "bnsy", "bnsz", "bopw", "bopx", "bopy", "bopz", "boqw", "boqx", "boqy", "boqz", "borw", "borx", "bory", "borz", "bosw", "bosx", "bosy", "bosz", "cmpw", "cmpx", "cmpy", "cmpz", "cmqw", "cmqx", "cmqy", "cmqz", "cmrw", "cmrx", "cmry", "cmrz", "cmsw", "cmsx", "cmsy", "cmsz", "cnpw", "cnpx", "cnpy", "cnpz", "cnqw", "cnqx", "cnqy", "cnqz", "cnrw", "cnrx", "cnry", "cnrz", "cnsw", "cnsx", "cnsy", "cnsz", "copw", "copx", "copy", "copz", "coqw", "coqx", "coqy", "coqz", "corw", "corx", "cory", "corz", "cosw", "cosx", "cosy", "cosz"], ["pdaw", "pdax", "pday", "pdaz", "pdbw", "pdbx", "pdby", "pdbz", "pdcw", "pdcx", "pdcy", "pdcz", "peaw", "peax", "peay", "peaz", "pebw", "pebx", "peby", "pebz", "pecw", "pecx", "pecy", "pecz", "pfaw", "pfax", "pfay", "pfaz", "pfbw", "pfbx", "pfby", "pfbz", "pfcw", "pfcx", "pfcy", "pfcz", "qdaw", "qdax", "qday", "qdaz", "qdbw", "qdbx", "qdby", "qdbz", "qdcw", "qdcx", "qdcy", "qdcz", "qeaw", "qeax", "qeay", "qeaz", "qebw", "qebx", "qeby", "qebz", "qecw", "qecx", "qecy", "qecz", "qfaw", "qfax", "qfay", "qfaz", "qfbw", "qfbx", "qfby", "qfbz", "qfcw", "qfcx", "qfcy", "qfcz", "rdaw", "rdax", "rday", "rdaz", "rdbw", "rdbx", "rdby", "rdbz", "rdcw", "rdcx", "rdcy", "rdcz", "reaw", "reax", "reay", "reaz", "rebw", "rebx", "reby", "rebz", "recw", "recx", "recy", "recz", "rfaw", "rfax", "rfay", "rfaz", "rfbw", "rfbx", "rfby", "rfbz", "rfcw", "rfcx", "rfcy", "rfcz", "sdaw", "sdax", "sday", "sdaz", "sdbw", "sdbx", "sdby", "sdbz", "sdcw", "sdcx", "sdcy", "sdcz", "seaw", "seax", "seay", "seaz", "sebw", "sebx", "seby", "sebz", "secw", "secx", "secy", "secz", "sfaw", "sfax", "sfay", "sfaz", "sfbw", "sfbx", "sfby", "sfbz", "sfcw", "sfcx", "sfcy", "sfcz"], ["tgam", "tgan", "tgao", "tgbm", "tgbn", "tgbo", "tgcm", "tgcn", "tgco", "tham", "than", "thao", "thbm", "thbn", "thbo", "thcm", "thcn", "thco", "tiam", "tian", "tiao", "tibm", "tibn", "tibo", "ticm", "ticn", "tico", "ugam", "ugan", "ugao", "ugbm", "ugbn", "ugbo", "ugcm", "ugcn", "ugco", "uham", "uhan", "uhao", "uhbm", "uhbn", "uhbo", "uhcm", "uhcn", "uhco", "uiam", "uian", "uiao", "uibm", "uibn", "uibo", "uicm", "uicn", "uico", "vgam", "vgan", "vgao", "vgbm", "vgbn", "vgbo", "vgcm", "vgcn", "vgco", "vham", "vhan", "vhao", "vhbm", "vhbn", "vhbo", "vhcm", "vhcn", "vhco", "viam", "vian", "viao", "vibm", "vibn", "vibo", "vicm", "vicn", "vico"], ["wwww", "wwwx", "wwwy", "wwwz", "wwxw", "wwxx", "wwxy", "wwxz", "wwyw", "wwyx", "wwyy", "wwyz", "wwzw", "wwzx", "wwzy", "wwzz", "wxww", "wxwx", "wxwy", "wxwz", "wxxw", "wxxx", "wxxy", "wxxz", "wxyw", "wxyx", "wxyy", "wxyz", "wxzw", "wxzx", "wxzy", "wxzz", "wyww", "wywx", "wywy", "wywz", "wyxw", "wyxx", "wyxy", "wyxz", "wyyw", "wyyx", "wyyy", "wyyz", "wyzw", "wyzx", "wyzy", "wyzz", "wzww", "wzwx", "wzwy", "wzwz", "wzxw", "wzxx", "wzxy", "wzxz", "wzyw", "wzyx", "wzyy", "wzyz", "wzzw", "wzzx", "wzzy", "wzzz", "xwww", "xwwx", "xwwy", "xwwz", "xwxw", "xwxx", "xwxy", "xwxz", "xwyw", "xwyx", "xwyy", "xwyz", "xwzw", "xwzx", "xwzy", "xwzz", "xxww", "xxwx", "xxwy", "xxwz", "xxxw", "xxxx", "xxxy", "xxxz", "xxyw", "xxyx", "xxyy", "xxyz", "xxzw", "xxzx", "xxzy", "xxzz", "xyww", "xywx", "xywy", "xywz", "xyxw", "xyxx", "xyxy", "xyxz", "xyyw", "xyyx", "xyyy", "xyyz", "xyzw", "xyzx", "xyzy", "xyzz", "xzww", "xzwx", "xzwy", "xzwz", "xzxw", "xzxx", "xzxy", "xzxz", "xzyw", "xzyx", "xzyy", "xzyz", "xzzw", "xzzx", "xzzy", "xzzz", "ywww", "ywwx", "ywwy", "ywwz", "ywxw", "ywxx", "ywxy", "ywxz", "ywyw", "ywyx", "ywyy", "ywyz", "ywzw", "ywzx", "ywzy", "ywzz", "yxww", "yxwx", "yxwy", "yxwz", "yxxw", "yxxx", "yxxy", "yxxz", "yxyw", "yxyx", "yxyy", "yxyz", "yxzw", "yxzx", "yxzy", "yxzz", "yyww", "yywx", "yywy", "yywz", "yyxw", "yyxx", "yyxy", "yyxz", "yyyw", "yyyx", "yyyy", "yyyz", "yyzw", "yyzx", "yyzy", "yyzz", "yzww", "yzwx", "yzwy", "yzwz", "yzxw", "yzxx", "yzxy", "yzxz", "yzyw", "yzyx", "yzyy", "yzyz", "yzzw", "yzzx", "yzzy", "yzzz", "zwww", "zwwx", "zwwy", "zwwz", "zwxw", "zwxx", "zwxy", "zwxz", "zwyw", "zwyx", "zwyy", "zwyz", "zwzw", "zwzx", "zwzy", "zwzz", "zxww", "zxwx", "zxwy", "zxwz", "zxxw", "zxxx", "zxxy", "zxxz", "zxyw", "zxyx", "zxyy", "zxyz", "zxzw", "zxzx", "zxzy", "zxzz", "zyww", "zywx", "zywy", "zywz", "zyxw", "zyxx", "zyxy", "zyxz", "zyyw", "zyyx", "zyyy", "zyyz", "zyzw", "zyzx", "zyzy", "zyzz", "zzww", "zzwx", "zzwy", "zzwz", "zzxw", "zzxx", "zzxy", "zzxz", "zzyw", "zzyx", "zzyy", "zzyz", "zzzw", "zzzx", "zzzy", "zzzz"], ["aaaa", "aaab", "aaac", "aaba", "aabb", "aabc", "aaca", "aacb", "aacc", "abaa", "abab", "abac", "abba", "abbb", "abbc", "abca", "abcb", "abcc", "acaa", "acab", "acac", "acba", "acbb", "acbc", "acca", "accb", "accc", "baaa", "baab", "baac", "baba", "babb", "babc", "baca", "bacb", "bacc", "bbaa", "bbab", "bbac", "bbba", "bbbb", "bbbc", "bbca", "bbcb", "bbcc", "bcaa", "bcab", "bcac", "bcba", "bcbb", "bcbc", "bcca", "bccb", "bccc", "caaa", "caab", "caac", "caba", "cabb", "cabc", "caca", "cacb", "cacc", "cbaa", "cbab", "cbac", "cbba", "cbbb", "cbbc", "cbca", "cbcb", "cbcc", "ccaa", "ccab", "ccac", "ccba", "ccbb", "ccbc", "ccca", "cccb", "cccc"], ["pppp", "pppq", "pppr", "ppps", "ppqp", "ppqq", "ppqr", "ppqs", "pprp", "pprq", "pprr", "pprs", "ppsp", "ppsq", "ppsr", "ppss", "pqpp", "pqpq", "pqpr", "pqps", "pqqp", "pqqq", "pqqr", "pqqs", "pqrp", "pqrq", "pqrr", "pqrs", "pqsp", "pqsq", "pqsr", "pqss", "prpp", "prpq", "prpr", "prps", "prqp", "prqq", "prqr", "prqs", "prrp", "prrq", "prrr", "prrs", "prsp", "prsq", "prsr", "prss", "pspp", "pspq", "pspr", "psps", "psqp", "psqq", "psqr", "psqs", "psrp", "psrq", "psrr", "psrs", "pssp", "pssq", "pssr", "psss", "qppp", "qppq", "qppr", "qpps", "qpqp", "qpqq", "qpqr", "qpqs", "qprp", "qprq", "qprr", "qprs", "qpsp", "qpsq", "qpsr", "qpss", "qqpp", "qqpq", "qqpr", "qqps", "qqqp", "qqqq", "qqqr", "qqqs", "qqrp", "qqrq", "qqrr", "qqrs", "qqsp", "qqsq", "qqsr", "qqss", "qrpp", "qrpq", "qrpr", "qrps", "qrqp", "qrqq", "qrqr", "qrqs", "qrrp", "qrrq", "qrrr", "qrrs", "qrsp", "qrsq", "qrsr", "qrss", "qspp", "qspq", "qspr", "qsps", "qsqp", "qsqq", "qsqr", "qsqs", "qsrp", "qsrq", "qsrr", "qsrs", "qssp", "qssq", "qssr", "qsss", "rppp", "rppq", "rppr", "rpps", "rpqp", "rpqq", "rpqr", "rpqs", "rprp", "rprq", "rprr", "rprs", "rpsp", "rpsq", "rpsr", "rpss", "rqpp", "rqpq", "rqpr", "rqps", "rqqp", "rqqq", "rqqr", "rqqs", "rqrp", "rqrq", "rqrr", "rqrs", "rqsp", "rqsq", "rqsr", "rqss", "rrpp", "rrpq", "rrpr", "rrps", "rrqp", "rrqq", "rrqr", "rrqs", "rrrp", "rrrq", "rrrr", "rrrs", "rrsp", "rrsq", "rrsr", "rrss", "rspp", "rspq", "rspr", "rsps", "rsqp", "rsqq", "rsqr", "rsqs", "rsrp", "rsrq", "rsrr", "rsrs", "rssp", "rssq", "rssr", "rsss", "sppp", "sppq", "sppr", "spps", "spqp", "spqq", "spqr", "spqs", "sprp", "sprq", "sprr", "sprs", "spsp", "spsq", "spsr", "spss", "sqpp", "sqpq", "sqpr", "sqps", "sqqp", "sqqq", "sqqr", "sqqs", "sqrp", "sqrq", "sqrr", "sqrs", "sqsp", "sqsq", "sqsr", "sqss", "srpp", "srpq", "srpr", "srps", "srqp", "srqq", "srqr", "srqs", "srrp", "srrq", "srrr", "srrs", "srsp", "srsq", "srsr", "srss", "sspp", "sspq", "sspr", "ssps", "ssqp", "ssqq", "ssqr", "ssqs", "ssrp", "ssrq", "ssrr", "ssrs", "sssp", "sssq", "sssr", "ssss"], ["wapg", "waph", "wapi", "waqg", "waqh", "waqi", "warg", "warh", "wari", "wasg", "wash", "wasi", "wbpg", "wbph", "wbpi", "wbqg", "wbqh", "wbqi", "wbrg", "wbrh", "wbri", "wbsg", "wbsh", "wbsi", "wcpg", "wcph", "wcpi", "wcqg", "wcqh", "wcqi", "wcrg", "wcrh", "wcri", "wcsg", "wcsh", "wcsi", "xapg", "xaph", "xapi", "xaqg", "xaqh", "xaqi", "xarg", "xarh", "xari", "xasg", "xash", "xasi", "xbpg", "xbph", "xbpi", "xbqg", "xbqh", "xbqi", "xbrg", "xbrh", "xbri", "xbsg", "xbsh", "xbsi", "xcpg", "xcph", "xcpi", "xcqg", "xcqh", "xcqi", "xcrg", "xcrh", "xcri", "xcsg", "xcsh", "xcsi", "yapg", "yaph", "yapi", "yaqg", "yaqh", "yaqi", "yarg", "yarh", "yari", "yasg", "yash", "yasi", "ybpg", "ybph", "ybpi", "ybqg", "ybqh", "ybqi", "ybrg", "ybrh", "ybri", "ybsg", "ybsh", "ybsi", "ycpg", "ycph", "ycpi", "ycqg", "ycqh", "ycqi", "ycrg", "ycrh", "ycri", "ycsg", "ycsh", "ycsi", "zapg", "zaph", "zapi", "zaqg", "zaqh", "zaqi", "zarg", "zarh", "zari", "zasg", "zash", "zasi", "zbpg", "zbph", "zbpi", "zbqg", "zbqh", "zbqi", "zbrg", "zbrh", "zbri", "zbsg", "zbsh", "zbsi", "zcpg", "zcph", "zcpi", "zcqg", "zcqh", "zcqi", "zcrg", "zcrh", "zcri", "zcsg", "zcsh", "zcsi"], ["jmtd", "jmte", "jmtf", "jmud", "jmue", "jmuf", "jmvd", "jmve", "jmvf", "jntd", "jnte", "jntf", "jnud", "jnue", "jnuf", "jnvd", "jnve", "jnvf", "jotd", "jote", "jotf", "joud", "joue", "jouf", "jovd", "jove", "jovf", "kmtd", "kmte", "kmtf", "kmud", "kmue", "kmuf", "kmvd", "kmve", "kmvf", "kntd", "knte", "kntf", "knud", "knue", "knuf", "knvd", "knve", "knvf", "kotd", "kote", "kotf", "koud", "koue", "kouf", "kovd", "kove", "kovf", "lmtd", "lmte", "lmtf", "lmud", "lmue", "lmuf", "lmvd", "lmve", "lmvf", "lntd", "lnte", "lntf", "lnud", "lnue", "lnuf", "lnvd", "lnve", "lnvf", "lotd", "lote", "lotf", "loud", "loue", "louf", "lovd", "love", "lovf"], ["pwpw", "pwpx", "pwpy", "pwpz", "pwqw", "pwqx", "pwqy", "pwqz", "pwrw", "pwrx", "pwry", "pwrz", "pwsw", "pwsx", "pwsy", "pwsz", "pxpw", "pxpx", "pxpy", "pxpz", "pxqw", "pxqx", "pxqy", "pxqz", "pxrw", "pxrx", "pxry", "pxrz", "pxsw", "pxsx", "pxsy", "pxsz", "pypw", "pypx", "pypy", "pypz", "pyqw", "pyqx", "pyqy", "pyqz", "pyrw", "pyrx", "pyry", "pyrz", "pysw", "pysx", "pysy", "pysz", "pzpw", "pzpx", "pzpy", "pzpz", "pzqw", "pzqx", "pzqy", "pzqz", "pzrw", "pzrx", "pzry", "pzrz", "pzsw", "pzsx", "pzsy", "pzsz", "qwpw", "qwpx", "qwpy", "qwpz", "qwqw", "qwqx", "qwqy", "qwqz", "qwrw", "qwrx", "qwry", "qwrz", "qwsw", "qwsx", "qwsy", "qwsz", "qxpw", "qxpx", "qxpy", "qxpz", "qxqw", "qxqx", "qxqy", "qxqz", "qxrw", "qxrx", "qxry", "qxrz", "qxsw", "qxsx", "qxsy", "qxsz", "qypw", "qypx", "qypy", "qypz", "qyqw", "qyqx", "qyqy", "qyqz", "qyrw", "qyrx", "qyry", "qyrz", "qysw", "qysx", "qysy", "qysz", "qzpw", "qzpx", "qzpy", "qzpz", "qzqw", "qzqx", "qzqy", "qzqz", "qzrw", "qzrx", "qzry", "qzrz", "qzsw", "qzsx", "qzsy", "qzsz", "rwpw", "rwpx", "rwpy", "rwpz", "rwqw", "rwqx", "rwqy", "rwqz", "rwrw", "rwrx", "rwry", "rwrz", "rwsw", "rwsx", "rwsy", "rwsz", "rxpw", "rxpx", "rxpy", "rxpz", "rxqw", "rxqx", "rxqy", "rxqz", "rxrw", "rxrx", "rxry", "rxrz", "rxsw", "rxsx", "rxsy", "rxsz", "rypw", "rypx", "rypy", "rypz", "ryqw", "ryqx", "ryqy", "ryqz", "ryrw", "ryrx", "ryry", "ryrz", "rysw", "rysx", "rysy", "rysz", "rzpw", "rzpx", "rzpy", "rzpz", "rzqw", "rzqx", "rzqy", "rzqz", "rzrw", "rzrx", "rzry", "rzrz", "rzsw", "rzsx", "rzsy", "rzsz", "swpw", "swpx", "swpy", "swpz", "swqw", "swqx", "swqy", "swqz", "swrw", "swrx", "swry", "swrz", "swsw", "swsx", "swsy", "swsz", "sxpw", "sxpx", "sxpy", "sxpz", "sxqw", "sxqx", "sxqy", "sxqz", "sxrw", "sxrx", "sxry", "sxrz", "sxsw", "sxsx", "sxsy", "sxsz", "sypw", "sypx", "sypy", "sypz", "syqw", "syqx", "syqy", "syqz", "syrw", "syrx", "syry", "syrz", "sysw", "sysx", "sysy", "sysz", "szpw", "szpx", "szpy", "szpz", "szqw", "szqx", "szqy", "szqz", "szrw", "szrx", "szry", "szrz", "szsw", "szsx", "szsy", "szsz"]], "loose": true}