Graphs | Vertex & Graph implementations

.github/workflows/pre-commit.yml

@@ -6,8 +6,8 @@ jobs:
   pre-commit:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
-      - uses: actions/cache@v2
+      - uses: actions/checkout@v5
+      - uses: actions/cache@v4
         with:
           path: |
             ~/.cache/pre-commit

README.md

@@ -1,6 +1,7 @@
 ## Python Snippets
 
 [![Build Status](https://travis-ci.org/BrianLusina/Python_Snippets.svg?branch=master)](https://travis-ci.org/BrianLusina/Python_Snippets)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/11cfc8e125c54bdb833fe19ed9ddad72)](https://app.codacy.com/gh/BrianLusina/Python_Snippets/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
 
 Repository for some of my simple [Python](https://www.python.org/ "Python") functions and snippets. Each directory
 and/or python package has a readme for more information about the Python program

algorithms/arrays/intersection/intersection_two.py

@@ -3,7 +3,9 @@
 T = TypeVar("T")
 
 
-def intersect(list_one: List[T], list_two: List[T], include_duplicates: bool = True) -> List[T]:
+def intersect(
+    list_one: List[T], list_two: List[T], include_duplicates: bool = True
+) -> List[T]:
     """
     Given two arrays, find their intersection. This assumes that the lists are not sorted. First sorting takes place
     on both lists which will incur a cost of O(nlog(n)) + O(mlog(m)) depending on the algorithm used. Time will also
@@ -35,7 +37,10 @@ def intersect(list_one: List[T], list_two: List[T], include_duplicates: bool = T
             if include_duplicates:
                 result.append(first_element)
             else:
-                if pointer_one == 0 or first_element != sorted_list_one[pointer_one - 1]:
+                if (
+                    pointer_one == 0
+                    or first_element != sorted_list_one[pointer_one - 1]
+                ):
                     result.append(first_element)
             pointer_one += 1
             pointer_two += 1

algorithms/arrays/non_constructible_change/test_non_constructible_change.py

@@ -95,11 +95,12 @@ def test_13(self):
         self.assertEqual(actual, expected)
 
     def test_input_not_mutated(self):
-       """should not mutate the input coins list"""
-       coins = [5, 7, 1, 1, 2, 3, 22]
-       snapshot = coins[:]
-       _ = non_constructible_change(coins)
-       self.assertEqual(coins, snapshot)
+        """should not mutate the input coins list"""
+        coins = [5, 7, 1, 1, 2, 3, 22]
+        snapshot = coins[:]
+        _ = non_constructible_change(coins)
+        self.assertEqual(coins, snapshot)
+
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

algorithms/arrays/optimal_task_assignment/test_optimal_task_assignment.py

@@ -11,5 +11,5 @@ def test_1(self):
         self.assertEqual(expected, actual)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

algorithms/arrays/sorted_squared_array/__init__.py

@@ -20,7 +20,7 @@ def sorted_squared_array(array: List[int]) -> List[int]:
     left, right = 0, n - 1
 
     # file result array from right to left (largest to smallest squares
-    for i in range(n-1, -1, -1):
+    for i in range(n - 1, -1, -1):
         left_abs = abs(array[left])
         right_abs = abs(array[right])
 
@@ -56,7 +56,7 @@ def sorted_squared_array_2(array: List[int]) -> List[int]:
     left, right = 0, n - 1
 
     # file result array from right to left (largest to smallest squares
-    for i in range(n-1, -1, -1):
+    for i in range(n - 1, -1, -1):
         left_square = array[left] ** 2
         right_square = array[right] ** 2
 

algorithms/arrays/sorted_squared_array/test_sorted_squared_array.py

@@ -19,8 +19,8 @@ def test_2(self):
 
     def test_3(self):
         """for an input of [-7,-3,2,3,11] it should return [4,9,9,49,121]"""
-        input_array = [-7,-3,2,3,11]
-        expected = [4,9,9,49,121]
+        input_array = [-7, -3, 2, 3, 11]
+        expected = [4, 9, 9, 49, 121]
         actual = sorted_squared_array(input_array)
         self.assertEqual(expected, actual)
 
@@ -42,11 +42,11 @@ def test_2(self):
 
     def test_3(self):
         """for an input of [-7,-3,2,3,11] it should return [4,9,9,49,121]"""
-        input_array = [-7,-3,2,3,11]
-        expected = [4,9,9,49,121]
+        input_array = [-7, -3, 2, 3, 11]
+        expected = [4, 9, 9, 49, 121]
         actual = sorted_squared_array_2(input_array)
         self.assertEqual(expected, actual)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

algorithms/arrays/subsequence/__init__.py

@@ -37,6 +37,7 @@ def is_valid_subsequence(array: List[int], sequence: List[int]) -> bool:
 
     return False
 
+
 def is_valid_subsequence_v2(array: List[int], sequence: List[int]) -> bool:
     """
     Returns true if a sequence is a subsequence of the provided array

algorithms/arrays/subsequence/test_is_valid_subsequence.py

@@ -12,32 +12,33 @@ def test_1(self):
 
     def test_2(self):
         """should return True for array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [5, 1, 22, 6, -1, 8, 10]"""
-        array =  [5, 1, 22, 25, 6, -1, 8, 10]
+        array = [5, 1, 22, 25, 6, -1, 8, 10]
         sequence = [5, 1, 22, 6, -1, 8, 10]
         actual = is_valid_subsequence(array, sequence)
         self.assertTrue(actual)
 
     def test_3(self):
         """should return False for array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [5, 6, 1, 10, 22, 8, -1, 25]"""
-        array =  [5, 1, 22, 25, 6, -1, 8, 10]
+        array = [5, 1, 22, 25, 6, -1, 8, 10]
         sequence = [5, 6, 1, 10, 22, 8, -1, 25]
         actual = is_valid_subsequence(array, sequence)
         self.assertFalse(actual)
 
     def test_4(self):
         """should return True for array = [1,2,3,4], sequence = [1,3,4]"""
-        array =  [1,2,3,4]
-        sequence = [1,3,4]
+        array = [1, 2, 3, 4]
+        sequence = [1, 3, 4]
         actual = is_valid_subsequence(array, sequence)
         self.assertTrue(actual)
 
     def test_5(self):
         """should return True for array = [1,2,3,4], sequence = [2,4]"""
-        array =  [1,2,3,4]
-        sequence = [2,4]
+        array = [1, 2, 3, 4]
+        sequence = [2, 4]
         actual = is_valid_subsequence(array, sequence)
         self.assertTrue(actual)
 
+
 class IsValidSubsequenceV2TestCase(unittest.TestCase):
     def test_1(self):
         """array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [1, 6, -1, 10]"""
@@ -48,32 +49,32 @@ def test_1(self):
 
     def test_2(self):
         """should return True for array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [5, 1, 22, 6, -1, 8, 10]"""
-        array =  [5, 1, 22, 25, 6, -1, 8, 10]
+        array = [5, 1, 22, 25, 6, -1, 8, 10]
         sequence = [5, 1, 22, 6, -1, 8, 10]
         actual = is_valid_subsequence_v2(array, sequence)
         self.assertTrue(actual)
 
     def test_3(self):
         """should return False for array = [5, 1, 22, 25, 6, -1, 8, 10], sequence = [5, 6, 1, 10, 22, 8, -1, 25]"""
-        array =  [5, 1, 22, 25, 6, -1, 8, 10]
+        array = [5, 1, 22, 25, 6, -1, 8, 10]
         sequence = [5, 6, 1, 10, 22, 8, -1, 25]
         actual = is_valid_subsequence_v2(array, sequence)
         self.assertFalse(actual)
 
     def test_4(self):
         """should return True for array = [1,2,3,4], sequence = [1,3,4]"""
-        array =  [1,2,3,4]
-        sequence = [1,3,4]
+        array = [1, 2, 3, 4]
+        sequence = [1, 3, 4]
         actual = is_valid_subsequence_v2(array, sequence)
         self.assertTrue(actual)
 
     def test_5(self):
         """should return True for array = [1,2,3,4], sequence = [2,4]"""
-        array =  [1,2,3,4]
-        sequence = [2,4]
+        array = [1, 2, 3, 4]
+        sequence = [2, 4]
         actual = is_valid_subsequence_v2(array, sequence)
         self.assertTrue(actual)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

algorithms/arrays/two_sum/__init__.py

@@ -27,6 +27,7 @@ def two_sum(numbers: List[int], target: int) -> List[int]:
         if complement in m:
             return [m[complement], idx]
         m[num] = idx
+    return []
 
 
 def two_sum_with_pointers(numbers: List[int], target: int) -> List[int]:

algorithms/arrays/two_sum_less_k/README.md

@@ -0,0 +1,23 @@
+# Two Sum Less Than K
+
+Given an array of integers, nums, and an integer k, find the maximum sum of two elements in nums less than k. Otherwise, 
+return −1 if no such pair exists.
+
+Constraints
+
+- 1 ≤ nums.length ≤ 100
+- 1 ≤ nums[i] ≤ 10^3
+- 1 ≤ k ≤ 10^3
+
+## Examples
+
+![Example 1](./images/examples/two_sum_less_k_example_1.png)
+![Example 2](./images/examples/two_sum_less_k_example_2.png)
+![Example 3](./images/examples/two_sum_less_k_example_3.png)
+![Example 4](./images/examples/two_sum_less_k_example_4.png)
+
+## Related Topics
+
+- Array
+- Two Pointers
+- Binary Search

algorithms/arrays/two_sum_less_k/__init__.py

@@ -0,0 +1,56 @@
+from typing import List
+
+
+def two_sum_less_than_k(nums: List[int], k: int) -> int:
+    """
+    Finds the maximum sum of two elements in a given list of numbers that is less than k.
+    Uses binary search to achieve a time complexity of O(n log n) and find the maximum sum of two elements
+    that is less than k. It takes the nums array and the target value k as input.
+    Args:
+        nums (List[int]): A sorted list of integers
+        k int: The target value to search for
+    Returns:
+        The maximum sum of two elements that is less than k
+    """
+    max_sum = -1
+
+    # sort the numbers in ascending order to facilitate binary search
+    nums.sort()
+
+    for x in range(len(nums)):
+        # find the maximum sum of two elements that is less than k, with the first element being nums[x]
+        y = search(nums, k - nums[x], x + 1)
+        if y > x:
+            # update max_sum with the maximum sum found so far
+            max_sum = max(max_sum, nums[x] + nums[y])
+
+    return max_sum
+
+
+def search(nums: List[int], target: int, start: int) -> int:
+    """
+    Searches for a number that is less than the target in a sorted list of numbers.
+    Uses binary search to achieve a time complexity of O(log n) and find the index j such that the sum
+    nums[i]+nums[j] < k. It takes the nums array, target value, and the start range of the search as input.
+    Args:
+        nums (List[int]): A sorted list of integers
+        target int: The target value to search for
+        start int: The starting index of the search range
+    Returns:
+        The index of the number that is less than the target, or -1 if no such number is found
+    """
+    left, right = start, len(nums) - 1
+    result = -1
+
+    while left <= right:
+        # calculate the midpoint of the search range
+        mid = (left + right) // 2
+        if nums[mid] < target:
+            # update result to mid and move left to mid + 1 to look for larger values.
+            result = mid
+            left = mid + 1
+        else:
+            # move right to mid - 1 to check smaller values.
+            right = mid - 1
+
+    return result

algorithms/arrays/two_sum_less_k/test_two_sum.py

@@ -0,0 +1,48 @@
+import unittest
+from . import two_sum_less_than_k
+
+
+class TwoSumLessKTestCase(unittest.TestCase):
+    def test_1(self):
+        """numbers = [4,2,11,2,5,3,5,8], target = 7"""
+        numbers = [4, 2, 11, 2, 5, 3, 5, 8]
+        target = 7
+        expected = 6
+        actual = two_sum_less_than_k(numbers, target)
+        self.assertEqual(expected, actual)
+
+    def test_2(self):
+        """numbers = [10,20,30], target = 15"""
+        numbers = [10, 20, 30]
+        target = 15
+        expected = -1
+        actual = two_sum_less_than_k(numbers, target)
+        self.assertEqual(expected, actual)
+
+    def test_3(self):
+        """numbers = [34,23,1,24,75,33,54,8], k = 60"""
+        numbers = [34, 23, 1, 24, 75, 33, 54, 8]
+        k = 60
+        expected = 58
+        actual = two_sum_less_than_k(numbers, k)
+        self.assertEqual(expected, actual)
+
+    def test_4(self):
+        """numbers = [5,5,5,5,5,5], k = 15"""
+        numbers = [5, 5, 5, 5, 5, 5]
+        k = 15
+        expected = 10
+        actual = two_sum_less_than_k(numbers, k)
+        self.assertEqual(expected, actual)
+
+    def test_5(self):
+        """numbers = [1,2,3,4,5], k = 3"""
+        numbers = [1, 2, 3, 4, 5]
+        k = 3
+        expected = -1
+        actual = two_sum_less_than_k(numbers, k)
+        self.assertEqual(expected, actual)
+
+
+if __name__ == "__main__":
+    unittest.main()