Annotate chapter 2

Author: StBogdan

README.md

@@ -2,7 +2,7 @@
 
 > Existing Python solutions can be found [officially here](https://github.com/careercup/CtCI-6th-Edition-Python/tree/e6bc732588601d0a98e5b1bc44d83644b910978d) and [user-created here](https://github.com/w-hat/ctci-solutions)
 
-### Current progress
+## Current progress
 | Nr. 	|         Chapter        	| Done 	| Total 		| Ommited 	| Notes |
 |:---:	|:----------------------:	|:----:	|:-----:	|:-------:	| :-------:	 |
 |   1 	| [Array and String](chapter_1)       	|   9  	|   9   	|       	|         	| |
@@ -24,15 +24,15 @@
 |  17 	| [Hard](chapter_17)                   	|  26  	|   26  	|         	| |
 
 
-### Running the solutions
+## Running the solutions
 
-For convenience, the project has a `setup.py` that specifies a package
-This can be installed locally in the python (virtual)environment by using
+For convenience, the project has a `setup.py` that specifies a package, for local path resolving.   
+This can be installed locally in the python (virtual)environment by using:
 ```bash
 pip install -e .
 ```
 
-Problems can be run by running the file, most should have a main method.
+Problems can be run by running the file, most should have a main method with some sample input, e.g. :
 ```bash
 python p16_20.py
 ```

chapter_2/linked_list_utils.py

@@ -20,6 +20,8 @@ def link_list_of_list(arr) -> Node:
 
 
 def llol(arr):
+    """Shorthand for (make) linked-list of list
+    """
     return link_list_of_list(arr)
 
 

chapter_2/p2_1.py

@@ -1,5 +1,13 @@
 from chapter_2.linked_list_utils import Node, llol
 
+# Method: Use a set
+# Time: O(n)
+# Space: O(n)
+
+# Method (no buffer): Pick one, try to find in rest of linked list
+# Time: O(n^2)
+# Space: O(1)
+
 
 def remove_dups_ll(head: Node):
     seen = set()
@@ -13,18 +21,18 @@ def remove_dups_ll(head: Node):
         head = head.next
 
 
-def remove_dups_nobuf(h: Node):
-    rc = h
+def remove_dups_nobuf(head: Node):
+    rc = head
     while rc:
         target = rc.val
         prev = rc
-        restp = rc.next
-        while restp:
-            if restp.val == target:
-                prev.next = restp.next
+        rest_ptr = rc.next
+        while rest_ptr:
+            if rest_ptr.val == target:
+                prev.next = rest_ptr.next
             else:
-                prev = restp
-            restp = restp.next
+                prev = rest_ptr
+            rest_ptr = rest_ptr.next
         rc = rc.next
 
 

chapter_2/p2_2.py

@@ -1,22 +1,28 @@
 from chapter_2.linked_list_utils import *
 
+# Method: Leader and follower pointer, at k distance
+# Time: O(n)
+# Space: O(1)
 
-def k_to_last(k: int, h: Node):
-    ldr = h
-    folw = h
-    d = -1
 
-    while ldr:
-        print(f"Ldr is {ldr} and folw {folw}")
-        d += 1
-        if d > k:
-            folw = folw.next
-        ldr = ldr.next
+def k_to_last(k: int, head: Node):
+    leader_ptr = head
+    follower_ptr = head
+    distance = -1
 
-    if d < k:
-        raise Exception(f"Input too short for distance {d}")
+    while leader_ptr:
+        print(f"Leader is {leader_ptr} "
+              f"and follower {follower_ptr},"
+              f" at distance {distance}")
+        distance += 1
+        if distance > k:
+            follower_ptr = follower_ptr.next
+        leader_ptr = leader_ptr.next
 
-    return folw.val
+    if distance < k:
+        raise Exception(f"Input too short for distance {distance}")
+
+    return follower_ptr.val
 
 
 if __name__ == "__main__":

chapter_2/p2_3.py

@@ -1,5 +1,9 @@
 from chapter_2.linked_list_utils import llol, Node
 
+# Method: Identity theft
+# Time: O(1)
+# Space: O(1)
+
 
 def remove_mid(mid_node: Node):
     victim = mid_node.next

chapter_2/p2_4.py

@@ -1,5 +1,9 @@
 from chapter_2.linked_list_utils import llol, Node
 
+# Method: Construct 2 other lists
+# Time: O(n)
+# Space: O(1)
+
 
 def part_around(x: int, head: Node):
     low_head = None

chapter_2/p2_5.py

@@ -1,5 +1,15 @@
 from chapter_2.linked_list_utils import Node, lllen, llol
 
+# Backward oder (head at least significant)
+# Method: Digit by digit, with carry
+# Time: O(n)
+# Space: O(n) (Constant if you overwrite one of the inputs)
+
+# Forward order
+# Method: Pad to len, recurse down
+# Time: O(n)
+# Space: O(n)
+
 
 def sum_ll(tl1: Node, tl2: Node):
     nl = None

chapter_2/p2_6.py

@@ -1,38 +1,42 @@
 from chapter_2.linked_list_utils import Node, llol
 
+# Method: Slow/Fast pointer, push to stack second half and check
+# Time: O(n)
+# Space: O(n)
 
-def check_ll_palindrome(h: Node):
-    sl_len = -1
-    fst_len = -1
 
-    if not h:
+def check_ll_palindrome(head: Node):
+    slow_len = -1
+    fast_len = -1
+
+    if not head:
         return True
 
-    slp = h
-    fstp = h
+    slow_ptr = head
+    fast_ptr = head
     stack = []
-    while fstp:
-        sl_len += 1
-        fst_len += 2
-        stack.append(slp.val)
+    while fast_ptr:
+        slow_len += 1
+        fast_len += 2
+        stack.append(slow_ptr.val)
 
-        slp = slp.next
-        fstp = fstp.next
+        slow_ptr = slow_ptr.next
+        fast_ptr = fast_ptr.next
 
-        if fstp:
-            fstp = fstp.next
-            if not fstp:
-                fst_len += 1
+        if fast_ptr:
+            fast_ptr = fast_ptr.next
+            if not fast_ptr:
+                fast_len += 1
 
-    if fst_len > 0 and fst_len % 2:
+    if fast_len > 0 and fast_len % 2:
         stack.pop()
 
-    print(f"Stack is {stack}, slp is {slp}")
+    print(f"Stack is {stack}, slp is {slow_ptr}")
 
-    while slp:
-        if slp.val != stack.pop():
+    while slow_ptr:
+        if slow_ptr.val != stack.pop():
             return False
-        slp = slp.next
+        slow_ptr = slow_ptr.next
 
     return not stack
 

chapter_2/p2_7.py

@@ -1,25 +1,29 @@
 from chapter_2.linked_list_utils import Node, link_list_of_list, lllen, llol
 
+# Method: Find total lenght, walk together until meet
+# Time: O(n)
+# Space: O(1)
+
 
 def get_intersecting_node(h1: Node, h2: Node):
-    ll1 = lllen(h1)
-    ll2 = lllen(h2)
+    len_ll1 = lllen(h1)
+    len_ll2 = lllen(h2)
 
     if get_last_of_ll(h1) != get_last_of_ll(h2):
         return None
 
-    if ll1 > ll2:
-        sl = h2
-        bl = h1
+    if len_ll1 > len_ll2:
+        short_ll = h2
+        longer_ll = h1
     else:
-        sl = h1
-        bl = h2
-
-    bl = adjust(bl, abs(ll1 - ll2))
-    while bl != sl:
-        bl = bl.next
-        sl = sl.next
-    return bl.val
+        short_ll = h1
+        longer_ll = h2
+
+    longer_ll = adjust(longer_ll, abs(len_ll1 - len_ll2))
+    while longer_ll != short_ll:
+        longer_ll = longer_ll.next
+        short_ll = short_ll.next
+    return longer_ll.val
 
 
 def adjust(head: Node, jumps):

chapter_2/p2_8.py

@@ -1,5 +1,8 @@
 from chapter_2.linked_list_utils import Node
 
+# Method: Fast/Slow pointer to meeting, restart pointer at beginning
+# Time: O(n)
+# Space: O(1)
 
 def get_first_loop_elem(h: Node):
     if not h.next:

chapter_2/readme.md

@@ -4,11 +4,11 @@ The complexity table is for a quick lookup, more details in the actual file (e.g
 
 | Nr. 	| Title 	| Solution 	| Time 	| Space 	| Notes 	|
 |:---:	|:-----:	|:--------:	|:----:	|:-----:	|:-----:	|
-| 2.1 	| Remove dups               | [Python](./p2_1.py) | O(n) 	| O(n) 	| 	|
-| 2.2 	| Return Kth to last        | [Python](./p2_2.py) | O(n*log(n)) 	| O(n) 	| 	|
-| 2.3 	| Delete Middle Node        | [Python](./p2_3.py) | O(n) 	| O(1) 	| 	|
+| 2.1 	| Remove dups               | [Python](./p2_1.py) | O(n^2) 	| O(1) 	| 	|
+| 2.2 	| Return Kth to last        | [Python](./p2_2.py) | O(n)) 	| O(1) 	| 	|
+| 2.3 	| Delete Middle Node        | [Python](./p2_3.py) | O(1) 	| O(1) 	| 	|
 | 2.4 	| Partition                 | [Python](./p2_4py)  | O(n) 	| O(1) 	| 	|
-| 2.5 	| Sum Lists                 | [Python](./p2_5.py) | O(min(n,m)) 	| O(1) 	| 	|
+| 2.5 	| Sum Lists                 | [Python](./p2_5.py) | O(n) 	| O(n) 	| 	|
 | 2.6 	| Palindrome                | [Python](./p2_6.py) | O(n) 	| O(n) 	| 	|
-| 2.7 	| Intersection              | [Python](./p2_7.py) | O(n*m) 	| O(1) 	| 	|
-| 2.8 	| Loop Detection            | [Python](./p2_8.py) | O(n*m) 	| O(1) 	| 	|
+| 2.7 	| Intersection              | [Python](./p2_7.py) | O(n) 	| O(1) 	| 	|
+| 2.8 	| Loop Detection            | [Python](./p2_8.py) | O(n) 	| O(1) 	| 	|