Skip to content

Commit 25cb7c2

Browse files
wislerttwislertt
committed
feat: add find_all_anagrams_in_a_string
1 parent 66fe564 commit 25cb7c2

30 files changed

+1066
-1
lines changed

‎.templates/leetcode/json/diagonal_traverse.json‎

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
{
2+
"problem_name": "diagonal_traverse",
3+
"solution_class_name": "Solution",
4+
"problem_number": "498",
5+
"problem_title": "Diagonal Traverse",
6+
"difficulty": "Medium",
7+
"topics": "Array, Matrix, Simulation",
8+
"_tags": { "list": [] },
9+
"readme_description": "Given an `m x n` matrix `mat`, return *an array of all the elements of the array in a diagonal order*.",
10+
"_readme_examples": {
11+
"list": [
12+
{
13+
"content": "![Diagonal Traverse](https://assets.leetcode.com/uploads/2021/04/10/diag1-grid.jpg)\n\n```\nInput: mat = [[1,2,3],[4,5,6],[7,8,9]]\nOutput: [1,2,4,7,5,3,6,8,9]\n```"
14+
},
15+
{ "content": "```\nInput: mat = [[1,2],[3,4]]\nOutput: [1,2,3,4]\n```" }
16+
]
17+
},
18+
"readme_constraints": "- `m == mat.length`\n- `n == mat[i].length`\n- `1 <= m, n <= 10^4`\n- `1 <= m * n <= 10^4`\n- `-10^5 <= mat[i][j] <= 10^5`",
19+
"readme_additional": "",
20+
"helpers_imports": "",
21+
"helpers_content": "",
22+
"helpers_run_name": "find_diagonal_order",
23+
"helpers_run_signature": "(solution_class: type, mat: list[list[int]])",
24+
"helpers_run_body": " implementation = solution_class()\n return implementation.find_diagonal_order(mat)",
25+
"helpers_assert_name": "find_diagonal_order",
26+
"helpers_assert_signature": "(result: list[int], expected: list[int]) -> bool",
27+
"helpers_assert_body": " assert result == expected\n return True",
28+
"solution_imports": "",
29+
"solution_contents": "",
30+
"solution_class_content": "",
31+
"test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .helpers import assert_find_diagonal_order, run_find_diagonal_order\nfrom .solution import Solution",
32+
"test_content": "",
33+
"test_class_name": "DiagonalTraverse",
34+
"test_class_content": " def setup_method(self):\n self.solution = Solution()",
35+
"_solution_methods": {
36+
"list": [
37+
{
38+
"name": "find_diagonal_order",
39+
"signature": "(self, mat: list[list[int]]) -> list[int]",
40+
"body": " # TODO: Implement find_diagonal_order\n return []"
41+
}
42+
]
43+
},
44+
"_test_helper_methods": {
45+
"list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
46+
},
47+
"_test_methods": {
48+
"list": [
49+
{
50+
"name": "test_find_diagonal_order",
51+
"signature": "(self, mat: list[list[int]], expected: list[int])",
52+
"parametrize": "mat, expected",
53+
"test_cases": "[([[1, 2, 3], [4, 5, 6], [7, 8, 9]], [1, 2, 4, 7, 5, 3, 6, 8, 9]), ([[1, 2], [3, 4]], [1, 2, 3, 4]), ([[1]], [1]), ([[1, 2, 3]], [1, 2, 3]), ([[1], [2], [3]], [1, 2, 3]), ([[1, 2, 3, 4], [5, 6, 7, 8]], [1, 2, 5, 6, 3, 4, 7, 8]), ([[1, 2], [3, 4], [5, 6]], [1, 2, 3, 5, 4, 6]), ([[1, 2, 3, 4, 5]], [1, 2, 3, 4, 5]), ([[1], [2], [3], [4], [5]], [1, 2, 3, 4, 5]), ([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], [1, 2, 5, 9, 6, 3, 4, 7, 10, 11, 8, 12]), ([[-1, 0, 1], [2, -3, 4]], [-1, 0, 2, -3, 1, 4]), ([[100]], [100])]",
54+
"body": " result = run_find_diagonal_order(Solution, mat)\n assert_find_diagonal_order(result, expected)"
55+
}
56+
]
57+
},
58+
"playground_imports": "from helpers import run_find_diagonal_order, assert_find_diagonal_order\nfrom solution import Solution",
59+
"playground_setup": "# Example test case\nmat = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]\nexpected = [1, 2, 4, 7, 5, 3, 6, 8, 9]",
60+
"playground_run": "result = run_find_diagonal_order(Solution, mat)\nresult",
61+
"playground_assert": "assert_find_diagonal_order(result, expected)"
62+
}

‎.templates/leetcode/json/find_all_anagrams_in_a_string.json‎

Lines changed: 64 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,64 @@
1+
{
2+
"problem_name": "find_all_anagrams_in_a_string",
3+
"solution_class_name": "Solution",
4+
"problem_number": "438",
5+
"problem_title": "Find All Anagrams in a String",
6+
"difficulty": "Medium",
7+
"topics": "Hash Table, String, Sliding Window",
8+
"_tags": { "list": ["grind-75"] },
9+
"readme_description": "Given two strings `s` and `p`, return an array of all the start indices of `p`'s anagrams in `s`. You may return the answer in any order.\n\nAn **anagram** is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.",
10+
"_readme_examples": {
11+
"list": [
12+
{
13+
"content": "```\nInput: s = \"cbaebabacd\", p = \"abc\"\nOutput: [0,6]\n```\n**Explanation:**\nThe substring with start index = 0 is \"cba\", which is an anagram of \"abc\".\nThe substring with start index = 6 is \"bac\", which is an anagram of \"abc\"."
14+
},
15+
{
16+
"content": "```\nInput: s = \"abab\", p = \"ab\"\nOutput: [0,1,2]\n```\n**Explanation:**\nThe substring with start index = 0 is \"ab\", which is an anagram of \"ab\".\nThe substring with start index = 1 is \"ba\", which is an anagram of \"ab\".\nThe substring with start index = 2 is \"ab\", which is an anagram of \"ab\"."
17+
}
18+
]
19+
},
20+
"readme_constraints": "- 1 <= s.length, p.length <= 3 * 10^4\n- s and p consist of lowercase English letters.",
21+
"readme_additional": "",
22+
"helpers_imports": "",
23+
"helpers_content": "",
24+
"helpers_run_name": "find_anagrams",
25+
"helpers_run_signature": "(solution_class: type, s: str, p: str)",
26+
"helpers_run_body": " implementation = solution_class()\n return implementation.find_anagrams(s, p)",
27+
"helpers_assert_name": "find_anagrams",
28+
"helpers_assert_signature": "(result: list[int], expected: list[int]) -> bool",
29+
"helpers_assert_body": " assert sorted(result) == sorted(expected)\n return True",
30+
"solution_imports": "",
31+
"solution_contents": "",
32+
"solution_class_content": "",
33+
"test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .helpers import assert_find_anagrams, run_find_anagrams\nfrom .solution import Solution",
34+
"test_content": "",
35+
"test_class_name": "FindAllAnagramsInAString",
36+
"test_class_content": " def setup_method(self):\n self.solution = Solution()",
37+
"_solution_methods": {
38+
"list": [
39+
{
40+
"name": "find_anagrams",
41+
"signature": "(self, s: str, p: str) -> list[int]",
42+
"body": " # TODO: Implement find_anagrams\n return []"
43+
}
44+
]
45+
},
46+
"_test_helper_methods": {
47+
"list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
48+
},
49+
"_test_methods": {
50+
"list": [
51+
{
52+
"name": "test_find_anagrams",
53+
"signature": "(self, s: str, p: str, expected: list[int])",
54+
"parametrize": "s, p, expected",
55+
"test_cases": "[('cbaebabacd', 'abc', [0, 6]), ('abab', 'ab', [0, 1, 2]), ('a', 'aa', []), ('aa', 'aa', [0]), ('abcdefg', 'xyz', []), ('aab', 'ab', [1]), ('aaab', 'ab', [2]), ('baa', 'aa', [1]), ('abacabad', 'aaab', []), ('ababacb', 'abc', [3, 4]), ('abaacbabc', 'abc', [3, 4, 6]), ('abab', 'abab', [0])]",
56+
"body": " result = run_find_anagrams(Solution, s, p)\n assert_find_anagrams(result, expected)"
57+
}
58+
]
59+
},
60+
"playground_imports": "from helpers import run_find_anagrams, assert_find_anagrams\nfrom solution import Solution",
61+
"playground_setup": "# Example test case\ns = 'cbaebabacd'\np = 'abc'\nexpected = [0, 6]",
62+
"playground_run": "result = run_find_anagrams(Solution, s, p)\nresult",
63+
"playground_assert": "assert_find_anagrams(result, expected)"
64+
}

‎.templates/leetcode/json/letter_combinations_of_a_phone_number.json‎

Lines changed: 63 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,63 @@
1+
{
2+
"problem_name": "letter_combinations_of_a_phone_number",
3+
"solution_class_name": "Solution",
4+
"problem_number": "17",
5+
"problem_title": "Letter Combinations of a Phone Number",
6+
"difficulty": "Medium",
7+
"topics": "Hash Table, String, Backtracking",
8+
"_tags": { "list": ["grind-75"] },
9+
"readme_description": "Given a string containing digits from `2-9` inclusive, return all possible letter combinations that the number could represent. Return the answer in **any order**.\n\nA mapping of digits to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters.",
10+
"_readme_examples": {
11+
"list": [
12+
{
13+
"content": "![Phone Keypad](https://assets.leetcode.com/uploads/2022/03/15/1200px-telephone-keypad2svg.png)\n\n```\nInput: digits = \"23\"\nOutput: [\"ad\",\"ae\",\"af\",\"bd\",\"be\",\"bf\",\"cd\",\"ce\",\"cf\"]\n```"
14+
},
15+
{ "content": "```\nInput: digits = \"\"\nOutput: []\n```" },
16+
{ "content": "```\nInput: digits = \"2\"\nOutput: [\"a\",\"b\",\"c\"]\n```" }
17+
]
18+
},
19+
"readme_constraints": "- `0 <= digits.length <= 4`\n- `digits[i]` is a digit in the range `['2', '9']`.",
20+
"readme_additional": "",
21+
"helpers_imports": "",
22+
"helpers_content": "",
23+
"helpers_run_name": "letter_combinations",
24+
"helpers_run_signature": "(solution_class: type, digits: str)",
25+
"helpers_run_body": " implementation = solution_class()\n return implementation.letter_combinations(digits)",
26+
"helpers_assert_name": "letter_combinations",
27+
"helpers_assert_signature": "(result: list[str], expected: list[str]) -> bool",
28+
"helpers_assert_body": " result.sort()\n expected.sort()\n assert result == expected\n return True",
29+
"solution_imports": "",
30+
"solution_contents": "",
31+
"solution_class_content": "",
32+
"test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .helpers import assert_letter_combinations, run_letter_combinations\nfrom .solution import Solution",
33+
"test_content": "",
34+
"test_class_name": "LetterCombinationsOfAPhoneNumber",
35+
"test_class_content": " def setup_method(self):\n self.solution = Solution()",
36+
"_solution_methods": {
37+
"list": [
38+
{
39+
"name": "letter_combinations",
40+
"signature": "(self, digits: str) -> list[str]",
41+
"body": " # TODO: Implement letter_combinations\n return []"
42+
}
43+
]
44+
},
45+
"_test_helper_methods": {
46+
"list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
47+
},
48+
"_test_methods": {
49+
"list": [
50+
{
51+
"name": "test_letter_combinations",
52+
"signature": "(self, digits: str, expected: list[str])",
53+
"parametrize": "digits, expected",
54+
"test_cases": "[('23', ['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf']), ('', []), ('2', ['a', 'b', 'c']), ('234', ['adg', 'adh', 'adi', 'aeg', 'aeh', 'aei', 'afg', 'afh', 'afi', 'bdg', 'bdh', 'bdi', 'beg', 'beh', 'bei', 'bfg', 'bfh', 'bfi', 'cdg', 'cdh', 'cdi', 'ceg', 'ceh', 'cei', 'cfg', 'cfh', 'cfi']), ('7', ['p', 'q', 'r', 's']), ('9', ['w', 'x', 'y', 'z']), ('79', ['pw', 'px', 'py', 'pz', 'qw', 'qx', 'qy', 'qz', 'rw', 'rx', 'ry', 'rz', 'sw', 'sx', 'sy', 'sz']), ('22', ['aa', 'ab', 'ac', 'ba', 'bb', 'bc', 'ca', 'cb', 'cc']), ('3456', ['dgjm', 'dgjn', 'dgjo', 'dgkm', 'dgkn', 'dgko', 'dglm', 'dgln', 'dglo', 'dhjm', 'dhjn', 'dhjo', 'dhkm', 'dhkn', 'dhko', 'dhlm', 'dhln', 'dhlo', 'dijm', 'dijn', 'dijo', 'dikm', 'dikn', 'diko', 'dilm', 'diln', 'dilo', 'egjm', 'egjn', 'egjo', 'egkm', 'egkn', 'egko', 'eglm', 'egln', 'eglo', 'ehjm', 'ehjn', 'ehjo', 'ehkm', 'ehkn', 'ehko', 'ehlm', 'ehln', 'ehlo', 'eijm', 'eijn', 'eijo', 'eikm', 'eikn', 'eiko', 'eilm', 'eiln', 'eilo', 'fgjm', 'fgjn', 'fgjo', 'fgkm', 'fgkn', 'fgko', 'fglm', 'fgln', 'fglo', 'fhjm', 'fhjn', 'fhjo', 'fhkm', 'fhkn', 'fhko', 'fhlm', 'fhln', 'fhlo', 'fijm', 'fijn', 'fijo', 'fikm', 'fikn', 'fiko', 'film', 'filn', 'filo']), ('25', ['aj', 'ak', 'al', 'bj', 'bk', 'bl', 'cj', 'ck', 'cl']), ('78', ['pt', 'pu', 'pv', 'qt', 'qu', 'qv', 'rt', 'ru', 'rv', 'st', 'su', 'sv']), ('89', ['tw', 'tx', 'ty', 'tz', 'uw', 'ux', 'uy', 'uz', 'vw', 'vx', 'vy', 'vz'])]",
55+
"body": " result = run_letter_combinations(Solution, digits)\n assert_letter_combinations(result, expected)"
56+
}
57+
]
58+
},
59+
"playground_imports": "from helpers import run_letter_combinations, assert_letter_combinations\nfrom solution import Solution",
60+
"playground_setup": "# Example test case\ndigits = '23'\nexpected = ['ad', 'ae', 'af', 'bd', 'be', 'bf', 'cd', 'ce', 'cf']",
61+
"playground_run": "result = run_letter_combinations(Solution, digits)\nresult",
62+
"playground_assert": "assert_letter_combinations(result, expected)"
63+
}

‎.templates/leetcode/json/word_search.json‎

Lines changed: 67 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,67 @@
1+
{
2+
"problem_name": "word_search",
3+
"solution_class_name": "Solution",
4+
"problem_number": "79",
5+
"problem_title": "Word Search",
6+
"difficulty": "Medium",
7+
"topics": "Array, String, Backtracking, Depth-First Search, Matrix",
8+
"_tags": { "list": ["grind-75"] },
9+
"readme_description": "Given an `m x n` grid of characters `board` and a string `word`, return `true` *if* `word` *exists in the grid*.\n\nThe word can be constructed from letters of sequentially adjacent cells, where adjacent cells are horizontally or vertically neighboring. The same letter cell may not be used more than once.",
10+
"_readme_examples": {
11+
"list": [
12+
{
13+
"content": "![Word Search Example 1](https://assets.leetcode.com/uploads/2020/11/04/word2.jpg)\n\n```\nInput: board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"ABCCED\"\nOutput: true\n```"
14+
},
15+
{
16+
"content": "![Word Search Example 2](https://assets.leetcode.com/uploads/2020/11/04/word-1.jpg)\n\n```\nInput: board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"SEE\"\nOutput: true\n```"
17+
},
18+
{
19+
"content": "![Word Search Example 3](https://assets.leetcode.com/uploads/2020/10/15/word3.jpg)\n\n```\nInput: board = [[\"A\",\"B\",\"C\",\"E\"],[\"S\",\"F\",\"C\",\"S\"],[\"A\",\"D\",\"E\",\"E\"]], word = \"ABCB\"\nOutput: false\n```"
20+
}
21+
]
22+
},
23+
"readme_constraints": "- `m == board.length`\n- `n = board[i].length`\n- `1 <= m, n <= 6`\n- `1 <= word.length <= 15`\n- `board` and `word` consists of only lowercase and uppercase English letters.",
24+
"readme_additional": "**Follow up:** Could you use search pruning to make your solution faster with a larger `board`?",
25+
"helpers_imports": "",
26+
"helpers_content": "",
27+
"helpers_run_name": "exist",
28+
"helpers_run_signature": "(solution_class: type, board: list[list[str]], word: str)",
29+
"helpers_run_body": " implementation = solution_class()\n return implementation.exist(board, word)",
30+
"helpers_assert_name": "exist",
31+
"helpers_assert_signature": "(result: bool, expected: bool) -> bool",
32+
"helpers_assert_body": " assert result == expected\n return True",
33+
"solution_imports": "",
34+
"solution_contents": "",
35+
"solution_class_content": "",
36+
"test_imports": "import pytest\nfrom leetcode_py.test_utils import logged_test\nfrom .helpers import assert_exist, run_exist\nfrom .solution import Solution",
37+
"test_content": "",
38+
"test_class_name": "WordSearch",
39+
"test_class_content": " def setup_method(self):\n self.solution = Solution()",
40+
"_solution_methods": {
41+
"list": [
42+
{
43+
"name": "exist",
44+
"signature": "(self, board: list[list[str]], word: str) -> bool",
45+
"body": " # TODO: Implement exist\n return False"
46+
}
47+
]
48+
},
49+
"_test_helper_methods": {
50+
"list": [{ "name": "setup_method", "parameters": "", "body": "self.solution = Solution()" }]
51+
},
52+
"_test_methods": {
53+
"list": [
54+
{
55+
"name": "test_exist",
56+
"signature": "(self, board: list[list[str]], word: str, expected: bool)",
57+
"parametrize": "board, word, expected",
58+
"test_cases": "[([['A', 'B', 'C', 'E'], ['S', 'F', 'C', 'S'], ['A', 'D', 'E', 'E']], 'ABCCED', True), ([['A', 'B', 'C', 'E'], ['S', 'F', 'C', 'S'], ['A', 'D', 'E', 'E']], 'SEE', True), ([['A', 'B', 'C', 'E'], ['S', 'F', 'C', 'S'], ['A', 'D', 'E', 'E']], 'ABCB', False), ([['A']], 'A', True), ([['A']], 'B', False), ([['A', 'B'], ['C', 'D']], 'ACDB', True), ([['A', 'B'], ['C', 'D']], 'ABDC', True), ([['A', 'B'], ['C', 'D']], 'ABCD', False), ([['C', 'A', 'A'], ['A', 'A', 'A'], ['B', 'C', 'D']], 'AAB', True), ([['A', 'B', 'C', 'E'], ['S', 'F', 'C', 'S'], ['A', 'D', 'E', 'E']], 'ABCESEEEFS', False), ([['A', 'A', 'A', 'A', 'A', 'A'], ['A', 'A', 'A', 'A', 'A', 'A'], ['A', 'A', 'A', 'A', 'A', 'A'], ['A', 'A', 'A', 'A', 'A', 'A'], ['A', 'A', 'A', 'A', 'A', 'A'], ['A', 'A', 'A', 'A', 'A', 'A']], 'AAAAAAAAAAAAAAB', False), ([['A', 'B', 'C', 'E'], ['S', 'F', 'C', 'S'], ['A', 'D', 'E', 'E']], 'SFCS', True)]",
59+
"body": " result = run_exist(Solution, board, word)\n assert_exist(result, expected)"
60+
}
61+
]
62+
},
63+
"playground_imports": "from helpers import run_exist, assert_exist\nfrom solution import Solution",
64+
"playground_setup": "# Example test case\nboard = [['A', 'B', 'C', 'E'], ['S', 'F', 'C', 'S'], ['A', 'D', 'E', 'E']]\nword = 'ABCCED'\nexpected = True",
65+
"playground_run": "result = run_exist(Solution, board, word)\nresult",
66+
"playground_assert": "assert_exist(result, expected)"
67+
}

‎Makefile‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
PYTHON_VERSION = 3.13
2-
PROBLEM ?= construct_binary_tree_from_preorder_and_inorder_traversal
2+
PROBLEM ?= find_all_anagrams_in_a_string
33
FORCE ?= 0
44
COMMA := ,
55

‎leetcode/diagonal_traverse/README.md‎

Lines changed: 37 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,37 @@
1+
# Diagonal Traverse
2+
3+
**Difficulty:** Medium
4+
**Topics:** Array, Matrix, Simulation
5+
**Tags:**
6+
7+
**LeetCode:** [Problem 498](https://leetcode.com/problems/diagonal-traverse/description/)
8+
9+
## Problem Description
10+
11+
Given an `m x n` matrix `mat`, return _an array of all the elements of the array in a diagonal order_.
12+
13+
## Examples
14+
15+
### Example 1:
16+
17+
![Diagonal Traverse](https://assets.leetcode.com/uploads/2021/04/10/diag1-grid.jpg)
18+
19+
```
20+
Input: mat = [[1,2,3],[4,5,6],[7,8,9]]
21+
Output: [1,2,4,7,5,3,6,8,9]
22+
```
23+
24+
### Example 2:
25+
26+
```
27+
Input: mat = [[1,2],[3,4]]
28+
Output: [1,2,3,4]
29+
```
30+
31+
## Constraints
32+
33+
- `m == mat.length`
34+
- `n == mat[i].length`
35+
- `1 <= m, n <= 10^4`
36+
- `1 <= m * n <= 10^4`
37+
- `-10^5 <= mat[i][j] <= 10^5`

‎leetcode/diagonal_traverse/__init__.py‎

Whitespace-only changes.

‎leetcode/diagonal_traverse/helpers.py‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,8 @@
1+
def run_find_diagonal_order(solution_class: type, mat: list[list[int]]):
2+
implementation = solution_class()
3+
return implementation.find_diagonal_order(mat)
4+
5+
6+
def assert_find_diagonal_order(result: list[int], expected: list[int]) -> bool:
7+
assert result == expected
8+
return True

‎leetcode/diagonal_traverse/playground.py‎

Lines changed: 29 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,29 @@
1+
# ---
2+
# jupyter:
3+
# jupytext:
4+
# text_representation:
5+
# extension: .py
6+
# format_name: percent
7+
# format_version: '1.3'
8+
# jupytext_version: 1.17.3
9+
# kernelspec:
10+
# display_name: leetcode-py-py3.13
11+
# language: python
12+
# name: python3
13+
# ---
14+
15+
# %%
16+
from helpers import assert_find_diagonal_order, run_find_diagonal_order
17+
from solution import Solution
18+
19+
# %%
20+
# Example test case
21+
mat = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
22+
expected = [1, 2, 4, 7, 5, 3, 6, 8, 9]
23+
24+
# %%
25+
result = run_find_diagonal_order(Solution, mat)
26+
result
27+
28+
# %%
29+
assert_find_diagonal_order(result, expected)

0 commit comments

Comments
 (0)