feat(ctci-2): solution and tests for p1-3

Author: Jessica Yung

laakmann-mcdowell/2-linked-lists/1_remove_duplicates.py

@@ -25,7 +25,6 @@ def remove_duplicates(first_node):
     :type first_node: LinkedListNode
     """
 
-    #
     set_of_values = set()
     previous_node = None
     current_node = first_node

laakmann-mcdowell/2-linked-lists/2_return_kth_to_last.py

@@ -0,0 +1,63 @@
+"""
+2.2 Return Kth to Last
+Implement an algorithm to find the kth to last element of a singly linked list.
+
+Author: Jessica Yung
+15 October 2016
+"""
+
+
+import unittest
+
+
+class LinkedListNode(object):
+    """Singly Linked List Node"""
+
+    def __init__(self, value):
+        super(LinkedListNode, self).__init__()
+        self.value = value
+        self.next = None
+
+
+def solution_one(head, k):
+    current_node = head
+    runner = current_node
+    for i in range(k):
+        if runner.next is not None:
+            runner = runner.next
+        else:
+            print("No kth to last element.")
+            return
+    while runner.next is not None:
+        runner = runner.next
+        current_node = current_node.next
+    return current_node
+
+
+class Tests(unittest.TestCase):
+
+    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)
+        a.next = b
+        b.next = c
+        c.next = d
+        d.next = e
+        e.next = f
+        f.next = g
+        return a
+
+
+    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()

laakmann-mcdowell/2-linked-lists/3_delete_middle_node.py

@@ -0,0 +1,51 @@
+"""
+2.3 Delete Middle Node
+
+Implement an algorithm to delete a node in the middle (i.e. any node but the first and last node,
+not necessarily the exact middle) of a singly linked list, given only access to that node.
+
+EXAMPLE:
+Input: node c from the linked list a->b->c->d->e->f
+Result: nothing is returned, but the new linked list looks like a->b->d->e->f
+
+"""
+
+"""
+Thoughts: need to change b.next even though we don't have access to b.
+This is a singly linked list so cannot say c.prev.next = c.next etc.
+"""
+from linked_list_classes import LinkedListNode
+import unittest
+
+def solution(input_node):
+    # How do we check that the input node is not the first node?
+    if input_node.next is not None:
+        next_node = input_node.next
+        input_node.value = next_node.value
+        input_node.next = next_node.next
+    return input_node
+
+
+class Tests(unittest.TestCase):
+
+    def test_solution(self):
+        a = LinkedListNode(1)
+        b = LinkedListNode(2)
+        c = LinkedListNode(3)
+        d = LinkedListNode(4)
+        e = LinkedListNode(5)
+        f = LinkedListNode(6)
+        g = LinkedListNode(7)
+        a.next = b
+        b.next = c
+        c.next = d
+        d.next = e
+        e.next = f
+        f.next = g
+        solution(e)
+        self.assertEqual(d.next.value, 6)
+        self.assertEqual(d.next.next, g)
+        self.assertEqual(f.next, g)
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -0,0 +1,46 @@
+"""
+2.4 Partition
+
+Write code to partition a linked list around a value x, such that
+all nodes less than x come before all nodes greater than
+or equal to x. If x is contained within the list, the values of x
+only need to be after the elements less than x. The partition element
+x can appear anywhere in the 'right partition'; it does not need to
+appear between the left and right partitions.
+
+EXAMPLE:
+3->5->8-5->10->2->1 [partition = 5]
+
+
+"""
+from linked_list_classes import LinkedListNode
+import unittest
+
+
+
+class Tests(unittest.TestCase):
+
+    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)
+        a.next = b
+        b.next = c
+        c.next = d
+        d.next = e
+        e.next = f
+        f.next = g
+        return a
+
+
+    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()

laakmann-mcdowell/2-linked-lists/linked_list_classes.py

@@ -4,12 +4,14 @@
 Taken from InterviewCake August 2016
 """
 
-class LinkedListNode():
-	"""Singly Linked List Nodes"""
-	def __init__(self, value):
-#		super(LinkedListNode, self).__init__()
-		self.value = value
-		self.next = None
+
+class LinkedListNode(object):
+    """Singly Linked List Node"""
+
+    def __init__(self, value):
+        super(LinkedListNode, self).__init__()
+        self.value = value
+        self.next = None
 
 
 # Build a singly linked list