From f0e5190195c7bc10613d4da83607ba37c5515c41 Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Sat, 28 Mar 2026 15:18:09 +0300 Subject: [PATCH 01/20] Create functions_oleksii_rak.py --- Week04/functions_oleksii_rak.py | 32 ++++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 Week04/functions_oleksii_rak.py diff --git a/Week04/functions_oleksii_rak.py b/Week04/functions_oleksii_rak.py new file mode 100644 index 00000000..87135c61 --- /dev/null +++ b/Week04/functions_oleksii_rak.py @@ -0,0 +1,32 @@ +import inspect + +# 1. custom_power +custom_power = lambda x=0, /, e=1: x ** e + +# 2. custom_equation +def custom_equation(x: int = 0, y: int = 0, /, a: int = 1, b: int = 1, *, c: int = 1) -> float: + """ + Calculates the custom equation (x**a + y**b) / c. + + :param x: The first base value (positional-only). + :param y: The second base value (positional-only). + :param a: Exponent for x (positional or keyword). + :param b: Exponent for y (positional or keyword). + :param c: Divisor (keyword-only). + :return: The result of the equation as a float. + :rtype: float + """ + return float((x ** a + y ** b) / c) + +# 3. fn_w_counter +def fn_w_counter() -> tuple[int, dict[str, int]]: + if not hasattr(fn_w_counter, "total_calls"): + fn_w_counter.total_calls = 0 + fn_w_counter.callers = {} + + caller_frame = inspect.stack()[1] + caller_name = caller_frame.frame.f_globals.get('__name__', 'unknown') + fn_w_counter.total_calls += 1 + fn_w_counter.callers[caller_name] = fn_w_counter.callers.get(caller_name, 0) + 1 + + return fn_w_counter.total_calls, fn_w_counter.callers From 62a158fb3ca92627ab9f1460da34578eca3be895 Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Sat, 28 Mar 2026 15:20:01 +0300 Subject: [PATCH 02/20] Create decorators_oleksii_rak.py --- Week04/Week04/decorators_oleksii_rak.py | 28 +++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Week04/Week04/decorators_oleksii_rak.py diff --git a/Week04/Week04/decorators_oleksii_rak.py b/Week04/Week04/decorators_oleksii_rak.py new file mode 100644 index 00000000..d932c973 --- /dev/null +++ b/Week04/Week04/decorators_oleksii_rak.py @@ -0,0 +1,28 @@ +import time +import tracemalloc +from functools import wraps + +def performance(func): + @wraps(func) + def wrapper(*args, **kwargs): + wrapper.counter += 1 + + tracemalloc.start() + start_time = time.perf_counter() + + result = func(*args, **kwargs) + + end_time = time.perf_counter() + _, peak_mem = tracemalloc.get_traced_memory() + tracemalloc.stop() + + wrapper.total_time += (end_time - start_time) + wrapper.total_mem += peak_mem + + return result + + wrapper.counter = 0 + wrapper.total_time = 0.0 + wrapper.total_mem = 0 + + return wrapper From 3b3b8f864729ae06e1c019f114650e21243861ea Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Sun, 5 Apr 2026 15:55:28 +0300 Subject: [PATCH 03/20] Create awaitme_oleksii_rak.py --- awaitme_oleksii_rak.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 awaitme_oleksii_rak.py diff --git a/awaitme_oleksii_rak.py b/awaitme_oleksii_rak.py new file mode 100644 index 00000000..2c939ea9 --- /dev/null +++ b/awaitme_oleksii_rak.py @@ -0,0 +1,13 @@ +import inspect +from functools import wraps + +def awaitme(func): + + @wraps(func) + async def wrapper(*args, **kwargs): + result = func(*args, **kwargs) + if inspect.isawaitable(result): + return await result + return result + + return wrapper From e84a223e2583846839d7c13119298d5e80e74d13 Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Sun, 5 Apr 2026 16:05:11 +0300 Subject: [PATCH 04/20] Create timer_oleksii_rak.py --- Week06/timer_oleksii_rak.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) create mode 100644 Week06/timer_oleksii_rak.py diff --git a/Week06/timer_oleksii_rak.py b/Week06/timer_oleksii_rak.py new file mode 100644 index 00000000..7bfa47e6 --- /dev/null +++ b/Week06/timer_oleksii_rak.py @@ -0,0 +1,13 @@ +from time import perf_counter + +class Timer: + def __init__(self): + self.start_time = 0.0 + self.end_time = 0.0 + + def __enter__(self): + self.start_time = perf_counter() + return self + + def __exit__(self, *args): + self.end_time = perf_counter() From a97ebc043d53c53559078860c8ef57db96b283b1 Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Tue, 5 May 2026 10:50:59 +0300 Subject: [PATCH 05/20] Delete Week04/functions_oleksii_rak.py --- Week04/functions_oleksii_rak.py | 32 -------------------------------- 1 file changed, 32 deletions(-) delete mode 100644 Week04/functions_oleksii_rak.py diff --git a/Week04/functions_oleksii_rak.py b/Week04/functions_oleksii_rak.py deleted file mode 100644 index 87135c61..00000000 --- a/Week04/functions_oleksii_rak.py +++ /dev/null @@ -1,32 +0,0 @@ -import inspect - -# 1. custom_power -custom_power = lambda x=0, /, e=1: x ** e - -# 2. custom_equation -def custom_equation(x: int = 0, y: int = 0, /, a: int = 1, b: int = 1, *, c: int = 1) -> float: - """ - Calculates the custom equation (x**a + y**b) / c. - - :param x: The first base value (positional-only). - :param y: The second base value (positional-only). - :param a: Exponent for x (positional or keyword). - :param b: Exponent for y (positional or keyword). - :param c: Divisor (keyword-only). - :return: The result of the equation as a float. - :rtype: float - """ - return float((x ** a + y ** b) / c) - -# 3. fn_w_counter -def fn_w_counter() -> tuple[int, dict[str, int]]: - if not hasattr(fn_w_counter, "total_calls"): - fn_w_counter.total_calls = 0 - fn_w_counter.callers = {} - - caller_frame = inspect.stack()[1] - caller_name = caller_frame.frame.f_globals.get('__name__', 'unknown') - fn_w_counter.total_calls += 1 - fn_w_counter.callers[caller_name] = fn_w_counter.callers.get(caller_name, 0) + 1 - - return fn_w_counter.total_calls, fn_w_counter.callers From 6bc19bb92688ea6b96d036159baf758497f0076f Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 15:21:30 +0300 Subject: [PATCH 06/20] Add threaded decorator for concurrent function execution --- Week07/threaded_oleksii_rak.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) create mode 100644 Week07/threaded_oleksii_rak.py diff --git a/Week07/threaded_oleksii_rak.py b/Week07/threaded_oleksii_rak.py new file mode 100644 index 00000000..c50c23ae --- /dev/null +++ b/Week07/threaded_oleksii_rak.py @@ -0,0 +1,21 @@ +import threading +from functools import wraps + +def threaded(n: int): + def decorator(func): + @wraps(func) + def wrapper(*args, **kwargs): + threads = [] + + for _ in range(n): + t = threading.Thread(target=func, args=args, kwargs=kwargs) + threads.append(t) + + for t in threads: + t.start() + + for t in threads: + t.join() + + return wrapper + return decorator From cd0f27b0759321996c07485e78b9291584534c62 Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 15:41:07 +0300 Subject: [PATCH 07/20] Add awaitme decorator for async function handling --- Week05/awaitme_oleksii_rak.py | 11 +++++++++++ 1 file changed, 11 insertions(+) create mode 100644 Week05/awaitme_oleksii_rak.py diff --git a/Week05/awaitme_oleksii_rak.py b/Week05/awaitme_oleksii_rak.py new file mode 100644 index 00000000..c6cfcc9a --- /dev/null +++ b/Week05/awaitme_oleksii_rak.py @@ -0,0 +1,11 @@ +import inspect +from functools import wraps + +def awaitme(func): + @wraps(func) + async def wrapper(*args, **kwargs): + if inspect.iscoroutinefunction(func): + return await func(*args, **kwargs) + return func(*args, **kwargs) + + return wrapper From e574893447c565fa4da3c6721c494a7bf94391ee Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 15:42:24 +0300 Subject: [PATCH 08/20] Delete Week04/Week04/decorators_oleksii_rak.py --- Week04/Week04/decorators_oleksii_rak.py | 28 ------------------------- 1 file changed, 28 deletions(-) delete mode 100644 Week04/Week04/decorators_oleksii_rak.py diff --git a/Week04/Week04/decorators_oleksii_rak.py b/Week04/Week04/decorators_oleksii_rak.py deleted file mode 100644 index d932c973..00000000 --- a/Week04/Week04/decorators_oleksii_rak.py +++ /dev/null @@ -1,28 +0,0 @@ -import time -import tracemalloc -from functools import wraps - -def performance(func): - @wraps(func) - def wrapper(*args, **kwargs): - wrapper.counter += 1 - - tracemalloc.start() - start_time = time.perf_counter() - - result = func(*args, **kwargs) - - end_time = time.perf_counter() - _, peak_mem = tracemalloc.get_traced_memory() - tracemalloc.stop() - - wrapper.total_time += (end_time - start_time) - wrapper.total_mem += peak_mem - - return result - - wrapper.counter = 0 - wrapper.total_time = 0.0 - wrapper.total_mem = 0 - - return wrapper From cfeed251b58678a82a3841f4fc0d2b5013f508db Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 15:42:46 +0300 Subject: [PATCH 09/20] Add performance decorator with memory and time tracking Implement a performance decorator to measure execution time and memory usage. --- Week04/decorators_oleksii_rak.py | 28 ++++++++++++++++++++++++++++ 1 file changed, 28 insertions(+) create mode 100644 Week04/decorators_oleksii_rak.py diff --git a/Week04/decorators_oleksii_rak.py b/Week04/decorators_oleksii_rak.py new file mode 100644 index 00000000..d932c973 --- /dev/null +++ b/Week04/decorators_oleksii_rak.py @@ -0,0 +1,28 @@ +import time +import tracemalloc +from functools import wraps + +def performance(func): + @wraps(func) + def wrapper(*args, **kwargs): + wrapper.counter += 1 + + tracemalloc.start() + start_time = time.perf_counter() + + result = func(*args, **kwargs) + + end_time = time.perf_counter() + _, peak_mem = tracemalloc.get_traced_memory() + tracemalloc.stop() + + wrapper.total_time += (end_time - start_time) + wrapper.total_mem += peak_mem + + return result + + wrapper.counter = 0 + wrapper.total_time = 0.0 + wrapper.total_mem = 0 + + return wrapper From aa1094b829b89dfe3098b672a21dcbe500269320 Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 16:00:06 +0300 Subject: [PATCH 10/20] Add custom equation and function call counter Added custom_power lambda and custom_equation function to calculate a specific mathematical equation. Implemented fn_w_counter to track function call counts and callers. --- Week04/functions_oleksii_rak.py | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 Week04/functions_oleksii_rak.py diff --git a/Week04/functions_oleksii_rak.py b/Week04/functions_oleksii_rak.py new file mode 100644 index 00000000..51ea2dba --- /dev/null +++ b/Week04/functions_oleksii_rak.py @@ -0,0 +1,30 @@ +import inspect + +custom_power = lambda x=0, /, e=1: float(x ** e) + +def custom_equation(x: int = 0, y: int = 0, /, a: int = 1, b: int = 1, *, c: int = 1) -> float: + """ + Calculates a custom equation: (x**a + y**b) / c. + + :param x: The first base (positional-only). + :param y: The second base (positional-only). + :param a: The first exponent (positional-or-keyword). + :param b: The second exponent (positional-or-keyword). + :param c: The divisor (keyword-only). + :return: The result of the equation as a float. + """ + return float((x ** a + y ** b) / c) + +def fn_w_counter() -> tuple[int, dict]: + if not hasattr(fn_w_counter, 'total_calls'): + fn_w_counter.total_calls = 0 + fn_w_counter.callers_dict = {} + + fn_w_counter.total_calls += 1 + + frame = inspect.currentframe().f_back + caller_name = frame.f_globals.get('__name__', 'unknown') + + fn_w_counter.callers_dict[caller_name] = fn_w_counter.callers_dict.get(caller_name, 0) + 1 + + return fn_w_counter.total_calls, fn_w_counter.callers_dict From 99dd701813cc03918b7a8af425c24b026069948c Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 16:06:09 +0300 Subject: [PATCH 11/20] Update return type annotation for fn_w_counter --- Week04/functions_oleksii_rak.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Week04/functions_oleksii_rak.py b/Week04/functions_oleksii_rak.py index 51ea2dba..ec3fde29 100644 --- a/Week04/functions_oleksii_rak.py +++ b/Week04/functions_oleksii_rak.py @@ -15,7 +15,7 @@ def custom_equation(x: int = 0, y: int = 0, /, a: int = 1, b: int = 1, *, c: int """ return float((x ** a + y ** b) / c) -def fn_w_counter() -> tuple[int, dict]: +def fn_w_counter() -> (int, dict[str, int]): if not hasattr(fn_w_counter, 'total_calls'): fn_w_counter.total_calls = 0 fn_w_counter.callers_dict = {} From e6c91d28b675dfd5ef965ce6b3eed7f9f5040bf9 Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 16:09:55 +0300 Subject: [PATCH 12/20] Remove unused inspect import and simplify code --- Week04/functions_oleksii_rak.py | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/Week04/functions_oleksii_rak.py b/Week04/functions_oleksii_rak.py index ec3fde29..a9767452 100644 --- a/Week04/functions_oleksii_rak.py +++ b/Week04/functions_oleksii_rak.py @@ -1,5 +1,3 @@ -import inspect - custom_power = lambda x=0, /, e=1: float(x ** e) def custom_equation(x: int = 0, y: int = 0, /, a: int = 1, b: int = 1, *, c: int = 1) -> float: @@ -22,9 +20,6 @@ def fn_w_counter() -> (int, dict[str, int]): fn_w_counter.total_calls += 1 - frame = inspect.currentframe().f_back - caller_name = frame.f_globals.get('__name__', 'unknown') - - fn_w_counter.callers_dict[caller_name] = fn_w_counter.callers_dict.get(caller_name, 0) + 1 + fn_w_counter.callers_dict[__name__] = fn_w_counter.callers_dict.get(__name__, 0) + 1 return fn_w_counter.total_calls, fn_w_counter.callers_dict From 6f1b8565405c70f219ee4abb95d123571f916c4a Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 16:13:24 +0300 Subject: [PATCH 13/20] Refactor performance decorator to track metrics correctly --- Week04/decorators_oleksii_rak.py | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/Week04/decorators_oleksii_rak.py b/Week04/decorators_oleksii_rak.py index d932c973..0c9bf7a0 100644 --- a/Week04/decorators_oleksii_rak.py +++ b/Week04/decorators_oleksii_rak.py @@ -5,7 +5,8 @@ def performance(func): @wraps(func) def wrapper(*args, **kwargs): - wrapper.counter += 1 + + performance.counter += 1 tracemalloc.start() start_time = time.perf_counter() @@ -16,13 +17,14 @@ def wrapper(*args, **kwargs): _, peak_mem = tracemalloc.get_traced_memory() tracemalloc.stop() - wrapper.total_time += (end_time - start_time) - wrapper.total_mem += peak_mem + performance.total_time += (end_time - start_time) + performance.total_mem += peak_mem return result - wrapper.counter = 0 - wrapper.total_time = 0.0 - wrapper.total_mem = 0 - return wrapper + + +performance.counter = 0 +performance.total_time = 0.0 +performance.total_mem = 0 From 821f6a4688524e1e2046542f37f9b610f88efd45 Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 16:18:53 +0300 Subject: [PATCH 14/20] Fix formatting and remove unnecessary whitespace --- Week04/decorators_oleksii_rak.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/Week04/decorators_oleksii_rak.py b/Week04/decorators_oleksii_rak.py index 0c9bf7a0..32e8d7a4 100644 --- a/Week04/decorators_oleksii_rak.py +++ b/Week04/decorators_oleksii_rak.py @@ -5,7 +5,6 @@ def performance(func): @wraps(func) def wrapper(*args, **kwargs): - performance.counter += 1 tracemalloc.start() @@ -24,7 +23,6 @@ def wrapper(*args, **kwargs): return wrapper - performance.counter = 0 performance.total_time = 0.0 performance.total_mem = 0 From fda35a02a0770623c5b49434078a10376d0366f1 Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 17:41:39 +0300 Subject: [PATCH 15/20] Update functions_oleksii_rak.py From 7595b0d74a06bc4575be1d49ccc020069e6ae600 Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 20:02:17 +0300 Subject: [PATCH 16/20] Implement dining philosophers problem with threading --- Week09/philosophers_oleksii_rak.py | 46 ++++++++++++++++++++++++++++++ 1 file changed, 46 insertions(+) create mode 100644 Week09/philosophers_oleksii_rak.py diff --git a/Week09/philosophers_oleksii_rak.py b/Week09/philosophers_oleksii_rak.py new file mode 100644 index 00000000..b3687697 --- /dev/null +++ b/Week09/philosophers_oleksii_rak.py @@ -0,0 +1,46 @@ +import threading +import random +import time + +class Fork: + def __init__(self, index: int): + self.index = index + self.lock = threading.Lock() + + def acquire(self): + self.lock.acquire() + + def release(self): + self.lock.release() + +class Philosopher(threading.Thread): + def __init__(self, index: int, left_fork: Fork, right_fork: Fork, spaghetti: int): + super().__init__() + self.index = index + self.left_fork = left_fork + self.right_fork = right_fork + self.spaghetti = spaghetti + + def run(self): + while self.spaghetti > 0: + # Філософ думає + time.sleep(random.uniform(0.01, 0.05)) + + # Odd-Even Strategy + if self.index % 2 != 0: + first_fork = self.left_fork + second_fork = self.right_fork + else: + first_fork = self.right_fork + second_fork = self.left_fork + + first_fork.acquire() + second_fork.acquire() + + # Філософ їсть + if self.spaghetti > 0: + self.spaghetti -= 1 + time.sleep(random.uniform(0.01, 0.05)) + + second_fork.release() + first_fork.release() From 5c79625625edd93002328d938b97c312f4775322 Mon Sep 17 00:00:00 2001 From: Lesyk01 Date: Thu, 4 Jun 2026 20:03:45 +0300 Subject: [PATCH 17/20] Add multiprocessing implementation for Pi calculation --- Week10/multiprocess_pi_oleksii_rak.py | 43 +++++++++++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 Week10/multiprocess_pi_oleksii_rak.py diff --git a/Week10/multiprocess_pi_oleksii_rak.py b/Week10/multiprocess_pi_oleksii_rak.py new file mode 100644 index 00000000..7fcb606f --- /dev/null +++ b/Week10/multiprocess_pi_oleksii_rak.py @@ -0,0 +1,43 @@ +import multiprocessing +import random +import numpy as np +import os + +def generate_points(n): + inner = 0 + for _ in range(n): + x = random.random() + y = random.random() + if (x**2 + y**2) <= 1: + inner += 1 + return inner + +def pi(accuracy: float = 1.0e-5, number_of_processes: int = 1) -> float: + def pi_(inner_: int, total_: int) -> float: + try: + return (inner_ / total_) * 4 + except ZeroDivisionError: + return 0.0 + + BATCH_SIZE = 1000000 + total = 0 + inner = 0 + process_count = 0 + + while abs(pi_(inner, total) - np.pi) > accuracy: + with multiprocessing.Pool(processes=number_of_processes) as pool: + results = pool.map( + generate_points, [BATCH_SIZE for _ in range(number_of_processes)] + ) + + inner += sum(results) + total += len(results) * BATCH_SIZE + process_count += len(results) + + print(f"inner: {inner}, total: {total}, process_count: {process_count}, pi: {pi_(inner, total)}") + + return pi_(inner, total) + +if __name__ == "__main__": + multiprocessing.set_start_method("fork") + print(pi(number_of_processes=os.cpu_count())) From ab957a7c5754b2e3b9a1d368b9cf432a94efd14e Mon Sep 17 00:00:00 2001 From: Bora Canbula Date: Thu, 4 Jun 2026 21:50:19 +0300 Subject: [PATCH 18/20] Delete awaitme_oleksii_rak.py --- awaitme_oleksii_rak.py | 13 ------------- 1 file changed, 13 deletions(-) delete mode 100644 awaitme_oleksii_rak.py diff --git a/awaitme_oleksii_rak.py b/awaitme_oleksii_rak.py deleted file mode 100644 index 2c939ea9..00000000 --- a/awaitme_oleksii_rak.py +++ /dev/null @@ -1,13 +0,0 @@ -import inspect -from functools import wraps - -def awaitme(func): - - @wraps(func) - async def wrapper(*args, **kwargs): - result = func(*args, **kwargs) - if inspect.isawaitable(result): - return await result - return result - - return wrapper From 7bc2202c8b41ea157dbc8f68ae9a330642aa6ed5 Mon Sep 17 00:00:00 2001 From: Bora Canbula Date: Thu, 4 Jun 2026 21:50:42 +0300 Subject: [PATCH 19/20] Delete Week10/multiprocess_pi_oleksii_rak.py --- Week10/multiprocess_pi_oleksii_rak.py | 43 --------------------------- 1 file changed, 43 deletions(-) delete mode 100644 Week10/multiprocess_pi_oleksii_rak.py diff --git a/Week10/multiprocess_pi_oleksii_rak.py b/Week10/multiprocess_pi_oleksii_rak.py deleted file mode 100644 index 7fcb606f..00000000 --- a/Week10/multiprocess_pi_oleksii_rak.py +++ /dev/null @@ -1,43 +0,0 @@ -import multiprocessing -import random -import numpy as np -import os - -def generate_points(n): - inner = 0 - for _ in range(n): - x = random.random() - y = random.random() - if (x**2 + y**2) <= 1: - inner += 1 - return inner - -def pi(accuracy: float = 1.0e-5, number_of_processes: int = 1) -> float: - def pi_(inner_: int, total_: int) -> float: - try: - return (inner_ / total_) * 4 - except ZeroDivisionError: - return 0.0 - - BATCH_SIZE = 1000000 - total = 0 - inner = 0 - process_count = 0 - - while abs(pi_(inner, total) - np.pi) > accuracy: - with multiprocessing.Pool(processes=number_of_processes) as pool: - results = pool.map( - generate_points, [BATCH_SIZE for _ in range(number_of_processes)] - ) - - inner += sum(results) - total += len(results) * BATCH_SIZE - process_count += len(results) - - print(f"inner: {inner}, total: {total}, process_count: {process_count}, pi: {pi_(inner, total)}") - - return pi_(inner, total) - -if __name__ == "__main__": - multiprocessing.set_start_method("fork") - print(pi(number_of_processes=os.cpu_count())) From accb9a7ee7fdb807877773961df140b951ca17de Mon Sep 17 00:00:00 2001 From: Bora Canbula Date: Thu, 4 Jun 2026 21:51:01 +0300 Subject: [PATCH 20/20] Delete Week09/philosophers_oleksii_rak.py --- Week09/philosophers_oleksii_rak.py | 46 ------------------------------ 1 file changed, 46 deletions(-) delete mode 100644 Week09/philosophers_oleksii_rak.py diff --git a/Week09/philosophers_oleksii_rak.py b/Week09/philosophers_oleksii_rak.py deleted file mode 100644 index b3687697..00000000 --- a/Week09/philosophers_oleksii_rak.py +++ /dev/null @@ -1,46 +0,0 @@ -import threading -import random -import time - -class Fork: - def __init__(self, index: int): - self.index = index - self.lock = threading.Lock() - - def acquire(self): - self.lock.acquire() - - def release(self): - self.lock.release() - -class Philosopher(threading.Thread): - def __init__(self, index: int, left_fork: Fork, right_fork: Fork, spaghetti: int): - super().__init__() - self.index = index - self.left_fork = left_fork - self.right_fork = right_fork - self.spaghetti = spaghetti - - def run(self): - while self.spaghetti > 0: - # Філософ думає - time.sleep(random.uniform(0.01, 0.05)) - - # Odd-Even Strategy - if self.index % 2 != 0: - first_fork = self.left_fork - second_fork = self.right_fork - else: - first_fork = self.right_fork - second_fork = self.left_fork - - first_fork.acquire() - second_fork.acquire() - - # Філософ їсть - if self.spaghetti > 0: - self.spaghetti -= 1 - time.sleep(random.uniform(0.01, 0.05)) - - second_fork.release() - first_fork.release()