Ensure all lines are <= 88 characters

Author: nickolashkraus

pyproject.toml

@@ -20,6 +20,14 @@ dependencies = [
   "ruff"
 ]
 
+[tool.pytest.ini_options]
+filterwarnings = [
+    "ignore:invalid escape sequence:SyntaxWarning"
+]
+
+[tool.ruff]
+line-length = 88
+
 [tool.ruff.lint]
 # A002: Argument is shadowing a Python builtin
 # E741: do not use variables named 'l', 'O', or 'I'

src/binary_tree_level_order_traversal.py

@@ -49,7 +49,9 @@ def levelOrder(self, root: TreeNode | None) -> list[list[int]]:
         self._levelOrder(root, 0, levels)
         return levels
 
-    def _levelOrder(self, root: TreeNode | None, level: int, levels: list[list[int]]) -> None:
+    def _levelOrder(
+        self, root: TreeNode | None, level: int, levels: list[list[int]]
+    ) -> None:
         if not root:
             return
         if len(levels) < level + 1:

src/classes/__init__.py

@@ -22,7 +22,9 @@ class TreeNode(Generic[T]):
     A tree node in a binary tree.
     """
 
-    def __init__(self, val: T, left: Self | None = None, right: Self | None = None) -> None:
+    def __init__(
+        self, val: T, left: Self | None = None, right: Self | None = None
+    ) -> None:
         self.val: T = val
         self.left: TreeNode[T] | None = right
         self.right: TreeNode[T] | None = left

src/flood_fill.py

@@ -58,7 +58,9 @@ class Solution:
     Uses breadth-first search.
     """
 
-    def floodFill(self, image: list[list[int]], sr: int, sc: int, color: int) -> list[list[int]]:
+    def floodFill(
+        self, image: list[list[int]], sr: int, sc: int, color: int
+    ) -> list[list[int]]:
         # If the starting pixel is already our target color, return `image`,
         # since no pixels will be modified.
         if image[sr][sc] == color:
@@ -104,7 +106,9 @@ class SolutionDFS:
     Uses depth-first search.
     """
 
-    def floodFill(self, image: list[list[int]], sr: int, sc: int, color: int) -> list[list[int]]:
+    def floodFill(
+        self, image: list[list[int]], sr: int, sc: int, color: int
+    ) -> list[list[int]]:
         # If the starting pixel is already our target color, return `image`,
         # since no pixels will be modified.
         if image[sr][sc] == color:

src/lowest_common_ancestor_of_a_binary_search_tree.py

@@ -28,7 +28,9 @@
 
 
 class Solution:
-    def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
+    def lowestCommonAncestor(
+        self, root: TreeNode, p: TreeNode, q: TreeNode
+    ) -> TreeNode:
         while True:
             if root.val > p.val and root.val > q.val and root.left:
                 root = root.left

src/lowest_common_ancestor_of_a_binary_tree.py

@@ -103,7 +103,9 @@ class Solution:
     Returns the LCA of `p` and `q` for the tree rooted at `root` recursively.
     """
 
-    def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
+    def lowestCommonAncestor(
+        self, root: TreeNode, p: TreeNode, q: TreeNode
+    ) -> TreeNode:
         # Base Case: If root is a leaf (None) or if root is p or q, return
         # root.
         if not root or root in (p, q):
@@ -135,7 +137,9 @@ class IterativeSolution:
     Returns the LCA of `p` and `q` for the tree rooted at `root` iteratively.
     """
 
-    def lowestCommonAncestor(self, root: TreeNode, p: TreeNode, q: TreeNode) -> TreeNode:
+    def lowestCommonAncestor(
+        self, root: TreeNode, p: TreeNode, q: TreeNode
+    ) -> TreeNode:
         stack: deque[TreeNode] = deque([root])
         parents: dict[TreeNode, TreeNode | None] = {root: None}
         curr: TreeNode = root

src/merge_two_sorted_lists.py

@@ -57,7 +57,9 @@
 
 
 class Solution:
-    def mergeTwoLists(self, list1: ListNode | None, list2: ListNode | None) -> ListNode | None:
+    def mergeTwoLists(
+        self, list1: ListNode | None, list2: ListNode | None
+    ) -> ListNode | None:
         prehead = ListNode(-1)
         curr = prehead
         # 1. Compare the heads of the two lists.

src/reorder_list.py

@@ -109,7 +109,9 @@ def reverseList(self, head: ListNode | None) -> ListNode | None:
             curr = _next
         return prev
 
-    def mergeTwoLists(self, list1: ListNode | None, list2: ListNode | None) -> ListNode | None:
+    def mergeTwoLists(
+        self, list1: ListNode | None, list2: ListNode | None
+    ) -> ListNode | None:
         """
         Given the head of two singly linked-lists, merge them starting with the
         head of the first list.

src/subtree_of_another_tree.py

@@ -38,6 +38,8 @@ def isSameTree(self, t1: TreeNode | None, t2: TreeNode | None) -> bool:
             return False
 
         if t1.val == t2.val:
-            return self.isSameTree(t1.left, t2.left) and self.isSameTree(t1.right, t2.right)
+            return self.isSameTree(t1.left, t2.left) and self.isSameTree(
+                t1.right, t2.right
+            )
 
         return False

src/top_k_frequent_elements.py

@@ -131,7 +131,9 @@ def topKFrequent(self, nums: list[int], k: int) -> list[int]:
         # is sorted anyway.
         return sorted(l[:k])
 
-    def quickselect(self, d: dict[int, int], l: list[int], left: int, right: int, k: int) -> int:
+    def quickselect(
+        self, d: dict[int, int], l: list[int], left: int, right: int, k: int
+    ) -> int:
         """
         Return the kth element (0-based) in the given list.
         """

src/valid_palindrome.py

@@ -52,13 +52,21 @@ def isPalindrome(self, s: str) -> bool:
         p0, p1 = 0, len(s) - 1
         while p0 < p1:
             c0, c1 = ord(s[p0]), ord(s[p1])
-            if (ASCII_0 <= c0 <= ASCII_9) or (ASCII_A <= c0 <= ASCII_Z) or (ASCII_a <= c0 <= ASCII_z):
+            if (
+                (ASCII_0 <= c0 <= ASCII_9)
+                or (ASCII_A <= c0 <= ASCII_Z)
+                or (ASCII_a <= c0 <= ASCII_z)
+            ):
                 if ASCII_A <= c0 <= ASCII_Z:
                     c0 = c0 + OFFSET
             else:
                 p0 = p0 + 1
                 continue
-            if (ASCII_0 <= c1 <= ASCII_9) or (ASCII_A <= c1 <= ASCII_Z) or (ASCII_a <= c1 <= ASCII_z):
+            if (
+                (ASCII_0 <= c1 <= ASCII_9)
+                or (ASCII_A <= c1 <= ASCII_Z)
+                or (ASCII_a <= c1 <= ASCII_z)
+            ):
                 if ASCII_A <= c1 <= ASCII_Z:
                     c1 = c1 + OFFSET
             else:

src/validate_binary_search_tree.py

@@ -72,4 +72,6 @@ def _isValidBST(self, root: TreeNode, lo: int, hi: int) -> bool:
         # Recursively apply the minimal subtree solution to all subtrees. Any
         # invalid subtree will cause the bitwise AND operation to return False
         # (0) for the entire tree.
-        return self._isValidBST(root.left, lo, root.val) and self._isValidBST(root.right, root.val, hi)
+        return self._isValidBST(root.left, lo, root.val) and self._isValidBST(
+            root.right, root.val, hi
+        )

tests/test_best_time_to_buy_and_sell_stock.py

@@ -6,7 +6,12 @@
 
 from unittest import TestCase
 
-from src.best_time_to_buy_and_sell_stock import NaiveSolution, OptimizedNaiveSolution, SlidingWindowSolution, Solution
+from src.best_time_to_buy_and_sell_stock import (
+    NaiveSolution,
+    OptimizedNaiveSolution,
+    SlidingWindowSolution,
+    Solution,
+)
 
 
 class TestSolution(TestCase):

tests/test_construct_binary_tree_from_preorder_and_inorder_traversal.py

@@ -13,7 +13,10 @@
 class TestSolution(TestCase):
     def test_1(self):
         exp = [3, 9, 20, None, None, 15, 7]
-        assert_tree(Solution().buildTree(preorder=[3, 9, 20, 15, 7], inorder=[9, 3, 15, 20, 7]), exp)
+        assert_tree(
+            Solution().buildTree(preorder=[3, 9, 20, 15, 7], inorder=[9, 3, 15, 20, 7]),
+            exp,
+        )
 
     def test_2(self):
         exp = [-1]

tests/test_flood_fill.py

@@ -22,7 +22,9 @@ def test_2(self):
 class TestSolutionDFS(TestCase):
     def test_1(self):
         exp = [[2, 2, 2], [2, 2, 0], [2, 0, 1]]
-        assert SolutionDFS().floodFill([[1, 1, 1], [1, 1, 0], [1, 0, 1]], 1, 1, 2) == exp
+        assert (
+            SolutionDFS().floodFill([[1, 1, 1], [1, 1, 0], [1, 0, 1]], 1, 1, 2) == exp
+        )
 
     def test_2(self):
         exp = [[0, 0, 0], [0, 0, 0]]

tests/test_longest_common_subsequence.py

@@ -6,7 +6,12 @@
 
 from unittest import TestCase
 
-from src.longest_common_subsequence import AlternativeSolution, MemoizationSolution, RecursiveSolution, Solution
+from src.longest_common_subsequence import (
+    AlternativeSolution,
+    MemoizationSolution,
+    RecursiveSolution,
+    Solution,
+)
 
 
 class TestSolution(TestCase):
@@ -24,7 +29,10 @@ def test_3(self):
 
     def test_4(self):
         exp = 4
-        assert Solution().longestCommonSubsequence("pmjghexybyrgzczy", "hafcdqbgncrcbihkd") == exp
+        assert (
+            Solution().longestCommonSubsequence("pmjghexybyrgzczy", "hafcdqbgncrcbihkd")
+            == exp
+        )
 
 
 class TestAlternativeSolution(TestCase):
@@ -42,7 +50,12 @@ def test_3(self):
 
     def test_4(self):
         exp = 4
-        assert AlternativeSolution().longestCommonSubsequence("pmjghexybyrgzczy", "hafcdqbgncrcbihkd") == exp
+        assert (
+            AlternativeSolution().longestCommonSubsequence(
+                "pmjghexybyrgzczy", "hafcdqbgncrcbihkd"
+            )
+            == exp
+        )
 
 
 class TestMemoizationSolution(TestCase):
@@ -60,7 +73,12 @@ def test_3(self):
 
     def test_4(self):
         exp = 4
-        assert MemoizationSolution().longestCommonSubsequence("pmjghexybyrgzczy", "hafcdqbgncrcbihkd") == exp
+        assert (
+            MemoizationSolution().longestCommonSubsequence(
+                "pmjghexybyrgzczy", "hafcdqbgncrcbihkd"
+            )
+            == exp
+        )
 
 
 class TestRecursiveSolution(TestCase):
@@ -78,4 +96,9 @@ def test_3(self):
 
     def test_4(self):
         exp = 4
-        assert MemoizationSolution().longestCommonSubsequence("pmjghexybyrgzczy", "hafcdqbgncrcbihkd") == exp
+        assert (
+            MemoizationSolution().longestCommonSubsequence(
+                "pmjghexybyrgzczy", "hafcdqbgncrcbihkd"
+            )
+            == exp
+        )

tests/test_longest_increasing_subsequence.py

@@ -6,7 +6,11 @@
 
 from unittest import TestCase
 
-from src.longest_increasing_subsequence import MemoizationSolution, RecursiveSolution, Solution
+from src.longest_increasing_subsequence import (
+    MemoizationSolution,
+    RecursiveSolution,
+    Solution,
+)
 
 
 class TestSolution(TestCase):
@@ -50,7 +54,10 @@ def test_4(self):
 
     def test_5(self):
         exp = 6
-        assert MemoizationSolution().lengthOfLIS([3, 5, 6, 2, 5, 4, 19, 5, 6, 7, 12]) == exp
+        assert (
+            MemoizationSolution().lengthOfLIS([3, 5, 6, 2, 5, 4, 19, 5, 6, 7, 12])
+            == exp
+        )
 
 
 class TestRecursiveSolution(TestCase):
@@ -72,4 +79,6 @@ def test_4(self):
 
     def test_5(self):
         exp = 6
-        assert RecursiveSolution().lengthOfLIS([3, 5, 6, 2, 5, 4, 19, 5, 6, 7, 12]) == exp
+        assert (
+            RecursiveSolution().lengthOfLIS([3, 5, 6, 2, 5, 4, 19, 5, 6, 7, 12]) == exp
+        )

tests/test_maximum_subarray.py

@@ -26,7 +26,9 @@ def test_3(self):
 class TestTabularizationSolution(TestCase):
     def test_1(self):
         exp = 6
-        assert TabularizationSolution().maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4]) == exp
+        assert (
+            TabularizationSolution().maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4]) == exp
+        )
 
     def test_2(self):
         exp = 1

tests/test_valid_palindrome.py

@@ -30,7 +30,9 @@ def test_4(self):
 class TestSimplifiedSolution(TestCase):
     def test_1(self):
         exp = True
-        assert SimplifiedSolution().isPalindrome("A man, a plan, a canal: Panama") == exp
+        assert (
+            SimplifiedSolution().isPalindrome("A man, a plan, a canal: Panama") == exp
+        )
 
     def test_2(self):
         exp = False

tests/utils.py

@@ -131,7 +131,9 @@ def _create_binary_tree_from_list(l: list[int | None], i: int) -> TreeNode | Non
     return node
 
 
-def create_bfs_list_from_binary_tree(*, root: TreeNode | None, values_only: bool = True) -> list[TreeNode | T]:
+def create_bfs_list_from_binary_tree(
+    *, root: TreeNode | None, values_only: bool = True
+) -> list[TreeNode | T]:
     """
     Creates a list of nodes in breadth-first search order given the root node
     of a binary tree. If values_only is False, the list contains the TreeNode