updated part11

Author: kattat13

part11/07_lottery_numbers.py

@@ -0,0 +1,11 @@
+
+class LotteryNumbers:
+    def __init__(self, week_number: int, seven_numbers: list):
+        self.week_number = week_number
+        self.seven_numbers = seven_numbers
+
+    def number_of_hits(self, numbers: list):
+        return sum([1 for n in numbers if n in self.seven_numbers])
+    
+    def hits_in_place(self, numbers: list):
+        return [i if i in self.seven_numbers else -1 for i in numbers]

part11/08_filter_forbidden.py

@@ -0,0 +1,3 @@
+
+def filter_forbidden(string: str, forbidden: str):
+    return ''.join([c for c in string if c not in forbidden])

part11/09_products_in_shopping_list.py

@@ -0,0 +1,38 @@
+
+class ShoppingList:
+    def __init__(self):
+        self.products = []
+
+    def number_of_items(self):
+        return len(self.products)
+
+    def add(self, product: str, number: int):
+        self.products.append((product, number))
+
+    def __iter__(self):
+        self.n = 0
+        return self
+
+    def __next__(self):
+        if self.n < len(self.products):
+            product = self.products[self.n]
+            self.n += 1
+            return product
+        else:
+            raise StopIteration
+        
+
+def products_in_shopping_list(shopping_list: ShoppingList, amount: int):
+    return [name[0] for name in shopping_list if name[1] >= amount]
+
+
+if __name__ == '__main__':
+    my_list = ShoppingList()
+    my_list.add("bananas", 10)
+    my_list.add("apples", 5)
+    my_list.add("alcohol free beer", 24)
+    my_list.add("pineapple", 1)
+
+    print("the shopping list contains at least 8 of the following items:")
+    for product in products_in_shopping_list(my_list, 8):
+        print(product)

part11/10_cheaper_properties.py

@@ -0,0 +1,42 @@
+
+class RealProperty:
+    def __init__(self, rooms: int , square_meters: int, price_per_sqm: int, description: str):
+        self.rooms = rooms
+        self.square_meters = square_meters
+        self.price_per_sqm = price_per_sqm
+        self.description = description
+
+    def bigger(self, compared_to):
+        return self.square_meters > compared_to.square_meters
+
+    def price_difference(self, compared_to):
+        # Function abs returns absolute value
+        difference = abs((self.price_per_sqm * self.square_meters) - (compared_to.price_per_sqm * compared_to.square_meters))
+        return difference
+
+    def more_expensive(self, compared_to):
+        difference = (self.price_per_sqm * self.square_meters) - (compared_to.price_per_sqm * compared_to.square_meters)
+        return difference > 0
+
+    def __repr__(self):
+        return (f'RealProperty(rooms = {self.rooms}, square_meters = {self.square_meters}, ' + 
+            f'price_per_sqm = {self.price_per_sqm}, description = {self.description})')
+
+
+def cheaper_properties(properties: list, reference: RealProperty):
+    return [(property, property.price_difference(reference)) for property in properties if not property.more_expensive(reference) and property.price_difference(reference) != 0]
+
+
+if __name__ == '__main__':
+    a1 = RealProperty(1, 16, 5500, "Central studio")
+    a2 = RealProperty(2, 38, 4200, "Two bedrooms downtown")
+    a3 = RealProperty(3, 78, 2500, "Three bedrooms in the suburbs")
+    a4 = RealProperty(6, 215, 500, "Farm in the middle of nowhere")
+    a5 = RealProperty(4, 105, 1700, "Loft in a small town")
+    a6 = RealProperty(25, 1200, 2500, "Countryside mansion")
+
+    properties = [a1, a2, a3, a4, a5, a6]
+
+    print(f"cheaper options when compared to {a3.description}:")
+    for item in cheaper_properties(properties, a3):
+        print(f"{item[0].description:35} price difference {item[1]} euros")

part11/11_lengths_of_strings.py

@@ -0,0 +1,2 @@
+def lengths(strings: list):
+    return {string : len(string) for string in strings}

part11/12_most_common_words.py

@@ -0,0 +1,13 @@
+import string 
+
+
+def most_common_words(filename: str, lower_limit: int):
+    data = open(filename).read().replace('\n', ' ').replace('.', '').replace(',', ' ').replace('  ', ' ')
+
+    words = data.split(' ')
+
+    return {word : words.count(word) for word in words if words.count(word) >= lower_limit}
+
+
+if __name__ == '__main__':
+    print(most_common_words('programming.txt', 4))

part11/13_add_numbers_to_list.py

@@ -0,0 +1,13 @@
+
+def add_numbers_to_list(numbers: list):
+    while len(numbers) % 5 != 0:
+        numbers.append(numbers[-1] + 1)
+        add_numbers_to_list(numbers)
+
+
+if __name__ == '__main__':
+    numbers = [1, 2]
+    add_numbers_to_list(numbers)
+    print(numbers)
+
+

part11/14_recursive_sum.py

@@ -0,0 +1,6 @@
+
+def recursive_sum(number: int):
+    # if the number is 1, there is nothing else to add
+    if number <= 1:
+        return number
+    return number + recursive_sum(number - 1)

part11/15_balanced_brackets.py

@@ -0,0 +1,38 @@
+
+def balanced_brackets(my_string: str):
+    new_str = ''
+    for char in my_string:
+        if char in '[]()':
+            new_str += char
+    if len(new_str) == 1:
+        return False
+    elif len(new_str) == 0:
+        return True
+    if new_str[0] == '(':
+        if not new_str[-1] == ')':
+            return False
+    elif new_str[0] == '[':
+        if not new_str[-1] == ']':
+            return False
+
+    # remove first and last character
+    return balanced_brackets(new_str[1:-1])
+
+
+if __name__ == '__main__':
+    ok = balanced_brackets("([([])])")
+    print(ok)
+
+    ok = balanced_brackets("(python version [3.7]) please use this one!")
+    print(ok)
+
+    # this is no good, the closing bracket doesn't match
+    ok = balanced_brackets("(()]")
+    print(ok)
+
+    # different types of brackets are mismatched
+    ok = balanced_brackets("([bad egg)]")
+    print(ok)
+
+    ok = balanced_brackets("(x)y)")
+    print(ok)

part11/16_greatest_node.py

@@ -0,0 +1,43 @@
+
+class Node:
+    """ Class is modeling single node in binary tree """
+    def __init__(self, value, left_child: 'Node' = None, right_child: 'Node' = None):
+        self.value = value
+        self.left_child = left_child
+        self.right_child = right_child
+
+
+def greatest_node(root: Node):
+    # Initialize the greatest value with the value of the current node
+    greatest = root.value
+ 
+    # Base case: If the node has no children, return its value
+    if root.left_child is None and root.right_child is None:
+        return root.value
+
+    # If the node has a left child, find the greatest value in the left subtree
+    if root.left_child is not None:
+        left_max = greatest_node(root.left_child)
+        # Update the greatest value if a greater value is found in the left subtree
+        greatest = max(greatest, left_max)
+        
+    # If the node has a right child, find the greatest value in the right subtree
+    if root.right_child is not None:
+        right_max = greatest_node(root.right_child)
+        # Update the greatest value if a greater value is found in the right subtree
+        greatest = max(greatest, right_max)
+    
+    return greatest
+
+
+if __name__ == "__main__":
+    tree = Node(2)
+
+    tree.left_child = Node(3)
+    tree.left_child.left_child = Node(5)
+    tree.left_child.right_child = Node(8)
+
+    tree.right_child = Node(4)
+    tree.right_child.right_child = Node(11)
+
+    print(greatest_node(tree))

part11/17_bosses_and_subordinates.py

@@ -0,0 +1,35 @@
+
+class Employee:
+    def __init__(self, name: str):
+        self.name = name
+        self.subordinates = []
+
+    def add_subordinate(self, employee: 'Employee'):
+        self.subordinates.append(employee)
+
+
+def count_subordinates(employee: Employee):
+    value = len(employee.subordinates)
+
+    if employee.subordinates != []:
+        for sub in employee.subordinates:
+            value += count_subordinates(sub)
+
+    return value
+    
+
+if __name__ == '__main__':
+    t1 = Employee("Sally")
+    t2 = Employee("Eric")
+    t3 = Employee("Matthew")
+    t4 = Employee("Emily")
+    t5 = Employee("Adele")
+    t6 = Employee("Claire")
+    t1.add_subordinate(t4)
+    t1.add_subordinate(t6)
+    t4.add_subordinate(t2)
+    t4.add_subordinate(t3)
+    t4.add_subordinate(t5)
+    print(count_subordinates(t1))
+    print(count_subordinates(t4))
+    print(count_subordinates(t5))