D. J.:

- Updated automated tests for format
- Added the leetcode problem and solution for 36, 48, 54, 73 and 289

Author: nobodyPerfecZ

.github/workflows/check-format.yaml

@@ -30,5 +30,4 @@ jobs:
           # stop the build if there are Python syntax errors or undefined names
           flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
           # exit-zero treats all errors as warnings. Black has 88 max-line-length
-          flake8 . --count --exit-zero --max-complexity=10 --max-line-length=88 --statistics --ignore=E121,E123,E126,E203,E226,E24,E704,W503,W504
-
+          flake8 . --count --extend-ignore=E203,C901 --exit-zero --max-complexity=10 --max-line-length=88 --statistics

README.md

@@ -42,10 +42,13 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [27 Remove Element](https://leetcode.com/problems/remove-element/description/)
 - [28 Find the Index of the First Occurrence in a String](https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string/description/)
 - [30 Substring with Concatenation of All Words](https://leetcode.com/problems/substring-with-concatenation-of-all-words/description/)
+- [36 Valid Sudoku](https://leetcode.com/problems/valid-sudoku/description/)
 - [42 Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/description/)
 - [45 Jump Game II](https://leetcode.com/problems/jump-game-ii/description/)
+- [48 Rotate Image](https://leetcode.com/problems/rotate-image/description/)
 - [49 Group Anagrams](https://leetcode.com/problems/group-anagrams/description/)
 - [50 Pow(x_n)](https://leetcode.com/problems/powx-n/description/)
+- [54 Spiral Matrix](https://leetcode.com/problems/spiral-matrix/description/)
 - [55 Jump Game](https://leetcode.com/problems/jump-game/description/)
 - [58 Length of Last Word](https://leetcode.com/problems/length-of-last-word/description/)
 - [56 Merge Intervals](https://leetcode.com/problems/merge-intervals/description/)
@@ -56,6 +59,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [68 Text Justification](https://leetcode.com/problems/text-justification/description/)
 - [69 Sqrt(x)](https://leetcode.com/problems/sqrtx/description/)
 - [71 Simplify Path](https://leetcode.com/problems/simplify-path/description/)
+- [73 Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/description/)
 - [76 Minimum Window Substring](https://leetcode.com/problems/minimum-window-substring/description/)
 - [80 Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/description/)
 - [82 Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/description/)
@@ -119,6 +123,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [238 Product of Array Except Self](https://leetcode.com/problems/product-of-array-except-self/description/)
 - [242 Valid Anagram](https://leetcode.com/problems/valid-anagram/description/)
 - [274 H-Index](https://leetcode.com/problems/h-index/description/)
+- [289 Game of Life](https://leetcode.com/problems/game-of-life/description/)
 - [290 Word Pattern](https://leetcode.com/problems/word-pattern/description/)
 - [380 Insert Delete GetRandom O(1)](https://leetcode.com/problems/insert-delete-getrandom-o1/description/)
 - [383 Ransom Note](https://leetcode.com/problems/ransom-note/description/)

awesome_python_leetcode/_289_game_of_life.py

@@ -0,0 +1,81 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def gameOfLife(self, board: List[List[int]]) -> None:
+        """
+        According to Wikipedia's article: "The Game of Life, also known simply as Life,
+        is a cellular automaton devised by the British mathematician John Horton
+        Conway in 1970."
+
+        The board is made up of an m x n grid of cells, where each cell has an initial
+        state: live (represented by a 1) or dead (represented by a 0). Each cell
+        interacts with its eight neighbors (horizontal, vertical, diagonal) using the
+        following four rules (taken from the above Wikipedia article):
+        1. Any live cell with fewer than two live neighbors dies as if caused by
+        under-population.
+        2. Any live cell with two or three live neighbors lives on to the next
+        generation.
+        3. Any live cell with more than three live neighbors dies, as if by
+        over-population.
+        4. Any dead cell with exactly three live neighbors becomes a live cell, as if
+        by reproduction.
+
+        The next state of the board is determined by applying the above rules
+        simultaneously to every cell in the current state of the m x n grid board. In
+        this process, births and deaths occur simultaneously.
+
+        Given the current state of the board, update the board to reflect its next
+        state.
+
+        Note that you do not need to return anything.
+        """
+
+        def kernel(row: int, col: int) -> int:
+            live = board[row][col] == 1
+            neighbors = [
+                (row - 1, col - 1),
+                (row - 1, col),
+                (row - 1, col + 1),
+                (row, col - 1),
+                (row, col + 1),
+                (row + 1, col - 1),
+                (row + 1, col),
+                (row + 1, col + 1),
+            ]
+            sumNeighbors = sum(
+                [
+                    (
+                        board[i_][j_] == 1 or board[i_][j_] == 3
+                        if i_ >= 0
+                        and i_ < len(board)
+                        and j_ >= 0
+                        and j_ < len(board[0])
+                        else 0
+                    )
+                    for (i_, j_) in neighbors
+                ]
+            )
+            if live:
+                if sumNeighbors < 2 or sumNeighbors > 3:
+                    return 1
+                else:
+                    return 3
+            else:
+                if sumNeighbors == 3:
+                    return 2
+                else:
+                    return 0
+
+        for row in range(len(board)):
+            for col in range(len(board[0])):
+                board[row][col] = kernel(row, col)
+
+        for row in range(len(board)):
+            for col in range(len(board[0])):
+                if board[row][col] == 1:
+                    board[row][col] = 0
+                elif board[row][col] == 2 or board[row][col] == 3:
+                    board[row][col] = 1

awesome_python_leetcode/_36_valid_sudoku.py

@@ -0,0 +1,47 @@
+import collections
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def isValidSudoku(self, board: List[List[str]]) -> bool:
+        """
+        Determine if a 9 x 9 Sudoku board is valid. Only the filled cells need to be
+        validated according to the following rules:
+        1. Each row must contain the digits 1-9 without repetition.
+        2. Each column must contain the digits 1-9 without repetition.
+        3. Each of the nine 3 x 3 sub-boxes of the grid must contain the digits 1-9
+        without repetition.
+
+        Note:
+        - A Sudoku board (partially filled) could be valid but is not necessarily
+        solvable.
+        - Only the filled cells need to be validated according to the mentioned rules.
+        """
+        rows, cols, squares = (
+            collections.defaultdict(set),
+            collections.defaultdict(set),
+            collections.defaultdict(set),
+        )
+
+        for row in range(len(board)):
+            for col in range(len(board[row])):
+                num = board[row][col]
+                if num == ".":
+                    continue
+                rowIdx = row
+                colIdx = col
+                squareIdx = 3 * (row // 3) + col // 3
+
+                if (
+                    num in rows[rowIdx]
+                    or num in cols[colIdx]
+                    or num in squares[squareIdx]
+                ):
+                    return False
+
+                rows[rowIdx].add(num)
+                cols[colIdx].add(num)
+                squares[squareIdx].add(num)
+        return True

awesome_python_leetcode/_48_rotate_image.py

@@ -0,0 +1,25 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def rotate(self, matrix: List[List[int]]) -> None:
+        """
+        You are given an n x n 2D matrix representing an image, rotate the image by 90
+        degrees (clockwise).
+
+        You have to rotate the image in-place, which means you have to modify the input
+        2D matrix directly. DO NOT allocate another 2D matrix and do the rotation.
+        """
+        i, n = 0, len(matrix) - 1
+        while i < n - i:
+            j = i
+            while j < n - i:
+                tmp = matrix[i][j]
+                matrix[i][j] = matrix[n - j][i]
+                matrix[n - j][i] = matrix[n - i][n - j]
+                matrix[n - i][n - j] = matrix[j][n - i]
+                matrix[j][n - i] = tmp
+                j += 1
+            i += 1

awesome_python_leetcode/_54_spiral_matrix.py

@@ -0,0 +1,35 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def spiralOrder(self, matrix: List[List[int]]) -> List[int]:
+        """
+        Given an m x n matrix, return all elements of the matrix in spiral order.
+        """
+        left, right = 0, len(matrix[0])
+        top, bottom = 0, len(matrix)
+
+        res = []
+        while left < right and top < bottom:
+            for i in range(left, right):
+                res.append(matrix[top][i])
+            top += 1
+
+            for i in range(top, bottom):
+                res.append(matrix[i][right - 1])
+            right -= 1
+
+            if not (left < right and top < bottom):
+                break
+
+            for i in range(right - 1, left - 1, -1):
+                res.append(matrix[bottom - 1][i])
+            bottom -= 1
+
+            for i in range(bottom - 1, top - 1, -1):
+                res.append(matrix[i][left])
+            left += 1
+
+        return res

awesome_python_leetcode/_73_set_matrix_zeroes.py

@@ -0,0 +1,35 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def setZeroes(self, matrix: List[List[int]]) -> None:
+        """
+        Given an m x n integer matrix matrix, if an element is 0, set its entire row
+        and column to 0's.
+
+        You must do it in place.
+        """
+        rowZero = False
+        for row in range(len(matrix)):
+            for col in range(len(matrix[0])):
+                if matrix[row][col] == 0:
+                    matrix[0][col] = 0
+                    if row > 0:
+                        matrix[row][0] = 0
+                    else:
+                        rowZero = True
+
+        for row in range(1, len(matrix)):
+            for col in range(1, len(matrix[0])):
+                if matrix[0][col] == 0 or matrix[row][0] == 0:
+                    matrix[row][col] = 0
+
+        if matrix[0][0] == 0:
+            for row in range(len(matrix)):
+                matrix[row][0] = 0
+
+        if rowZero:
+            for col in range(len(matrix[0])):
+                matrix[0][col] = 0

tests/test_289_game_of_life.py

@@ -0,0 +1,21 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._289_game_of_life import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["board", "expected"],
+    argvalues=[
+        (
+            [[0, 1, 0], [0, 0, 1], [1, 1, 1], [0, 0, 0]],
+            [[0, 0, 0], [1, 0, 1], [0, 1, 1], [0, 1, 0]],
+        ),
+        ([[1, 1], [1, 0]], [[1, 1], [1, 1]]),
+    ],
+)
+def test_func(board: List[List[int]], expected: List[List[int]]):
+    """Tests the solution of a LeetCode problem."""
+    Solution().gameOfLife(board)
+    assert board == expected

tests/test_36_valid_sudoku.py

@@ -0,0 +1,44 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._36_valid_sudoku import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["board", "expected"],
+    argvalues=[
+        (
+            [
+                ["5", "3", ".", ".", "7", ".", ".", ".", "."],
+                ["6", ".", ".", "1", "9", "5", ".", ".", "."],
+                [".", "9", "8", ".", ".", ".", ".", "6", "."],
+                ["8", ".", ".", ".", "6", ".", ".", ".", "3"],
+                ["4", ".", ".", "8", ".", "3", ".", ".", "1"],
+                ["7", ".", ".", ".", "2", ".", ".", ".", "6"],
+                [".", "6", ".", ".", ".", ".", "2", "8", "."],
+                [".", ".", ".", "4", "1", "9", ".", ".", "5"],
+                [".", ".", ".", ".", "8", ".", ".", "7", "9"],
+            ],
+            True,
+        ),
+        (
+            [
+                ["8", "3", ".", ".", "7", ".", ".", ".", "."],
+                ["6", ".", ".", "1", "9", "5", ".", ".", "."],
+                [".", "9", "8", ".", ".", ".", ".", "6", "."],
+                ["8", ".", ".", ".", "6", ".", ".", ".", "3"],
+                ["4", ".", ".", "8", ".", "3", ".", ".", "1"],
+                ["7", ".", ".", ".", "2", ".", ".", ".", "6"],
+                [".", "6", ".", ".", ".", ".", "2", "8", "."],
+                [".", ".", ".", "4", "1", "9", ".", ".", "5"],
+                [".", ".", ".", ".", "8", ".", ".", "7", "9"],
+            ],
+            False,
+        ),
+    ],
+)
+def test_func(board: List[List[str]], expected: bool):
+    """Tests the solution of a LeetCode problem."""
+    is_valid = Solution().isValidSudoku(board)
+    assert is_valid is expected

tests/test_48_rotate_image.py

@@ -0,0 +1,21 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._48_rotate_image import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["matrix", "expected"],
+    argvalues=[
+        ([[1, 2, 3], [4, 5, 6], [7, 8, 9]], [[7, 4, 1], [8, 5, 2], [9, 6, 3]]),
+        (
+            [[5, 1, 9, 11], [2, 4, 8, 10], [13, 3, 6, 7], [15, 14, 12, 16]],
+            [[15, 13, 2, 5], [14, 3, 4, 1], [12, 6, 8, 9], [16, 7, 10, 11]],
+        ),
+    ],
+)
+def test_func(matrix: List[List[int]], expected: List[List[int]]):
+    """Tests the solution of a LeetCode problem."""
+    Solution().rotate(matrix)
+    assert matrix == expected