refactor(datastructures, linkedlist): cleans up reverse_between method

Adds validation checks for the reverse_between method of the singly
linked list class and tests to validate these changes.

Additionally adds linting fixes to the code base

Author: BrianLusina

datastructures/linked_lists/singly_linked_list/__init__.py

@@ -0,0 +1,75 @@
+from typing import List
+import unittest
+from parameterized import parameterized
+from datastructures.linked_lists.singly_linked_list.single_linked_list import (
+    SinglyLinkedList,
+)
+
+
+class ReverseBetweenSinglyLinkedListTestCase(unittest.TestCase):
+    def test_return_none_for_empty_linked_list(self):
+        """should return none for an empty linked list when attempting to reverse"""
+        linked_list = SinglyLinkedList()
+
+        actual = linked_list.reverse_between(0, 1)
+        self.assertIsNone(actual)
+
+    def test_raises_exception_for_invalid_arguments(self):
+        """should raise an exception for invalid left and right arguments"""
+        linked_list = SinglyLinkedList()
+
+        with self.assertRaises(ValueError):
+            linked_list.reverse_between(10, 9)
+
+    @parameterized.expand(
+        [
+            ([1, 2, 3, 4, 5, 4, 3, 2, 1], 1, 9, [1, 2, 3, 4, 5, 4, 3, 2, 1]),
+            ([1, 2, 3, 4, 5], 2, 4, [1, 4, 3, 2, 5]),
+            ([1, 2, 3, 4, 5], 1, 5, [5, 4, 3, 2, 1]),
+            (
+                [103, 7, 10, -9, 105, 67, 31, 63],
+                1,
+                8,
+                [63, 31, 67, 105, -9, 10, 7, 103],
+            ),
+            (
+                [103, 7, 10, -9, 105, 67, 31, 63],
+                1,
+                8,
+                [63, 31, 67, 105, -9, 10, 7, 103],
+            ),
+            ([-499, 399, -299, 199, -99, 9], 3, 5, [-499, 399, -99, 199, -299, 9]),
+            ([7, -9, 2, -10, 1, -8, 6], 2, 5, [7, 1, -10, 2, -9, -8, 6]),
+            ([6, 8, 7], 1, 2, [8, 6, 7]),
+            ([9, 0, 8, 2], 2, 4, [9, 2, 8, 0]),
+            ([7, 4, 6, 1, 5, 8], 2, 5, [7, 5, 1, 6, 4, 8]),
+            ([3, 7, 12, 2, 5, 1], 3, 6, [3, 7, 1, 5, 2, 12]),
+            ([3, 6, 7, 4, 2], 2, 4, [3, 4, 7, 6, 2]),
+        ]
+    )
+    def test_reverse_between(
+        self, data: List[int], left: int, right: int, expected: List[int]
+    ):
+        """should reverse linked list between left and right arguments"""
+        linked_list = SinglyLinkedList()
+        # add the data to the linked list
+        for d in data:
+            linked_list.append(d)
+
+        # perform reversal
+        actual = linked_list.reverse_between(left, right)
+
+        # since the head node is returned, we want the values of the linked list and not just the head node
+        # to check that the actual reversal worked
+        actual_list: List[int] = []
+        curr = actual
+        while curr:
+            actual_list.append(curr.data)
+            curr = curr.next
+
+        # perform assertion
+        self.assertEqual(expected, actual_list)
+
+
+if __name__ == "__main__":
+    unittest.main()

datastructures/linked_lists/singly_linked_list/single_linked_list.py

@@ -59,6 +59,7 @@ def __bubble_down(self, idx: int):
 
             self.__bubble_down(min_child_index)
 
+    # FIXME: fails on some instances with a KeyError, check the puzzle min_cost_connect_sticks
     def __bubble_up(self, idx: int):
         if idx == 0:
             return

datastructures/linked_lists/singly_linked_list/test_singly_linked_revese.py

@@ -16,22 +16,22 @@ def __init__(self, data: T, key: Optional[T] = None):
     def name(self):
         return self.__class__.__name__
 
-    def __eq__(self, other: 'HeapNode') -> bool:
+    def __eq__(self, other: "HeapNode") -> bool:
         return self.data == other.data
 
-    def __lt__(self, other: 'HeapNode') -> bool:
+    def __lt__(self, other: "HeapNode") -> bool:
         return self.data < other.data
 
-    def __gt__(self, other: 'HeapNode') -> bool:
+    def __gt__(self, other: "HeapNode") -> bool:
         return self.data > other.data
 
-    def __le__(self, other: 'HeapNode') -> bool:
+    def __le__(self, other: "HeapNode") -> bool:
         return self.data <= other.data
 
-    def __ge__(self, other: 'HeapNode') -> bool:
+    def __ge__(self, other: "HeapNode") -> bool:
         return self.data >= other.data
 
-    def __ne__(self, other: 'HeapNode') -> bool:
+    def __ne__(self, other: "HeapNode") -> bool:
         return self.data != other.data
 
     def __hash__(self) -> int:

datastructures/trees/heaps/binary/min_heap/__init__.py

@@ -10,6 +10,7 @@ class SuffixTree:
     Basically, this is a Trie optimized for suffix matching by storing reversed strings.
     Each node tracks the best candidate word for tie-breaking.
     """
+
     def __init__(self):
         super().__init__()
         self.root = SuffixTreeNode()

datastructures/trees/heaps/node.py

@@ -1,4 +1,4 @@
-from typing import DefaultDict, Tuple
+from typing import DefaultDict
 from collections import defaultdict
 from datastructures.trees.trie.trie_node import TrieNode
 from datastructures.trees.trie.suffix.types import WordInfo, INF_WORD_INFO
@@ -10,6 +10,7 @@ class SuffixTreeNode(TrieNode):
     Each node stores its children and the index of the best word
     (shortest, earliest) that passes through this node.
     """
+
     def __init__(self):
         super().__init__()
         # index of best word passing through this node
@@ -18,4 +19,3 @@ def __init__(self):
         # Stores the best WordInfo (length, index) for any word that passes
         # through or ends at this node. Initialized to infinity.
         self.best_info: WordInfo = INF_WORD_INFO
-

datastructures/trees/trie/suffix/suffix_tree.py

@@ -1,6 +1,6 @@
-from typing import DefaultDict, Tuple
+from typing import Tuple
 
 # Type alias for the best word info: (length, original_index)
 WordInfo = Tuple[int, int]
 # Initialize with a very large length to ensure the first word always wins
-INF_WORD_INFO: WordInfo = (float('inf'), float('inf'))
+INF_WORD_INFO: WordInfo = (float("inf"), float("inf"))

datastructures/trees/trie/suffix/suffix_tree_node.py

@@ -4,13 +4,13 @@
 
 class MinCostConnectSticksTestCase(unittest.TestCase):
     def test_1(self):
-        sticks = [3,5,4]
+        sticks = [3, 5, 4]
         expected = 19
         actual = connect_sticks(sticks)
         self.assertEqual(expected, actual)
 
     def test_2(self):
-        sticks = [2,9,4,6]
+        sticks = [2, 9, 4, 6]
         expected = 39
         actual = connect_sticks(sticks)
         self.assertEqual(expected, actual)
@@ -22,7 +22,7 @@ def test_3(self):
         self.assertEqual(expected, actual)
 
     def test_4(self):
-        sticks = [3,3,3]
+        sticks = [3, 3, 3]
         expected = 15
         actual = connect_sticks(sticks)
         self.assertEqual(expected, actual)
@@ -34,38 +34,39 @@ def test_5(self):
         self.assertEqual(expected, actual)
 
     def test_6(self):
-        sticks = [7,10,16]
+        sticks = [7, 10, 16]
         expected = 50
         actual = connect_sticks(sticks)
         self.assertEqual(expected, actual)
 
     def test_7(self):
-        sticks = [5,120,7,30,10]
+        sticks = [5, 120, 7, 30, 10]
         expected = 258
         actual = connect_sticks(sticks)
         self.assertEqual(expected, actual)
 
     def test_8(self):
-        sticks = [100,200,300,400,500]
+        sticks = [100, 200, 300, 400, 500]
         expected = 3300
         actual = connect_sticks(sticks)
         self.assertEqual(expected, actual)
 
     def test_9(self):
-        sticks = [20,20,20,20]
+        sticks = [20, 20, 20, 20]
         expected = 160
         actual = connect_sticks(sticks)
         self.assertEqual(expected, actual)
 
+
 class MinCostConnectSticks2TestCase(unittest.TestCase):
     def test_1(self):
-        sticks = [3,5,4]
+        sticks = [3, 5, 4]
         expected = 19
         actual = connect_sticks_2(sticks)
         self.assertEqual(expected, actual)
 
     def test_2(self):
-        sticks = [2,9,4,6]
+        sticks = [2, 9, 4, 6]
         expected = 39
         actual = connect_sticks_2(sticks)
         self.assertEqual(expected, actual)
@@ -77,7 +78,7 @@ def test_3(self):
         self.assertEqual(expected, actual)
 
     def test_4(self):
-        sticks = [3,3,3]
+        sticks = [3, 3, 3]
         expected = 15
         actual = connect_sticks_2(sticks)
         self.assertEqual(expected, actual)
@@ -89,29 +90,29 @@ def test_5(self):
         self.assertEqual(expected, actual)
 
     def test_6(self):
-        sticks = [7,10,16]
+        sticks = [7, 10, 16]
         expected = 50
         actual = connect_sticks_2(sticks)
         self.assertEqual(expected, actual)
 
     def test_7(self):
-        sticks = [5,120,7,30,10]
+        sticks = [5, 120, 7, 30, 10]
         expected = 258
         actual = connect_sticks_2(sticks)
         self.assertEqual(expected, actual)
 
     def test_8(self):
-        sticks = [100,200,300,400,500]
+        sticks = [100, 200, 300, 400, 500]
         expected = 3300
         actual = connect_sticks_2(sticks)
         self.assertEqual(expected, actual)
 
     def test_9(self):
-        sticks = [20,20,20,20]
+        sticks = [20, 20, 20, 20]
         expected = 160
         actual = connect_sticks_2(sticks)
         self.assertEqual(expected, actual)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()

datastructures/trees/trie/suffix/types.py

@@ -29,15 +29,3 @@ def memesorting(meme):
                 spelled_word += letter
 
     return receiver.get(letters[spelled_word], "Vlad")
-
-
-Test.assert_equals(memesorting("This is programmer meme ecause it has bug"), "Roma")
-Test.assert_equals(
-    memesorting("This is also programbur meme gecause it has needed key word"), "Roma"
-)
-Test.assert_equals(memesorting("This is edsigner meme cause it has key word"), "Danik")
-Test.assert_equals(
-    memesorting("This could be chemistry meme but our gey word boom is too late"),
-    "Roma",
-)
-Test.assert_equals(memesorting("This is meme"), "Vlad")