D. J.:

- Added the leetcode problem and solution for 102 and 103
- Fixed typing errors

Author: nobodyPerfecZ

Diff for: README.md

@@ -0,0 +1,30 @@
+from typing import List, Optional
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def levelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        """
+        Given the root of a binary tree, return the level order traversal of its nodes'
+        values. (i.e., from left to right, level by level).
+        """
+        if root is None:
+            return []
+        parents = [root]
+        result = []
+        while parents:
+            # Build childs and level
+            childs = []
+            level = []
+            for p in parents:
+                if p.left:
+                    childs.append(p.left)
+                if p.right:
+                    childs.append(p.right)
+                level.append(p.val)
+            parents = childs
+            result.append(level)
+        return result

Diff for: awesome_python_leetcode/_102_binary_tree_level_order_traversal.py

@@ -0,0 +1,39 @@
+from typing import List, Optional
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def zigzagLevelOrder(self, root: Optional[TreeNode]) -> List[List[int]]:
+        """
+        Given the root of a binary tree, return the zigzag level order traversal of its
+        nodes' values. (i.e., from left to right, then right to left for the next level
+        and alternate between).
+        """
+        if root is None:
+            return []
+        parents = [root]
+        result = []
+        even_level = True
+        while parents:
+            # Build childs and zig-zag levelorder
+            childs = []
+            levelorder = []
+            for p in reversed(parents):
+                if even_level:
+                    if p.left:
+                        childs.append(p.left)
+                    if p.right:
+                        childs.append(p.right)
+                else:
+                    if p.right:
+                        childs.append(p.right)
+                    if p.left:
+                        childs.append(p.left)
+                levelorder.append(p.val)
+            parents = childs
+            result.append(levelorder)
+            even_level = not even_level
+        return result

Diff for: awesome_python_leetcode/_103_binary_tree_zigzag_level_order_traversal.py

@@ -2,6 +2,8 @@
 
 
 class Solution:
+    """Base class for all LeetCode Problems."""
+
     def singleNumber(self, nums: List[int]) -> int:
         """
         Given a non-empty array of integers nums, every element appears twice except for

Diff for: awesome_python_leetcode/_136_single_number.py

@@ -2,6 +2,8 @@
 
 
 class Solution:
+    """Base class for all LeetCode Problems."""
+
     def singleNumber(self, nums: List[int]) -> int:
         """
         Given an integer array nums where every element appears three times except for

Diff for: awesome_python_leetcode/_137_single_number_II.py

@@ -1,4 +1,6 @@
 class Solution:
+    """Base class for all LeetCode Problems."""
+
     def reverseBits(self, n: int) -> int:
         """Reverse bits of a given 32 bits unsigned integer."""
         res = 0

Diff for: awesome_python_leetcode/_190_reverse_bits.py

@@ -1,4 +1,6 @@
 class Solution:
+    """Base class for all LeetCode Problems."""
+
     def hammingWeight(self, n: int) -> int:
         """
         Given a positive integer n, write a function that returns the number of set bits

Diff for: awesome_python_leetcode/_191_number_of_1_bits.py

@@ -4,6 +4,8 @@
 
 
 class Solution:
+    """Base class for all LeetCode Problems."""
+
     def rightSideView(self, root: Optional[TreeNode]) -> List[int]:
         """
         Given the root of a binary tree, imagine yourself standing on the right side of

Diff for: awesome_python_leetcode/_199_binary_tree_right_side_view.py

@@ -1,4 +1,6 @@
 class Solution:
+    """Base class for all LeetCode Problems."""
+
     def rangeBitwiseAnd(self, left: int, right: int) -> int:
         """
         Given two integers left and right that represent the range [left, right],

Diff for: awesome_python_leetcode/_201_bitwise_and_of_numbers_range.py

@@ -4,6 +4,8 @@
 
 
 class Solution:
+    """Base class for all LeetCode Problems."""
+
     def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
         """
         Given the root of a binary tree, return the average value of the nodes on each

Diff for: awesome_python_leetcode/_637_average_of_levels_in_binary_tree.py

@@ -1,4 +1,6 @@
 class Solution:
+    """Base class for all LeetCode Problems."""
+
     def addBinary(self, a: str, b: str) -> str:
         """Given two binary strings a and b, return their sum as a binary string."""
         result, overhead = "", "0"

Diff for: awesome_python_leetcode/_67_add_binary.py

@@ -14,6 +14,7 @@
     ],
 )
 def test_func(p: List[int], q: List[int], expected: bool):
+    """Tests the solution of a LeetCode problem."""
     p = TreeNode.build(p)
     q = TreeNode.build(q)
     is_same_tree = Solution().isSameTree(p, q)

Diff for: tests/test_100_same_tree.py

@@ -13,6 +13,7 @@
     ],
 )
 def test_func(root: List[int], expected: bool):
+    """Tests the solution of a LeetCode problem."""
     root = TreeNode.build(root)
     is_symmetric = Solution().isSymmetric(root)
     assert is_symmetric == expected

Diff for: tests/test_101_symmetric_tree.py

@@ -0,0 +1,21 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._102_binary_tree_level_order_traversal import Solution
+from awesome_python_leetcode.tree import TreeNode
+
+
+@pytest.mark.parametrize(
+    argnames=["root", "expected"],
+    argvalues=[
+        ([3, 9, 20, None, None, 15, 7], [[3], [9, 20], [15, 7]]),
+        ([1], [[1]]),
+        ([], []),
+    ],
+)
+def test_func(root: List[int], expected: List[List[int]]):
+    """Tests the solution of a LeetCode problem."""
+    root = TreeNode.build(root)
+    level_order = Solution().levelOrder(root)
+    assert level_order == expected

Diff for: tests/test_102_binary_tree_level_order_traversal.py

@@ -0,0 +1,23 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._103_binary_tree_zigzag_level_order_traversal import (
+    Solution,
+)
+from awesome_python_leetcode.tree import TreeNode
+
+
+@pytest.mark.parametrize(
+    argnames=["root", "expected"],
+    argvalues=[
+        ([3, 9, 20, None, None, 15, 7], [[3], [20, 9], [15, 7]]),
+        ([1], [[1]]),
+        ([], []),
+    ],
+)
+def test_func(root: List[int], expected: List[List[int]]):
+    """Tests the solution of a LeetCode problem."""
+    root = TreeNode.build(root)
+    zig_zag_level_order = Solution().zigzagLevelOrder(root)
+    assert zig_zag_level_order == expected

Diff for: tests/test_103_binary_tree_zigzag_level_order_traversal.py

@@ -13,6 +13,7 @@
     ],
 )
 def test_func(root: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
     root = TreeNode.build(root)
     max_depth = Solution().maxDepth(root)
     assert max_depth == expected

Diff for: tests/test_104_maximum_depth_of_binary_tree.py

@@ -17,6 +17,7 @@
     ],
 )
 def test_func(preorder: List[int], inorder: List[int], expected: List[int]):
+    """Tests the solution of a LeetCode problem."""
     solution = TreeNode.build(expected)
     actual = Solution().buildTree(preorder, inorder)
     assert TreeNode.compare(actual, solution) is True

Diff for: tests/test_105_construct_binary_tree_from_preorder_and_inorder_traversal.py

@@ -14,6 +14,7 @@
     ],
 )
 def test_func(root: List[int], targetSum: int, expected: bool):
+    """Tests the solution of a LeetCode problem."""
     root = TreeNode.build(root)
     has_path_sum = Solution().hasPathSum(root, targetSum)
     assert has_path_sum == expected

Diff for: tests/test_112_path_sum.py

@@ -17,6 +17,7 @@
     ],
 )
 def test_func(root: List[int], expected: List[int]):
+    """Tests the solution of a LeetCode problem."""
     root = TreeNode.build(root)
     solution = TreeNode.build(expected)
     Solution().flatten(root)

Diff for: tests/test_114_flatten_binary_tree_to_linked_list.py

@@ -17,6 +17,7 @@
     ],
 )
 def test_func(root: List[int], expected: List[int]):
+    """Tests the solution of a LeetCode problem."""
     root = TreeNode.build(root)
     connected_root = Solution().connect(root)
     print(root)

Diff for: tests/test_117_populating_next_right_pointers_in_each_node_II.py

@@ -13,5 +13,6 @@
     ],
 )
 def test_func(prices: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
     max_profit = Solution().maxProfit(prices)
     assert max_profit == expected

Diff for: tests/test_121_best_time_to_buy_and_sell_stock.py

@@ -14,5 +14,6 @@
     ],
 )
 def test_func(prices: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
     max_profit = Solution().maxProfit(prices)
     assert max_profit == expected

Diff for: tests/test_122_best_time_to_buy_and_sell_stock_II.py

@@ -13,6 +13,7 @@
     ],
 )
 def test_func(root: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
     root = TreeNode.build(root)
     max_path_sum = Solution().maxPathSum(root)
     assert max_path_sum == expected

Diff for: tests/test_124_binary_tree_maximum_path.py

@@ -12,5 +12,6 @@
     ],
 )
 def test_func(s: str, expected: bool):
+    """Tests the solution of a LeetCode problem."""
     max_profit = Solution().isPalindrome(s)
     assert max_profit == expected

Diff for: tests/test_125_valid_palindrome.py

@@ -13,5 +13,6 @@
     ],
 )
 def test_func(nums: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
     longest_consecutive = Solution().longestConsecutive(nums)
     assert longest_consecutive == expected

Diff for: tests/test_128_longest_consecutive_sequence.py

@@ -13,6 +13,7 @@
     ],
 )
 def test_func(root: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
     root = TreeNode.build(root)
     sum_root_to_leaf_numbers = Solution().sumNumbers(root)
     assert sum_root_to_leaf_numbers == expected

Diff for: tests/test_129_sum_root_to_leaf_numbers.py

@@ -13,5 +13,6 @@
     ],
 )
 def test_func(nums: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
     num = Solution().singleNumber(nums)
     assert num == expected

Diff for: tests/test_136_single_number.py

@@ -12,5 +12,6 @@
     ],
 )
 def test_func(nums: List[int], expected: str):
+    """Tests the solution of a LeetCode problem."""
     num = Solution().singleNumber(nums)
     assert num == expected

Diff for: tests/test_137_single_number.py

@@ -14,5 +14,6 @@
     ],
 )
 def test_func(tokens: List[str], expected: int):
+    """Tests the solution of a LeetCode problem."""
     value = Solution().evalRPN(tokens)
     assert value == expected

Diff for: tests/test_150_evaluate_reverse_polish_notation.py

@@ -2,6 +2,7 @@
 
 
 def test_func():
+    """Tests the solution of a LeetCode problem."""
     min_stack = MinStack()
     min_stack.push(-2)
     min_stack.push(0)

Diff for: tests/test_155_min_stack.py

@@ -13,5 +13,6 @@
     ],
 )
 def test_func(nums: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
     majority_element = Solution().majorityElement(nums)
     assert majority_element == expected

Diff for: tests/test_169_majority_element.py

@@ -5,6 +5,7 @@
 
 
 def test_func():
+    """Tests the solution of a LeetCode problem."""
     root = TreeNode.build([7, 3, 15, None, None, 9, 20])
     iterator = BSTIterator(root)
     assert iterator.next() == 3

Diff for: tests/test_173_binary_search_tree_iterator.py

@@ -13,5 +13,6 @@
     ],
 )
 def test_func(nums: List[int], k: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
     Solution().rotate(nums, k)
     assert nums == expected

Diff for: tests/test_189_rotate_array.py

@@ -11,5 +11,6 @@
     ],
 )
 def test_func(n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
     n_reversed = Solution().reverseBits(n)
     assert n_reversed == expected

Diff for: tests/test_190_reverse_bits.py

@@ -12,5 +12,6 @@
     ],
 )
 def test_func(n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
     c = Solution().hammingWeight(n)
     assert c == expected

Diff for: tests/test_191_number_of_1_bits.py

@@ -16,6 +16,7 @@
     ],
 )
 def test_func(root: List[int], expected: List[int]):
+    """Tests the solution of a LeetCode problem."""
     root = TreeNode.build(root)
     right_side_view = Solution().rightSideView(root)
     assert right_side_view == expected

Diff for: tests/test_199_binary_tree_right_side_view.py

@@ -12,5 +12,6 @@
     ],
 )
 def test_func(left: int, right: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
     range_bitwise_and = Solution().rangeBitwiseAnd(left, right)
     assert range_bitwise_and == expected

Diff for: tests/test_201_bitwise_and_of_numbers_range.py

@@ -11,5 +11,6 @@
     ],
 )
 def test_func(n: int, expected: bool):
+    """Tests the solution of a LeetCode problem."""
     is_happy = Solution().isHappy(n)
     assert is_happy == expected

Diff for: tests/test_202_happy_number.py

@@ -8,5 +8,6 @@
     argvalues=[("egg", "add", True), ("foo", "bar", False), ("paper", "title", True)],
 )
 def test_func(s: str, t: str, expected: bool):
+    """Tests the solution of a LeetCode problem."""
     is_isomorphic = Solution().isIsomorphic(s, t)
     assert is_isomorphic == expected

Diff for: tests/test_205_isomorphic_strings.py

@@ -14,5 +14,6 @@
     ],
 )
 def test_func(nums: List[int], k: int, expected: bool):
+    """Tests the solution of a LeetCode problem."""
     contains_nearby_duplicate = Solution().containsNearbyDuplicate(nums, k)
     assert contains_nearby_duplicate == expected

Diff for: tests/test_219_contains_duplicates_II.py

@@ -14,6 +14,7 @@
     ],
 )
 def test_func(root: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
     root = TreeNode.build(root)
     num_nodes = Solution().countNodes(root)
     assert num_nodes == expected