More solutions, bonus problems folder

Author: StBogdan

bonus/max_perf_tree.py

@@ -0,0 +1,32 @@
+from utils.graphs import BiNode, ltbt
+
+
+def maximum_perfect_tree(tree_root: BiNode):
+    max_now = 0
+
+    def max_perf_tree_depth(root: BiNode) -> int:
+        nonlocal max_now
+        if not root:
+            return 0
+
+        l_max = max_perf_tree_depth(root.left)
+        r_max = max_perf_tree_depth(root.right)
+        val_now = 1 + min(l_max, r_max)
+
+        if val_now > max_now:
+            max_now = val_now
+
+        return val_now
+
+    max_perf_tree_depth(tree_root)
+    return 2**max_now -1
+
+
+if __name__ == "__main__":
+    tree_arr =      [1] +\
+                [2,                 3] + \
+            [None, 4] +            [5, 6] +\
+    [None, None] + [None, None] + [7, 8] + [9, 10]
+    [None] * 14 +                       [11]
+    example_root = ltbt(tree_arr)
+    print(f"Max tree is {maximum_perfect_tree(example_root)}")

bonus/spiral_copy.py

@@ -0,0 +1,67 @@
+def search_rot_arr(arr_rotated, num):
+    n = len(arr_rotated)
+
+    if not arr_rotated:
+        return -1
+    elif n == 1:
+        return 0 if arr_rotated[0] == num else -1
+    elif arr_rotated[0] < arr_rotated[-1]:
+        return binary_search(arr_rotated, 0, n-1, num)
+
+    pivot_index = find_pivot_index(arr_rotated)
+    res_index = -1
+
+    print(f"Found pivot index: {pivot_index}")
+
+    search_start, search_end = \
+        (pivot_index+1, n-1) if num <= arr_rotated[-1] else (0, pivot_index)
+    return binary_search(arr_rotated, search_start, search_end, num)
+
+
+def binary_search(arr, s, e, target):
+    low = s
+    high = e
+    while low <= high:
+        mid = (low + high) // 2
+
+        if arr[mid] == target:
+            return mid
+        elif arr[mid] > target:
+            high = mid-1
+        else:
+            low = mid+1
+
+    return -1
+
+
+def find_pivot_index(arr):
+    """Addresable index of the last element before pivot"""
+    low = 0
+    high = len(arr)-1
+
+    while low <= high:
+        mid = (low+high) // 2  # Divide and floor
+
+        if mid == len(arr):
+            return 0
+
+        if arr[mid+1] < arr[mid]:
+            return mid
+
+        if arr[mid] > arr[-1]:
+            low = mid+1
+        else:
+            high = mid - 1
+
+    return 0
+
+
+if __name__ == "__main__":
+    exs = [([2], 2),
+           ([1, 2], 2),
+           ([0, 1, 2, 3, 4, 5], 1),
+           ([9, 12, 17, 2, 4, 5], 17),
+           ([9, 12, 17, 2, 4, 5, 6], 4)]
+    for arr, target in exs:
+        print(
+            f"Looking for {target} in {arr}, found location ? {search_rot_arr(arr, target)}")

chapter_10/p10_3.py

@@ -0,0 +1,42 @@
+class Listy:
+    def __init__(self, arr):
+        self.arr = arr
+
+    def elemAt(self, index: int):
+        return self.arr[index] if index < len(self.arr) else -1
+
+def search_unsized_list(arr: Listy, target: int) -> int:
+    # Lenght is not known
+    ind = 0
+    low = 0
+    while arr.elemAt(ind) != -1 and arr.elemAt(ind) <= target:
+        ce = arr.elemAt(ind)
+        low = ind
+        if not ind:
+            ind = 1
+        else:
+            ind *= 2
+
+    high = ind
+    while low <= high:
+        # print(f"Looking at low and high {low} and {high}")
+        mid = (low + high) // 2
+        ce = arr.elemAt(mid)
+        if ce == target:
+            return mid
+        elif ce == -1 or ce > target:
+            high = mid - 1
+        else:
+            low = mid + 1
+    return -1
+
+
+if __name__ == "__main__":
+    exs = [([1, 2, 3, 4, 5, 6, 7, 8], 10),
+           ([12, 13, 14, 15], 15),
+           (list(range(62)), 61)]
+    for arr, target in exs:
+        listy_arr = Listy(arr)
+        print(
+            f"Looking for {target} in {arr}, found location ?"
+            f" {search_unsized_list(listy_arr, target)}")

chapter_10/p10_4.py

@@ -0,0 +1,34 @@
+from typing import List
+
+
+def sparse_search(warr: List[str], target):
+    low = 0
+    high = len(warr) - 1
+    while low <= high:
+        mid = (low + high) // 2
+
+        # Go right until limit or non-empty
+        while mid < high and not warr[mid]:
+            mid += 1
+
+        if warr[mid] == target:
+            return mid
+        elif (not warr[mid]) or warr[mid] > target:
+            # In case that right side is empty, look left
+            high = mid-1
+        else:
+            low = mid+1
+    return -1
+
+
+if __name__ == "__main__":
+    test_arr = ['b', '', '', 'car', '', '', 'tar', '', '', '', '', 'zar']
+    exs = [(test_arr, 'zar'),
+           (test_arr, 'car'),
+           (test_arr, "potato"),
+           (test_arr, 'b'),
+           ([''], "potato"),
+           (['', 'aaa', ''], 'aaa'),
+           (['aaa'], 'aaa')]
+    for arr, target in exs:
+        print(f"Position of {target}\tis {sparse_search(arr,target)}\tin {arr}")

chapter_10/p10_5.py

@@ -0,0 +1,38 @@
+import heapq as hq
+
+
+class MedianHolder:
+
+    def __init__(self):
+        self.left_heap = [] # Max (on top) heap
+        self.right_heap = [] # Min (on top) heap
+        self.size = 0
+
+    def add_elem(self, x: int):
+
+        if self.left_heap and x > -self.left_heap[0]:
+            hq.heappush(self.right_heap, x)
+        else:
+            hq.heappush(self.left_heap, -x)
+
+        if len(self.left_heap) < len(self.right_heap):  # Too much on right
+            hq.heappush(self.left_heap, - hq.heappop(self.right_heap))
+        elif len(self.left_heap) > len(self.right_heap) + 1:  # Too much on left
+            hq.heappush(self.right_heap, -hq.heappop(self.left_heap))
+
+        self.size += 1
+
+    def get_median(self):
+        if self.size == 0:
+            raise Exception("No elems")
+        if self.size % 2 == 0:
+            return (-self.left_heap[0] + self.right_heap[0]) / 2
+        else:
+            return -self.left_heap[0]
+
+
+if __name__ == "__main__":
+    mh = MedianHolder()
+    for i in range(25):
+        mh.add_elem(i)
+        print(f"At elem {i}\t, Median is now {mh.get_median()} ")