feat(ctci2): add p4-6a solutions and tests

Author: Jessica Yung

laakmann-mcdowell/2-linked-lists/4_partition.py

@@ -9,38 +9,122 @@
 appear between the left and right partitions.
 
 EXAMPLE:
-3->5->8-5->10->2->1 [partition = 5]
+3->5->8->5->10->2->1 [partition = 5]
+has possible solution
+3->2->1->5->8->5->10
 
+Author: Jessica Yung
+16 October 2016
 
+WRITE have-two-lists-(before and after)-that-you-merge version of solution.
 """
 from linked_list_classes import LinkedListNode
 import unittest
 
+def partition_linked_list(head, partition):
+    # partition is a float or an int.
+    complete = False
+    # For each pass:
+    while complete == False:
+        # Initialise or reset variables
+        current_node = head
+        swaps = 0
+        prev_prev_node = None
+        prev_node = None
+        passed_greater_than_partition = 0
+        # Loop through nodes
+        while current_node is not None:
+            # if number >= partition, toggle = 1
+            if passed_greater_than_partition == 1 and current_node.value < partition:
+                # Swap current node with prev node
+                swaps = 1
+                if prev_prev_node is not None:
+                    # a b c d, c current
+                    # a.next = c
+                    # b.next = d
+                    # c.next = b
+                    # a c b d
+                    # SWAP
+                    prev_prev_node.next = current_node
+                    prev_node.next = current_node.next
+                    current_node.next = prev_node
+                    if prev_node is not None and current_node is not None:
+                        print("swapped ", prev_node.value, " with ", current_node.value)
+                    # Shift
+                    # c current, next current is d.
+                else:
+                    # a b c, b current
+                    # a.next = c
+                    # b.next = a
+                    # b a c
+                    # SWAP
+                    prev_node.next = current_node.next
+                    current_node.next = prev_node
+                    if prev_node is not None and current_node is not None:
+                        print("swapped ", prev_node.value, " with ", current_node.value)
+                    # SHIFT nodes
+                    # current is still b
+                    # Next current is c
+                    head = current_node
+                # Shift nodes
+                if current_node.next.next is not None:
+                    prev_prev_node = current_node
+                    current_node = current_node.next.next
+                else:
+                    # a b d c
+                    current_node = current_node.next
+            else:
+                if current_node.value >= partition:
+                    passed_greater_than_partition = 1
+                # No swap
+                # Shift nodes
+                # a b c d, current is c.
+                # Next current is d
+                prev_prev_node = prev_node
+                prev_node = current_node
+                current_node = current_node.next
+        # If there were no alterations, we're done
+        if swaps == 0:
+            complete = True
+        if head.next.next.next is not None:
+            print(head.value, head.next.value, head.next.next.value, head.next.next.next.value)
+    return head
 
+def partition_linked_list_split_solution(head, partition):
+    pass
 
 class Tests(unittest.TestCase):
+    def test_partition_short(self):
+        a = LinkedListNode(9)
+        b = LinkedListNode(7)
+        c = LinkedListNode(2)
+        d = LinkedListNode(1)
+        a.next = b
+        b.next = c
+        c.next = d
+        h = partition_linked_list(a, 5)
+        print(h, h.next.value, h.next.next.value, h.next.next.next.value)
 
-    def set_up_linked_list(self):
-        a = LinkedListNode(1)
-        b = LinkedListNode(2)
-        c = LinkedListNode(3)
-        d = LinkedListNode(4)
-        e = LinkedListNode(5)
-        f = LinkedListNode(6)
-        g = LinkedListNode(7)
+
+    def test_partition(self):
+        a = LinkedListNode(9)
+        b = LinkedListNode(7)
+        c = LinkedListNode(6)
+        d = LinkedListNode(5)
+        e = LinkedListNode(4)
+        f = LinkedListNode(3)
+        g = LinkedListNode(2)
         a.next = b
         b.next = c
         c.next = d
         d.next = e
         e.next = f
         f.next = g
-        return a
-
+        h = partition_linked_list(a, 5)
+        fourh = h.next.next.next
+        print(h.value, h.next.value, h.next.next.value, fourh.value, fourh.next.value,
+              fourh.next.next.value, fourh.next.next.next.value)
 
-    def test_solution_one(self):
-        a = self.set_up_linked_list()
-        self.assertEqual(solution_one(a, 3).value, 4)
-        self.assertEqual(solution_one(a, 0).value, 7)
 
 if __name__ == '__main__':
-    unittest.main()
+    unittest.main()

laakmann-mcdowell/2-linked-lists/5_sum_lists.py

@@ -1,8 +1,66 @@
+"""
+2.5 Sum Lists
 
-def ll_length(node):
-	pass
+Author: Jessica Yung
+16 October 2016
+"""
+from linked_list_classes import LinkedListNode
+import unittest
 
-def sum_lists(ll_one_node, ll_two_node):
-	if ll_length(ll_one_node) != ll_length(ll_two_node):
-		pass
-		# 
+
+def sum_lists(list_one_head, list_two_head):
+    pointer_one = list_one_head
+    pointer_two = list_two_head
+    sum_list_start = 0
+    carry = 0
+    sum_head = None
+    pointer_sum = None
+    while pointer_one is not None or pointer_two is not None:
+        if pointer_one is not None and pointer_two is not None:
+            digit_sum = pointer_one.value + pointer_two.value + carry
+        elif pointer_one is not None:
+            digit_sum = pointer_one.value + carry
+        else:
+            digit_sum = pointer_two.value + carry
+        print("Digit Sum: ", digit_sum)
+        carry, new_digit = divmod(digit_sum, 10)
+        print("Carry: ", carry, "New digit: ", new_digit)
+        # Add resulting digit to 'sum' linked list and move pointer to that digit
+        if sum_list_start == 0:
+            sum_head = LinkedListNode(new_digit)
+            pointer_sum = sum_head
+            sum_list_start = 1
+        else:
+            pointer_sum.next = LinkedListNode(new_digit)
+            pointer_sum = pointer_sum.next
+        # Move to the next digit in the lists
+        if pointer_one is not None:
+            pointer_one = pointer_one.next
+        if pointer_two is not None:
+            pointer_two = pointer_two.next
+    return sum_head
+
+
+class Tests(unittest.TestCase):
+
+    def test_partition(self):
+        a = LinkedListNode(9)
+        b = LinkedListNode(7)
+        c = LinkedListNode(6)
+        d = LinkedListNode(5)
+        e = LinkedListNode(4)
+        f = LinkedListNode(3)
+        g = LinkedListNode(2)
+        # List 1: 679
+        a.next = b
+        b.next = c
+        # List 2: 2345
+        d.next = e
+        e.next = f
+        f.next = g
+        # Sum:
+        h = sum_lists(a, d)
+        print(h.value, h.next.value, h.next.next.value, h.next.next.next.value)
+
+if __name__ == '__main__':
+    unittest.main()

laakmann-mcdowell/2-linked-lists/6_palindrome.py

@@ -0,0 +1,58 @@
+"""
+6 Palindrome
+
+Author: Jessica Yung
+16 October 2016
+"""
+from linked_list_classes import LinkedListNode
+import unittest
+
+# If it's a doubly-linked list, it's easy. We just send a pointer to the end
+# then have it trace back and compare the values one by one until ceiling(len/2).
+
+def is_dll_palindrome(head):
+    """`head` is a DoublyLinkedListNode."""
+    current = head
+    runner = head
+    list_length = 1
+    number_checked = 0
+    # Send runner to the back
+    while runner.next is not None:
+        runner = runner.next
+        list_length += 1
+    while number_checked < int(list_length / 2 + 1)
+        if current.value != runner.value:
+            return False
+        else:
+            current = current.next
+            runner = runner.prev
+            number_checked += 1
+    # All checked
+    return True
+
+# If it's a singly-linked list, then we go through it once and get the length.
+# We may as well get all the values and put it in an array and compare?
+
+class Tests(unittest.TestCase):
+
+    def test_sll_palindrome(self):
+        a = LinkedListNode(9)
+        b = LinkedListNode(7)
+        c = LinkedListNode(6)
+        d = LinkedListNode(5)
+        e = LinkedListNode(6)
+        f = LinkedListNode(7)
+        g = LinkedListNode(9)
+        # List 1: 679
+        a.next = b
+        b.next = c
+        c.next = d
+        d.next = e
+        e.next = f
+        f.next = g
+        # Sum:
+        h = sum_lists(a, d)
+        print(h.value, h.next.value, h.next.next.value, h.next.next.next.value)
+
+if __name__ == '__main__':
+    unittest.main()