update

Week03/pyramid_vladyslav_senkiv.py

@@ -0,0 +1,10 @@
+def calculate_pyramid_height(number_of_blocks):
+    height = 0
+    needed_blocks = 1
+
+    while number_of_blocks >= needed_blocks:
+        number_of_blocks -= needed_blocks
+        height += 1
+        needed_blocks += 1
+
+    return height

Week03/sequences_vladyslav_senkiv.py

@@ -0,0 +1,29 @@
+def remove_duplicates(seq: list) -> list:
+    result = []
+
+    for item in seq:
+        if item not in result:
+            result.append(item)
+
+    return result
+
+
+def list_counts(seq: list) -> dict:
+    result = {}
+
+    for item in seq:
+        if item in result:
+            result[item] += 1
+        else:
+            result[item] = 1
+
+    return result
+
+
+def reverse_dict(d: dict) -> dict:
+    result = {}
+
+    for key, value in d.items():
+        result[value] = key
+
+    return result

Week04/decorators_vladyslav.senkiv.py

@@ -0,0 +1,30 @@
+import time
+import sys
+from functools import wraps
+
+
+def performance(func):
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.perf_counter()
+
+        result = func(*args, **kwargs)
+
+        end_time = time.perf_counter()
+
+        performance.counter += 1
+        performance.total_time += end_time - start_time
+        performance.total_mem += sys.getsizeof(result)
+
+        if isinstance(result, list):
+            for item in result:
+                performance.total_mem += sys.getsizeof(item)
+
+        return result
+
+    return wrapper
+
+
+performance.counter = 0
+performance.total_time = 0
+performance.total_mem = 0

Week04/functions_vladyslav_senkiv.py

@@ -0,0 +1,42 @@
+custom_power = lambda x=0, /, e=1: x ** e
+
+
+def custom_equation(
+    x: int = 0,
+    y: int = 0,
+    /,
+    a: int = 1,
+    b: int = 1,
+    *,
+    c: int = 1
+) -> float:
+    """
+    Calculates the equation (a*x + b*y) / c.
+
+    :param x: first integer value
+    :param y: second integer value
+    :param a: multiplier for x
+    :param b: multiplier for y
+    :param c: divisor value
+    :return: result of the equation
+    """
+
+    values = [x, y, a, b, c]
+
+    for value in values:
+        if not isinstance(value, int):
+            raise TypeError("All parameters must be integers")
+
+    return (a * x + b * y) / c
+
+
+counter = 0
+
+
+def fn_w_counter() -> (int, dict[str, int]):
+    global counter
+
+    counter += 1
+    module_name = __name__
+
+    return counter, {module_name: counter}

Week05/awaitme_vladyslav_senkiv.py

@@ -0,0 +1,9 @@
+from functools import wraps
+
+
+def awaitme(func):
+    @wraps(func)
+    async def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    return wrapper

Week06/timer_vladyslav_senkiv.py

@@ -0,0 +1,15 @@
+from time import perf_counter
+
+
+class Timer:
+    def __init__(self):
+        self.start_time = None
+        self.end_time = None
+
+    def __enter__(self):
+        self.start_time = perf_counter()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        self.end_time = perf_counter()
+        return False

Week07/threaded_vladyslav_senkiv.py

@@ -0,0 +1,25 @@
+import threading
+from functools import wraps
+
+
+def threaded(number_of_threads):
+    def decorator(func):
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            threads = []
+
+            for _ in range(number_of_threads):
+                thread = threading.Thread(
+                    target=func,
+                    args=args,
+                    kwargs=kwargs
+                )
+                threads.append(thread)
+                thread.start()
+
+            for thread in threads:
+                thread.join()
+
+        return wrapper
+
+    return decorator

Week08/estimate_pi_w_threads_vladyslav_senkiv.py

@@ -0,0 +1,47 @@
+import random
+import threading
+import math
+
+
+class PiWorker(threading.Thread):
+    def __init__(self, points_count):
+        super().__init__()
+        self.points_count = points_count
+        self.inside_circle = 0
+
+    def run(self):
+        for _ in range(self.points_count):
+            x = random.random()
+            y = random.random()
+
+            if x * x + y * y <= 1:
+                self.inside_circle += 1
+
+
+def estimate_pi(total_points=1000000, thread_count=4):
+    points_per_thread = total_points // thread_count
+    threads = []
+
+    for _ in range(thread_count):
+        thread = PiWorker(points_per_thread)
+        threads.append(thread)
+        thread.start()
+
+    inside_circle = 0
+
+    for thread in threads:
+        thread.join()
+        inside_circle += thread.inside_circle
+
+    used_points = points_per_thread * thread_count
+    pi_value = 4 * inside_circle / used_points
+
+    return pi_value
+
+
+if __name__ == "__main__":
+    pi = estimate_pi(total_points=1000000, thread_count=4)
+
+    print("Estimated PI:", pi)
+    print("Real PI:", math.pi)
+    print("Difference:", abs(math.pi - pi))

Week09/dining_philosophers_vladyslav_senkiv.py

@@ -0,0 +1,72 @@
+import threading
+import time
+import random
+
+
+class Fork:
+    def __init__(self, number):
+        self.number = number
+        self.lock = threading.Lock()
+
+
+class Philosopher(threading.Thread):
+    def __init__(self, number, left_fork, right_fork, meals_count=3):
+        super().__init__()
+        self.number = number
+        self.left_fork = left_fork
+        self.right_fork = right_fork
+        self.meals_count = meals_count
+
+    def think(self):
+        print(f"Philosopher {self.number} is thinking")
+        time.sleep(random.uniform(0.5, 1.5))
+
+    def eat(self):
+        print(f"Philosopher {self.number} is eating")
+        time.sleep(random.uniform(0.5, 1.5))
+
+    def run(self):
+        for _ in range(self.meals_count):
+            self.think()
+
+            if self.number % 2 == 0:
+                first_fork = self.left_fork
+                second_fork = self.right_fork
+            else:
+                first_fork = self.right_fork
+                second_fork = self.left_fork
+
+            with first_fork.lock:
+                print(f"Philosopher {self.number} took fork {first_fork.number}")
+
+                with second_fork.lock:
+                    print(f"Philosopher {self.number} took fork {second_fork.number}")
+                    self.eat()
+
+                print(f"Philosopher {self.number} released fork {second_fork.number}")
+
+            print(f"Philosopher {self.number} released fork {first_fork.number}")
+
+
+if __name__ == "__main__":
+    philosophers_count = 5
+    forks = [Fork(i) for i in range(philosophers_count)]
+
+    philosophers = []
+
+    for i in range(philosophers_count):
+        philosopher = Philosopher(
+            number=i,
+            left_fork=forks[i],
+            right_fork=forks[(i + 1) % philosophers_count],
+            meals_count=3
+        )
+        philosophers.append(philosopher)
+
+    for philosopher in philosophers:
+        philosopher.start()
+
+    for philosopher in philosophers:
+        philosopher.join()
+
+    print("Dinner is finished")

dining_philosophers_vladyslav_senkiv.py

@@ -0,0 +1,72 @@
+import threading
+import time
+import random
+
+
+class Fork:
+    def __init__(self, number):
+        self.number = number
+        self.lock = threading.Lock()
+
+
+class Philosopher(threading.Thread):
+    def __init__(self, number, left_fork, right_fork, meals_count=3):
+        super().__init__()
+        self.number = number
+        self.left_fork = left_fork
+        self.right_fork = right_fork
+        self.meals_count = meals_count
+
+    def think(self):
+        print(f"Philosopher {self.number} is thinking")
+        time.sleep(random.uniform(0.5, 1.5))
+
+    def eat(self):
+        print(f"Philosopher {self.number} is eating")
+        time.sleep(random.uniform(0.5, 1.5))
+
+    def run(self):
+        for _ in range(self.meals_count):
+            self.think()
+
+            if self.number % 2 == 0:
+                first_fork = self.left_fork
+                second_fork = self.right_fork
+            else:
+                first_fork = self.right_fork
+                second_fork = self.left_fork
+
+            with first_fork.lock:
+                print(f"Philosopher {self.number} took fork {first_fork.number}")
+
+                with second_fork.lock:
+                    print(f"Philosopher {self.number} took fork {second_fork.number}")
+                    self.eat()
+
+                print(f"Philosopher {self.number} released fork {second_fork.number}")
+
+            print(f"Philosopher {self.number} released fork {first_fork.number}")
+
+
+if __name__ == "__main__":
+    philosophers_count = 5
+    forks = [Fork(i) for i in range(philosophers_count)]
+
+    philosophers = []
+
+    for i in range(philosophers_count):
+        philosopher = Philosopher(
+            number=i,
+            left_fork=forks[i],
+            right_fork=forks[(i + 1) % philosophers_count],
+            meals_count=3
+        )
+        philosophers.append(philosopher)
+
+    for philosopher in philosophers:
+        philosopher.start()
+
+    for philosopher in philosophers:
+        philosopher.join()
+
+    print("Dinner is finished")