Partial readme for chapter 17

Author: StBogdan

chapter_17/p17_1.py

@@ -1,3 +1,8 @@
+
+# Method: Bitwise addition, recurse with carry
+# Time: O(log(n))
+# Space: O(log(n))
+
 def add_overfill(left, res, ctr, carry):
     while left:
         # print(f"Diggin into {left:b}, resutl now {res:b}")
@@ -84,11 +89,13 @@ def add_no_alg_better(a, b):
     # exs = [(0b1011, 0b1011)]
     fails = 0
     for a, b in exs:
-        if add_no_alg(a, b) != a+b or add_no_alg_better(a,b) != a+b:
+        if add_no_alg(a, b) != a + b or add_no_alg_better(a, b) != a + b:
             print(
-                f"Result\t{add_no_alg(a,b):b},\nsame as\t{(a+b):b} ? {add_no_alg(a,b) == a+b}, for inputs {a:b} and {b:b}")
+                f"Result\t{add_no_alg(a,b):b}," 
+                f"same as\t{(a+b):b} ? {add_no_alg(a,b) == a+b}, for inputs {a:b} and {b:b}"
+            )
             fails += 1
-            print("*"*50)
+            print("*" * 50)
         else:
             # print(f"Good for {a} and {b}")
             pass

chapter_17/p17_10.py

@@ -1,23 +1,28 @@
 from typing import List
 
+# Method: If there is a majority element, it's going to have enough buget to displace all others
+# Time: O(n)
+# Space: O(1)
+
 
 def majority_elem(arr):
     candidate = maj_elem(arr)
     return candidate if is_majority(candidate, arr) else -1
 
 
-def is_majority(x, arr):
+def is_majority(x: int, arr: List[int]) -> bool:
     count = 0
     for elem in arr:
-        count += (elem == x)
+        count += elem == x
     print(f"Count is {count}")
-    return count > len(arr)/2
+    return count > len(arr) / 2
 
 
 def maj_elem(arr: List[int]) -> int:
     elem_now = arr[1]
     count = 1
-    for x in arr[1:]:
+    for i in range(1, len(arr)):
+        x = arr[i]
         if x == elem_now:
             count += 1
         else:

chapter_17/p17_11.py

@@ -1,13 +1,23 @@
-# idea: Reverse index
-
-# create mapping from key: word , value: sorted set of occurences (count words in book)
-
-# when looking for shortest distance between 2 words, run 2 pointers in the sorted arr, find min diff
 import re
 from typing import List
 from collections import defaultdict
 import os
 
+# Method: Index occurences, run through 2 sorted occurence lists
+# Time: O(w*o + max(o))
+# Space: O(w*o)
+# Notes: o = nr of occurences of a word, max(o) = **the** most frequent word
+
+# Idea: Reverse index
+# create mapping from
+#  key: word ,
+#  value: sorted set of occurences
+# (count words in book)
+
+# when looking for shortest distance between 2 words,
+# run 2 pointers in the sorted arr,
+# find min diff
+
 
 def build_reverse_index(words: List[str]):
     rev_index = defaultdict(list)
@@ -24,7 +34,7 @@ def get_min_interword_distance(w1: str, w2: str, rev_index: dict):
     if not occ_w1 or not occ_w2:
         raise Exception("Not all words present")
 
-    min_sum = float('inf')
+    min_sum = float("inf")
     p1 = 0
     p2 = 0
     while p1 < len(occ_w1) and p2 < len(occ_w2):
@@ -42,8 +52,7 @@ def get_min_interword_distance(w1: str, w2: str, rev_index: dict):
 
 if __name__ == "__main__":
     with open(os.path.join("utils", "lorem_ipsum.txt")) as words_source:
-        all_non_empty_words = filter(
-            bool, re.split(" |\n|\.", words_source.read()))
+        all_non_empty_words = filter(bool, re.split(" |\n|\.", words_source.read()))
         all_text = list(map(lambda x: x.lower(), all_non_empty_words))
 
     reverse_index = build_reverse_index(all_text)
@@ -53,5 +62,7 @@ def get_min_interword_distance(w1: str, w2: str, rev_index: dict):
     ]
 
     for w1, w2 in exs:
-        print(f"Shortest distance b/t {w1} and {w2}"
-              f" at {get_min_interword_distance(w1,w2, reverse_index)}")
+        print(
+            f"Shortest distance b/t {w1} and {w2}"
+            f" at {get_min_interword_distance(w1,w2, reverse_index)}"
+        )

chapter_17/p17_12.py

@@ -1,3 +1,10 @@
+from typing import Tuple
+
+# Method: Recursive call, returning left and right edges of result linked list
+# Time: O(n)
+# Space: O(d)
+# Where d = depth of BST
+
 
 class BiNode:
     def __init__(self, val):
@@ -11,16 +18,18 @@ def flatten_binary_tree(root: BiNode):
     return left_side
 
 
-def flat_helper(root: BiNode) -> tuple:
+def flat_helper(root: BiNode) -> Tuple[BiNode, BiNode]:
     left_edge = root
     right_edge = root
+
     if root.node1:
         left_edge_left, left_edge_right = flat_helper(root.node1)
 
         root.node1 = left_edge_right
         left_edge_right.node2 = root
 
         left_edge = left_edge_left
+
     if root.node2:
         right_edge_left, right_edge_right = flat_helper(root.node2)
 
@@ -32,11 +41,6 @@ def flat_helper(root: BiNode) -> tuple:
     return (left_edge, right_edge)
 
 
-#	20
-#  10       25
-# 5        22
-#	  21   23
-
 if __name__ == "__main__":
     root = BiNode(20)
     root.node1 = BiNode(10)

chapter_17/p17_13.py

@@ -1,31 +1,35 @@
 from typing import List
-import utils.datasets
 from functools import lru_cache
 
+# Method: DFS, prefix and best-of-rest with lookup against dict
+# Time: O(n^2)
+# Space: O(n)
+
+
 def add_spaces(alltext: str, words: List[str]):
     word_set = set(words)
     space_arr, invalids = add_spaces_helper(alltext, 0, word_set, {})
 
-    print(f"Managed to do it with {invalids} characters unknown, splits {space_arr}")
+    # print(f"Managed to do it with {invalids} characters unknown, splits {space_arr}")
     i = 0
     spaced_text = []
     for i in range(len(alltext)):
         spaced_text.append(alltext[i])
         if i in space_arr:
             spaced_text.append(" ")
-        
 
     return "".join(spaced_text)
 
 
-def add_spaces_helper(text: str,
-                      start_poz: int,
-                    #   split_pozs: List[int],
-                      word_set: set,
-                      memo:dict):
-    if (start_poz in memo):
+def add_spaces_helper(
+    text: str,
+    start_poz: int,
+    word_set: set,
+    memo: dict,
+):
+    if start_poz in memo:
         return memo[start_poz]
-    
+
     n = len(text)
     if start_poz == n:
         return [], 0
@@ -41,13 +45,14 @@ def add_spaces_helper(text: str,
 
         if invals < best_invals:
 
-            rest_words, rest_invals_count = \
-                add_spaces_helper(text, i + 1, word_set, memo)
+            rest_words, rest_invals_count = add_spaces_helper(
+                text, i + 1, word_set, memo
+            )
 
             if rest_invals_count + invals < best_invals:
-                current_splits = [start_poz-1, i] if invals == 0 else []
+                current_splits = [start_poz - 1, i] if invals == 0 else []
                 best_invals = rest_invals_count + invals
-                best_words = rest_words + current_splits       
+                best_words = rest_words + current_splits
 
     # print(f"At start {start_poz} Got best words {best_words}, and invals {best_invals}")
     memo[start_poz] = (best_words, best_invals)
@@ -56,11 +61,7 @@ def add_spaces_helper(text: str,
 
 
 if __name__ == "__main__":
-    exs = [
-        "helplinustechtipsineedtorebootmypc",
-        "linusz",
-        "torebootmy"
-        ]
+    exs = ["helplinustechtipsineedtorebootmypc", "linusz", "torebootmy"]
 
     # words = utils.datasets.get_system_word_list()
     words = ["help", "tech", "tips", "boot", "my", "reboot", "need", "to", "linus"]

chapter_17/p17_14.py

@@ -2,14 +2,18 @@
 from typing import List
 import heapq
 
+# Method: Minheap
+# Time: O(n * log(k))
+# Space: O(k)
+
 
 def smallest_k_elem(arr: List[int], k: int) -> List[int]:
     heap = []
 
     for i in range(k):
         heapq.heappush(heap, -arr[i])
 
-    for i in range(k+1, len(arr)):
+    for i in range(k + 1, len(arr)):
         if arr[i] < -heap[0]:
             heapq.heappop(heap)
             heapq.heappush(heap, -arr[i])
@@ -18,10 +22,7 @@ def smallest_k_elem(arr: List[int], k: int) -> List[int]:
 
 
 if __name__ == "__main__":
-    exs = [
-        ([1, 2, 3, 4, 5, 6], 4),
-        ([1, 2, 2, 2, 1, 1, 0], 3)
-    ]
+    exs = [([1, 2, 3, 4, 5, 6], 4), ([1, 2, 2, 2, 1, 1, 0], 3)]
 
     for ex, k in exs:
         print(f"{k} smalles in {ex} are {smallest_k_elem(ex,k)}")

chapter_17/p17_15.py

@@ -1,16 +1,20 @@
 from typing import List
 
+# Method: See if any split is buildable (left + right)
+# Time: O(w*(lw^2))
+# Space: O(w*(lw^2))
+# Note: w = nr of words lw: length of a word
+# Low confidence on both estimates
+
 
 def get_longest_gestaltwort(words: List[str]):
     known_words = {word: True for word in words}
 
     words_by_len = sorted(known_words, key=len, reverse=True)
 
     for word in words_by_len:
-        for i in range(1, len(word)):
-            if can_build_word(word, True, known_words):
-                print(known_words)
-                return word
+        if can_build_word(word, True, known_words):
+            return word
 
 
 def can_build_word(word, is_given_word, known_words):
@@ -20,28 +24,39 @@ def can_build_word(word, is_given_word, known_words):
     for i in range(1, len(word)):
         left = word[:i]
         right = word[i:]
-        if left in known_words and known_words[left]\
-                and can_build_word(right, False, known_words):
+        if (
+            left in known_words
+            and known_words[left]
+            and can_build_word(right, False, known_words)
+        ):
             known_words[word] = True
-            return True
+            return known_words[word]
 
     known_words[word] = False
-    return False
+    return known_words[word]
 
 
 def sys_word_test():
     with open("/usr/share/dict/words", "r") as system_words_file:
-        big_list = list(map(lambda word: word.lower(),
-                            system_words_file.read().split("\n")))
+        big_list = list(
+            map(lambda word: word.lower(), system_words_file.read().split("\n"))
+        )
 
     print(f"Have a total of {len(big_list)} words")
     print(f"The longest is: {sorted(big_list, key = len)[-1]}")
 
-    print(
-        f"For the words, the longest is {get_longest_gestaltwort(big_list[1:])}")
+    print(f"For the words, the longest is: {get_longest_gestaltwort(big_list[1:])}")
 
 
 if __name__ == "__main__":
-    words = ["cat", "banana", "dog", "nana",
-             "walk", "walker", "dogwalker", "catdognana"]
-    print(f"For the words, the longest is {get_longest_gestaltwort(words)}")
+    words = [
+        "cat",
+        "banana",
+        "dog",
+        "nana",
+        "walk",
+        "walker",
+        "dogwalker",
+        "catdognana",
+    ]
+    print(f"For the words, the longest is: {get_longest_gestaltwort(words)}")

chapter_17/p17_16.py

@@ -1,25 +1,26 @@
 from typing import List
 
+# Method: Bottom-up DP, max of times considering gap
+# Time: O(n)
+# Space: O(n)
+
 
 def masseuse_sched(appointments: List[int]):
     n = len(appointments)
 
-    dp = [0 for _ in range(n+3)]
+    dp = [0 for _ in range(n + 3)]
     cmax = 0
 
-    for i in range(n-1, -1, -1):
-        dp[i] = appointments[i] + max(dp[i+2], dp[i+3])
+    for i in range(n - 1, -1, -1):
+        dp[i] = appointments[i] + max(dp[i + 2], dp[i + 3])
         if dp[i] > cmax:
             cmax = dp[i]
 
     return max(dp[0], dp[1])
 
 
 if __name__ == "__main__":
-    exs = [
-        [30, 15, 60, 75, 45, 15, 15, 45],
-        [150, 30, 45, 60, 75, 150]
-    ]
+    exs = [[30, 15, 60, 75, 45, 15, 15, 45], [150, 30, 45, 60, 75, 150]]
 
     for ex in exs:
         print(f"Max mins is {masseuse_sched(ex)} for bookings {ex}")