More solutions, 2 medium , 1 hard, 1 soft

Author: StBogdan

chapter_16/p16_21.py

@@ -0,0 +1,31 @@
+from typing import List
+
+
+def sum_swap(arr1: List[int], arr2: List[int]) -> tuple:
+    if len(arr1) < len(arr2):
+        return sum_swap(arr2, arr1)
+
+    posibs_set = set(arr2)
+    target_change = abs(sum(arr1) - sum(arr2))
+
+    if target_change % 2 == 1:
+        return None
+        target_change //= 2
+
+    for x in arr1:
+        if x-target_change in posibs_set:
+            return (x, x-target_change)
+        elif x+target_change in posibs_set:
+            return (x, x + target_change)
+
+    return None
+
+
+if __name__ == "__main__":
+    exs = [
+        ([4, 1, 2, 1, 1, 2], [3, 6, 3, 3]),
+        ([1, 2, 3, 4, 5], [1, 2, 3, 4, 4])
+    ]
+
+    for arr1, arr2 in exs:
+        print(f"Swap {sum_swap(arr1, arr2)} to make {arr1} have same sum ar {arr2}")

chapter_16/p16_23.py

@@ -0,0 +1,25 @@
+import random
+from collections import defaultdict
+
+STATISTICAL_SIGNIF_THRESHOLD = 10**6
+
+
+def rand5() -> int:
+    return random.randint(0, 4)
+
+
+def rand7() -> int:
+    res = rand5()*5 + rand5()  # Get res in range 0-24
+    while res >= 21:  # Reroll until in 7-divisible range
+        res = rand5()*5 + rand5()
+
+    return res % 7
+
+
+if __name__ == "__main__":
+    results = defaultdict(lambda: 0)
+    for _ in range(STATISTICAL_SIGNIF_THRESHOLD):
+        results[rand7()] += 1
+
+    for x in sorted(results.keys()):
+        print(f"Value {x} found times: {results[x]}")

chapter_17/p17_19.py

@@ -0,0 +1,49 @@
+
+from typing import List
+import math
+import copy
+import random
+
+TRIALS = 10
+
+
+def find_two_missing(arr: List[int], N: int) -> List[int]:
+    # print(f"Array of len {len(arr)} is {arr}")
+    all_sum = sum(range(1, N+1))
+    all_quad_sum = sum(i**2 for i in range(1, N+1))
+
+    real_sum = sum(arr)
+    real_quad_sum = sum(x**2 for x in arr)
+
+    delta_s = all_sum - real_sum
+    delta_q = all_quad_sum - real_quad_sum
+
+    b = int((delta_s + math.sqrt(2*delta_q - delta_s**2)) / 2)
+    a = int((delta_s ** 2 - delta_q) / (2*b))
+
+    return [a, b]
+
+
+def get_indexes_to_remove(N: int) -> tuple:
+    a = random.randint(0, N-1)
+    b = random.randint(0, N-1)
+    while b == a:
+        b = random.randint(0, N-1)
+
+    return (a, b)
+
+
+if __name__ == "__main__":
+    N = 100
+    all_arr = list(range(1, N+1))
+
+    for i in range(TRIALS):
+        test_arr = copy.copy(all_arr)
+        i1, i2 = get_indexes_to_remove(N)
+
+        a, b = test_arr[i1], test_arr[i2]
+
+        test_arr = [test_arr[i] for i in range(len(test_arr))
+                    if i not in {i1, i2}]
+
+        print(f"Missing from arr are {find_two_missing(test_arr,N)}, expected {a}, {b}")

chapter_4/p4_10.py

@@ -0,0 +1,34 @@
+from utils.graphs import ltbt, BiNode
+
+
+def check_same_tree(root1: BiNode, root2: BiNode) -> bool:
+    if (not root1) and (not root2):
+        return True
+    elif (not root1) or (not root2):
+        return False
+    else:
+        if root1.val != root2.val:
+            return False
+        else:
+            return check_same_tree(root1.left, root2.left) \
+                and check_same_tree(root1.right, root2.right)
+
+
+def check_sub_tree(t1: BiNode, t2: BiNode) -> bool:
+    if not t1:
+        return False
+    if t1.val == t2.val:
+        return check_same_tree(t1, t2)
+    else:
+        return check_sub_tree(t1.left, t2) or check_sub_tree(t1.right, t2)
+
+
+if __name__ == "__main__":
+    tree1_list = [0, 10, 15, 20, 30, 25, 35] + [None] * 5 + [45]
+    tree2_list = [10, 20, 30]
+
+    t1 = ltbt(tree1_list)
+    t2 = ltbt(tree2_list)
+
+    print(f"Is t2 a subtree of t1 ? {check_sub_tree(t1,t2)}")
+    print(f"Is t1 a subtree of t2 ? {check_sub_tree(t2,t1)}")