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/walls-and-gates.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "116", "slug": "walls-and-gates", "id": 116, "title": "Walls and Gates", "difficulty": "Medium", "category": "graph", "link": "https://leetcode.com/problems/walls-and-gates/", "examples": [{"input": "rooms = [[2147483647,-1,0,2147483647],[2147483647,2147483647,2147483647,-1],[2147483647,-1,2147483647,-1],[0,-1,2147483647,2147483647]]", "output": "[[3,-1,0,1],[2,2,1,-1],[1,-1,2,-1],[0,-1,3,4]]", "explanation": "The distances to the nearest gate are: [[3,-1,0,1],[2,2,1,-1],[1,-1,2,-1],[0,-1,3,4]]."}, {"input": "rooms = [[-1,2147483647],[0,2147483647]]", "output": "[[-1,2],[0,1]]", "explanation": "The distances to the nearest gate are: [[-1,2],[0,1]]."}], "hints": ["Start a breadth-first search from all gates at the same time.", "The first time an empty room is reached is through its nearest gate."], "statement": "You are given a nonempty rectangular matrix `rooms` containing three kinds of cells:\n\n- `-1` is a wall.\n- `0` is a gate.\n- `2147483647` is an empty room.\n\nFor every empty room, fill it with the distance to its nearest gate using horizontal and vertical moves. Walls cannot be crossed. If no gate is reachable, leave the room as `2147483647`.\n\nThis version adapts the usual in-place operation: return the completed matrix.\n\n**Constraints:**\n- `1 <= rooms.length <= 250`\n- `1 <= rooms[r].length <= 250`\n- Every row has the same length.\n- Every cell is `-1`, `0`, or `2147483647`.\n", "solution": "## Approach\n\nCopy the matrix for the return-value adaptation, then put every gate into one breadth-first-search queue. Expanding all gates together visits each empty room first from its nearest gate. Assign a distance only when the cell still has the empty-room sentinel, which also prevents repeated work and leaves unreachable rooms unchanged.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m * n), because every room enters the queue at most once.\n- **Space Complexity:** O(m * n) for the returned copy and the breadth-first-search queue.\n\n## Implementation\n\n```python\nfrom collections import deque\nfrom typing import List\n\n\nclass Solution:\n def wallsAndGates(self, rooms: List[List[int]]) -> List[List[int]]:\n result = [row.copy() for row in rooms]\n rows, cols = len(result), len(result[0])\n queue = deque(\n (row, col)\n for row in range(rows)\n for col in range(cols)\n if result[row][col] == 0\n )\n while queue:\n row, col = queue.popleft()\n for row_step, col_step in ((1, 0), (-1, 0), (0, 1), (0, -1)):\n next_row = row + row_step\n next_col = col + col_step\n if not (0 <= next_row < rows and 0 <= next_col < cols):\n continue\n if result[next_row][next_col] != 2147483647:\n continue\n result[next_row][next_col] = result[row][col] + 1\n queue.append((next_row, next_col))\n return result\n```\n", "starter": {"go": "package main\n\nfunc WallsAndGates(rooms [][]int) [][]int {\n return [][]int{}\n}\n", "python": "from typing import List\n\nclass Solution:\n def wallsAndGates(self, rooms: List[List[int]]) -> List[List[int]]:\n return []\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n vector<vector<int>> wallsAndGates(vector<vector<int>>& rooms) {\n return {};\n }\n};"}, "fn": "wallsAndGates", "params": [{"name": "rooms", "type": "int_array_2d", "visualizeType": "matrix"}], "outputType": "int_array_2d", "tests": [["[[2147483647]]"], ["[[0]]"], ["[[-1]]"], ["[[2147483647,0]]"], ["[[0,2147483647]]"], ["[[2147483647,-1]]"], ["[[-1,2147483647]]"], ["[[2147483647,2147483647,0]]"], ["[[0,2147483647,2147483647]]"], ["[[2147483647,-1,0]]"], ["[[2147483647],[0]]"], ["[[0],[2147483647]]"], ["[[2147483647],[-1],[0]]"], ["[[2147483647,2147483647],[2147483647,0]]"], ["[[0,2147483647],[2147483647,2147483647]]"], ["[[-1,2147483647],[0,2147483647]]"], ["[[2147483647,-1],[2147483647,0]]"], ["[[0,-1],[-1,2147483647]]"], ["[[0,0],[0,0]]"], ["[[2147483647,2147483647],[2147483647,2147483647]]"], ["[[2147483647,0,2147483647],[2147483647,2147483647,2147483647]]"], ["[[2147483647,2147483647,2147483647],[0,-1,0]]"], ["[[0,-1,2147483647],[2147483647,-1,2147483647],[2147483647,2147483647,2147483647]]"], ["[[2147483647,-1,0],[2147483647,-1,2147483647],[2147483647,2147483647,2147483647]]"], ["[[2147483647,2147483647,2147483647],[2147483647,-1,2147483647],[0,2147483647,0]]"], ["[[0,2147483647,0],[2147483647,2147483647,2147483647],[0,2147483647,0]]"], ["[[-1,-1,-1],[-1,2147483647,-1],[-1,-1,0]]"], ["[[2147483647,-1,2147483647],[0,-1,0],[2147483647,-1,2147483647]]"], ["[[0,2147483647,2147483647,2147483647]]"], ["[[2147483647,2147483647,2147483647,0]]"], ["[[0,-1,2147483647,2147483647,0]]"], ["[[2147483647],[2147483647],[2147483647],[0]]"], ["[[0],[2147483647],[-1],[2147483647],[0]]"], ["[[2147483647,2147483647,-1,0],[2147483647,-1,2147483647,2147483647]]"], ["[[0,2147483647,-1,2147483647],[-1,2147483647,2147483647,2147483647]]"], ["[[2147483647,-1,0,2147483647],[2147483647,2147483647,2147483647,-1],[2147483647,-1,2147483647,-1],[0,-1,2147483647,2147483647]]"], ["[[0,2147483647,2147483647,2147483647],[2147483647,-1,-1,2147483647],[2147483647,2147483647,2147483647,2147483647]]"], ["[[2147483647,2147483647,2147483647,0],[-1,-1,2147483647,-1],[0,2147483647,2147483647,2147483647]]"], ["[[2147483647,-1,2147483647,0],[2147483647,-1,2147483647,-1],[2147483647,2147483647,2147483647,2147483647]]"], ["[[0,-1,2147483647,2147483647],[2147483647,-1,2147483647,-1],[2147483647,2147483647,2147483647,0]]"], ["[[2147483647,2147483647,0,2147483647,2147483647],[2147483647,-1,-1,-1,2147483647],[2147483647,2147483647,2147483647,2147483647,2147483647]]"], ["[[0,2147483647,2147483647,-1,2147483647],[2147483647,-1,2147483647,-1,2147483647],[2147483647,-1,2147483647,2147483647,0]]"], ["[[2147483647,-1,0,-1,2147483647],[2147483647,-1,2147483647,-1,2147483647],[2147483647,2147483647,2147483647,2147483647,2147483647]]"], ["[[2147483647,2147483647,2147483647],[2147483647,0,2147483647],[2147483647,2147483647,2147483647],[2147483647,-1,2147483647]]"], ["[[0,-1,2147483647],[2147483647,-1,2147483647],[2147483647,-1,2147483647],[2147483647,2147483647,2147483647]]"], ["[[2147483647,2147483647,2147483647,2147483647],[2147483647,-1,-1,2147483647],[0,2147483647,2147483647,0],[2147483647,-1,2147483647,2147483647]]"], ["[[2147483647,-1,2147483647,-1,0],[2147483647,-1,2147483647,2147483647,2147483647],[0,2147483647,2147483647,-1,2147483647]]"], ["[[0,2147483647,-1,2147483647,0],[2147483647,2147483647,-1,2147483647,2147483647],[-1,2147483647,2147483647,2147483647,-1]]"], ["[[2147483647,2147483647,2147483647,2147483647,2147483647],[2147483647,-1,-1,-1,2147483647],[2147483647,-1,0,-1,2147483647],[2147483647,-1,2147483647,-1,2147483647],[2147483647,2147483647,2147483647,2147483647,2147483647]]"], ["[[0,-1,2147483647,2147483647,2147483647],[2147483647,-1,2147483647,-1,2147483647],[2147483647,-1,2147483647,-1,2147483647],[2147483647,2147483647,2147483647,-1,0]]"], ["[[2147483647,0,2147483647,2147483647],[2147483647,-1,2147483647,-1],[2147483647,2147483647,2147483647,2147483647],[0,-1,2147483647,2147483647]]"], ["[[2147483647,-1,2147483647,0,2147483647,2147483647],[2147483647,-1,2147483647,-1,-1,2147483647],[0,2147483647,2147483647,2147483647,2147483647,2147483647]]"], ["@javascript:JSON.stringify(Array.from({length:40},(_,r)=>Array.from({length:250},(_,c)=>r===0&&c===0?0:2147483647)))"]], "expected": [[[2147483647]], [[0]], [[-1]], [[1, 0]], [[0, 1]], [[2147483647, -1]], [[-1, 2147483647]], [[2, 1, 0]], [[0, 1, 2]], [[2147483647, -1, 0]], [[1], [0]], [[0], [1]], [[2147483647], [-1], [0]], [[2, 1], [1, 0]], [[0, 1], [1, 2]], [[-1, 2], [0, 1]], [[2, -1], [1, 0]], [[0, -1], [-1, 2147483647]], [[0, 0], [0, 0]], [[2147483647, 2147483647], [2147483647, 2147483647]], [[1, 0, 1], [2, 1, 2]], [[1, 2, 1], [0, -1, 0]], [[0, -1, 6], [1, -1, 5], [2, 3, 4]], [[6, -1, 0], [5, -1, 1], [4, 3, 2]], [[2, 3, 2], [1, -1, 1], [0, 1, 0]], [[0, 1, 0], [1, 2, 1], [0, 1, 0]], [[-1, -1, -1], [-1, 2147483647, -1], [-1, -1, 0]], [[1, -1, 1], [0, -1, 0], [1, -1, 1]], [[0, 1, 2, 3]], [[3, 2, 1, 0]], [[0, -1, 2, 1, 0]], [[3], [2], [1], [0]], [[0], [1], [-1], [1], [0]], [[2147483647, 2147483647, -1, 0], [2147483647, -1, 2, 1]], [[0, 1, -1, 5], [-1, 2, 3, 4]], [[3, -1, 0, 1], [2, 2, 1, -1], [1, -1, 2, -1], [0, -1, 3, 4]], [[0, 1, 2, 3], [1, -1, -1, 4], [2, 3, 4, 5]], [[3, 2, 1, 0], [-1, -1, 2, -1], [0, 1, 2, 3]], [[7, -1, 1, 0], [6, -1, 2, -1], [5, 4, 3, 4]], [[0, -1, 3, 4], [1, -1, 2, -1], [2, 2, 1, 0]], [[2, 1, 0, 1, 2], [3, -1, -1, -1, 3], [4, 5, 6, 5, 4]], [[0, 1, 2, -1, 2], [1, -1, 3, -1, 1], [2, -1, 2, 1, 0]], [[6, -1, 0, -1, 6], [5, -1, 1, -1, 5], [4, 3, 2, 3, 4]], [[2, 1, 2], [1, 0, 1], [2, 1, 2], [3, -1, 3]], [[0, -1, 8], [1, -1, 7], [2, -1, 6], [3, 4, 5]], [[2, 3, 3, 2], [1, -1, -1, 1], [0, 1, 1, 0], [1, -1, 2, 1]], [[2, -1, 4, -1, 0], [1, -1, 3, 2, 1], [0, 1, 2, -1, 2]], [[0, 1, -1, 1, 0], [1, 2, -1, 2, 1], [-1, 3, 4, 3, -1]], [[8, 9, 10, 9, 8], [7, -1, -1, -1, 7], [6, -1, 0, -1, 6], [5, -1, 1, -1, 5], [4, 3, 2, 3, 4]], [[0, -1, 5, 4, 3], [1, -1, 6, -1, 2], [2, -1, 6, -1, 1], [3, 4, 5, -1, 0]], [[1, 0, 1, 2], [2, -1, 2, -1], [1, 2, 3, 4], [0, -1, 4, 5]], [[2, -1, 1, 0, 1, 2], [1, -1, 2, -1, -1, 3], [0, 1, 2, 3, 4, 4]], [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249], [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250], [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251], [3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252], [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253], [5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254], [6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255], [7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256], [8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257], [9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258], [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259], [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260], [12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261], [13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262], [14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263], [15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264], [16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265], [17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266], [18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267], [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268], [20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269], [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270], [22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271], [23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272], [24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273], [25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274], [26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275], [27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276], [28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277], [29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278], [30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279], [31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280], [32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281], [33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282], [34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283], [35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284], [36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285], [37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286], [38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287], [39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255, 256, 257, 258, 259, 260, 261, 262, 263, 264, 265, 266, 267, 268, 269, 270, 271, 272, 273, 274, 275, 276, 277, 278, 279, 280, 281, 282, 283, 284, 285, 286, 287, 288]]], "loose": false}

package/data/problems/water-and-jug-problem.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "444", "slug": "water-and-jug-problem", "id": 444, "title": "Water and Jug Problem", "difficulty": "Medium", "category": "math", "link": "https://leetcode.com/problems/water-and-jug-problem/", "examples": [{"input": "x = 3, y = 5, target = 4", "output": "true", "explanation": "A fill-pour-empty cycle can isolate exactly 4 litres."}, {"input": "x = 2, y = 6, target = 5", "output": "false", "explanation": "Every reachable total is even, so 5 can never appear."}, {"input": "x = 1, y = 2, target = 3", "output": "true", "explanation": "Fill both jugs."}], "hints": ["Model reachable totals with the greatest common divisor of x and y.", "The target must not exceed x + y, and zero is always reachable.", "Otherwise the target works exactly when it is a multiple of gcd(x, y)."], "statement": "You hold two jugs holding exactly `x` and `y` litres, plus an unlimited water\nsupply. In any step you may fill a jug completely, empty a jug completely, or\npour from one jug into the other until either the source is empty or the\ndestination is full.\n\nDecide whether these moves can leave exactly `target` litres combined across\nboth jugs.\n\nA useful insight: every reachable total is a multiple of the greatest common\ndivisor of the two capacities, and any such multiple up to `x + y` is\nreachable. A target of zero is always reachable (both jugs empty).\n\n**Constraints:**\n- `0 <= x, y, target <= 10^3`\n", "solution": "## Approach\n\nPouring preserves multiples of `gcd(x, y)`: every reachable combined total is\nsuch a multiple, and every multiple between 0 and `x + y` is reachable. The\nanswer is therefore true exactly when the target fits in both jugs and passes\nthe divisibility test, with zero always reachable.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(log(min(x, y))) for the GCD.\n- **Space Complexity:** O(1).\n\n## Implementation\n\n```python\nimport math\n\nclass Solution:\n def canMeasureWater(self, x: int, y: int, target: int) -> bool:\n if target < 0:\n return False\n if target == 0:\n return True\n if x + y < target:\n return False\n if x == 0:\n return y == target\n if y == 0:\n return x == target\n return target % math.gcd(x, y) == 0\n```\n", "starter": {"go": "package main\n\nfunc CanMeasureWater(x int, y int, target int) bool {\n \n}", "python": "from typing import List\nclass Solution:\n def canMeasureWater(self, x: int, y: int, target: int) -> bool:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n bool canMeasureWater(int x, int y, int target) {\n return false;\n }\n};"}, "fn": "canMeasureWater", "params": [{"name": "x", "type": "int"}, {"name": "y", "type": "int"}, {"name": "target", "type": "int"}], "outputType": "boolean", "tests": [["3", "5", "4"], ["2", "6", "5"], ["1", "2", "3"], ["0", "0", "0"], ["0", "5", "5"], ["0", "5", "3"], ["5", "0", "5"], ["5", "0", "4"], ["1", "1", "1"], ["1", "1", "2"], ["1", "1", "0"], ["4", "6", "8"], ["4", "6", "7"], ["3", "6", "9"], ["3", "6", "10"], ["6", "9", "3"], ["6", "9", "12"], ["6", "9", "15"], ["6", "9", "16"], ["11", "13", "1"], ["11", "13", "24"], ["11", "13", "25"], ["7", "7", "7"], ["7", "7", "14"], ["7", "7", "15"], ["1000", "1000", "1000"], ["1000", "999", "1"], ["34", "68", "34"]], "expected": [true, false, true, true, true, false, true, false, true, true, true, true, false, true, false, true, true, true, false, true, true, false, true, true, false, true, true, true], "loose": false}

package/data/problems/wiggle-sort-ii.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "411", "slug": "wiggle-sort-ii", "id": 411, "title": "Wiggle Sort II", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/wiggle-sort-ii/", "examples": [{"explanation": "1 < 6 > 1 < 5 > 1 < 4 holds; other valid orders such as [1,4,1,5,1,6] are also accepted.", "input": "nums = [1,5,1,1,6,4]", "output": "[1,6,1,5,1,4]"}, {"explanation": "2 < 3 > 1 < 3 > 1 < 2 is a valid strict wiggle.", "input": "nums = [1,3,2,2,3,1]", "output": "[2,3,1,3,1,2]"}, {"explanation": "With one peak in the middle, 1 < 2 > 1 works.", "input": "nums = [1,1,2]", "output": "[1,2,1]"}], "hints": ["Adaptation: the original asks for in-place void; here return the reordered array.", "Sort a copy, split it into a smaller half and a larger half, reverse both, then interleave small, large, small, large.", "Any permutation with the strict wiggle property and the same multiset is accepted."], "statement": "You are given an integer array `nums` and must reorder it so that strict ups and downs alternate: `nums[0] < nums[1] > nums[2] < nums[3] ...`. Every input given here admits at least one such ordering. Return any reordered array meeting the condition (it must reuse exactly the same elements).\n\n*Adaptation note:* the original statement rearranges the array in place without returning anything; here you return the reordered array instead, holding the same values.\n\n**Constraints:**\n- `1 <= nums.length <= 5 * 10^4`\n- `0 <= nums[i] <= 5000`\n- A valid answer always exists for the given input.\n", "solution": "## Approach\n\nSort a copy of the array and cut it into a smaller half and a larger half. Reverse both halves and interleave them (small, large, small, large, ...). Reversing keeps equal values apart so that every even position is strictly below its right neighbor and every odd position strictly above, whenever a valid ordering exists.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n log n), where n is the length of `nums`, dominated by sorting.\n- **Space Complexity:** O(n) for the sorted copy and the result.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def wiggleSort(self, nums: List[int]) -> List[int]:\n s = sorted(nums)\n n = len(nums)\n mid = (n + 1) // 2\n left = s[:mid][::-1]\n right = s[mid:][::-1]\n res = []\n for i in range(len(right)):\n res.append(left[i])\n res.append(right[i])\n if len(left) > len(right):\n res.append(left[-1])\n return res\n```\n", "starter": {"go": "package main\n\nfunc WiggleSort(nums []int) []int {\n \n}", "python": "from typing import List\nclass Solution:\n def wiggleSort(self, nums: List[int]) -> List[int]:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<int> wiggleSort(vector<int>& nums) {\n return {};\n }\n};"}, "fn": "wiggleSort", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int_array", "tests": [["[1,5,1,1,6,4]"], ["[1,3,2,2,3,1]"], ["[1,1,2]"], ["[1]"], ["[1,2]"], ["[2,1]"], ["[1,2,3,4,5]"], ["[5,4,3,2,1]"], ["[1,1,2,2,3,3]"], ["[1,1,1,2,2,3]"], ["[4,5,5,6]"], ["[3,5,2,1,6,4]"], ["[6,6,5,6,3,8]"], ["[1,2,1]"], ["[2,3,2]"], ["[1,2,2,3,3]"], ["[2,1,3]"], ["[3,2,1]"], ["[1,3,2]"], ["[2,3,1]"], ["[1,1,2,3,4]"], ["[5,3,1,2,4,6]"], ["[1,2,1,2,1,2,3]"], ["[4,1,3,2,5]"], ["[1,4,2,5,3]"], ["[7,9,4,3,2,8,6]"], ["[1,2,3,4,4,5]"], ["[3,1,2,2,1,3]"], ["[2,4,1,5,3,6,7]"], ["[5,1,4,2,3,6]"], ["[1,1,2,2,2,3]"], ["[5,5,4,4,3]"]], "expected": [[1, 6, 1, 5, 1, 4], [2, 3, 1, 3, 1, 2], [1, 2, 1], [1], [1, 2], [1, 2], [3, 5, 2, 4, 1], [3, 5, 2, 4, 1], [2, 3, 1, 3, 1, 2], [1, 3, 1, 2, 1, 2], [5, 6, 4, 5], [3, 6, 2, 5, 1, 4], [6, 8, 5, 6, 3, 6], [1, 2, 1], [2, 3, 2], [2, 3, 2, 3, 1], [2, 3, 1], [2, 3, 1], [2, 3, 1], [2, 3, 1], [2, 4, 1, 3, 1], [3, 6, 2, 5, 1, 4], [2, 3, 1, 2, 1, 2, 1], [3, 5, 2, 4, 1], [3, 5, 2, 4, 1], [6, 9, 4, 8, 3, 7, 2], [3, 5, 2, 4, 1, 4], [2, 3, 1, 3, 1, 2], [4, 7, 3, 6, 2, 5, 1], [3, 6, 2, 5, 1, 4], [2, 3, 1, 2, 1, 2], [4, 5, 4, 5, 3]], "loose": false}

package/data/problems/wiggle-sort.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "378", "slug": "wiggle-sort", "id": 378, "title": "Wiggle Sort", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/wiggle-sort/", "examples": [{"input": "nums = [3,5,2,1,6,4]", "output": "[3,5,1,6,2,4]", "explanation": "One valid wiggle is [3,5,1,6,2,4] with 3<=5>=1<=6>=2<=4."}, {"input": "nums = [6,6,5,6,3,8]", "output": "[6,6,3,6,5,8]", "explanation": "[6,6,3,6,5,8] satisfies the wiggle inequalities."}, {"input": "nums = [1]", "output": "[1]", "explanation": "A single element already wiggles."}], "hints": ["Adaptation: the original asks for in-place void; here return the reordered array.", "Scan once: for even i require nums[i] <= nums[i+1], for odd i require nums[i] >= nums[i+1]; swap when violated.", "Any permutation with the wiggle property is accepted."], "statement": "Reorder the array into wiggle order: `nums[0] <= nums[1] >= nums[2] <= nums[3] ...`.\n\n**Adaptation:** the original requires an in-place void update; here implement\n`wiggleSort(nums)` returning a reordered copy. Any ordering with the wiggle\nproperty and the same multiset of values is accepted.\n\n**Constraints:**\n- `1 <= nums.length <= 10^4`\n- `0 <= nums[i] <= 10^4`\n", "solution": "## Approach\n\nWalk the array once and fix each adjacent pair locally: swap positions i and i+1 whenever an even index violates <= or an odd index violates >=. One pass suffices because each swap only affects the current pair's relation.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n)\n- **Space Complexity:** O(1) extra besides the returned copy.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def wiggleSort(self, nums: List[int]) -> List[int]:\n a = list(nums)\n for i in range(len(a) - 1):\n if (i % 2 == 0 and a[i] > a[i + 1]) or (i % 2 == 1 and a[i] < a[i + 1]):\n a[i], a[i + 1] = a[i + 1], a[i]\n return a\n```\n", "starter": {"go": "package main\n\nfunc WiggleSort(nums []int) []int {\n \n}", "python": "from typing import List\nclass Solution:\n def wiggleSort(self, nums: List[int]) -> List[int]:\n pass", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<int> wiggleSort(vector<int>& nums) {\n return {};\n }\n};"}, "fn": "wiggleSort", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int_array", "tests": [["[3,5,2,1,6,4]"], ["[6,6,5,6,3,8]"], ["[1]"], ["[1,2]"], ["[2,1]"], ["[3,3,3]"], ["[1,2,3,4,5]"], ["[5,4,3,2,1]"], ["[1,3,2,2,3,1]"], ["[0,0,0,0]"], ["[4,5,5,6]"], ["[9,6,8,3,7]"], ["[1,1,2]"], ["[2,2,1]"], ["[1,0]"], ["[3,1,2]"], ["[7,7,7,8,7]"], ["[10,9,8,7,6,5,4]"], ["[1,2,2,3]"], ["[5,3,1,2,3]"], ["[2,1,3]"], ["[4,4,4,4]"], ["[1,2,3]"], ["[3,2,1]"], ["[0]"], ["[0,1]"], ["[5,5,4,4,3,3]"], ["[8,7,6,5,4,3,2,1]"], ["[1,3,2,4,3,5]"], ["[9,1,9,1,9]"]], "expected": [[3, 5, 1, 6, 2, 4], [6, 6, 5, 6, 3, 8], [1], [1, 2], [1, 2], [3, 3, 3], [1, 3, 2, 5, 4], [4, 5, 2, 3, 1], [1, 3, 2, 3, 1, 2], [0, 0, 0, 0], [4, 5, 5, 6], [6, 9, 3, 8, 7], [1, 2, 1], [2, 2, 1], [0, 1], [1, 3, 2], [7, 7, 7, 8, 7], [9, 10, 7, 8, 5, 6, 4], [1, 2, 2, 3], [3, 5, 1, 3, 2], [1, 3, 2], [4, 4, 4, 4], [1, 3, 2], [2, 3, 1], [0], [0, 1], [5, 5, 4, 4, 3, 3], [7, 8, 5, 6, 3, 4, 1, 2], [1, 3, 2, 4, 3, 5], [1, 9, 1, 9, 9]], "loose": false}

package/data/problems/wiggle-subsequence.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "453", "slug": "wiggle-subsequence", "id": 453, "title": "Wiggle Subsequence", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/wiggle-subsequence/", "examples": [{"input": "nums = [1,7,4,9,2,5]", "output": "6", "explanation": "All five steps alternate."}, {"input": "nums = [1,17,5,10,13,15,10,5,16,8]", "output": "7", "explanation": "A seven-entry subsequence alternates."}, {"input": "nums = [1,2,3,4,5,6,7,8,9]", "output": "2", "explanation": "Monotone climbs allow only length 2."}], "hints": ["Track the lengths of the best subsequences ending with an upward step and with a downward step.", "A rise extends the best downward run; a fall extends the best upward run.", "Equal neighbors extend nothing and are skipped."], "statement": "Measure the longest subsequence whose steps zigzag up and down.\n\nA wiggle run requires neighboring differences to strictly alternate in sign: positive, negative, positive, and so on. The opening step may point either way. A single value always qualifies with length 1, and any two different values qualify with length 2, while equal neighbors can never sit next to each other in the subsequence. From `nums`, keep a subsequence (deleting entries freely but preserving order) that wiggles and is as long as possible, then return its length.\n\n**Constraints:**\n- `1 <= nums.length <= 1000`\n- `0 <= nums[i] <= 1000`\n", "solution": "## Approach\n\nKeep two counters: the best wiggle ending with a rise and the best ending with a fall. A higher neighbor extends the falling best by one, a lower neighbor extends the rising best by one, and equal neighbors change nothing. The answer is the larger counter.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), a single scan of `nums`.\n- **Space Complexity:** O(1) extra.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def wiggleMaxLength(self, nums: List[int]) -> int:\n if len(nums) < 2:\n return len(nums)\n up = down = 1\n for i in range(1, len(nums)):\n if nums[i] > nums[i - 1]:\n up = down + 1\n elif nums[i] < nums[i - 1]:\n down = up + 1\n return max(up, down)\n```\n", "starter": {"go": "package main\n\nfunc WiggleMaxLength(nums []int) int {\n return 0\n}", "python": "from typing import List\n\nclass Solution:\n def wiggleMaxLength(self, nums: List[int]) -> int:\n return 0\n", "cpp": "#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n int wiggleMaxLength(vector<int>& nums) {\n return 0;\n }\n};"}, "fn": "wiggleMaxLength", "params": [{"name": "nums", "type": "int_array"}], "outputType": "int", "tests": [["[1,7,4,9,2,5]"], ["[1,17,5,10,13,15,10,5,16,8]"], ["[1,2,3,4,5,6,7,8,9]"], ["[1]"], ["[1,1]"], ["[1,2]"], ["[2,1]"], ["[1,1,1]"], ["[3,3,3,2,5]"], ["[1,7,4,5,5]"], ["[9,8,7,6,5]"], ["[1,3,2,4,3,5,4]"], ["[0,0,1,0]"], ["[1,2,2,3,4]"], ["[5,5,5,5,6]"], ["[1,2,1,2,1,2]"], ["[2,2,2,2,2,1]"], ["[1,100,1,100,1]"], ["[33,53,12,64,50,41,45,21,97,35,47,92,39,0,93,55,40,46,69,42,51,49,30,4,43,41,48,19,57,83,20,79,73,23,27,71,64,10,74,17]"], ["[0]"], ["[1000,0,1000,0,1000]"], ["[1,2,3,2,1,2,3,2,1]"], ["[5,1,5,1,5,1,5]"], ["[1,2,3,4,3,2,1]"], ["[8,8,9,9,8,8,9]"], ["[1,0,1,0,1,0,1]"], ["[10,9,8,7,8,9,10]"], ["[4,4,4,4]"], ["[1,2,3,4,5,4,3,2,1,2,3]"], ["[22,11,22,11,22]"]], "expected": [6, 7, 2, 1, 1, 2, 2, 1, 3, 4, 2, 7, 3, 2, 2, 6, 2, 5, 29, 1, 5, 5, 7, 3, 4, 7, 3, 1, 4, 5], "loose": false}

package/data/problems/wildcard-matching.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "265", "slug": "wildcard-matching", "id": 265, "title": "Wildcard Matching", "difficulty": "Hard", "category": "string", "link": "https://leetcode.com/problems/wildcard-matching/", "examples": [{"input": "s = \"aa\", p = \"a\"", "output": "false", "explanation": "One literal \"a\" cannot cover the two-character text."}, {"input": "s = \"aa\", p = \"*\"", "output": "true", "explanation": "A single star absorbs any text, including all of \"aa\"."}, {"input": "s = \"cb\", p = \"?a\"", "output": "false", "explanation": "\"?\" matches \"c\", but then \"a\" disagrees with \"b\"."}], "hints": ["Walk both strings with two pointers; when a '*' is seen, remember it and the text position so a later mismatch can stretch the star by one more character.", "Only the most recent star needs remembering, because an earlier star can always absorb whatever the later one gives up."], "statement": "You are given a text `s` and a pattern `p` that may contain two special symbols: `'?'`, which stands for exactly one arbitrary character, and `'*'`, which stands for any (possibly empty) run of characters.\n\nDecide whether the *entire* text matches the *entire* pattern under these rules \u2014 a partial overlap is not enough.\n\n**Constraints:**\n- `0 <= s.length, p.length <= 2000`\n- `s` holds only lowercase English letters.\n- `p` holds only lowercase English letters, `'?'`, and `'*'`.\n", "solution": "## Approach\n\nScan the text and pattern together with two pointers. Matching characters (or `?`) advance both; a `*` is recorded along with the current text position while the pattern moves on. On a mismatch, fall back to the last star and let it swallow one more character. Trailing stars are skipped at the end, and success means the whole pattern was consumed.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * m) worst case, where n and m are the text and pattern lengths; typically near-linear.\n- **Space Complexity:** O(1) extra space.\n\n## Implementation\n\n```python\nclass Solution:\n def isMatch(self, s: str, p: str) -> bool:\n i = j = 0\n star, mark = -1, 0\n while i < len(s):\n if j < len(p) and (p[j] == '?' or p[j] == s[i]):\n i += 1\n j += 1\n elif j < len(p) and p[j] == '*':\n star = j\n mark = i\n j += 1\n elif star != -1:\n j = star + 1\n mark += 1\n i = mark\n else:\n return False\n while j < len(p) and p[j] == '*':\n j += 1\n return j == len(p)\n```\n", "starter": {"go": "package main\n\nfunc IsMatch(s string, p string) bool {\n \n}", "python": "class Solution:\n def isMatch(self, s: str, p: str) -> bool:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n bool isMatch(string s, string p) {\n return false;\n }\n};"}, "fn": "isMatch", "params": [{"name": "s", "type": "string"}, {"name": "p", "type": "string"}], "outputType": "boolean", "tests": [["aa", "a"], ["aa", "*"], ["cb", "?a"], ["adceb", "*a*b"], ["acdcb", "a*c?b"], ["ab", "?*"], ["aab", "c*a*b"], ["abc", "abc"], ["abc", "a?c"], ["abc", "a*d"], ["", ""], ["a", ""], ["", "a"], ["", "*"], ["", "?"], ["ho", "ho**"], ["ho", "**ho"], ["abcdef", "a*f"], ["abcdef", "a*e"], ["aaaa", "***a"], ["aaabbbaab", "a*******b"], ["abefcdgiescdfimde", "ab*cd*ef*"], ["abcabczzzde", "*abc???def*"], ["mississippi", "m??*ss*?i*pi"], ["abcccd", "*ccd"], ["abcccd", "*c?d"], ["abcd", "****"], ["abcd", "a***d"], ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "*aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa*"], ["aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", "a*b*a*b"]], "expected": [false, true, false, true, false, true, false, true, true, false, true, false, false, true, false, true, true, true, false, true, true, false, false, false, true, true, true, true, true, false], "loose": false}

package/data/problems/word-abbreviation.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "586", "slug": "word-abbreviation", "id": 586, "title": "Word Abbreviation", "difficulty": "Hard", "category": "string", "link": "https://leetcode.com/problems/word-abbreviation/", "examples": [{"input": "words = [\"like\",\"god\",\"internal\",\"me\",\"internet\",\"interval\",\"intension\",\"face\",\"intrusion\"]", "output": "[\"l2e\",\"god\",\"internal\",\"me\",\"i6t\",\"interval\",\"inte4n\",\"f2e\",\"intr4n\"]", "explanation": "\"internal\" and \"interval\" collide until the full word is needed; \"intension\" and \"intrusion\" separate with longer prefixes."}, {"input": "words = [\"abcdef\",\"abcdeg\"]", "output": "[\"a4f\",\"a4g\"]", "explanation": "One-letter prefixes already separate the two words."}, {"input": "words = [\"word\",\"world\",\"would\"]", "output": "[\"w2d\",\"world\",\"would\"]", "explanation": "Further prefixes would not shorten \"world\"/\"would\", so both keep full forms that are already unique."}], "hints": ["Start every word with a one-letter prefix abbreviation, keeping the original when it is not shorter.", "Group words by their current abbreviation; any group with more than one member needs longer prefixes.", "Repeat the growth step until every group holds exactly one word."], "statement": "You are given a list of distinct lowercase words. For each word, build its *abbreviation* as follows: keep a prefix of the word, then write the count of skipped middle characters, then keep the last character. For example, with a one-letter prefix, `word` becomes `w2d` (keep `w`, skip 2 letters, keep `d`).\n\nTwo rules apply:\n- If the abbreviation is not strictly shorter than the original word, keep the original word instead.\n- Abbreviations in the final answer must be pairwise unique, so no two words may share one. Resolve clashes with the *shared-prefix growth rule*: while any abbreviation is used by more than one word, extend the kept prefix by one character for every word in each clashing group and rebuild those abbreviations (keeping the original whenever it is not shorter).\n\nReturn the abbreviations in the same order as the input words.\n\n**Constraints:**\n- `1 <= words.length <= 400`\n- `1 <= words[i].length <= 400`\n- All words are distinct and contain only lowercase English letters.\n", "solution": "## Approach\n\nGive every word a one-letter-prefix abbreviation, falling back to the full word whenever shortening saves nothing. Then repeatedly collect words by their current abbreviation: in any group of two or more, lengthen each member's prefix by one letter and rebuild. Because prefixes only grow and full words are always distinct, the process must settle with all unique results.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * L^2) in the worst case, where n is the word count and L the maximum length, since each word's prefix can grow up to its full length.\n- **Space Complexity:** O(n * L) for the answers and grouping map.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def wordsAbbreviation(self, words: List[str]) -> List[str]:\n def abbr(w, pref):\n if pref + 2 >= len(w):\n return w\n return w[:pref] + str(len(w) - pref - 1) + w[-1]\n n = len(words)\n pref = [1] * n\n ans = [abbr(w, 1) for w in words]\n while True:\n groups = {}\n for i, a in enumerate(ans):\n groups.setdefault(a, []).append(i)\n dup = [g for g in groups.values() if len(g) > 1]\n if not dup:\n break\n for g in dup:\n for i in g:\n pref[i] += 1\n ans[i] = abbr(words[i], pref[i])\n return ans\n```\n", "starter": {"go": "package main\n\nfunc WordsAbbreviation(words []string) []string {\n return []string{}\n}", "python": "from typing import List\nclass Solution:\n def wordsAbbreviation(self, words: List[str]) -> List[str]:\n return []\n", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n vector<string> wordsAbbreviation(vector<string>& words) {\n return {};\n }\n};"}, "fn": "wordsAbbreviation", "params": [{"name": "words", "type": "string_array"}], "outputType": "string_list", "tests": [["[\"like\",\"god\",\"internal\",\"me\",\"internet\",\"interval\",\"intension\",\"face\",\"intrusion\"]"], ["[\"abcdef\",\"abcdeg\"]"], ["[\"word\",\"world\",\"would\"]"], ["[\"a\"]"], ["[\"ab\",\"ac\"]"], ["[\"abc\",\"abd\",\"abe\"]"], ["[\"hello\"]"], ["[\"apple\",\"apply\",\"aptly\"]"], ["[\"test\",\"tent\",\"text\"]"], ["[\"abcdefg\",\"abcdeff\",\"abcdeef\"]"], ["[\"aa\",\"aaa\",\"aaaa\"]"], ["[\"x\",\"xy\",\"xyz\"]"], ["[\"same\",\"samey\",\"samer\"]"], ["[\"abcdef\",\"abcxef\",\"abcyef\"]"], ["[\"qwerty\",\"qwertz\",\"qwertt\"]"], ["[\"aaaaab\",\"aaaaac\",\"aaaaad\"]"], ["[\"ab\",\"abc\",\"abcd\",\"abcde\"]"], ["[\"zz\",\"zzz\",\"zzzz\",\"zzzzz\"]"], ["[\"cat\",\"car\",\"cart\",\"care\"]"], ["[\"dog\",\"dot\",\"dote\",\"dodge\"]"], ["[\"internationalization\",\"localization\"]"], ["[\"accessibility\",\"accessibilities\"]"], ["[\"kite\",\"kit\",\"kits\",\"kiteboarding\"]"], ["[\"book\",\"books\",\"booking\",\"booked\"]"], ["[\"aaaa\",\"aaab\",\"aaba\",\"abaa\"]"], ["[\"m\",\"mm\",\"mmm\",\"mmmm\",\"mmmmm\"]"], ["[\"abcd\",\"abce\",\"abde\",\"acde\"]"], ["[\"abcdefghi\",\"abcdefgjk\",\"abcdefgkl\"]"]], "expected": [["l2e", "god", "internal", "me", "i6t", "interval", "inte4n", "f2e", "intr4n"], ["a4f", "a4g"], ["w2d", "world", "would"], ["a"], ["ab", "ac"], ["abc", "abd", "abe"], ["h3o"], ["a3e", "apply", "aptly"], ["test", "tent", "text"], ["a5g", "abcdeff", "abcdeef"], ["aa", "aaa", "a2a"], ["x", "xy", "xyz"], ["s2e", "s3y", "s3r"], ["abcdef", "abcxef", "abcyef"], ["q4y", "q4z", "q4t"], ["a4b", "a4c", "a4d"], ["ab", "abc", "a2d", "a3e"], ["zz", "zzz", "z2z", "z3z"], ["cat", "car", "c2t", "c2e"], ["dog", "dot", "d2e", "d3e"], ["i18n", "l10n"], ["a11y", "a13s"], ["k2e", "kit", "k2s", "k10g"], ["b2k", "b3s", "b5g", "b4d"], ["aaaa", "a2b", "aaba", "abaa"], ["m", "mm", "mmm", "m2m", "m3m"], ["a2d", "abce", "abde", "acde"], ["a7i", "a7k", "a7l"]], "loose": false}

package/data/problems/word-break-ii.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "213", "slug": "word-break-ii", "id": 213, "title": "Word Break II", "difficulty": "Hard", "category": "dp", "link": "https://leetcode.com/problems/word-break-ii/", "examples": [{"input": "s = \"catsanddog\", wordDict = [\"cat\",\"cats\",\"and\",\"sand\",\"dog\"]", "output": "[\"cats and dog\",\"cat sand dog\"]", "explanation": "Add spaces in \"catsanddog\" so that each word is a valid dictionary word."}, {"input": "s = \"pineapplepenapple\", wordDict = [\"apple\",\"pen\",\"applepen\",\"pine\",\"pineapple\"]", "output": "[\"pine apple pen apple\",\"pineapple pen apple\",\"pine applepen apple\"]", "explanation": "Note that you are allowed to reuse a dictionary word."}, {"input": "s = \"catsandog\", wordDict = [\"cats\",\"dog\",\"sand\",\"and\",\"cat\"]", "output": "[]", "explanation": "The string cannot be segmented into dictionary words, so the result is empty."}], "hints": ["Think of the string positions as cut points: every valid sentence is a sequence of dictionary words that tile `s` from position 0 to the end.", "Use recursion with memoization keyed by the start position to avoid re-computing all suffix segmentations.", "Build each sentence by concatenating a matched word with the space-separated segmentations of the remaining suffix."], "statement": "You are given a string `s` plus a list of strings `wordDict`. Place blanks into `s` so that it becomes a blank-separated sentence in which every token shows up in `wordDict`, and gather every distinct sentence obtainable this way. Return the whole collection in any sequence.\n\nA single dictionary entry may be drawn on repeatedly inside one sentence.\n\n**Constraints:**\n\n- `1 <= s.length <= 20`\n- `1 <= wordDict.length <= 1000`\n- `1 <= wordDict[i].length <= 10`\n- `s` and `wordDict[i]` consist of only lowercase English letters.\n- All the strings of `wordDict` are **unique**.\n- Input is generated in a way that the length of the answer doesn't exceed 10^5.\n", "solution": "## Approach\n\nRecursion with memoization over start positions. At each position `start`, every dictionary word that matches the substring beginning at `start` is a candidate; for each match we append the word to every sentence produced by segmenting the remaining suffix starting at `start + len(word)`. Because the suffix work depends only on the start index, memoizing by position avoids recomputing the same suffix multiple times. The empty sentence at the end of the string serves as the base case.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n * L * R) where n is `s.length`, L is the maximum length of a dictionary word (checked at each position), and R is the number of results produced for a suffix. Since results are memoized per position, each position contributes its combinations only once.\n- **Space Complexity:** O(n * R) for the memoized lists plus the recursion stack depth of O(n).\n\n## Implementation\n\n```python\nfrom typing import List\n\n\nclass Solution:\n def wordBreak(self, s: str, wordDict: List[str]) -> List[str]:\n words = set(wordDict)\n n = len(s)\n memo: dict[int, List[str]] = {}\n\n def break_at(start: int) -> List[str]:\n if start == n:\n return [\"\"]\n if start in memo:\n return memo[start]\n result: List[str] = []\n for word in words:\n if s.startswith(word, start):\n for tail in break_at(start + len(word)):\n result.append(word if not tail else word + \" \" + tail)\n memo[start] = result\n return result\n\n return break_at(0)\n```", "starter": {"go": "package main\n\nfunc WordBreak(s string, wordDict []string) []string {\n \n}", "python": "from typing import List\nclass Solution:\n def wordBreak(self, s: str, wordDict: List[str]) -> List[str]:\n ", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n vector<string> wordBreak(string s, vector<string>& wordDict) {\n \n }\n};"}, "fn": "wordBreak", "params": [{"name": "s", "type": "string"}, {"name": "wordDict", "type": "string_array"}], "outputType": "string_list", "tests": [["a", "[\"a\"]"], ["a", "[\"b\"]"], ["ab", "[\"a\",\"b\",\"ab\"]"], ["catsanddog", "[\"cat\",\"cats\",\"and\",\"sand\",\"dog\"]"], ["catsandog", "[\"cats\",\"dog\",\"sand\",\"and\",\"cat\"]"], ["pineapplepenapple", "[\"apple\",\"pen\",\"applepen\",\"pine\",\"pineapple\"]"], ["aaaa", "[\"a\",\"aa\",\"aaa\"]"], ["aaaaaaa", "[\"aaaa\",\"aa\",\"a\"]"], ["leetcode", "[\"leet\",\"code\",\"lee\",\"tcode\"]"], ["aaaa", "[\"aaaaa\"]"], ["aaaaaaaaaa", "[\"a\",\"aa\"]"], ["abcdef", "[\"abc\",\"def\",\"abcdef\",\"bc\",\"a\",\"d\",\"ef\"]"], ["b", "['a']"], ["ab", "['ab']"], ["aa", "['a']"], ["aaa", "['a', 'aa']"], ["abc", "['a', 'b', 'c']"], ["abcd", "['ab', 'cd']"], ["dogcat", "['dog', 'cat']"], ["catdogcat", "['cat', 'dog']"], ["aaaaa", "['a', 'aa']"], ["abab", "['a', 'b', 'ab']"], ["xyz", "['xy', 'z']"], ["helloworld", "['hello', 'world']"], ["aaaaaaaa", "['a', 'aa', 'aaa']"], ["abcde", "['ab', 'cde']"], ["qq", "['q']"], ["pqr", "['p', 'qr']"], ["aab", "['a', 'ab']"], ["bac", "['b', 'a', 'c']"]], "expected": null, "loose": false}

package/data/problems/word-break.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "20", "slug": "word-break", "id": 20, "title": "Word Break", "difficulty": "Medium", "category": "dp", "link": "https://leetcode.com/problems/word-break/", "examples": [{"input": "s=\"leetcode\", wordDict=[\"leet\",\"code\"]", "output": "true", "explanation": "\"leetcode\" can be segmented into \"leet\" and \"code\", both in the dictionary."}, {"input": "s=\"applepenapple\", wordDict=[\"apple\",\"pen\"]", "output": "true", "explanation": "\"applepenapple\" can be segmented into \"apple\", \"pen\", and \"apple\", all in the dictionary."}], "hints": ["DP over prefixes: dp[i]=true if there exists j<i such that dp[j] and s[j..i) in dict. Optimize by max word length."], "statement": "You receive a string `s` together with a list of strings `wordDict`. Decide whether `s` can be tiled end to end by a chain of one or more pieces such that every piece appears in `wordDict`. Entries from the list may be drawn on any number of times. Return `true` when at least one such tiling exists, and `false` otherwise.\n\n**Constraints:**\n\n- 1 \u2264 s.length \u2264 300\n- 1 \u2264 wordDict.length \u2264 1000\n- 1 \u2264 wordDict[i].length \u2264 20\n- s and wordDict[i] consist of only lowercase English letters.\n- All the strings of wordDict are unique.\n", "solution": "## Approach\n\nUse dynamic programming where dp[i] indicates whether the prefix s[:i] can be segmented into dictionary words. For each position, check all substrings ending at i against the word set.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n\u00b2)\n- **Space Complexity:** O(n)\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def wordBreak(self, s: str, wordDict: List[str]) -> bool:\n words = set(wordDict)\n max_len = max(len(w) for w in wordDict) if wordDict else 0\n dp = [False] * (len(s) + 1)\n dp[0] = True\n for i in range(1, len(s) + 1):\n for j in range(max(0, i - max_len), i):\n if dp[j] and s[j:i] in words:\n dp[i] = True\n break\n return dp[len(s)]\n```\n", "starter": {"go": "package main\n\nfunc WordBreak(s string, wordDict []string) bool {\n \n}", "python": "from typing import List\nclass Solution:\n def wordBreak(self, s: str, wordDict: List[str]) -> bool:\n pass\n", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n bool wordBreak(string s, vector<string>& wordDict) {\n return false;\n }\n};"}, "fn": "wordBreak", "params": [{"name": "s", "type": "string"}, {"name": "wordDict", "type": "string_array"}], "outputType": "boolean", "tests": [["leetcode", "['leet', 'code']"], ["applepenapple", "['apple', 'pen']"], ["catsandog", "['cats', 'dog', 'sand', 'and', 'cat']"], ["@javascript: 'a'.repeat(300)", "['a', 'aa', 'aaa', 'aaaa', 'aaaaa']"], ["a", "['a']"], ["b", "['a']"], ["ab", "['a', 'b']"], ["aa", "['a']"], ["abc", "['ab', 'c']"], ["aaaa", "['a', 'aa']"], ["abcd", "['a', 'b', 'c', 'd']"], ["catsanddog", "['cat', 'cats', 'and', 'sand', 'dog']"], ["cars", "['car', 'ca', 'rs']"], ["helloworld", "['hello', 'world']"], ["helloworldx", "['hello', 'world']"], ["aaaaaaaab", "['a', 'aa', 'aaa']"], ["bb", "['b', 'bb']"], ["abcabc", "['abc']"], ["abbc", "['ab', 'bc']"], ["pineapple", "['pine', 'apple']"], ["pineapplepie", "['pine', 'apple', 'pie']"], ["qqqqq", "['qq', 'qqq']"], ["abcdabcd", "['ab', 'cd']"], ["zzzzzzzzzz", "['z', 'zz', 'zzz']"], ["abcdefghij", "['ab', 'cd', 'ef', 'gh', 'ij']"], ["abcdefghijk", "['ab', 'cd', 'ef', 'gh', 'ij']"], ["aaaaaaaaaaaaaaaaaaaa", "['a', 'aa', 'aaa', 'aaaa']"], ["aaaaaaaaaaaaaaaaaaaab", "['a', 'aa', 'aaa', 'aaaa']"], ["dogcatdog", "['dog', 'cat']"], ["onetwothree", "['one', 'two', 'three']"]], "expected": null, "loose": false}

package/data/problems/word-ladder-ii.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "299", "slug": "word-ladder-ii", "id": 299, "title": "Word Ladder II", "difficulty": "Hard", "category": "graph", "link": "https://leetcode.com/problems/word-ladder-ii/", "examples": [{"input": "beginWord = \"hit\", endWord = \"cog\", wordList = [\"hot\",\"dot\",\"dog\",\"lot\",\"log\",\"cog\"]", "output": "[[\"hit\",\"hot\",\"dot\",\"dog\",\"cog\"],[\"hit\",\"hot\",\"lot\",\"log\",\"cog\"]]", "explanation": "Both ladders use 5 words, which is minimal here."}, {"input": "beginWord = \"hit\", endWord = \"cog\", wordList = [\"hot\",\"dot\",\"dog\",\"lot\",\"log\"]", "output": "[]", "explanation": "Without \"cog\" in the dictionary the target is unreachable."}], "hints": ["BFS from the start records the shortest distance to each reachable word.", "Revisit words level by level so every shortest predecessor is captured.", "DFS backwards from the target through predecessors to enumerate all shortest ladders."], "statement": "A ladder from `beginWord` to `endWord` is a chain where neighboring words differ by exactly one letter, every middle word belongs to `wordList`, and the final word equals `endWord`. The starting word itself does not need to appear in `wordList`.\n\nReturn every shortest possible ladder as a list of words from start to finish. If no ladder exists, return an empty list. The order of the ladders does not matter.\n\n**Constraints:**\n- `1 <= beginWord.length <= 5`\n- `endWord.length == beginWord.length`\n- `1 <= wordList.length <= 500`\n- `wordList[i].length == beginWord.length`\n- All strings use lowercase English letters.\n- `beginWord != endWord`\n- All `wordList` entries are unique.\n\n**Adaptation note:** The original return type is `List<List<String>>`. Here it is `string_list_2d`, with order-insensitive grading: any permutation of the ladder set is accepted.\n", "solution": "## Approach\n\nRun BFS from the start word, recording the shortest distance to every reachable dictionary word and all predecessors that achieve that distance. Words are discovered level by level so that each word's predecessor list contains exactly the neighbors one step closer to the start. Then DFS from the target back through predecessors enumerates every shortest ladder.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(N * L * 26), where N is the dictionary size and L is the word length, plus output size for enumeration.\n- **Space Complexity:** O(N * L) for distances, predecessors, and the queue.\n\n## Implementation\n\n```python\nfrom typing import List\nfrom collections import deque, defaultdict\nclass Solution:\n def findLadders(self, beginWord: str, endWord: str, wordList: List[str]) -> List[List[str]]:\n words = set(wordList)\n if endWord not in words:\n return []\n words.add(beginWord)\n dist = {beginWord: 0}\n pred = defaultdict(list)\n q = deque([beginWord])\n level = 0\n found = False\n while q and not found:\n level += 1\n for _ in range(len(q)):\n word = q.popleft()\n arr = list(word)\n for i in range(len(arr)):\n orig = arr[i]\n for c in \"abcdefghijklmnopqrstuvwxyz\":\n if c == orig:\n continue\n arr[i] = c\n nb = \"\".join(arr)\n if nb not in words:\n continue\n if nb not in dist:\n dist[nb] = level\n pred[nb].append(word)\n q.append(nb)\n if nb == endWord:\n found = True\n elif dist[nb] == level:\n pred[nb].append(word)\n arr[i] = orig\n if endWord not in dist:\n return []\n ans = []\n path = [endWord]\n def dfs(cur):\n if cur == beginWord:\n ans.append(list(reversed(path)))\n return\n for p in pred[cur]:\n path.append(p)\n dfs(p)\n path.pop()\n dfs(endWord)\n return ans\n```\n", "starter": {"go": "package main\n\nfunc FindLadders(beginWord string, endWord string, wordList []string) [][]string {\n return [][]string{}\n}", "python": "from typing import List\nclass Solution:\n def findLadders(self, beginWord: str, endWord: str, wordList: List[str]) -> List[List[str]]:\n return []", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<vector<string>> findLadders(string beginWord, string endWord, vector<string>& wordList) {\n return {};\n }\n};"}, "fn": "findLadders", "params": [{"name": "beginWord", "type": "string"}, {"name": "endWord", "type": "string"}, {"name": "wordList", "type": "string_array"}], "outputType": "string_list_2d", "tests": [["hit", "cog", "['hot', 'dot', 'dog', 'lot', 'log', 'cog']"], ["hit", "cog", "['hot', 'dot', 'dog', 'lot', 'log']"], ["a", "c", "['a', 'b', 'c']"], ["hot", "dog", "['hot', 'dog', 'dot']"], ["red", "tax", "['ted', 'tex', 'red', 'tax', 'tad', 'den', 'rex', 'pee']"], ["hit", "cog", "['hot', 'dot', 'dog', 'lot', 'log', 'cog', 'hog', 'hig']"], ["aa", "bb", "['ab', 'ba', 'aa', 'bb']"], ["ab", "ba", "['ab', 'ba', 'aa', 'bb']"], ["a", "b", "['a', 'b']"], ["a", "b", "['c', 'd']"], ["lost", "cost", "['most', 'mist', 'miss', 'lost', 'cost']"], ["cat", "dog", "['cat', 'bat', 'bot', 'bog', 'dog', 'cog', 'cot']"], ["kiss", "tusk", "['miss', 'disk', 'kiss', 'dusk', 'tusk', 'risk', 'musk']"], ["qa", "qb", "['qa', 'qb', 'qc']"], ["hot", "dot", "['hot', 'dot', 'lot', 'hit']"], ["talk", "tail", "['talk', 'tall', 'tail']"], ["cold", "warm", "['cold', 'cord', 'card', 'ward', 'warm', 'corm']"], ["game", "thee", "['game', 'gane', 'tane', 'thane', 'thee', 'gave']"], ["cet", "ism", "['cet', 'cat', 'bat', 'bit', 'bim', 'ism', 'sim']"], ["hit", "hot", "['hot', 'hit', 'hit']"], ["ab", "cd", "['ab', 'ac', 'ad', 'cd', 'bd']"], ["dog", "cat", "['dog', 'dot', 'cot', 'cat']"], ["sand", "acne", "['sand', 'acne']"], ["code", "coke", "['code', 'coke', 'cake', 'coke']"], ["b", "c", "['b', 'c', 'a']"], ["nanny", "aloud", "['nanny', 'aloud', 'nancy']"], ["zz", "aa", "['za', 'az', 'aa', 'zz']"], ["teach", "place", "['teach', 'peach', 'place']"]], "expected": null, "loose": false}

package/data/problems/word-ladder.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "121", "slug": "word-ladder", "id": 121, "title": "Word Ladder", "difficulty": "Hard", "category": "graph", "link": "https://leetcode.com/problems/word-ladder/", "examples": [{"input": "beginWord = \"hit\", endWord = \"cog\", wordList = [\"hot\",\"dot\",\"dog\",\"lot\",\"log\",\"cog\"]", "output": "5", "explanation": "One shortest sequence is hit -> hot -> dot -> dog -> cog."}, {"input": "beginWord = \"hit\", endWord = \"cog\", wordList = [\"hot\",\"dot\",\"dog\",\"lot\",\"log\"]", "output": "0", "explanation": "The end word is not in the list."}], "hints": ["Words are graph nodes; two words share an edge when they differ in exactly one position.", "Generate neighbors by replacing each character with every lowercase letter instead of comparing every pair of words.", "Bidirectional BFS from beginWord and endWord can substantially reduce the explored search space."], "statement": "You are given a starting string `beginWord`, a destination string `endWord`, and a pool of strings `wordList`. Consider chains that open with `beginWord` and finish at `endWord`, alter precisely one letter between consecutive links, and draw every link after the first from `wordList`.\n\nAmong all such chains, return how many strings the briefest one holds, counting both the opening and the closing string. When the two ends cannot be connected this way, return `0`.\n\n**Constraints:**\n\n- `1 <= beginWord.length <= 10`\n- `endWord.length == beginWord.length`\n- `1 <= wordList.length <= 5000`\n- Every word contains only lowercase English letters and has the same length as `beginWord`.\n- All words in `wordList` are unique.\n- `beginWord != endWord`\n", "solution": "## Approach\n\nStore unused dictionary words in a set and run bidirectional breadth-first search from `beginWord` and `endWord`. Always expand the smaller frontier, generating neighbors by replacing one character with each lowercase letter. The first generated word in the opposite frontier completes a shortest transformation sequence.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(N * L^2) for a fixed 26-letter alphabet, where N is the number of words and L is their length; constructing each generated Python string costs O(L).\n- **Space Complexity:** O(N * L) for the dictionary and BFS frontiers.\n\n## Implementation\n\n```python\nfrom typing import List\n\n\nclass Solution:\n def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:\n unused = set(wordList)\n if endWord not in unused:\n return 0\n\n front = {beginWord}\n back = {endWord}\n unused.discard(beginWord)\n unused.discard(endWord)\n length = 1\n\n while front and back:\n if len(front) > len(back):\n front, back = back, front\n\n next_front = set()\n for word in front:\n chars = list(word)\n for i, original in enumerate(chars):\n for code in range(ord(\"a\"), ord(\"z\") + 1):\n replacement = chr(code)\n if replacement == original:\n continue\n chars[i] = replacement\n candidate = \"\".join(chars)\n if candidate in back:\n return length + 1\n if candidate in unused:\n unused.remove(candidate)\n next_front.add(candidate)\n chars[i] = original\n\n front = next_front\n length += 1\n\n return 0\n```\n", "starter": {"go": "package main\n\nfunc LadderLength(beginWord string, endWord string, wordList []string) int {\n return 0\n}\n", "python": "from typing import List\n\nclass Solution:\n def ladderLength(self, beginWord: str, endWord: str, wordList: List[str]) -> int:\n return 0\n", "cpp": "#include <string>\n#include <vector>\nusing namespace std;\n\nclass Solution {\npublic:\n int ladderLength(string beginWord, string endWord, vector<string>& wordList) {\n return 0;\n }\n};"}, "fn": "ladderLength", "params": [{"name": "beginWord", "type": "string"}, {"name": "endWord", "type": "string"}, {"name": "wordList", "type": "string_array"}], "outputType": "int", "tests": [["hit", "cog", "[\"hot\",\"dot\",\"dog\",\"lot\",\"log\",\"cog\"]"], ["hit", "cog", "[\"hot\",\"dot\",\"dog\",\"lot\",\"log\"]"], ["a", "c", "[\"a\",\"b\",\"c\"]"], ["a", "z", "[\"z\"]"], ["a", "b", "[\"c\",\"d\"]"], ["aa", "bb", "[\"ab\",\"bb\"]"], ["aa", "bb", "[\"ba\",\"bb\"]"], ["aa", "bb", "[\"ab\",\"ba\",\"bb\"]"], ["aa", "zz", "[\"az\",\"za\",\"aa\"]"], ["ab", "cd", "[\"ad\",\"cd\",\"cb\"]"], ["ab", "cd", "[\"ac\",\"cc\",\"cd\"]"], ["ab", "cd", "[\"cb\",\"cd\",\"ad\",\"bd\"]"], ["az", "za", "[\"aa\",\"za\"]"], ["az", "za", "[\"zz\",\"za\"]"], ["go", "me", "[\"ge\",\"me\",\"mo\"]"], ["cat", "dog", "[\"cot\",\"cog\",\"dog\"]"], ["cat", "dog", "[\"dat\",\"dot\",\"dog\"]"], ["cat", "dog", "[\"cot\",\"dot\",\"dog\",\"cog\"]"], ["cat", "dog", "[\"cot\",\"cog\",\"dig\",\"fig\"]"], ["red", "tax", "[\"ted\",\"tex\",\"red\",\"tax\",\"tad\",\"den\",\"rex\",\"pee\"]"], ["hot", "dog", "[\"hot\",\"dog\",\"dot\"]"], ["hot", "dog", "[\"dog\"]"], ["lost", "cost", "[\"cost\"]"], ["lost", "miss", "[\"most\",\"mist\",\"miss\"]"], ["lost", "miss", "[\"list\",\"mist\",\"miss\"]"], ["lost", "miss", "[\"most\",\"mist\",\"miss\",\"moss\",\"mass\"]"], ["cold", "warm", "[\"cord\",\"card\",\"ward\",\"warm\"]"], ["cold", "warm", "[\"cord\",\"word\",\"worm\",\"warm\"]"], ["cold", "warm", "[\"bold\",\"bald\",\"bard\",\"ward\",\"warm\"]"], ["cold", "warm", "[\"cord\",\"card\",\"ward\",\"warn\"]"], ["same", "diff", "[\"dame\",\"dime\",\"dire\",\"dirt\",\"dirf\",\"diff\"]"], ["same", "diff", "[\"some\",\"dome\",\"dime\",\"dire\",\"diff\"]"], ["same", "diff", "[\"sime\",\"dime\",\"dife\",\"diff\"]"], ["same", "diff", "[\"dame\",\"dime\",\"dire\",\"dirt\"]"], ["stone", "money", "[\"stony\",\"atony\",\"money\"]"], ["stone", "money", "[\"stony\",\"story\",\"store\",\"money\"]"], ["stone", "money", "[\"stony\",\"stoey\",\"mopey\",\"money\"]"], ["stone", "money", "[\"atone\",\"alone\",\"clone\",\"clove\",\"glove\",\"glory\",\"money\"]"], ["aaaa", "bbbb", "[\"baaa\",\"bbaa\",\"bbba\",\"bbbb\"]"], ["aaaa", "bbbb", "[\"aaab\",\"aabb\",\"abbb\",\"bbbb\"]"], ["aaaa", "bbbb", "[\"baaa\",\"abaa\",\"aaba\",\"aaab\",\"bbbb\"]"], ["aaaa", "bbbb", "[\"baaa\",\"bbaa\",\"bbba\",\"bbbb\",\"aaab\",\"aabb\",\"abbb\"]"], ["lead", "gold", "[\"load\",\"goad\",\"gold\"]"], ["lead", "gold", "[\"lend\",\"land\",\"load\",\"goad\",\"gold\"]"], ["lead", "gold", "[\"load\",\"goad\",\"goat\",\"goal\"]"], ["talk", "tail", "[\"tall\",\"tail\"]"], ["talk", "tail", "[\"task\",\"tusk\",\"tuil\",\"tail\"]"], ["talk", "tail", "[\"tall\",\"tell\",\"teal\",\"tail\"]"], ["code", "data", "[\"cade\",\"cate\",\"date\",\"data\"]"], ["code", "data", "[\"coda\",\"doda\",\"data\"]"], ["code", "data", "[\"cade\",\"cate\",\"date\",\"data\",\"coda\",\"doda\"]"], ["code", "data", "[\"cade\",\"cate\",\"date\",\"dote\",\"done\"]"], ["aaaaaaaaaa", "zzzzzzzzzz", "@javascript:(()=>{const words=[];for(let value=0;value<2490;value++){let number=value,suffix='';for(let i=0;i<9;i++){suffix=String.fromCharCode(97+number%26)+suffix;number=Math.floor(number/26);}words.push('m'+suffix);}for(let length=1;length<=10;length++){words.push('z'.repeat(length)+'a'.repeat(10-length));}return JSON.stringify(words);})()"]], "expected": [5, 0, 2, 2, 0, 3, 3, 3, 0, 3, 4, 3, 3, 3, 3, 4, 4, 4, 0, 4, 3, 0, 2, 4, 4, 4, 5, 5, 6, 0, 6, 0, 5, 0, 0, 0, 0, 0, 5, 5, 0, 5, 4, 4, 0, 3, 0, 3, 5, 0, 5, 0, 11], "loose": false}

package/data/problems/word-pattern-ii.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "387", "slug": "word-pattern-ii", "id": 387, "title": "Word Pattern II", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/word-pattern-ii/", "examples": [{"input": "pattern = \"abab\", s = \"redblueredblue\"", "output": "true", "explanation": "'a' maps to \"red\" and 'b' maps to \"blue\"."}, {"input": "pattern = \"aaaa\", s = \"asdasdasdasd\"", "output": "true", "explanation": "Each 'a' maps to \"asd\"."}, {"input": "pattern = \"aabb\", s = \"xyzabcxzyabc\"", "output": "false", "explanation": "No bijective block mapping rebuilds the text."}], "hints": ["Try assigning the next pattern letter to every possible non-empty block starting at the current text position, then solve the rest recursively.", "Keep both directions of the mapping: letter -> block and used blocks, so two letters never share one block.", "When a letter already has a block, simply check the text continues with that block instead of guessing again."], "statement": "You are given a `pattern` string made of lowercase English letters and a text string `s`.\nDecide whether `s` follows the pattern: every pattern letter must stand for one non-empty\nblock of characters, the same letter always stands for the same block, and two different\nletters must stand for two different blocks. Concatenating the blocks in pattern order must\nreproduce `s` exactly.\n\n**Constraints:**\n- `1 <= pattern.length <= 20`\n- `1 <= s.length <= 20`\n- `pattern` and `s` contain only lowercase English letters.\n", "solution": "## Approach\n\nBacktrack over the pattern: bind each new letter to every feasible next block and recurse, enforcing a two-way (bijective) mapping.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n^m) worst case\n- **Space Complexity:** O(m + n)\n\n## Implementation\n\n```python\nclass Solution:\n def wordPatternMatch(self, pattern: str, s: str) -> bool:\n mapping, used = {}, set()\n def dfs(i: int, j: int) -> bool:\n if i == len(pattern):\n return j == len(s)\n c = pattern[i]\n if c in mapping:\n w = mapping[c]\n return s.startswith(w, j) and dfs(i + 1, j + len(w))\n for k in range(j + 1, len(s) + 1):\n w = s[j:k]\n if w in used:\n continue\n mapping[c] = w\n used.add(w)\n if dfs(i + 1, k):\n return True\n del mapping[c]\n used.remove(w)\n return False\n return dfs(0, 0)\n```\n", "starter": {"go": "package main\n\nfunc WordPatternMatch(pattern string, s string) bool {\n return false\n}", "python": "class Solution:\n def wordPatternMatch(self, pattern: str, s: str) -> bool:\n ", "cpp": "#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n bool wordPatternMatch(string pattern, string s) {\n return false;\n }\n};"}, "fn": "wordPatternMatch", "params": [{"name": "pattern", "type": "string"}, {"name": "s", "type": "string"}], "outputType": "boolean", "tests": [["abab", "redblueredblue"], ["aaaa", "asdasdasdasd"], ["aabb", "xyzabcxzyabc"], ["a", "x"], ["a", ""], ["ab", "aa"], ["aa", "ab"], ["ab", "ab"], ["abc", "xyz"], ["abc", "xxyyzz"], ["aba", "catcatcat"], ["abba", "redbluebluered"], ["abba", "redblueredblue"], ["aaaa", "abcd"], ["abcabc", "abccbaabccba"], ["abcd", "abcd"], ["abca", "redblueredred"], ["abca", "redbluegreenred"], ["aab", "xxxy"], ["aab", "xxyy"], ["abbb", "xyyy"], ["abbb", "xyyx"], ["abcba", "mnomnom"], ["abcba", "redblueredblue"], ["ab", "qwertyqwerty"], ["ba", "qwertyqwerty"], ["aaab", "aaab"], ["abbbba", "xyyyyyx"]], "expected": [true, true, false, true, false, false, false, true, true, true, false, true, false, false, true, true, true, true, true, true, true, false, false, false, true, true, true, false], "loose": false}

package/data/problems/word-pattern.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "386", "slug": "word-pattern", "id": 386, "title": "Word Pattern", "difficulty": "Easy", "category": "string", "link": "https://leetcode.com/problems/word-pattern/", "examples": [{"input": "pattern = \"abba\", s = \"dog cat cat dog\"", "output": "true", "explanation": "a maps to dog and b maps to cat bijectively."}, {"input": "pattern = \"abba\", s = \"dog cat cat fish\"", "output": "false", "explanation": "The last fish breaks the a-dog pairing."}, {"input": "pattern = \"aaaa\", s = \"dog cat cat dog\"", "output": "false", "explanation": "One letter cannot map to two different words."}], "hints": ["Split s on single spaces; lengths of pattern and word list must match.", "Enforce a bijection with two maps (letter->word and word->letter).", "Reject when one side would map to two different partners."], "statement": "Check whether the sentence `s` follows the letter pattern.\n\nEach letter in `pattern` must map to exactly one distinct word in `s` and\neach word to exactly one letter (a bijection). Words in `s` are separated by\nsingle spaces with no leading or trailing gaps. Implement\n`wordPattern(pattern, s)` returning true on a full match.\n\n**Constraints:**\n- `1 <= pattern.length <= 300`, lowercase letters.\n- `1 <= s.length <= 3000`, lowercase letters and single spaces.\n", "solution": "## Approach\n\nSplit the sentence into words and require equal length to the pattern. Maintain forward and reverse maps while scanning pairs; any conflict means no bijection.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n) over pattern plus words.\n- **Space Complexity:** O(k) for distinct symbols.\n\n## Implementation\n\n```python\nclass Solution:\n def wordPattern(self, pattern: str, s: str) -> bool:\n words = s.split(\" \")\n if len(words) != len(pattern):\n return False\n c2w: dict[str, str] = {}\n w2c: dict[str, str] = {}\n for c, w in zip(pattern, words):\n if c in c2w and c2w[c] != w:\n return False\n if w in w2c and w2c[w] != c:\n return False\n c2w[c] = w\n w2c[w] = c\n return True\n```\n", "starter": {"go": "package main\n\nfunc WordPattern(pattern string, s string) bool {\n \n}", "python": "class Solution:\n def wordPattern(self, pattern: str, s: str) -> bool:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n bool wordPattern(string pattern, string s) {\n return false;\n }\n};"}, "fn": "wordPattern", "params": [{"name": "pattern", "type": "string"}, {"name": "s", "type": "string"}], "outputType": "boolean", "tests": [["abba", "dog cat cat dog"], ["abba", "dog cat cat fish"], ["aaaa", "dog cat cat dog"], ["abba", "dog dog dog dog"], ["a", "x"], ["ab", "dog cat"], ["abc", "dog cat fish"], ["abc", "dog cat dog"], ["abba", "dog cat cat dog extra"], ["a", "a a a a"], ["abca", "dog cat fish dog"], ["abcd", "one two three four"], ["aaaa", "dog dog dog dog"], ["ab", "dog dog"], ["aa", "dog cat"], ["abc", "b c a"], ["aba", "dog cat dog"], ["aba", "dog cat cat"], ["a", "a"], ["abba", "cat dog dog cat"], ["ab", "dog fish"], ["aa", "dog dog"], ["ab", "dog cat cat"], ["abcba", "a b c b a"], ["abc", "a a a"], ["abbc", "dog cat cat dog"], ["abcd", "a b c d"], ["aaaa", "a a a"], ["xyz", "foo bar baz"], ["abab", "dog cat dog cat"]], "expected": [true, false, false, false, true, true, true, false, false, false, true, true, true, false, false, true, true, false, true, true, true, true, false, true, false, false, true, false, true, true], "loose": false}

package/data/problems/word-search-ii.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "73", "slug": "word-search-ii", "id": 73, "title": "Word Search II", "difficulty": "Hard", "category": "tree", "link": "https://leetcode.com/problems/word-search-ii/", "examples": [{"input": "board = [[a,b,c,e],[s,f,c,s],[a,d,e,e]], words = [see,abcced,abcb]", "output": "[see,abcced]", "explanation": "\"see\" is found via s(1,3)->e(2,3)->e(2,2). \"abcced\" is found via a(0,0)->b(0,1)->c(0,2)->c(1,2)->e(2,2)->d(2,1). \"abcb\" has no valid path."}], "hints": ["Build a trie of words and backtrack from each cell, pruning via the trie; mark visited cells and collect matches once per word."], "statement": "You receive a character grid `board` with `m` rows and `n` columns, together with a list of strings `words`. Collect every entry of `words` that can be traced on the grid by walking from cell to orthogonally touching cell (upward, downward, leftward, or rightward) in letter order, never stepping onto one cell twice while tracing a single entry. Return the subset of entries for which at least one such walk exists.\n\n**Constraints:**\n\n- m == board.length\n- n == board[i].length\n- 1 \u2264 m, n \u2264 12\n- board[i][j] is a lowercase English letter.\n- 1 \u2264 words.length \u2264 3 * 10^4\n- 1 \u2264 words[i].length \u2264 10\n- words[i] consists of lowercase English letters.\n- All the strings of words are unique.\n", "solution": "## Approach\n\nBuild a trie of all target words, then perform DFS from each cell on the board, pruning the search when the current path no longer matches any prefix in the trie.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m\u00d7n\u00d74^L)\n- **Space Complexity:** O(total characters in words)\n\n## Implementation\n\n```python\nfrom typing import List\nclass TrieNode:\n def __init__(self):\n self.children = {}\n self.word = None\nclass Solution:\n def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:\n root = TrieNode()\n for w in words:\n node = root\n for c in w:\n if c not in node.children:\n node.children[c] = TrieNode()\n node = node.children[c]\n node.word = w\n m, n = len(board), len(board[0])\n res = set()\n def dfs(i, j, node):\n if i < 0 or i >= m or j < 0 or j >= n:\n return\n c = board[i][j]\n if c not in node.children:\n return\n node = node.children[c]\n if node.word:\n res.add(node.word)\n board[i][j] = '#'\n for di, dj in ((1,0),(-1,0),(0,1),(0,-1)):\n dfs(i + di, j + dj, node)\n board[i][j] = c\n for i in range(m):\n for j in range(n):\n dfs(i, j, root)\n return list(res)\n```\n", "starter": {"go": "package main\n\nfunc FindWords(board [][]byte, words []string) []string {\n \n}", "python": "from typing import List\nclass Solution:\n def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:\n return []\n", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n vector<string> findWords(vector<vector<char>>& board, vector<string>& words) {\n return {};\n }\n};"}, "fn": "findWords", "params": [{"name": "board", "type": "char_array_2d", "visualizeType": "matrix"}, {"name": "words", "type": "string_array"}], "outputType": "string_list", "tests": [["[['o', 'a', 'a', 'n'], ['e', 't', 'a', 'e'], ['i', 'h', 'k', 'r'], ['i', 'f', 'l', 'v']]", "['oath', 'pea', 'eat', 'rain']"], ["[['a', 'b'], ['c', 'd']]", "['ab', 'cb', 'ad', 'bd', 'ac', 'ca', 'da', 'bc', 'db', 'adcb', 'dabc', 'abb', 'acb']"], ["[['a', 'a']]", "['aaa']"], ["[['a']]", "['a']"], ["[['a']]", "['b']"], ["[['a', 'b']]", "['ab', 'ba']"], ["[['a'], ['b']]", "['ab', 'ba']"], ["[['c', 'a', 't'], ['d', 'o', 'g']]", "['cat', 'dog', 'cog', 'tag']"], ["[['a', 'b'], ['c', 'd'], ['e', 'f']]", "['ab', 'cd', 'ef', 'abcdef']"], ["[['x']]", "['x', 'xx', 'y']"], ["[['a', 'a'], ['a', 'a']]", "['aa', 'aaa', 'aaaa']"], ["[['s', 'e', 'e'], ['a', 'b', 'c']]", "['see', 'sea', 'abc']"], ["[['h', 'e', 'l', 'l', 'o']]", "['hello', 'hell', 'ole']"], ["[['m']]", "['m', 'n', 'mm']"], ["[['a', 'b', 'c'], ['d', 'e', 'f']]", "['abcdef', 'fedcba', 'ace']"], ["[['z', 'z'], ['z', 'z']]", "['z', 'zz', 'zzz', 'zzzz']"], ["[['p', 'y']]", "['py', 'yp', 'ppy']"], ["[['q', 'w', 'e']]", "['qwe', 'ewq', 'qw']"], ["[['a', 'b', 'c', 'd']]", "['abcd', 'dcba', 'ac']"], ["[['t', 'a', 'p']]", "['tap', 'pat', 'apt']"], ["[['a', 'b'], ['b', 'a']]", "['ab', 'ba', 'aba']"], ["[['l', 'e', 'e', 't']]", "['leet', 'leetco', 'teel']"], ["[['c', 'o', 'd', 'e']]", "['code', 'decode', 'ecod']"], ["[['a', 'c'], ['e', 'g']]", "['aceg', 'geca', 'ac']"], ["[['r', 'a', 'i', 'n']]", "['rain', 'niar', 'ran']"], ["[['a', 'b', 'c'], ['c', 'b', 'a']]", "['abc', 'cba', 'abccba']"], ["[['d', 'o', 'g']]", "['dog', 'god', 'do']"], ["[['k', 'i', 't', 'e']]", "['kite', 'etik', 'kit']"], ["[['b', 'a', 'd']]", "['bad', 'dab', 'adb']"], ["[['f', 'o', 'o']]", "['foo', 'oof', 'of']"]], "expected": null, "loose": false}

package/data/problems/word-search.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "49", "slug": "word-search", "id": 49, "title": "Word Search", "difficulty": "Medium", "category": "matrix", "link": "https://leetcode.com/problems/word-search/", "examples": [{"input": "board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"ABCCED\"", "output": "true", "explanation": "The word \"ABCCED\" can be found in the board via adjacent cells."}, {"input": "board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"SEE\"", "output": "true", "explanation": "The word \"SEE\" can be found in the board via adjacent cells."}, {"input": "board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"ABCB\"", "output": "false", "explanation": "The word \"ABCB\" does not exist in the board."}], "hints": ["Backtracking/DFS from each starting cell, marking visited cells, exploring four directions, and backtracking on mismatch."], "statement": "You are handed a rectangular arrangement `board` of `m` rows by `n` columns holding single characters, plus a target string `word`. Decide whether `word` can be traced across the arrangement by stepping from cell to orthogonally touching cell \u2014 upward, downward, leftward, or rightward \u2014 matching its letters in order, without stepping onto any single cell twice within the same trace. Return `true` when such a trace exists, and `false` otherwise.\n\n**Constraints:**\n\n- m == board.length\n- n = board[i].length\n- 1 \u2264 m, n \u2264 6\n- 1 \u2264 word.length \u2264 15\n- board and word consists of only lowercase and uppercase English letters.\n", "solution": "## Approach\n\nUse DFS with backtracking from each cell, marking visited cells with a temporary placeholder to avoid reuse, and exploring all four directions.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(m\u00d7n\u00d74^L)\n- **Space Complexity:** O(L)\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def exist(self, board: List[List[str]], word: str) -> bool:\n m, n = len(board), len(board[0])\n def dfs(i, j, k):\n if k == len(word):\n return True\n if i < 0 or i >= m or j < 0 or j >= n or board[i][j] != word[k]:\n return False\n tmp = board[i][j]\n board[i][j] = '#'\n if dfs(i+1,j,k+1) or dfs(i-1,j,k+1) or dfs(i,j+1,k+1) or dfs(i,j-1,k+1):\n return True\n board[i][j] = tmp\n return False\n for i in range(m):\n for j in range(n):\n if dfs(i, j, 0):\n return True\n return False\n```\n", "starter": {"go": "package main\n\nfunc Exist(board [][]byte, word string) bool {\n \n}", "python": "from typing import List\nclass Solution:\n def exist(self, board: List[List[str]], word: str) -> bool:\n pass\n", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n bool exist(vector<vector<char>>& board, string word) {\n return false;\n }\n};"}, "fn": "exist", "params": [{"name": "board", "type": "char_array_2d", "visualizeType": "matrix"}, {"name": "word", "type": "string"}], "outputType": "boolean", "tests": [["[[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]]", "ABCCED"], ["[[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]]", "SEE"], ["[[\"A\",\"B\"],[\"C\",\"D\"]]", "ABCD"], ["[[\"A\"]]", "A"], ["[[\"A\"]]", "B"], ["[[\"A\",\"B\"],[\"C\",\"D\"]]", "ACDB"], ["[[\"A\",\"B\"],[\"C\",\"D\"]]", "ACBD"], ["[[\"a\"]]", "aa"], ["[[\"a\",\"b\",\"c\"]]", "abc"], ["[[\"a\",\"b\",\"c\"]]", "acb"], ["[[\"x\",\"y\"],[\"z\",\"w\"]]", "xywz"], ["[[\"p\",\"q\",\"r\"],[\"s\",\"t\",\"u\"]]", "pqrstu"], ["[[\"A\",\"a\"],[\"b\",\"B\"]]", "AaBb"], ["[[\"Z\"]]", "ZZZZZZZZZZZZZZZ"], ["[[\"m\",\"n\"],[\"o\",\"p\"]]", "mnpo"], ["[[\"a\",\"a\",\"a\"],[\"a\",\"a\",\"a\"]]", "aaaaaaa"], ["[[\"a\",\"a\",\"a\"],[\"a\",\"a\",\"a\"]]", "aaaaaaaaaaa"], ["[[\"A\",\"B\",\"C\"]]", "ABC"], ["[[\"A\",\"B\",\"C\"]]", "CBA"], ["[[\"k\"]]", "k"], ["[[\"H\",\"e\",\"l\",\"l\",\"o\"]]", "Hello"], ["[[\"a\",\"b\"],[\"d\",\"c\"]]", "abcd"], ["[[\"T\",\"E\",\"S\",\"T\"]]", "TESTEST"], ["[[\"q\",\"w\"],[\"e\",\"r\"],[\"t\",\"y\"]]", "qwerty"], ["[[\"a\",\"B\",\"c\",\"D\",\"e\"]]", "aBcDe"], ["[[\"M\"]]", "N"], ["[[\"A\",\"B\",\"C\",\"D\",\"E\",\"F\"]]", "ABCDEF"], ["[[\"A\",\"B\",\"C\",\"D\",\"E\",\"F\"]]", "FEDCBA"], ["[[\"g\",\"o\",\"o\",\"d\"]]", "good"], ["[[\"U\",\"V\"],[\"W\",\"X\"],[\"Y\",\"Z\"]]", "VWXYZU"]], "expected": [true, true, false, true, false, true, false, false, true, false, true, false, true, false, true, false, false, true, true, true, true, true, false, false, true, false, true, true, true, false], "loose": false}

package/data/problems/word-squares.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "495", "slug": "word-squares", "id": 495, "title": "Word Squares", "difficulty": "Hard", "category": "string", "link": "https://leetcode.com/problems/word-squares/", "examples": [{"input": "words=[\"area\",\"lead\",\"wall\",\"lady\",\"ball\"]", "output": "[[\"wall\",\"area\",\"lead\",\"lady\"],[\"ball\",\"area\",\"lead\",\"lady\"]]", "explanation": "Both arrangements read the same across rows and down columns."}, {"input": "words=[\"abat\",\"baba\",\"atan\",\"atal\"]", "output": "[[\"baba\",\"abat\",\"baba\",\"atan\"],[\"baba\",\"abat\",\"baba\",\"atal\"]]", "explanation": "Each arrangement mirrors along the diagonal."}], "hints": ["Index every word by each of its prefixes so the required next-row prefix is a fast lookup.", "Grow squares row by row: the next needed prefix is spelled by the latest column characters.", "Backtrack and record a copy once the square reaches full size."], "statement": "You receive a dictionary `words` holding distinct lowercase strings, all sharing one length. A word square is a sequence of that same length where row `k` and column `k` spell the same word for every `k`. In other words, if the sequence is `r0, r1, ..., r_{n-1}`, then the `j`-th letter of `ri` must equal the `j`-th letter of `rj` pattern: the prefix formed by the first `t` rows constrains which word may sit in row `t`.\n\nList every word square you can assemble from `words`. Words may be reused. The order of the returned squares does not matter.\n\n**Constraints:**\n- `1 <= words.length <= 1000`\n- `1 <= words[i].length <= 5`\n- All words share the same length and are pairwise distinct.\n- All words use lowercase English letters.\n\nAdaptation: the source returns a nested list of strings; here it maps to `string_list_2d`.\n", "solution": "## Approach\n\nPrecompute a map from every prefix to the words carrying it. Then extend a partial square one row at a time: the letters already placed in column `r` spell the prefix the next word must have. Look up candidates with that prefix and recurse. A full-size arrangement is a valid square by construction.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(candidates explored). Prefix lookups are O(1) and each complete square costs O(n^2) to copy.\n- **Space Complexity:** O(total prefix entries + recursion depth n).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def wordSquares(self, words: List[str]) -> List[List[str]]:\n if not words:\n return []\n n = len(words[0])\n pref = {}\n for w in words:\n for i in range(n + 1):\n pref.setdefault(w[:i], []).append(w)\n ans = []\n def backtrack(cur):\n if len(cur) == n:\n ans.append(list(cur))\n return\n r = len(cur)\n need = ''.join(row[r] for row in cur)\n for w in pref.get(need, []):\n cur.append(w)\n backtrack(cur)\n cur.pop()\n backtrack([])\n return ans\n```\n", "starter": {"go": "package main\n\nfunc WordSquares(words []string) [][]string {\n \n}", "python": "from typing import List\nclass Solution:\n def wordSquares(self, words: List[str]) -> List[List[str]]:\n pass\n", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\nclass Solution {\npublic:\n vector<vector<string>> wordSquares(vector<string>& words) {\n return {};\n }\n};"}, "fn": "wordSquares", "params": [{"name": "words", "type": "string_array"}], "outputType": "string_list_2d", "tests": [["[\"area\",\"lead\",\"wall\",\"lady\",\"ball\"]"], ["[\"abat\",\"baba\",\"atan\",\"atal\"]"], ["[\"a\"]"], ["[\"ab\",\"ba\"]"], ["[\"aa\",\"bb\"]"], ["[\"abc\",\"bca\",\"cab\"]"], ["[\"a\",\"b\"]"], ["[\"ball\",\"area\",\"read\",\"lady\"]"], ["[\"abcd\",\"bnrt\",\"crmy\",\"dtye\"]"], ["[\"aa\",\"aa\"]"], ["[\"ab\",\"aa\",\"ba\"]"], ["[\"o\"]"], ["[\"aa\",\"ab\"]"], ["[\"ab\",\"bb\"]"], ["[\"ba\",\"aa\"]"], ["[\"abc\",\"def\"]"], ["[\"aaa\",\"aab\"]"], ["[\"aba\",\"bab\"]"], ["[\"abcd\",\"abce\"]"], ["[\"a\",\"b\",\"c\"]"], ["[\"o\",\"a\"]"], ["[\"ab\",\"cd\"]"], ["[\"aa\",\"bb\",\"cc\"]"], ["[\"ab\",\"bc\",\"ca\"]"], ["[\"at\",\"ta\"]"], ["[\"no\",\"on\"]"], ["[\"abc\",\"bca\"]"], ["[\"aaa\",\"bbb\"]"], ["[\"aba\",\"aca\"]"], ["[\"abcd\",\"bcda\"]"]], "expected": [[["wall", "area", "lead", "lady"], ["ball", "area", "lead", "lady"]], [["baba", "abat", "baba", "atan"], ["baba", "abat", "baba", "atal"]], [["a"]], [["ab", "ba"], ["ba", "ab"]], [["aa", "aa"], ["bb", "bb"]], [["abc", "bca", "cab"], ["bca", "cab", "abc"], ["cab", "abc", "bca"]], [["a"], ["b"]], [], [["abcd", "bnrt", "crmy", "dtye"]], [["aa", "aa"], ["aa", "aa"], ["aa", "aa"], ["aa", "aa"]], [["ab", "ba"], ["aa", "ab"], ["aa", "aa"], ["ba", "ab"], ["ba", "aa"]], [["o"]], [["aa", "aa"], ["aa", "ab"]], [["ab", "bb"], ["bb", "bb"]], [["ba", "aa"], ["aa", "aa"]], [], [["aaa", "aaa", "aaa"], ["aaa", "aaa", "aab"]], [["aba", "bab", "aba"], ["bab", "aba", "bab"]], [], [["a"], ["b"], ["c"]], [["o"], ["a"]], [], [["aa", "aa"], ["bb", "bb"], ["cc", "cc"]], [["ab", "bc"], ["bc", "ca"], ["ca", "ab"]], [["at", "ta"], ["ta", "at"]], [["no", "on"], ["on", "no"]], [], [["aaa", "aaa", "aaa"], ["bbb", "bbb", "bbb"]], [], []], "loose": true}

package/data/problems/word-subsets.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "904", "slug": "word-subsets", "id": 904, "title": "Word Subsets", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/word-subsets/", "examples": [{"input": "words1 = [\"amazon\",\"apple\",\"facebook\",\"google\",\"leetcode\"], words2 = [\"e\",\"o\"]", "output": "[\"facebook\",\"google\",\"leetcode\"]", "explanation": "These are the words containing at least one e and at least one o."}, {"input": "words1 = [\"amazon\",\"apple\",\"facebook\",\"google\",\"leetcode\"], words2 = [\"lo\",\"eo\"]", "output": "[\"google\",\"leetcode\"]", "explanation": "Only these words cover the letter demands of both \"lo\" and \"eo\"."}, {"input": "words1 = [\"amazon\",\"apple\",\"facebook\",\"google\",\"leetcode\"], words2 = [\"ec\",\"oc\",\"ceo\"]", "output": "[\"facebook\",\"leetcode\"]", "explanation": "Each of these words contains every letter pattern required by all of words2."}], "hints": ["A words1 entry is universal when, for every letter, its count there reaches the largest count demanded by any single words2 entry.", "Collapse all of words2 into one demand table holding per-letter maxima, then test each words1 entry against it.", "The order of the returned words does not matter for judging; sorted comparison is used."], "statement": "You are given two string arrays `words1` and `words2`. A word from `words1` is called universal when, for every word `b` in `words2`, each letter appears in it at least as many times as it appears in `b`.\n\nReturn the list of all universal words from `words1`. The order of the returned list does not matter.\n\n**Constraints:**\n- `1 <= words1.length, words2.length <= 10^4`\n- `1 <= words1[i].length, words2[i].length <= 30`\n- All words consist of lowercase English letters\n", "solution": "## Approach\n\nFor each letter, only the strongest demand across all of `words2` matters: a candidate must contain every letter at least that many times. Build this per-letter demand table once, then keep the `words1` entries whose letter counts dominate it everywhere.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(total characters in words1 plus total characters in words2).\n- **Space Complexity:** O(1) extra besides the output (two fixed 26-counters).\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def wordSubsets(self, words1: List[str], words2: List[str]) -> List[str]:\n need = [0] * 26\n for w in words2:\n c = [0] * 26\n for ch in w:\n c[ord(ch) - 97] += 1\n for i in range(26):\n if c[i] > need[i]:\n need[i] = c[i]\n ans = []\n for w in words1:\n c = [0] * 26\n for ch in w:\n c[ord(ch) - 97] += 1\n if all(c[i] >= need[i] for i in range(26)):\n ans.append(w)\n return ans\n```\n", "starter": {"go": "package main\n\nfunc WordSubsets(words1 []string, words2 []string) []string {\n \n}", "python": "from typing import List\nclass Solution:\n def wordSubsets(self, words1: List[str], words2: List[str]) -> List[str]:\n ", "cpp": "#include <vector>\n#include <string>\nusing namespace std;\n\nclass Solution {\npublic:\n vector<string> wordSubsets(vector<string>& words1, vector<string>& words2) {\n \n }\n};"}, "fn": "wordSubsets", "params": [{"name": "words1", "type": "string_array"}, {"name": "words2", "type": "string_array"}], "outputType": "string_list", "tests": [["[\"amazon\", \"apple\", \"facebook\", \"google\", \"leetcode\"]", "[\"e\", \"o\"]"], ["[\"amazon\", \"apple\", \"facebook\", \"google\", \"leetcode\"]", "[\"l\", \"e\"]"], ["[\"amazon\", \"apple\", \"facebook\", \"google\", \"leetcode\"]", "[\"e\", \"oo\"]"], ["[\"amazon\", \"apple\", \"facebook\", \"google\", \"leetcode\"]", "[\"lo\", \"eo\"]"], ["[\"amazon\", \"apple\", \"facebook\", \"google\", \"leetcode\"]", "[\"ec\", \"oc\", \"ceo\"]"], ["[\"eaee\", \"beccd\", \"c\", \"dcbeabeb\", \"cae\", \"dbbeddd\"]", "[\"eabc\", \"daad\"]"], ["[\"bb\", \"ba\", \"baeabee\", \"cdce\", \"eecdae\"]", "[\"d\", \"e\", \"ab\"]"], ["[\"dbecaeb\", \"bcedb\", \"dbabaec\", \"abee\", \"eede\", \"dcdebab\"]", "[\"ddbd\"]"], ["[\"bbbba\", \"e\", \"ebbb\", \"bbd\", \"e\", \"bbcdadc\"]", "[\"eaba\", \"b\", \"ad\"]"], ["[\"aec\"]", "[\"ab\", \"aeb\", \"db\"]"], ["[\"cbcbacbd\", \"cdca\", \"b\", \"eb\", \"eacadadc\", \"ebec\"]", "[\"ad\"]"], ["[\"ddebb\", \"dbe\", \"eec\", \"bba\", \"ebcacc\"]", "[\"cead\"]"], ["[\"b\", \"adabddba\", \"cddea\", \"cbecab\", \"debeda\"]", "[\"d\", \"daa\", \"d\"]"], ["[\"c\", \"dbcd\", \"cedabdb\", \"bcdabcbb\", \"cdcddc\"]", "[\"bda\"]"], ["[\"cebeb\", \"eadbc\"]", "[\"db\", \"edbc\", \"abcc\"]"], ["[\"eda\", \"ddeaddcb\", \"eb\"]", "[\"a\", \"ded\", \"a\"]"], ["[\"cabce\", \"ec\", \"a\", \"cecba\"]", "[\"dced\"]"], ["[\"aebceec\", \"cba\", \"caacb\", \"aeece\", \"e\"]", "[\"ed\", \"ddca\"]"], ["[\"b\", \"aaadc\", \"dee\", \"cbeebd\", \"bdcacddc\"]", "[\"cd\", \"ed\", \"eee\"]"], ["[\"eecbc\", \"ddaadd\", \"a\"]", "[\"ed\"]"], ["[\"bdccaa\", \"ceadbb\", \"dccaabce\", \"ac\", \"bdd\", \"ebeb\"]", "[\"a\"]"], ["[\"da\"]", "[\"ebb\", \"d\", \"abce\"]"], ["[\"cde\", \"b\", \"cabcbccb\", \"dceabae\", \"ddbeedb\", \"a\"]", "[\"cc\", \"dedc\"]"], ["[\"ebeeecb\", \"b\", \"cdddcd\", \"bbaeed\"]", "[\"dd\"]"], ["[\"daecec\"]", "[\"ecca\", \"acbe\", \"ccb\"]"], ["[\"cbedadae\", \"ca\"]", "[\"ceb\", \"acd\", \"dc\"]"], ["[\"ee\", \"eaecc\"]", "[\"ecb\", \"be\"]"], ["[\"deadbea\", \"eecdd\", \"cbebe\", \"dadd\", \"bbac\", \"ccaecaee\"]", "[\"caba\", \"d\"]"]], "expected": [["facebook", "google", "leetcode"], ["apple", "google", "leetcode"], ["facebook", "google"], ["google", "leetcode"], ["facebook", "leetcode"], [], [], [], [], [], ["cbcbacbd", "cdca", "eacadadc"], [], ["adabddba"], ["cedabdb", "bcdabcbb"], [], ["ddeaddcb"], [], [], [], [], ["bdccaa", "ceadbb", "dccaabce", "ac"], [], [], ["cdddcd"], [], ["cbedadae"], [], []], "loose": true}

package/data/problems/x-of-a-kind-in-a-deck-of-cards.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "902", "slug": "x-of-a-kind-in-a-deck-of-cards", "id": 902, "title": "X of a Kind in a Deck of Cards", "difficulty": "Easy", "category": "array", "link": "https://leetcode.com/problems/x-of-a-kind-in-a-deck-of-cards/", "examples": [{"input": "deck = [1,2,3,4,4,3,2,1]", "output": "true", "explanation": "Split into four pairs: [1,1], [2,2], [3,3], [4,4]."}, {"input": "deck = [1,1,1,2,2,2,3,3]", "output": "false", "explanation": "No group size X >= 2 divides every value count (3, 3, 2)."}, {"input": "deck = [1,1,2,2,2,2]", "output": "true", "explanation": "Use X = 2: [1,1], [2,2], [2,2]."}, {"input": "deck = [1]", "output": "false", "explanation": "A single card cannot form a group of size at least 2."}], "hints": ["Count how many times each distinct value appears; every count must be a multiple of the shared group size X.", "That is possible exactly when the greatest common divisor of all counts is at least 2.", "A deck with fewer than 2 cards, or with a count of 1 anywhere while others disagree, fails."], "statement": "You are given an integer array `deck` where each entry is the value written on one card. Decide whether the whole deck can be split into groups satisfying all of these rules:\n\n- Every group contains the same number of cards `X`, with `X >= 2`.\n- All cards inside a single group show the same value.\n\nReturn `true` if such a split exists, otherwise `false`.\n\n**Constraints:**\n- `1 <= deck.length <= 10^4`\n- `0 <= deck[i] < 10^4`\n", "solution": "## Approach\n\nTally the occurrences of each distinct card. A common group size `X` works exactly when it divides every tally, so the best candidate is the greatest common divisor of all tallies. The deck splits evenly precisely when that divisor is at least 2.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + m log m) for counting plus gcd steps over the tallies.\n- **Space Complexity:** O(m) for the frequency table of m distinct values.\n\n## Implementation\n\n```python\nfrom typing import List\nfrom collections import Counter\nimport math\nclass Solution:\n def hasGroupsSizeX(self, deck: List[int]) -> bool:\n counts = Counter(deck).values()\n g = 0\n for c in counts:\n g = math.gcd(g, c)\n return g >= 2\n```\n", "starter": {"go": "package main\n\nfunc HasGroupsSizeX(deck []int) bool {\n return false\n}", "python": "from typing import List\nclass Solution:\n def hasGroupsSizeX(self, deck: List[int]) -> bool:\n return False\n", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n bool hasGroupsSizeX(vector<int>& deck) {\n return false;\n }\n};"}, "fn": "hasGroupsSizeX", "params": [{"name": "deck", "type": "int_array"}], "outputType": "boolean", "tests": [["[1,2,3,4,4,3,2,1]"], ["[1,1,1,2,2,2,3,3]"], ["[1]"], ["[1,1]"], ["[1,1,2,2,2,2]"], ["[1,1,1,2,2,2]"], ["[1,1,1,2,2,2,3,3,3]"], ["[2,2,2,3,3,3,3,3,3]"], ["[0,0,0,0]"], ["[5,5,5,5,5]"], ["[1,2,3,4]"], ["[1,1,2,2]"], ["[1,1,1,1,2,2,2,2,3,3,3,3]"], ["[7,7,7]"], ["[4,4,4,4,4,4]"], ["[1,1,1,1,1,1,2,2,2,2,2,2]"], ["[9,9,8,8,8,9,9,8]"], ["[3,3,3,3,3,3,3,3,3]"], ["[1,1,1,1,2,2,2,3,3]"], ["[6,6,6,6,6,6,6,6,6,6,6,6]"], ["[1,2]"], ["[0,0,1,1,1,1]"], ["[2]"], ["[1,1,1,1]"], ["[1,2,2,3,3,3]"], ["[4,4,4,4,4,4,4,4]"], ["[1,3,1,3,1,3]"], ["[10,10,10,20,20,20,20,20,20,30,30,30]"]], "expected": [true, false, false, true, true, true, true, true, true, true, false, true, true, true, true, true, true, true, false, true, false, true, false, true, false, true, true, true], "loose": false}

package/data/problems/zigzag-conversion.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "251", "slug": "zigzag-conversion", "id": 251, "title": "Zigzag Conversion", "difficulty": "Medium", "category": "string", "link": "https://leetcode.com/problems/zigzag-conversion/", "examples": [{"input": "s = \"PAYPALISHIRING\", numRows = 3", "output": "\"PAHNAPLSIIGYIR\"", "explanation": "Rows are \"PAHN\", \"APLSIIG\", \"YIR\"."}, {"input": "s = \"PAYPALISHIRING\", numRows = 4", "output": "\"PINALSIGYAHRPI\""}, {"input": "s = \"A\", numRows = 1", "output": "\"A\""}], "hints": ["Simulate the row index moving down then up, appending each character to its row.", "If numRows is 1, the answer is the original string."], "statement": "Given a string `s` and a positive integer `numRows`, arrange the characters of `s` in a zigzag across `numRows` rows, then read the rows from top to bottom, left to right.\n\nTo picture the ordering, write the characters diagonally down and then diagonally up, repeating: move down one row at a time until the bottom row, then move up one row at a time until the top row, and repeat. Characters that land in the same row keep their original left-to-right order.\n\nReturn the string obtained by concatenating the rows in order.\n\n**Constraints:**\n- `1 <= s.length <= 1000`\n- `s` consists of English letters, `,` and `.`\n- `1 <= numRows <= 1000`\n", "solution": "## Approach\n\nSimulate walking through the rows in a down-then-up cycle. Keep one string builder per row and append each character to the current row. Reverse direction at the top row and the bottom row. When there is only one row, the walk never moves, so the input is returned unchanged. Finally concatenate the rows.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n), where n is the length of `s`. Each character is visited once.\n- **Space Complexity:** O(n) for the row buffers and the output.\n\n## Implementation\n\n```python\nclass Solution:\n def convert(self, s: str, numRows: int) -> str:\n if numRows == 1 or len(s) <= numRows:\n return s\n rows = [\"\" for _ in range(numRows)]\n cur = 0\n down = True\n for c in s:\n rows[cur] += c\n if cur == 0:\n down = True\n elif cur == numRows - 1:\n down = False\n cur += 1 if down else -1\n return \"\".join(rows)\n```\n", "starter": {"go": "package main\n\nfunc Convert(s string, numRows int) string {\n \n}", "python": "class Solution:\n def convert(self, s: str, numRows: int) -> str:\n pass", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n string convert(string s, int numRows) {\n return \"\";\n }\n};"}, "fn": "convert", "params": [{"name": "s", "type": "string"}, {"name": "numRows", "type": "int"}], "outputType": "string", "tests": [["PAYPALISHIRING", "3"], ["PAYPALISHIRING", "4"], ["A", "1"], ["AB", "1"], ["ABC", "2"], ["ABCD", "2"], ["ABCDE", "4"], ["HELLO,WORLD.", "3"], ["ABCDEFGHIJKLMN", "5"], ["A", "1000"], ["AB", "2"], ["PAYPALISHIRING", "5"], ["ZZZ", "2"], ["ABCDEF", "3"], ["ABCDEFG", "3"], ["A.B,C", "2"], ["XYZ", "5"], ["HELLOWORLD", "1"], ["ABCDEFGHIJ", "4"], ["AAABBBCCC", "2"], ["QWERTYUIOPASDFGHJKL", "3"], ["A,B.C", "3"], ["SHORT", "10"], ["REPEATEDREPEATED", "6"], [".,.,.,", "2"], ["ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", "7"]], "expected": ["PAHNAPLSIIGYIR", "PINALSIGYAHRPI", "A", "AB", "ACB", "ACBD", "ABCED", "HOREL,OL.LWD", "AIBHJCGKDFLNEM", "A", "AB", "PHASIYIRPLIGAN", "ZZZ", "AEBDFC", "AEBDFCG", "ABC.,", "XYZ", "HELLOWORLD", "AGBFHCEIDJ", "AABCCABBC", "QTODJWRYIPSFHKEUAGL", "AC,.B", "SHORT", "RPEEEPRAEDTAEETD", "...,,,", "AMYkwBLNXZjlvxCKOWaimuyDJPVbhntzEIQUcgosFHRTdfprGSeq"], "loose": false}

package/data/problems/zigzag-iterator.json ADDED Viewed

@@ -0,0 +1 @@

+ {"basic": false, "label": "379", "slug": "zigzag-iterator", "id": 379, "title": "Zigzag Iterator", "difficulty": "Medium", "category": "array", "link": "https://leetcode.com/problems/zigzag-iterator/", "examples": [{"input": "v1 = [1,2], v2 = [3,4,5,6]", "output": "[1,3,2,4,5,6]", "explanation": "Alternate starting with v1; append the tail of the longer list."}, {"input": "v1 = [1], v2 = []", "output": "[1]", "explanation": "Only v1 has values."}, {"input": "v1 = [], v2 = [1]", "output": "[1]", "explanation": "Only v2 has values."}], "hints": ["Adaptation: the original iterator class with next/hasNext is replaced by a function returning the full zigzag order.", "Alternate taking from v1 then v2; when one list is exhausted, drain the other.", "Start with v1."], "statement": "Given two integer lists, produce their zigzag interleaving.\n\n**Adaptation:** the original design asks for an iterator class with `next`\nand `hasNext`; here implement `zigzagIterate(v1, v2)` returning the whole\ntraversal: take one element from `v1`, then one from `v2`, alternating, and\ndrain whichever list remains when the other runs out.\n\n**Constraints:**\n- `0 <= v1.length, v2.length <= 1000`\n- `1 <= v1[i], v2[i] <= 1000` when present.\n", "solution": "## Approach\n\nWalk both lists with two indices and a toggle. On each step take from the toggled list when it still has items, otherwise take from the other list, then flip the toggle until both lists are drained.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(n + m)\n- **Space Complexity:** O(n + m) for the output.\n\n## Implementation\n\n```python\nfrom typing import List\nclass Solution:\n def zigzagIterate(self, v1: List[int], v2: List[int]) -> List[int]:\n res, i, j, take_first = [], 0, 0, True\n while i < len(v1) or j < len(v2):\n if take_first:\n if i < len(v1):\n res.append(v1[i]); i += 1\n else:\n res.append(v2[j]); j += 1\n else:\n if j < len(v2):\n res.append(v2[j]); j += 1\n else:\n res.append(v1[i]); i += 1\n take_first = not take_first\n return res\n```\n", "starter": {"go": "package main\n\nfunc ZigzagIterate(v1 []int, v2 []int) []int {\n return []int{}\n}", "python": "from typing import List\nclass Solution:\n def zigzagIterate(self, v1: List[int], v2: List[int]) -> List[int]:\n return []", "cpp": "#include <vector>\nusing namespace std;\nclass Solution {\npublic:\n vector<int> zigzagIterate(vector<int>& v1, vector<int>& v2) {\n return {};\n }\n};"}, "fn": "zigzagIterate", "params": [{"name": "v1", "type": "int_array"}, {"name": "v2", "type": "int_array"}], "outputType": "int_array", "tests": [["[1,2]", "[3,4,5,6]"], ["[1]", "[]"], ["[]", "[1]"], ["[]", "[]"], ["[1,3,5]", "[2,4,6]"], ["[1,2,3,4,5]", "[6]"], ["[1]", "[2,3,4,5]"], ["[1,2]", "[3]"], ["[5]", "[5]"], ["[0,0,0]", "[1,1,1]"], ["[1,2,3]", "[]"], ["[]", "[4,5,6]"], ["[7,8]", "[9,10,11,12,13]"], ["[1,1,1,1]", "[2,2]"], ["[3]", "[1,2]"], ["[1,2,3]", "[4,5,6]"], ["[10]", "[20]"], ["[1,2,3,4]", "[]"], ["[]", "[5,6,7,8]"], ["[1]", "[2]"], ["[9,8,7]", "[1,2,3,4,5]"], ["[100]", "[200,300]"], ["[5,5,5]", "[5,5,5]"], ["[1,3,5,7]", "[2,4]"], ["[42]", "[42,42]"], ["[2,4,6,8,10]", "[1,3,5,7,9]"], ["[7,7,7]", "[8]"], ["[1000]", "[1]"], ["[3,1]", "[2]"], ["[6,5,4]", "[3,2,1]"]], "expected": [[1, 3, 2, 4, 5, 6], [1], [1], [], [1, 2, 3, 4, 5, 6], [1, 6, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 3, 2], [5, 5], [0, 1, 0, 1, 0, 1], [1, 2, 3], [4, 5, 6], [7, 9, 8, 10, 11, 12, 13], [1, 2, 1, 2, 1, 1], [3, 1, 2], [1, 4, 2, 5, 3, 6], [10, 20], [1, 2, 3, 4], [5, 6, 7, 8], [1, 2], [9, 1, 8, 2, 7, 3, 4, 5], [100, 200, 300], [5, 5, 5, 5, 5, 5], [1, 2, 3, 4, 5, 7], [42, 42, 42], [2, 1, 4, 3, 6, 5, 8, 7, 10, 9], [7, 8, 7, 7], [1000, 1], [3, 2, 1], [6, 3, 5, 2, 4, 1]], "loose": false}

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

@@ -0,0 +1 @@

+ {"basic": false, "label": "552", "slug": "zuma-game", "id": 552, "title": "Zuma Game", "difficulty": "Hard", "category": "string", "link": "https://leetcode.com/problems/zuma-game/", "examples": [{"input": "board = \"WRRBBW\", hand = \"RB\"", "output": "-1", "explanation": "No insertion order empties the row with these two hand balls."}, {"input": "board = \"WWRRBBWW\", hand = \"WRBRW\"", "output": "2", "explanation": "Two well placed insertions trigger cascading deletions that clear the row."}, {"input": "board = \"G\", hand = \"GGGGG\"", "output": "2", "explanation": "Adding two more G balls makes three in a row, which are then removed."}], "hints": ["Search over game states with breadth-first or depth-first search plus memoization; the state is the current row together with remaining hand counts.", "Only insertions next to an equal-colored ball can be useful, and identical resulting rows from different gaps need be tried once.", "Write a helper that repeatedly deletes every run of length three or more until the row is stable."], "statement": "A row of colored balls sits on a board. Each ball shows one of five colors, written as single letters `R`, `Y`, `B`, `G` or `W`. You also hold a small collection of extra balls described by a second short string.\n\nOn each move you may take one ball from your hand and slide it into the row at any gap, including both ends. After the insertion, look for runs of three or more equal neighbors. Remove every such run. The removal can join previously separated equal balls, so keep deleting newly formed runs until none remain. If the row becomes empty you have cleared the board.\n\nYour task is to use as few hand balls as possible to empty the row. Return that minimum count, or `-1` when the hand cannot finish the job.\n\n**Constraints:**\n- `1 <= board.length <= 16`\n- `1 <= hand.length <= 5`\n- Both strings use only `R`, `Y`, `B`, `G` and `W`\n- The starting row never already contains three equal neighbors in a row\n", "solution": "## Approach\n\nTreat each distinct pair of current row plus remaining hand counts as a search state. Depth-first search tries every useful insertion: a hand ball placed directly beside an equal-colored row ball. After each insertion a helper repeatedly strips runs of three or more until stable, then recursion continues. Memoization on the state keeps the branching tiny because the hand holds at most five balls. If no branch empties the row the answer is `-1`.\n\n## Complexity Analysis\n\n- **Time Complexity:** O(S * B * H) where S is the number of reachable states, B the row length and H the hand size. With the given limits this easily fits.\n- **Space Complexity:** O(S) for the memo table and recursion stack.\n\n## Implementation\n\n```python\nfrom typing import Dict, Tuple\n\nclass Solution:\n def findMinStep(self, board: str, hand: str) -> int:\n colors = ['R', 'Y', 'B', 'G', 'W']\n cnt = [hand.count(c) for c in colors]\n memo: Dict[Tuple[str, Tuple[int, ...]], int] = {}\n\n def collapse(s: str) -> str:\n cur = s\n while True:\n nxt = []\n i = 0\n changed = False\n while i < len(cur):\n j = i\n while j < len(cur) and cur[j] == cur[i]:\n j += 1\n if j - i >= 3:\n changed = True\n else:\n nxt.append(cur[i:j])\n i = j\n cur = \"\".join(nxt)\n if not changed:\n return cur\n\n def dfs(b: str, h: Tuple[int, ...]) -> int:\n if not b:\n return 0\n key = (b, h)\n if key in memo:\n return memo[key]\n best = 100\n hlist = list(h)\n for ci, c in enumerate(colors):\n if hlist[ci] == 0:\n continue\n seen = set()\n for i in range(len(b) + 1):\n adj = (i > 0 and b[i - 1] == c) or (i < len(b) and b[i] == c)\n if not adj:\n continue\n nb = collapse(b[:i] + c + b[i:])\n if nb in seen:\n continue\n seen.add(nb)\n hlist[ci] -= 1\n sub = dfs(nb, tuple(hlist))\n hlist[ci] += 1\n if sub < 100:\n best = min(best, 1 + sub)\n memo[key] = best\n return best\n\n ans = dfs(board, tuple(cnt))\n return -1 if ans >= 100 else ans\n```\n", "starter": {"go": "package main\n\nfunc FindMinStep(board string, hand string) int {\n \n}", "python": "class Solution:\n def findMinStep(self, board: str, hand: str) -> int:\n pass\n", "cpp": "#include <string>\nusing namespace std;\nclass Solution {\npublic:\n int findMinStep(string board, string hand) {\n return 0;\n }\n};"}, "fn": "findMinStep", "params": [{"name": "board", "type": "string"}, {"name": "hand", "type": "string"}], "outputType": "int", "tests": [["WRRBBW", "RB"], ["WWRRBBWW", "WRBRW"], ["G", "GGGGG"], ["RR", "RR"], ["R", "R"], ["R", "RR"], ["Y", "YY"], ["RB", "RB"], ["RRYBB", "RYB"], ["WW", "WW"], ["RRWW", "RW"], ["YWWY", "YW"], ["BB", "BBB"], ["RYYR", "RY"], ["WBRY", "WBRY"], ["GG", "GGG"], ["RRBB", "RB"], ["YBBR", "YBR"], ["W", "W"], ["W", "WW"], ["RW", "RRW"], ["YYRR", "YR"], ["BBRY", "BRY"], ["RBRBR", "RBB"], ["WWYWW", "YW"], ["RGBW", "RGBW"], ["RRY", "RY"], ["BWWB", "WB"]], "expected": [-1, 2, 2, 1, -1, 2, 2, -1, -1, 1, 2, 2, 1, 2, -1, 1, 2, -1, -1, 2, -1, 2, -1, -1, -1, -1, -1, 2], "loose": false}