More solutions

Author: StBogdan

chapter_16/p17_20.py renamed to chapter_16/p16_5.py

@@ -0,0 +1,48 @@
+
+from typing import List
+from collections import defaultdict
+
+
+def longest_superseq(longer: List[int], shorter: List[int]) -> List[int]:
+    short_set = set(shorter)
+    count_now = defaultdict(int)
+
+    start = 0
+    number_uniq = 0
+
+    min_seq_now = float("inf")
+    min_seq_indexes = (-1, -1)
+
+    for i in range(len(longer)):
+        x = longer[i]
+        if x in short_set:
+            if count_now[x] == 0:
+                number_uniq += 1
+            count_now[x] += 1
+
+        while number_uniq == len(shorter) and start < i:
+            current_subseq_len = i - start + 1
+            if current_subseq_len < min_seq_now:
+                min_seq_now = current_subseq_len
+                min_seq_indexes = (start, i)
+
+            if longer[start] in short_set:
+                count_now[longer[start]] -= 1
+
+                if count_now[longer[start]] == 0:
+                    number_uniq -= 1
+
+            start += 1
+
+    return list(min_seq_indexes)
+
+
+if __name__ == "__main__":
+    exs = [
+        ([1, 5, 9], [7, 5, 9, 0, 2, 1, 3, 5, 7, 9, 1, 1, 5, 8, 8, 9, 7]),
+        ([1, 2, 3], [1, 1, 2, 2, 2, 3, 3, 9, 9, 2, 1, 1, 3])
+    ]
+
+    for shorter, longer in exs:
+        print(f"Between {longest_superseq(longer,shorter)}, "
+              f"you will find {shorter} in {longer}")

chapter_17/p17_18.py

@@ -0,0 +1,72 @@
+from typing import List, Tuple
+
+
+def precomp_down_left_squares(m: List[List[int]]) \
+        -> Tuple[List[List[int]], List[List[int]]]:
+    rows = len(m)
+    cols = len(m[0])
+
+    down_sq = [[0 for _ in range(cols+1)] for _ in range(rows+1)]
+    right_sq = [[0 for _ in range(cols+1)] for _ in range(rows+1)]
+
+    for row in range(rows-1, -1, -1):
+        for col in range(cols-1, -1, -1):
+            down_sq[row][col] = 0 if m[row][col] == 0 else 1 + \
+                down_sq[row+1][col]
+            right_sq[row][col] = 0 if m[row][col] == 0 else 1 + \
+                right_sq[row][col+1]
+
+    return down_sq, right_sq
+
+
+def check_square(coords: tuple, sq_size: int,
+                 down_sq: List[List[int]],
+                 right_sq: List[List[int]]) -> bool:
+    """ Check that the square has squares for all the sides, as required by the the size
+    l     r
+    # # # # top
+    #     #
+    #     #
+    # # # # bot
+    <-----> sq_size
+    """
+    top_left_col, top_left_row = coords
+    bot_left_col, bot_left_row = top_left_col, top_left_row + sq_size-1
+    top_right_col, top_right_row = top_left_col + sq_size - 1, top_left_row
+
+    if down_sq[top_left_row][top_left_col] < sq_size \
+            or right_sq[top_left_row][top_left_col] < sq_size:
+        return False
+
+    if down_sq[top_right_row][top_right_col] < sq_size \
+            or right_sq[bot_left_row][bot_left_col] < sq_size:
+        return False
+
+    return True
+
+
+def max_square_outline(matrix: List[List[int]]) -> List[tuple]:
+    # Return the 4 coordonates, zero-indexed
+    n = len(matrix)
+    down_sq, right_sq = precomp_down_left_squares(matrix)
+
+    for square_size in range(n, 0, -1):
+        for row in range(0, n-square_size+1):
+            for col in range(0, n-square_size+1):
+                if check_square((row, col), square_size, down_sq, right_sq):
+                    return [
+                        (row, col),
+                        (row+square_size - 1, col + square_size - 1)
+                    ]
+
+    return []
+
+
+if __name__ == "__main__":
+    matrix = [
+        [0, 1, 1, 1, 1],
+        [1, 0, 1, 0, 0],
+        [1, 1, 1, 1, 0],
+        [1, 0, 1, 1, 1]]
+
+    print(f"Max square in test matrix is {max_square_outline(matrix)}")

chapter_17/p17_23.py

@@ -0,0 +1,19 @@
+def triple_step(n: int) -> int:
+
+    dp = [1, 1, 2]
+
+    if n < 3:
+        return dp[n]
+
+    for i in range(3, n+1):
+        new_elem = sum(dp)
+        dp[0] = dp[1]
+        dp[1] = dp[2]
+        dp[2] = new_elem
+
+    return dp[2]
+
+
+if __name__ == "__main__":
+    for i in range(20):
+        print(f"Going to {i} step, ways to do this: {triple_step(i)}")

chapter_8/p8_1.py

@@ -0,0 +1,46 @@
+from functools import lru_cache
+from collections import namedtuple
+from typing import List
+
+Box = namedtuple("Box", "w l h")
+
+
+def can_stack(bot: Box, top: Box):
+    return bot.w > top.w and bot.l > top.l and bot.h > top.h
+
+
+def max_box_stack(boxes: List[Box]):
+    # Need to be immutable for the cache
+    sort_boxes = tuple(sorted(boxes, key=lambda box: -box.h))
+    # print(f"Sorted boxes are {sort_boxes}")
+
+    box_stack_sizes = [stack_boxes(sort_boxes, i)
+                       for i in range(len(sort_boxes))]
+    return max(box_stack_sizes)
+
+
+@lru_cache(None)
+def stack_boxes(boxes: List[Box], box_index: int) -> int:
+    height_of_boxpile = 0
+    box_now = boxes[box_index]
+
+    max_h_added = 0
+
+    for i in range(box_index+1, len(boxes)):
+        h_added = 0
+        if can_stack(box_now, boxes[i]):
+            h_added = stack_boxes(boxes, i)
+            max_h_added = max(max_h_added, h_added)
+
+    height_of_boxpile = box_now.h + max_h_added
+    return height_of_boxpile
+
+
+if __name__ == "__main__":
+    boxes = [
+        Box(20, 20, 20),
+        Box(10, 10, 10),
+        Box(5, 5, 5),
+        Box(30, 5, 30),
+        Box(15, 15, 15)]
+    print(f"Maximum height for boxes is {max_box_stack(boxes)}")

chapter_8/p8_13.py

@@ -0,0 +1,50 @@
+from typing import List
+
+
+def find_magic_index(arr: List[int]) -> int:
+    low = 0
+    high = len(arr)-1
+    while low <= high:
+        mid = (low + high) // 2
+        if mid == arr[mid]:
+            return mid
+        elif mid > arr[mid]:
+            low = mid + 1
+        else:
+            high = mid - 1
+
+    return -1
+
+
+def find_magic_index_dups(arr: List[int]) -> int:
+    return fmidh(arr, 0, len(arr)-1)
+
+
+def fmidh(arr, s, e) -> int:
+    if s > e:
+        return -1
+
+    mid = (s+e) // 2
+    elem = arr[mid]
+
+    if elem == mid:
+        return mid
+
+    lr = fmidh(arr, s, min(mid - 1, arr[mid]))
+    if lr > 0:
+        return lr
+
+    rr = fmidh(arr, max(mid+1, arr[mid]), e)
+    if rr > 0:
+        return rr
+
+    return -1
+
+
+if __name__ == "__main__":
+    ex1 = [-1, 1, 5, 6, 7, 8, 9, 10]
+    ex_dups = [-10, -5, 2, 2, 2, 3, 4, 5, 9, 12, 13]
+
+    print(f"A good index is {find_magic_index(ex1)}"
+          f" same as {find_magic_index_dups(ex1)}, in {ex1}")
+    print(f"With dups index: {find_magic_index_dups(ex_dups)} in {ex_dups}")