8/24/23

- stack_with_max.py
- delete_node_from_list.py
- do_lists_overlap.py
- do_terminated_lists_overlap.py
- int_as_list_add.py

Author: jsgoller1

elements-of-programming-interviews/problem_mapping.js

@@ -740,7 +740,7 @@ problem_mapping = {
                 "total": 106
             },
             "Python: do_terminated_lists_overlap.py": {
-                "passed": 0,
+                "passed": 106,
                 "total": 106
             }
         },
@@ -754,7 +754,7 @@ problem_mapping = {
                 "total": 120
             },
             "Python: do_lists_overlap.py": {
-                "passed": 0,
+                "passed": 120,
                 "total": 120
             }
         },
@@ -768,7 +768,7 @@ problem_mapping = {
                 "total": 512
             },
             "Python: delete_node_from_list.py": {
-                "passed": 0,
+                "passed": 512,
                 "total": 512
             }
         },
@@ -866,7 +866,7 @@ problem_mapping = {
                 "total": 2002
             },
             "Python: int_as_list_add.py": {
-                "passed": 0,
+                "passed": 2002,
                 "total": 2002
             }
         }
@@ -882,7 +882,7 @@ problem_mapping = {
                 "total": 101
             },
             "Python: stack_with_max.py": {
-                "passed": 0,
+                "passed": 101,
                 "total": 101
             }
         },

elements-of-programming-interviews/python/delete_node_from_list.py

@@ -7,8 +7,9 @@
 
 # Assumes node_to_delete is not tail.
 def deletion_from_list(node_to_delete: ListNode) -> None:
-    # TODO - you fill in here.
-    return
+    if node_to_delete:
+        node_to_delete.data = node_to_delete.next.data
+        node_to_delete.next = node_to_delete.next.next
 
 
 @enable_executor_hook

elements-of-programming-interviews/python/do_lists_overlap.py

@@ -6,12 +6,103 @@
 from test_framework.test_failure import TestFailure
 from test_framework.test_utils import enable_executor_hook
 
+"""
+Cases:
+    - No cycle, no overlap
+    - Cycle, no overlap
+    - No cycle, overlap
+    - Cycle, overlap 
 
-def overlapping_lists(l0: ListNode, l1: ListNode) -> Optional[ListNode]:
-    # TODO - you fill in here.
+if only one is cyclic:
+    return no overlap
+if both are cyclic:
+    get beginning of cycle for both. Starting at one,
+    if it wraps all the way around without reaching the other's beginning
+    of cycle, no overlap 
+else:
+    shorten to equal length, use
+    previous method 
+"""
+
+
+def get_list_len(head: ListNode):
+    fast = slow = head
+    i = 0
+    while slow:
+        slow = slow.next
+        i += 1
+        if fast:
+            fast = fast.next
+        if fast:
+            fast = fast.next
+        if fast and fast is slow:
+            return -1
+    return i
+
+
+def check_noncyclic_overlap(l0, l0_len, l1, l1_len):
+    while l0_len > l1_len:
+        l0 = l0.next
+        l0_len -= 1
+
+    while l1_len > l0_len:
+        l1 = l1.next
+        l1_len -= 1
+
+    while l0 is not l1:
+        l0 = l0.next
+        l1 = l1.next
+
+    return l0
+
+
+def get_cycle_head(head: ListNode):
+    slow = fast = head
+    while True:
+        slow = slow.next
+        fast = fast.next.next
+        if slow is fast:
+            break
+
+    slow = head
+    while slow is not fast:
+        slow = slow.next
+        fast = fast.next
+
+    return fast
+
+
+def check_cyclic_overlap(l0, l1):
+    l0_cycle_head = get_cycle_head(l0)
+    l1_cycle_head = get_cycle_head(l1)
+    if l0_cycle_head is l1_cycle_head:
+        return l0_cycle_head
+
+    curr = l0_cycle_head.next
+    while curr is not l0_cycle_head:
+        if curr is l1_cycle_head:
+            return curr
+        curr = curr.next
     return None
 
 
+def overlapping_lists(l0: ListNode, l1: ListNode) -> Optional[ListNode]:
+    if not l0 or not l1:
+        return None
+    l0_len = get_list_len(l0)
+    l1_len = get_list_len(l1)
+
+    # One's a cycle, the other is not
+    if -1 in [l0_len, l1_len] and l0_len != l1_len:
+        return None
+
+    # Neither is cyclic
+    if l0_len != -1:
+        return check_noncyclic_overlap(l0, l0_len, l1, l1_len)
+    else:
+        return check_cyclic_overlap(l0, l1)
+
+
 @enable_executor_hook
 def overlapping_lists_wrapper(executor, l0, l1, common, cycle0, cycle1):
     if common:
@@ -65,7 +156,26 @@ def overlapping_lists_wrapper(executor, l0, l1, common, cycle0, cycle1):
         raise TestFailure('Invalid result')
 
 
+def print_list(head):
+    seen = set()
+    while head:
+        if id(head) in seen:
+            print("cycle detected; quitting.")
+            return
+        seen.add(id(head))
+        print(f"node: {head.data}")
+        head = head.next
+
+
 if __name__ == '__main__':
+    """
+    head = curr = ListNode(0, None)
+    for i in range(1, 10):
+        curr.next = ListNode(i, None)
+        curr = curr.next
+    # curr.next = head.next.next.next
+    print(overlapping_lists(head, head.next.next.next.next).data)
+    """
     exit(
         generic_test.generic_test_main('do_lists_overlap.py',
                                        'do_lists_overlap.tsv',

elements-of-programming-interviews/python/do_terminated_lists_overlap.py

@@ -5,10 +5,33 @@
 from test_framework.test_failure import TestFailure
 from test_framework.test_utils import enable_executor_hook
 
+# if lists are same length and overlap, they overlap at the same place
+# so shorten one if necessary, then compare node-by-node.
+
+
+def get_list_len(head: ListNode):
+    size = 0
+    while head:
+        size += 1
+        head = head.next
+    return size
+
 
 def overlapping_no_cycle_lists(l0: ListNode, l1: ListNode) -> ListNode:
-    # TODO - you fill in here.
-    return ListNode()
+    l0_len = get_list_len(l0)
+    l1_len = get_list_len(l1)
+    while l0_len > l1_len:
+        l0 = l0.next
+        l0_len -= 1
+    while l0_len < l1_len:
+        l1 = l1.next
+        l1_len -= 1
+
+    while l0 is not l1:
+        l0 = l0.next
+        l1 = l1.next
+
+    return l0 if l0 is l1 and l0 is not None else None
 
 
 @enable_executor_hook

elements-of-programming-interviews/python/int_as_list_add.py

@@ -3,10 +3,27 @@
 from list_node import ListNode
 from test_framework import generic_test
 
+# TODO: Negatives
+
 
 def add_two_numbers(L1: ListNode, L2: ListNode) -> Optional[ListNode]:
-    # TODO - you fill in here.
-    return None
+    # NOTE: Only works for nonnegatives
+    if not L2 or not L1:
+        return L1 if L1 else L2
+
+    head = curr = ListNode(-1, None)
+    carry = 0
+    while L1 or L2 or carry:
+        op1 = L1.data if L1 else 0
+        op2 = L2.data if L2 else 0
+        digit = (op1 + op2 + carry) % 10
+        carry = (op1 + op2 + carry) // 10
+        curr.next = ListNode(digit, None)
+        curr = curr.next
+        L1 = L1.next if L1 else L1
+        L2 = L2.next if L2 else L2
+
+    return head.next
 
 
 if __name__ == '__main__':

elements-of-programming-interviews/python/stack_with_max.py

@@ -3,21 +3,25 @@
 
 
 class Stack:
+    def __init__(self):
+        self.data = []
+        self._maxes = []
+
     def empty(self) -> bool:
-        # TODO - you fill in here.
-        return True
+        return len(self.data) == 0
 
     def max(self) -> int:
-        # TODO - you fill in here.
-        return 0
+        return self._maxes[-1]
 
     def pop(self) -> int:
-        # TODO - you fill in here.
-        return 0
+        if self.data[-1] == self._maxes[-1]:
+            self._maxes.pop()
+        return self.data.pop()
 
     def push(self, x: int) -> None:
-        # TODO - you fill in here.
-        return
+        self.data.append(x)
+        if len(self._maxes) == 0 or self.data[-1] >= self._maxes[-1]:
+            self._maxes.append(x)
 
 
 def stack_tester(ops):
@@ -51,6 +55,16 @@ def stack_tester(ops):
 
 
 if __name__ == '__main__':
+    """
+    s = Stack()
+    s.push(10)
+    print(s.max())
+    s.push(12)
+    print(s.max())
+    s.pop()
+    print(s.max())
+
+    """
     exit(
         generic_test.generic_test_main('stack_with_max.py',
                                        'stack_with_max.tsv', stack_tester))