Add Black formatting and pre-commit hooks to repository

Introduce Black code formatter for consistent styling across the codebase. Add GitHub Actions workflow for format validation and a pre-commit configuration for local enforcement. Update all Python files to adhere to Black formatting standards.

Author: nicholasadamou

.github/workflows/format-check.yml

@@ -0,0 +1,15 @@
+name: Format Check
+on: [push, pull_request]
+jobs:
+    format-check:
+        runs-on: ubuntu-latest
+        steps:
+            - uses: actions/checkout@v3
+            - name: Set up Python
+              uses: actions/setup-python@v3
+              with:
+                  python-version: 3.9
+            - name: Install Black
+              run: pip install black
+            - name: Run Black
+              run: black --check .

.pre-commit-config.yaml

@@ -0,0 +1,5 @@
+repos:
+    - repo: https://github.com/psf/black
+      rev: 23.9.1  # Use the latest stable version
+      hooks:
+          - id: black

Arrays & Hashing/contains_duplicate.py

@@ -3,16 +3,18 @@
 import unittest
 from typing import List
 
+
 def has_duplicate(nums: List[int]) -> bool:
-     seen = set()
+    seen = set()
+
+    for num in nums:
+        if num in seen:
+            return True
 
-     for num in nums:
-            if num in seen:
-                return True
+        seen.add(num)
 
-            seen.add(num)
+    return False
 
-     return False
 
 class Test(unittest.TestCase):
     def test_has_duplicate(self):

Arrays & Hashing/encode_and_decode_strings.py

@@ -3,14 +3,16 @@
 import unittest
 from typing import List
 
+
 def encode(words: List[str]) -> str:
     encoded_words = []
 
     for word in words:
         encoded_word = str(len(word)) + "#" + word
         encoded_words.append(encoded_word)
 
-    return ' '.join(encoded_words)
+    return " ".join(encoded_words)
+
 
 def decode(encoded_words: str) -> List[str]:
     n = len(encoded_words)
@@ -20,7 +22,7 @@ def decode(encoded_words: str) -> List[str]:
     while i < n:
         j = i
         # Find the position of the next '#'
-        while j < n and encoded_words[j] != '#':
+        while j < n and encoded_words[j] != "#":
             j += 1
 
         # If no '#' is found, break the loop to avoid infinite loop
@@ -39,7 +41,9 @@ def decode(encoded_words: str) -> List[str]:
 
         # Check if the end of the word is within bounds
         if j > n:
-            raise ValueError(f"Word length {length} is out of bounds for the string: {encoded_words[i:]}")
+            raise ValueError(
+                f"Word length {length} is out of bounds for the string: {encoded_words[i:]}"
+            )
 
         decoded_word = encoded_words[i:j]
         decoded_words.append(decoded_word)
@@ -49,16 +53,16 @@ def decode(encoded_words: str) -> List[str]:
 
     return decoded_words
 
+
 class Test(unittest.TestCase):
     def setUp(self):
-        self.example1 = ["neet","code","love","you"]
-        self.example2 = ["we","say",":","yes"]
+        self.example1 = ["neet", "code", "love", "you"]
+        self.example2 = ["we", "say", ":", "yes"]
 
-        self.expected_encoding1 = '4#neet 4#code 4#love 3#you'
-        self.expected_encoding2 = '2#we 3#say 1#: 3#yes'
+        self.expected_encoding1 = "4#neet 4#code 4#love 3#you"
+        self.expected_encoding2 = "2#we 3#say 1#: 3#yes"
 
     def test_encode(self):
-
         self.assertEqual(encode(self.example1), self.expected_encoding1)
         self.assertEqual(encode(self.example2), self.expected_encoding2)
 

Arrays & Hashing/group_anagrams.py

@@ -4,11 +4,12 @@
 from typing import List
 from collections import defaultdict
 
+
 def group_anagrams(words: List[str]) -> List[List[str]]:
     anagram_groups = defaultdict(list)
 
     for word in words:
-        sorted_word = ''.join(sorted(word))
+        sorted_word = "".join(sorted(word))
 
         if sorted_word in anagram_groups:
             anagram_groups[sorted_word].append(word)
@@ -18,6 +19,7 @@ def group_anagrams(words: List[str]) -> List[List[str]]:
 
     return [group for group in anagram_groups.values()]
 
+
 class Test(unittest.TestCase):
     def assertEqualAnagramGroups(self, result, expected):
         # Sort each group and the outer list
@@ -30,7 +32,7 @@ def assertEqualAnagramGroups(self, result, expected):
     def test_group_anagrams(self):
         self.assertEqualAnagramGroups(
             group_anagrams(["act", "pots", "tops", "cat", "stop", "hat"]),
-            [["hat"], ["act", "cat"], ["stop", "pots", "tops"]]
+            [["hat"], ["act", "cat"], ["stop", "pots", "tops"]],
         )
         self.assertEqualAnagramGroups(group_anagrams(["x"]), [["x"]])
         self.assertEqualAnagramGroups(group_anagrams([""]), [[""]])

Arrays & Hashing/longest_consecutive_sequence.py

@@ -3,12 +3,13 @@
 import unittest
 from typing import List
 
+
 def longest_consecutive(nums: List[int]) -> int:
     nums_set = set(nums)
     longest = 0
 
     for num in nums_set:
-        if (num - 1) not in nums_set: # Are we are the start of a sequence?
+        if (num - 1) not in nums_set:  # Are we are the start of a sequence?
             length = 1
 
             while (num + length) in nums_set:
@@ -18,6 +19,7 @@ def longest_consecutive(nums: List[int]) -> int:
 
     return longest
 
+
 class Test(unittest.TestCase):
     def test_longest_consecutive(self):
         self.assertEqual(longest_consecutive([2, 20, 4, 10, 3, 4, 5]), 4)

Arrays & Hashing/product_of_array_except_self.py

@@ -3,6 +3,7 @@
 import unittest
 from typing import List
 
+
 def product_except_self(nums: List[int]) -> List[int]:
     n = len(nums)
 
@@ -20,6 +21,7 @@ def product_except_self(nums: List[int]) -> List[int]:
 
     return result
 
+
 class Test(unittest.TestCase):
     def test_product_except_self(self):
         self.assertEqual(product_except_self([1, 2, 4, 6]), [48, 24, 12, 8])

Arrays & Hashing/top_k_frequent_elements.py

@@ -14,6 +14,7 @@
 #     # Use heapq.nlargest to get the k elements with the highest counts
 #     return heapq.nlargest(k, counts.keys(), key=counts.get)
 
+
 def top_k_frequent(nums: List[int], k: int) -> List[int]:
     n = len(nums)
 
@@ -25,7 +26,9 @@ def top_k_frequent(nums: List[int], k: int) -> List[int]:
     min_heap = []
 
     for num, count in counts.items():
-        heapq.heappush(min_heap, (-count, num)) # negate the count to convert min heap to max heap
+        heapq.heappush(
+            min_heap, (-count, num)
+        )  # negate the count to convert min heap to max heap
 
     result = []
 
@@ -35,6 +38,7 @@ def top_k_frequent(nums: List[int], k: int) -> List[int]:
 
     return result
 
+
 class Test(unittest.TestCase):
     def test_top_k_frequent(self):
         self.assertEqual(top_k_frequent([1, 2, 2, 3, 3, 3], 2), [3, 2])

Arrays & Hashing/two_sum.py

@@ -4,21 +4,21 @@
 from typing import List
 from collections import defaultdict
 
+
 def two_sum(nums: List[int], target) -> List[int]:
     complements = defaultdict(int)
 
     for i, num in enumerate(nums):
         complement = target - num
 
         if complement in complements:
-            return [
-                complements[complement], i
-            ]
+            return [complements[complement], i]
 
         complements[num] = i
 
     return []
 
+
 class Test(unittest.TestCase):
     def test_two_sum(self):
         self.assertEqual(two_sum([3, 4, 5, 6], 7), [0, 1])

Arrays & Hashing/vaild_anagram.py

@@ -2,6 +2,7 @@
 
 import unittest
 
+
 def is_anagram(word_one: str, word_two: str) -> bool:
     n = len(word_one)
     m = len(word_two)
@@ -29,6 +30,7 @@ def is_anagram(word_one: str, word_two: str) -> bool:
 
     return True
 
+
 class Test(unittest.TestCase):
     def test_is_anagram(self):
         self.assertTrue(is_anagram("racecar", "carrace"))

Arrays & Hashing/valid_sudoku.py

@@ -4,6 +4,7 @@
 from typing import List
 from collections import defaultdict
 
+
 def is_valid_sudoku(board: List[List[str]]) -> bool:
     rows = defaultdict(set)
     cols = defaultdict(set)
@@ -13,13 +14,13 @@ def is_valid_sudoku(board: List[List[str]]) -> bool:
         for col in range(9):
             cell = board[row][col]
 
-            if cell == '.': # Skip empty cells
+            if cell == ".":  # Skip empty cells
                 continue
 
             if (
-                cell in rows[row] or
-                cell in cols[col] or
-                cell in squares[(row // 3, col // 3)]
+                cell in rows[row]
+                or cell in cols[col]
+                or cell in squares[(row // 3, col // 3)]
             ):
                 return False
 
@@ -29,23 +30,36 @@ def is_valid_sudoku(board: List[List[str]]) -> bool:
 
     return True
 
+
 class Test(unittest.TestCase):
     def test_is_valid_sudoku(self):
-        self.assertTrue(is_valid_sudoku([["1","2",".",".","3",".",".",".","."],
-                                         ["4",".",".","5",".",".",".",".","."],
-                                         [".","9","8",".",".",".",".",".","3"],
-                                         ["5",".",".",".","6",".",".",".","4"],
-                                         [".",".",".","8",".","3",".",".","5"],
-                                         ["7",".",".",".","2",".",".",".","6"],
-                                         [".",".",".",".",".",".","2",".","."],
-                                         [".",".",".","4","1","9",".",".","8"],
-                                         [".",".",".",".","8",".",".","7","9"]]))
-        self.assertFalse(is_valid_sudoku([["1","2",".",".","3",".",".",".","."],
-                                          ["4",".",".","5",".",".",".",".","."],
-                                          [".","9","1",".",".",".",".",".","3"],
-                                          ["5",".",".",".","6",".",".",".","4"],
-                                          [".",".",".","8",".","3",".",".","5"],
-                                          ["7",".",".",".","2",".",".",".","6"],
-                                          [".",".",".",".",".",".","2",".","."],
-                                          [".",".",".","4","1","9",".",".","8"],
-                                          [".",".",".",".","8",".",".","7","9"]]))
+        self.assertTrue(
+            is_valid_sudoku(
+                [
+                    ["1", "2", ".", ".", "3", ".", ".", ".", "."],
+                    ["4", ".", ".", "5", ".", ".", ".", ".", "."],
+                    [".", "9", "8", ".", ".", ".", ".", ".", "3"],
+                    ["5", ".", ".", ".", "6", ".", ".", ".", "4"],
+                    [".", ".", ".", "8", ".", "3", ".", ".", "5"],
+                    ["7", ".", ".", ".", "2", ".", ".", ".", "6"],
+                    [".", ".", ".", ".", ".", ".", "2", ".", "."],
+                    [".", ".", ".", "4", "1", "9", ".", ".", "8"],
+                    [".", ".", ".", ".", "8", ".", ".", "7", "9"],
+                ]
+            )
+        )
+        self.assertFalse(
+            is_valid_sudoku(
+                [
+                    ["1", "2", ".", ".", "3", ".", ".", ".", "."],
+                    ["4", ".", ".", "5", ".", ".", ".", ".", "."],
+                    [".", "9", "1", ".", ".", ".", ".", ".", "3"],
+                    ["5", ".", ".", ".", "6", ".", ".", ".", "4"],
+                    [".", ".", ".", "8", ".", "3", ".", ".", "5"],
+                    ["7", ".", ".", ".", "2", ".", ".", ".", "6"],
+                    [".", ".", ".", ".", ".", ".", "2", ".", "."],
+                    [".", ".", ".", "4", "1", "9", ".", ".", "8"],
+                    [".", ".", ".", ".", "8", ".", ".", "7", "9"],
+                ]
+            )
+        )

Binary Search/binary_search.py

@@ -20,6 +20,7 @@
 #     # If target is not present, return -1
 #     return -1
 
+
 def binary_search(nums: List[int], target: int) -> int:
     n = len(nums)
 
@@ -39,6 +40,7 @@ def binary_search(nums: List[int], target: int) -> int:
 
     return -1
 
+
 class Test(unittest.TestCase):
     def test_binary_search(self):
         self.assertEqual(binary_search([-1, 0, 2, 4, 6, 8], 4), 3)

Binary Search/koko_eating_bananas.py

@@ -4,10 +4,11 @@
 import unittest
 from typing import List
 
+
 def min_eating_speed(piles: List[int], hours: int) -> int:
     piles.sort()
 
-    left =  1
+    left = 1
     right = max(piles)
 
     result = right
@@ -27,6 +28,7 @@ def min_eating_speed(piles: List[int], hours: int) -> int:
 
     return result
 
+
 class Test(unittest.TestCase):
     def test_min_eating_speed(self):
         self.assertEqual(min_eating_speed([1, 4, 3, 2], 9), 2)

Binary Search/search_a_2d_matrix.py

@@ -19,6 +19,7 @@
 #     # Check if the target is actually at the found index
 #     return index < len(flat_list) and flat_list[index] == target
 
+
 def search_matrix(matrix: List[List[int]], target: int) -> bool:
     n = len(matrix)
     m = len(matrix[0])
@@ -45,7 +46,12 @@ def search_matrix(matrix: List[List[int]], target: int) -> bool:
 
     return False
 
+
 class Test(unittest.TestCase):
     def test_search_matrix(self):
-        self.assertTrue(search_matrix([[1, 2, 4, 8],[10, 11, 12, 13],[14, 20, 30, 40]], 10))
-        self.assertFalse(search_matrix([[1, 2, 4, 8],[10, 11, 12, 13],[14, 20, 30, 40]], 15))
+        self.assertTrue(
+            search_matrix([[1, 2, 4, 8], [10, 11, 12, 13], [14, 20, 30, 40]], 10)
+        )
+        self.assertFalse(
+            search_matrix([[1, 2, 4, 8], [10, 11, 12, 13], [14, 20, 30, 40]], 15)
+        )

README.md

@@ -13,6 +13,8 @@ The repository is organized based on the categories from NeetCode's Road Map.
 ## Prerequisites
 
 - Python 3.9 or above should be installed.
+- Some problems may require [LeetCode Premium](https://leetcode.com/subscribe).
+- [Black](https://black.readthedocs.io/en/stable/) formatter should be installed to ensure consistent code formatting.
 
 ## Test