Add files via upload

Author: ApressGryffinWinkler

Broadway_Tower.jpg

@@ -0,0 +1,4 @@
+def factorial(n):
+    if n == 1 or n == 0:
+        return 1 
+    return factorial(n - 1) * n 

Listing_1_1_factorial.py

@@ -0,0 +1,21 @@
+def sum_n_integers(n):
+    """Given input n, sum all nonnegative integers up to n
+    """
+    if n == 0 or n == 1:
+        return n 
+    return sum_n_integers(n - 1) + n 
+
+def sum_arr_v1(nums):
+    if len(nums) == 1:
+        return nums[0]
+    return nums[0] + sum_arr_v1(nums[1:])
+
+def sum_arr_v2(nums):
+    if len(nums) == 1:
+        return nums[-1]
+    return nums[-1] + sum_arr_v2(nums[:-1])
+
+if __name__ == "__main__":
+    assert sum_n_integers(5) == 15
+    assert sum_arr_v1([1,2,3,4,5]) == 15
+    assert sum_arr_v2([1,2,3,4,5]) == 15

Listing_1_2_simple_recursion_examples.py

@@ -0,0 +1,7 @@
+def count_unique_paths(m, n):
+    if m == 1 or n == 1:
+        return 1
+    return count_unique_paths(m-1, n) + count_unique_paths(m, n-1)
+
+if __name__ == "__main__":
+    print (count_unique_paths(7,4))

Listing_1_3_number_unique_paths.py

@@ -0,0 +1,39 @@
+import math
+import matplotlib.pyplot as plt
+plt.figure()
+def draw_line(x1, y1, x2, y2):
+    plt.plot([x1, x2], [y1, y2], color = 'r', lw = 2)
+
+def draw_h_tree(x0, y0, length, level, factor):
+    if level == 0:
+        return
+
+    coord_c_x = x0 - length / 2.
+    coord_c_y = y0
+    coord_d_x = x0 + length / 2.
+    coord_d_y = y0
+
+    coord_a_x = x0 - length / 2.
+    coord_a_y = y0 + length / 2.
+    coord_e_x = x0 - length / 2.
+    coord_e_y = y0 - length / 2.
+    coord_b_x = x0 + length / 2.
+    coord_b_y = y0 + length / 2.
+    coord_f_x = x0 + length / 2.
+    coord_f_y = y0 - length / 2.
+    
+    draw_line(coord_c_x, coord_c_y, coord_d_x, coord_d_y)
+    draw_line(coord_a_x, coord_a_y, coord_e_x, coord_e_y)
+    draw_line(coord_b_x, coord_b_y, coord_f_x, coord_f_y)
+
+    length /= math.sqrt(factor)
+    level -= 1
+    draw_h_tree(coord_a_x, coord_a_y, length, level, factor)
+    draw_h_tree(coord_b_x, coord_b_y, length, level, factor)
+    draw_h_tree(coord_e_x, coord_e_y, length, level, factor)
+    draw_h_tree(coord_f_x, coord_f_y, length, level, factor)
+
+if __name__ == "__main__":
+   draw_h_tree(0, 0, 2, 5, 4)
+   plt.tight_layout()
+   plt.show()

Listing_1_4_h_tree_generation.py

@@ -0,0 +1,10 @@
+def tower_of_hanoi(num_disks, from_pole, with_pole, to_pole):
+    if num_disks == 1:
+        print (f"Move disk 1 from {from_pole} to {to_pole}")
+    else:
+        tower_of_hanoi(num_disks - 1,from_pole, to_pole, with_pole)
+        print (f"Move disk {num_disks} from {from_pole} to {to_pole}")
+        tower_of_hanoi(num_disks - 1, with_pole, from_pole, to_pole)
+
+if __name__ == "__main__":
+    tower_of_hanoi(4, "A", "B", "C")

Listing_1_5_tower_of_hanoi.py

@@ -0,0 +1,25 @@
+class TreeNode:
+    def __init__(self, value):
+        self.value = value
+        self.left = None 
+        self.right = None 
+
+def pre_order_traversal(root):
+    sequence = []
+    def preorder_helper(node):
+        if node: 
+            sequence.append(node.value)
+            preorder_helper(node.left)
+            preorder_helper(node.right)
+    preorder_helper(root)
+    return sequence
+
+if __name__ == "__main__":
+    root = TreeNode(1)
+    root.left = TreeNode(2)
+    root.right = TreeNode(3)
+    root.left.left = TreeNode(4)
+    root.left.right = TreeNode(5)
+    root.right.left = TreeNode(6)
+    root.right.right = TreeNode(7)
+    print("Preorder traversal of the tree:", pre_order_traversal(root))

Listing_1_6_application_preorder.py

@@ -0,0 +1,36 @@
+class TreeNode:
+    def __init__(self, value):
+        self.value = value
+        self.left = None 
+        self.right = None 
+
+def in_order_traversal(root):
+    sequence = []
+    def inorder_helper(node):
+        if node: 
+            inorder_helper(node.left)
+            sequence.append(node.value)
+            inorder_helper(node.right)
+    inorder_helper(root)
+    return sequence
+
+def post_order_traversal(root):
+    sequence = []
+    def postorder_helper(node):
+        if node: 
+            postorder_helper(node.left)
+            postorder_helper(node.right)
+            sequence.append(node.value)
+    postorder_helper(root)
+    return sequence
+
+if __name__ == "__main__":
+    root = TreeNode(1)
+    root.left = TreeNode(2)
+    root.right = TreeNode(3)
+    root.left.left = TreeNode(4)
+    root.left.right = TreeNode(5)
+    root.right.left = TreeNode(6)
+    root.right.right = TreeNode(7)
+    print("Inorder traversal of the tree:", in_order_traversal(root))
+    print("Postorder traversal of the tree", post_order_traversal(root))

Listing_1_7_application_inorder_postorder.py

@@ -0,0 +1,24 @@
+def guess_number(lower_bound, upper_bound, num):
+    # expand the bounds by 1 to avoid getting stuck in infinite loops
+    lower_bound -= 1
+    upper_bound += 1
+    num_guesses = 1
+    guess = (lower_bound + upper_bound) // 2
+    print (f"initial guess -->{guess}" )
+    while guess != num:
+        if guess > num:
+            upper_bound = guess
+        elif guess < num:
+            lower_bound = guess
+        else:
+            print (f"Guessed it, the number is {guess}")
+        guess = (lower_bound + upper_bound) // 2
+        print (f"guess -->{guess}" )
+        num_guesses += 1
+    print (f"it takes {num_guesses} guesses to guess {num}")
+
+if __name__ == "__main__":
+    lower_bound = 1
+    upper_bound = 100
+    num = 99
+    guess_number(lower_bound, upper_bound, num)

Listing_2_1_guess_number.py

@@ -0,0 +1,45 @@
+def selection_sort(nums):
+    def find_min_index(arr):
+        min_idx = None  
+        min_val = float("inf")
+        for idx, num in enumerate(arr):
+            if num < min_val:
+                min_idx, min_val = idx, num 
+        return min_idx, min_val
+
+    i = 0
+    while i < len(nums):
+        min_idx, min_val = find_min_index(nums[i:])
+        if nums[i] > min_val:
+            nums[i], nums[min_idx + i] = nums[min_idx + i], nums[i]
+        i += 1
+    return nums 
+
+def bubble_sort(nums):
+    for i in range(len(nums)):
+        for j in range(len(nums) - 1 - i):
+            if nums[j] > nums[j+1]:
+                nums[j], nums[j+1] = nums[j+1], nums[j]
+    return nums
+
+def insertion_sort(nums):
+    for i in range(1, len(nums)):
+        j = i 
+        while j > 0:
+            if nums[j] < nums[j-1]:
+                nums[j], nums[j-1] = nums[j-1], nums[j]
+            j -= 1
+    return nums 
+
+if __name__ == "__main__":
+    unsorted_arr_1 = [5, -1, 0, 3, 2]
+    sorted_arr_1 = selection_sort(unsorted_arr_1)
+    print (sorted_arr_1)
+
+    unsorted_arr_2 = [5, -1, 0, 3, 2]
+    bubble_sort(unsorted_arr_2)
+    print (unsorted_arr_2)
+
+    unsorted_arr_3 = [5, -1, 0, 3, 2]
+    insertion_sort(unsorted_arr_3)
+    print (unsorted_arr_3)