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"))