diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 000000000..acff47db0
Binary files /dev/null and b/.DS_Store differ
diff --git a/conditions/.DS_Store b/conditions/.DS_Store
new file mode 100644
index 000000000..676fcb8f2
Binary files /dev/null and b/conditions/.DS_Store differ
diff --git a/deprecated_tests/.DS_Store b/deprecated_tests/.DS_Store
new file mode 100644
index 000000000..55d925d62
Binary files /dev/null and b/deprecated_tests/.DS_Store differ
diff --git a/deprecated_tests/sem01/tests/test_lesson02_tasks.py b/deprecated_tests/sem01/tests/test_lesson02_tasks.py
index f11403f4d..b7febe4ba 100644
--- a/deprecated_tests/sem01/tests/test_lesson02_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson02_tasks.py
@@ -10,7 +10,7 @@
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
             0,
@@ -44,7 +44,7 @@ def test_get_factorial(num: int, result_expected: int) -> None:
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
             0,
@@ -83,7 +83,7 @@ def test_get_doubled_factorial(num: int, result_expected: int) -> None:
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
             1,
@@ -125,7 +125,7 @@ def test_get_amount_of_ways_to_climb(
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
             1,
@@ -162,7 +162,7 @@ def test_get_multiplications_amount(
 
 
 @pytest.mark.parametrize(
-    "num1, num2, result_expected", 
+    "num1, num2, result_expected",
     (
         pytest.param(
             1,
@@ -229,7 +229,7 @@ def test_get_gcd(
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
             1,
@@ -273,10 +273,10 @@ def test_get_sum_of_prime_divisors(num: int, result_expected: int) -> None:
 
 
 @pytest.mark.parametrize(
-    "num, result_expected", 
+    "num, result_expected",
     (
         pytest.param(
-            -10**10,
+            -(10**10),
             False,
             id="negative-ten-billion",
         ),
diff --git a/deprecated_tests/sem01/tests/test_lesson04_tasks.py b/deprecated_tests/sem01/tests/test_lesson04_tasks.py
index 4110bdcc0..c98b6f22a 100644
--- a/deprecated_tests/sem01/tests/test_lesson04_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson04_tasks.py
@@ -1,6 +1,7 @@
-import pytest 
 import random
 
+import pytest
+
 from solutions.sem01.lesson04.task1 import is_arithmetic_progression
 from solutions.sem01.lesson04.task2 import merge_intervals
 from solutions.sem01.lesson04.task3 import find_single_number
@@ -8,62 +9,89 @@
 from solutions.sem01.lesson04.task5 import find_row_with_most_ones
 from solutions.sem01.lesson04.task6 import count_cycles
 
-@pytest.mark.parametrize("lst, expected", [
-    pytest.param([], True, id="empty_list"),
-    pytest.param([5], True, id="single_element"),
-    pytest.param([1, 3], True, id="two_elements"),
-    pytest.param([3, 1], True, id="two_elements_unsorted"),
-    pytest.param([1, 3, 5, 7], True, id="already_sorted_ap"),
-    pytest.param([3, 1, 5, 7], True, id="unsorted_ap"),
-    pytest.param([1, 2, 4], False, id="not_ap"),
-    pytest.param([10, 5, 0, -5], True, id="negative_difference"),
-    pytest.param([1, 1, 1, 1], True, id="constant_sequence"),
-    pytest.param([1, 2, 3, 5], False, id="almost_ap_but_not"),
-    pytest.param([0, 0, 1], False, id="two_same_one_different"),
-    pytest.param([10**5 + i*10**2 for i in range(1000)], True, id="long_list_true"),
-    pytest.param([10**5 + i*10**2 for i in range(999)] + [1], False, id="long_list_false"),
-])
+
+@pytest.mark.parametrize(
+    "lst, expected",
+    [
+        pytest.param([], True, id="empty_list"),
+        pytest.param([5], True, id="single_element"),
+        pytest.param([1, 3], True, id="two_elements"),
+        pytest.param([3, 1], True, id="two_elements_unsorted"),
+        pytest.param([1, 3, 5, 7], True, id="already_sorted_ap"),
+        pytest.param([3, 1, 5, 7], True, id="unsorted_ap"),
+        pytest.param([1, 2, 4], False, id="not_ap"),
+        pytest.param([10, 5, 0, -5], True, id="negative_difference"),
+        pytest.param([1, 1, 1, 1], True, id="constant_sequence"),
+        pytest.param([1, 2, 3, 5], False, id="almost_ap_but_not"),
+        pytest.param([0, 0, 1], False, id="two_same_one_different"),
+        pytest.param([10**5 + i * 10**2 for i in range(1000)], True, id="long_list_true"),
+        pytest.param([10**5 + i * 10**2 for i in range(999)] + [1], False, id="long_list_false"),
+    ],
+)
 def test_is_arithmetic_progression_parametrized(lst, expected):
     if len(lst) > 500:
         random.shuffle(lst)
     assert is_arithmetic_progression(lst) == expected
 
 
-@pytest.mark.parametrize("intervals, expected", [
-    pytest.param([], [], id="empty"),
-    pytest.param([[1, 3]], [[1, 3]], id="single_interval"),
-    pytest.param([[10, 13], [1, 3], [2, 6], [8, 10], [15, 18]], [[1, 6], [8, 13], [15, 18]], id="classic_merge"),
-    pytest.param([[1, 4], [4, 5]], [[1, 5]], id="touching_intervals"),
-    pytest.param([[1, 4], [2, 3]], [[1, 4]], id="nested_interval"),
-    pytest.param([[5, 7], [1, 3], [15, 20], [0, 0], [2, 4], [6, 10], [0, 2]], [[0, 4], [5, 10], [15, 20]], id="unsorted_input"),
-    pytest.param([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4], [5, 6]], id="no_overlap"),
-    pytest.param([[1, 10], [2, 3], [4, 5], [6, 7]], [[1, 10]], id="all_merged"),
-])
+@pytest.mark.parametrize(
+    "intervals, expected",
+    [
+        pytest.param([], [], id="empty"),
+        pytest.param([[1, 3]], [[1, 3]], id="single_interval"),
+        pytest.param(
+            [[10, 13], [1, 3], [2, 6], [8, 10], [15, 18]],
+            [[1, 6], [8, 13], [15, 18]],
+            id="classic_merge",
+        ),
+        pytest.param([[1, 4], [4, 5]], [[1, 5]], id="touching_intervals"),
+        pytest.param([[1, 4], [2, 3]], [[1, 4]], id="nested_interval"),
+        pytest.param(
+            [[5, 7], [1, 3], [15, 20], [0, 0], [2, 4], [6, 10], [0, 2]],
+            [[0, 4], [5, 10], [15, 20]],
+            id="unsorted_input",
+        ),
+        pytest.param([[1, 2], [3, 4], [5, 6]], [[1, 2], [3, 4], [5, 6]], id="no_overlap"),
+        pytest.param([[1, 10], [2, 3], [4, 5], [6, 7]], [[1, 10]], id="all_merged"),
+    ],
+)
 def test_merge_intervals(intervals, expected):
     assert merge_intervals(intervals) == expected
 
-@pytest.mark.parametrize("nums, expected", [
-    pytest.param([2, 2, 1], 1, id="simple_case"),
-    pytest.param([4, 1, 2, 1, 2], 4, id="middle_single"),
-    pytest.param([1], 1, id="single_element"),
-    pytest.param([100, 200, 300, 200, 100], 300, id="large_numbers"),
-    pytest.param([0, 1, 0], 1, id="with_zero"),
-    pytest.param([7, 8, 9, 8, 7], 9, id="unsorted"),
-    pytest.param([i + 10**5 for i in range(500)] + [i + 10**5 for i in range(500)] + [69], 69, id="long_list"),
-])
+
+@pytest.mark.parametrize(
+    "nums, expected",
+    [
+        pytest.param([2, 2, 1], 1, id="simple_case"),
+        pytest.param([4, 1, 2, 1, 2], 4, id="middle_single"),
+        pytest.param([1], 1, id="single_element"),
+        pytest.param([100, 200, 300, 200, 100], 300, id="large_numbers"),
+        pytest.param([0, 1, 0], 1, id="with_zero"),
+        pytest.param([7, 8, 9, 8, 7], 9, id="unsorted"),
+        pytest.param(
+            [i + 10**5 for i in range(500)] + [i + 10**5 for i in range(500)] + [69],
+            69,
+            id="long_list",
+        ),
+    ],
+)
 def test_find_single_number(nums, expected):
     assert find_single_number(nums) == expected
 
-@pytest.mark.parametrize("input_list, expected_list, expected_index", [
-    pytest.param([0, 1, 0, 3, 12], [1, 3, 12, 0, 0], 3, id="basic"),
-    pytest.param([0, 0, 1], [1, 0, 0], 1, id="zeros_first"),
-    pytest.param([1, 2, 3], [1, 2, 3], 3, id="no_zeros"),
-    pytest.param([0, 0, 0], [0, 0, 0], 0, id="all_zeros"),
-    pytest.param([1, 0, 2, 0, 3, 0], [1, 2, 3, 0, 0, 0], 3, id="interleaved"),
-    pytest.param([], [], 0, id="empty"),
-    pytest.param([0], [0], 0, id="single_zero"),
-    pytest.param([42], [42], 1, id="single_nonzero"),
-])
+
+@pytest.mark.parametrize(
+    "input_list, expected_list, expected_index",
+    [
+        pytest.param([0, 1, 0, 3, 12], [1, 3, 12, 0, 0], 3, id="basic"),
+        pytest.param([0, 0, 1], [1, 0, 0], 1, id="zeros_first"),
+        pytest.param([1, 2, 3], [1, 2, 3], 3, id="no_zeros"),
+        pytest.param([0, 0, 0], [0, 0, 0], 0, id="all_zeros"),
+        pytest.param([1, 0, 2, 0, 3, 0], [1, 2, 3, 0, 0, 0], 3, id="interleaved"),
+        pytest.param([], [], 0, id="empty"),
+        pytest.param([0], [0], 0, id="single_zero"),
+        pytest.param([42], [42], 1, id="single_nonzero"),
+    ],
+)
 def test_move_zeros_to_end_parametrized(input_list, expected_list, expected_index):
     arr = input_list[:]
     result_index = move_zeros_to_end(arr)
@@ -71,89 +99,54 @@ def test_move_zeros_to_end_parametrized(input_list, expected_list, expected_inde
     assert result_index == expected_index
 
 
-@pytest.mark.parametrize("matrix, expected_row", [
-    pytest.param(
-        [[0, 0, 1, 1],
-         [0, 1, 1, 1],
-         [0, 0, 0, 1],
-         [1, 1, 1, 1],
-         [0, 1, 1, 1]],
-        3,
-        id="classic"
-    ),
-    pytest.param(
-        [[0, 0, 0],
-         [0, 0, 0],
-         [0, 0, 0]],
-        0,
-        id="all_zeros"
-    ),
-    pytest.param(
-        [[1, 1, 1],
-         [1, 1, 1],
-         [1, 1, 1]],
-        0,
-        id="all_ones_first"
-    ),
-    pytest.param(
-        [[0, 1],
-         [1, 1]],
-        1,
-        id="two_rows"
-    ),
-    pytest.param(
-        [[0]],
-        0,
-        id="single_zero"
-    ),
-    pytest.param(
-        [[1]],
-        0,
-        id="single_one"
-    ),
-    pytest.param(
-        [],
-        0,
-        id="empty_matrix"
-    ),
-    pytest.param(
-        [[0, 0, 1],
-         [0, 1, 1],
-         [0, 1, 1]], 
-        1, 
-        id="tie"
-    ),
-])
+@pytest.mark.parametrize(
+    "matrix, expected_row",
+    [
+        pytest.param(
+            [[0, 0, 1, 1], [0, 1, 1, 1], [0, 0, 0, 1], [1, 1, 1, 1], [0, 1, 1, 1]], 3, id="classic"
+        ),
+        pytest.param([[0, 0, 0], [0, 0, 0], [0, 0, 0]], 0, id="all_zeros"),
+        pytest.param([[1, 1, 1], [1, 1, 1], [1, 1, 1]], 0, id="all_ones_first"),
+        pytest.param([[0, 1], [1, 1]], 1, id="two_rows"),
+        pytest.param([[0]], 0, id="single_zero"),
+        pytest.param([[1]], 0, id="single_one"),
+        pytest.param([], 0, id="empty_matrix"),
+        pytest.param([[0, 0, 1], [0, 1, 1], [0, 1, 1]], 1, id="tie"),
+    ],
+)
 def test_find_row_with_most_ones(matrix, expected_row):
     assert find_row_with_most_ones(matrix) == expected_row
 
 
 def test_find_row_with_most_ones_big_data():
     size = 10000
-    matrix = [[0]*size for i in range(size)]
-    matrix[size-1][size-1] = 1
+    matrix = [[0] * size for i in range(size)]
+    matrix[size - 1][size - 1] = 1
 
     for i in range(50):
         assert find_row_with_most_ones(matrix) == 9999
 
     size = 10000
-    matrix = [[1]*size for i in range(size)]
+    matrix = [[1] * size for i in range(size)]
     matrix[0][0] = 0
 
     for i in range(50):
         assert find_row_with_most_ones(matrix) == 1
 
 
-@pytest.mark.parametrize("input_arr, expected", [
-    pytest.param([0], 1, id="self_loop"),
-    pytest.param([1, 0], 1, id="two_cycle"),
-    pytest.param([1, 2, 0], 1, id="three_cycle"),
-    pytest.param([0, 1, 2], 3, id="three_self_loops"),
-    pytest.param([1, 0, 3, 2], 2, id="two_2_cycles"),
-    pytest.param([2, 0, 1, 4, 3], 2, id="mixed_cycles"),
-    pytest.param([10, 6, 2, 9, 4, 0, 3, 8, 7, 1, 5], 5, id="mixed_cycles"),
-    pytest.param([], 0, id="empty"),
-])
+@pytest.mark.parametrize(
+    "input_arr, expected",
+    [
+        pytest.param([0], 1, id="self_loop"),
+        pytest.param([1, 0], 1, id="two_cycle"),
+        pytest.param([1, 2, 0], 1, id="three_cycle"),
+        pytest.param([0, 1, 2], 3, id="three_self_loops"),
+        pytest.param([1, 0, 3, 2], 2, id="two_2_cycles"),
+        pytest.param([2, 0, 1, 4, 3], 2, id="mixed_cycles"),
+        pytest.param([10, 6, 2, 9, 4, 0, 3, 8, 7, 1, 5], 5, id="mixed_cycles"),
+        pytest.param([], 0, id="empty"),
+    ],
+)
 def test_count_cycles(input_arr, expected):
     arr = input_arr[:]
     assert count_cycles(arr) == expected
diff --git a/deprecated_tests/sem01/tests/test_lesson05_tasks.py b/deprecated_tests/sem01/tests/test_lesson05_tasks.py
index 72ad6bc8f..a43a2a456 100644
--- a/deprecated_tests/sem01/tests/test_lesson05_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson05_tasks.py
@@ -1,4 +1,4 @@
-import pytest 
+import pytest
 
 from solutions.sem01.lesson05.task1 import is_palindrome
 from solutions.sem01.lesson05.task2 import are_anagrams
@@ -7,145 +7,166 @@
 from solutions.sem01.lesson05.task5 import reg_validator
 from solutions.sem01.lesson05.task6 import simplify_path
 
-@pytest.mark.parametrize("s, expected", [
-    pytest.param("", True, id="empty_string"),
-    pytest.param("a", True, id="single_char"),
-    pytest.param("aa", True, id="two_same"),
-    pytest.param("ab", False, id="two_different"),
-    pytest.param("aba", True, id="odd_palindrome"),
-    pytest.param("abba", True, id="even_palindrome"),
-    pytest.param("abcba", True, id="long_odd_palindrome"),
-    pytest.param("abccba", True, id="long_even_palindrome"),
-    pytest.param("abc", False, id="not_palindrome"),
-    pytest.param("Aa", True, id="case_sensitive_mismatch"),
-    pytest.param("Racecar", True, id="real_word_case_sensitive"),
-    pytest.param("aA", True, id="reverse_case"),
-    pytest.param("abcdefedcba", True, id="long_true"),
-    pytest.param("abcdefedcbx", False, id="long_false"),
-])
+
+@pytest.mark.parametrize(
+    "s, expected",
+    [
+        pytest.param("", True, id="empty_string"),
+        pytest.param("a", True, id="single_char"),
+        pytest.param("aa", True, id="two_same"),
+        pytest.param("ab", False, id="two_different"),
+        pytest.param("aba", True, id="odd_palindrome"),
+        pytest.param("abba", True, id="even_palindrome"),
+        pytest.param("abcba", True, id="long_odd_palindrome"),
+        pytest.param("abccba", True, id="long_even_palindrome"),
+        pytest.param("abc", False, id="not_palindrome"),
+        pytest.param("Aa", True, id="case_sensitive_mismatch"),
+        pytest.param("Racecar", True, id="real_word_case_sensitive"),
+        pytest.param("aA", True, id="reverse_case"),
+        pytest.param("abcdefedcba", True, id="long_true"),
+        pytest.param("abcdefedcbx", False, id="long_false"),
+    ],
+)
 def test_is_palindrome(s, expected):
     assert is_palindrome(s) == expected
 
 
-@pytest.mark.parametrize("w1, w2, expected", [
-    pytest.param("listen", "silent", True, id="classic_anagram"),
-    pytest.param("evil", "vile", True, id="another_anagram"),
-    pytest.param("a", "a", True, id="single_char_same"),
-    pytest.param("A", "A", True, id="single_upper_same"),
-    pytest.param("A", "a", False, id="case_sensitive_diff"),
-    pytest.param("Listen", "Silent", False, id="mixed_case_not_anagram"),
-    pytest.param("Aa", "aA", True, id="same_chars_permuted"),
-    pytest.param("Ab", "ab", False, id="one_letter_case_diff"),
-    pytest.param("abc", "cba", True, id="permuted_same_case"),
-    pytest.param("abc", "Cba", False, id="case_breaks_anagram"),
-    pytest.param("aabbcc", "abcabc", True, id="repeated_letters"),
-    pytest.param("aabbcc", "aabbcd", False, id="extra_different_char"),
-])
+@pytest.mark.parametrize(
+    "w1, w2, expected",
+    [
+        pytest.param("listen", "silent", True, id="classic_anagram"),
+        pytest.param("evil", "vile", True, id="another_anagram"),
+        pytest.param("a", "a", True, id="single_char_same"),
+        pytest.param("A", "A", True, id="single_upper_same"),
+        pytest.param("A", "a", False, id="case_sensitive_diff"),
+        pytest.param("Listen", "Silent", False, id="mixed_case_not_anagram"),
+        pytest.param("Aa", "aA", True, id="same_chars_permuted"),
+        pytest.param("Ab", "ab", False, id="one_letter_case_diff"),
+        pytest.param("abc", "cba", True, id="permuted_same_case"),
+        pytest.param("abc", "Cba", False, id="case_breaks_anagram"),
+        pytest.param("aabbcc", "abcabc", True, id="repeated_letters"),
+        pytest.param("aabbcc", "aabbcd", False, id="extra_different_char"),
+    ],
+)
 def test_are_anagrams_linear(w1, w2, expected):
     assert are_anagrams(w1, w2) == expected
 
 
-@pytest.mark.parametrize("s, expected", [
-    pytest.param("!!!", True, id="only_exclamations"),
-    pytest.param("...?", True, id="dots_and_question"),
-    pytest.param("", False, id="empty_string"),
-    pytest.param("a", False, id="letter"),
-    pytest.param("1", False, id="digit"),
-    pytest.param(" ! ", False, id="space_inside"),
-    pytest.param("!?.", True, id="symbols_only"),
-    pytest.param("!a!", False, id="letter_in_middle"),
-    pytest.param(" ", False, id="only_space"),
-    pytest.param(".,;", True, id="commas_dots_semicolons"),
-    pytest.param("", False, id="commas_dots_semicolons"),
-])
+@pytest.mark.parametrize(
+    "s, expected",
+    [
+        pytest.param("!!!", True, id="only_exclamations"),
+        pytest.param("...?", True, id="dots_and_question"),
+        pytest.param("", False, id="empty_string"),
+        pytest.param("a", False, id="letter"),
+        pytest.param("1", False, id="digit"),
+        pytest.param(" ! ", False, id="space_inside"),
+        pytest.param("!?.", True, id="symbols_only"),
+        pytest.param("!a!", False, id="letter_in_middle"),
+        pytest.param(" ", False, id="only_space"),
+        pytest.param(".,;", True, id="commas_dots_semicolons"),
+        pytest.param("", False, id="commas_dots_semicolons"),
+    ],
+)
 def test_is_only_punctuation(s, expected):
     assert is_punctuation(s) == expected
 
-@pytest.mark.parametrize("compressed, expected", [
-    pytest.param("AbcD*4 ef GhI*2", "AbcDAbcDAbcDAbcDefGhIGhI", id="example"),
-    pytest.param("a*3 b*2", "aaabb", id="simple_letters"),
-    pytest.param("Hello", "Hello", id="star_one"),
-    pytest.param("xyz", "xyz", id="no_compression"),
-    pytest.param("", "", id="empty_input"),
-    pytest.param("Test*2 Space", "TestTestSpace", id="mixed"),
-    pytest.param("a*10", "aaaaaaaaaa", id="ten_a"),
-    pytest.param("x y z", "xyz", id="three_plain"),
-    pytest.param("Word word", "Wordword", id="case_sensitive"),
-])
+
+@pytest.mark.parametrize(
+    "compressed, expected",
+    [
+        pytest.param("AbcD*4 ef GhI*2", "AbcDAbcDAbcDAbcDefGhIGhI", id="example"),
+        pytest.param("a*3 b*2", "aaabb", id="simple_letters"),
+        pytest.param("Hello", "Hello", id="star_one"),
+        pytest.param("xyz", "xyz", id="no_compression"),
+        pytest.param("", "", id="empty_input"),
+        pytest.param("Test*2 Space", "TestTestSpace", id="mixed"),
+        pytest.param("a*10", "aaaaaaaaaa", id="ten_a"),
+        pytest.param("x y z", "xyz", id="three_plain"),
+        pytest.param("Word word", "Wordword", id="case_sensitive"),
+    ],
+)
 def test_decompress(compressed, expected):
     assert unzip(compressed) == expected
 
-@pytest.mark.parametrize("regexp, s, expected", [
-    pytest.param("d", "123", True, id="d_valid_number"),
-    pytest.param("d", "0", True, id="d_zero"),
-    pytest.param("d", "abc", False, id="d_letters_instead_of_digits"),
-    pytest.param("d", "", False, id="d_empty_string"),
-    pytest.param("w", "hello", True, id="w_lowercase_word"),
-    pytest.param("w", "HelloWorld", True, id="w_mixed_case_word"),
-    pytest.param("w", "hello123", False, id="w_word_with_digits"),
-    pytest.param("w", "", False, id="w_empty_string"),
-    pytest.param("s", "abc123", True, id="s_alphanum"),
-    pytest.param("s", "ABC99", True, id="s_uppercase_and_digits"),
-    pytest.param("s", "abc_123", False, id="s_contains_underscore"),
-    pytest.param("s", "", False, id="s_empty_string"),
-    pytest.param("d-d", "12-34", True, id="d_dash_d_valid"),
-    pytest.param("d-d", "12--34", False, id="d_dash_d_double_dash"),
-    pytest.param("d-d", "12-abc", False, id="d_dash_d_letters_after_dash"),
-    pytest.param("d-d", "1234", False, id="d_dash_d_missing_dash"),
-    pytest.param("w.w", "hi.there", True, id="w_dot_w_valid"),
-    pytest.param("w.w", "hi..there", False, id="w_dot_w_double_dot"),
-    pytest.param("w.w", "hi1.there", False, id="w_dot_w_digit_in_first_word"),
-    pytest.param("s.s", "h1i.th32ere", True, id="s_dot_s_valid"),
-    pytest.param("s.s", "hi4..t2here", False, id="s_dot_s_double_dot"),
-    pytest.param("d-dw", "12-45abc", True, id="example_valid"),
-    pytest.param("d-dw", "1-abs", False, id="example_second_part_not_digit"),
-    pytest.param("d-dw", "1-b123r", False, id="example_letter_after_dash"),
-    pytest.param("d-dw", "1--123vdg", False, id="example_double_dash"),
-    pytest.param("d-dw", "123-456XYZ", True, id="d-dw_all_caps"),
-    pytest.param("d-dw", "0-0a", True, id="d-dw_minimal_valid"),
-    pytest.param("d@d", "5@7", True, id="d_at_d_valid"),
-    pytest.param("d@d", "5@@7", False, id="d_at_d_double_at"),
-    pytest.param("w s", "hi 123", True, id="w_space_s_valid"),
-    pytest.param("w s", "hi123", False, id="w_space_s_missing_space"),
-    pytest.param("w s", "hi 123!", False, id="w_space_s_extra_char_in_s"),
-    pytest.param("", "", True, id="empty_regexp_empty_string"),
-    pytest.param("", "a", False, id="empty_regexp_non_empty_string"),
-    pytest.param("d", "", False, id="non_empty_regexp_empty_string"),
-    pytest.param("d!", "5!", True, id="d_exclam_valid"),
-    pytest.param("d!", "5", False, id="d_exclam_missing_exclam"),
-    pytest.param("d!", "5!!", False, id="d_exclam_extra_exclam"),
-    pytest.param("s", "a1", True, id="s_letter_digit"),
-    pytest.param("s", "1a", True, id="s_digit_letter"),
-    pytest.param("s", "a!1", False, id="s_contains_exclamation"),
-    pytest.param("d-w-s", "123-abc-XY1Z23", True, id="d_w_s_valid"),
-    pytest.param("d-w-s", "123-abc-XYZ_123", False, id="d_w_s_underscore_in_s"),
-])
+
+@pytest.mark.parametrize(
+    "regexp, s, expected",
+    [
+        pytest.param("d", "123", True, id="d_valid_number"),
+        pytest.param("d", "0", True, id="d_zero"),
+        pytest.param("d", "abc", False, id="d_letters_instead_of_digits"),
+        pytest.param("d", "", False, id="d_empty_string"),
+        pytest.param("w", "hello", True, id="w_lowercase_word"),
+        pytest.param("w", "HelloWorld", True, id="w_mixed_case_word"),
+        pytest.param("w", "hello123", False, id="w_word_with_digits"),
+        pytest.param("w", "", False, id="w_empty_string"),
+        pytest.param("s", "abc123", True, id="s_alphanum"),
+        pytest.param("s", "ABC99", True, id="s_uppercase_and_digits"),
+        pytest.param("s", "abc_123", False, id="s_contains_underscore"),
+        pytest.param("s", "", False, id="s_empty_string"),
+        pytest.param("d-d", "12-34", True, id="d_dash_d_valid"),
+        pytest.param("d-d", "12--34", False, id="d_dash_d_double_dash"),
+        pytest.param("d-d", "12-abc", False, id="d_dash_d_letters_after_dash"),
+        pytest.param("d-d", "1234", False, id="d_dash_d_missing_dash"),
+        pytest.param("w.w", "hi.there", True, id="w_dot_w_valid"),
+        pytest.param("w.w", "hi..there", False, id="w_dot_w_double_dot"),
+        pytest.param("w.w", "hi1.there", False, id="w_dot_w_digit_in_first_word"),
+        pytest.param("s.s", "h1i.th32ere", True, id="s_dot_s_valid"),
+        pytest.param("s.s", "hi4..t2here", False, id="s_dot_s_double_dot"),
+        pytest.param("d-dw", "12-45abc", True, id="example_valid"),
+        pytest.param("d-dw", "1-abs", False, id="example_second_part_not_digit"),
+        pytest.param("d-dw", "1-b123r", False, id="example_letter_after_dash"),
+        pytest.param("d-dw", "1--123vdg", False, id="example_double_dash"),
+        pytest.param("d-dw", "123-456XYZ", True, id="d-dw_all_caps"),
+        pytest.param("d-dw", "0-0a", True, id="d-dw_minimal_valid"),
+        pytest.param("d@d", "5@7", True, id="d_at_d_valid"),
+        pytest.param("d@d", "5@@7", False, id="d_at_d_double_at"),
+        pytest.param("w s", "hi 123", True, id="w_space_s_valid"),
+        pytest.param("w s", "hi123", False, id="w_space_s_missing_space"),
+        pytest.param("w s", "hi 123!", False, id="w_space_s_extra_char_in_s"),
+        pytest.param("", "", True, id="empty_regexp_empty_string"),
+        pytest.param("", "a", False, id="empty_regexp_non_empty_string"),
+        pytest.param("d", "", False, id="non_empty_regexp_empty_string"),
+        pytest.param("d!", "5!", True, id="d_exclam_valid"),
+        pytest.param("d!", "5", False, id="d_exclam_missing_exclam"),
+        pytest.param("d!", "5!!", False, id="d_exclam_extra_exclam"),
+        pytest.param("s", "a1", True, id="s_letter_digit"),
+        pytest.param("s", "1a", True, id="s_digit_letter"),
+        pytest.param("s", "a!1", False, id="s_contains_exclamation"),
+        pytest.param("d-w-s", "123-abc-XY1Z23", True, id="d_w_s_valid"),
+        pytest.param("d-w-s", "123-abc-XYZ_123", False, id="d_w_s_underscore_in_s"),
+    ],
+)
 def test_match_pattern(regexp, s, expected):
     assert reg_validator(regexp, s) == expected
 
 
-@pytest.mark.parametrize("path, expected", [
-    pytest.param("/home/", "/home", id="trailing_slash"),
-    pytest.param("/../", "", id="go_above_root"),
-    pytest.param("/home//foo/", "/home/foo", id="double_slash"),
-    pytest.param("/home/./foo/", "/home/foo", id="current_dir_dot"),
-    pytest.param("/./././", "/", id="only_dots_and_slashes"),
-    pytest.param("/a/./b/../../c/", "/c", id="complex_up_and_down"),
-    pytest.param("/a/b/c/../../../", "/", id="back_to_root"),
-    pytest.param("/", "/", id="root_only"),
-    pytest.param("/.", "/", id="root_with_dot"),
-    pytest.param("/..", "", id="root_with_double_dot"),
-    pytest.param("/...", "/...", id="triple_dot_as_name"),
-    pytest.param("/..a", "/..a", id="dot_dot_a_as_name"),
-    pytest.param("/a.b/c.d", "/a.b/c.d", id="names_with_dots"),
-    pytest.param("/a//b////c/d//././/..", "/a/b/c", id="messy_path"),
-    pytest.param("/a/./b/./c/./d", "/a/b/c/d", id="dots_everywhere"),
-    pytest.param("/a/./b/../../c/./d/", "/c/d", id="up_down_with_dots"),
-    pytest.param("/../foo", "", id="up_then_valid"),
-    pytest.param("/../../foo", "", id="multiple_up_then_valid"),
-    pytest.param("/../../../", "", id="three_up_from_root"),
-    pytest.param("/home/foo/./../../../", "", id="too_many_up"),
-    pytest.param("/_a.b/c__1/..", "/_a.b", id="names_with_underscores_and_dots"),
-])
+@pytest.mark.parametrize(
+    "path, expected",
+    [
+        pytest.param("/home/", "/home", id="trailing_slash"),
+        pytest.param("/../", "", id="go_above_root"),
+        pytest.param("/home//foo/", "/home/foo", id="double_slash"),
+        pytest.param("/home/./foo/", "/home/foo", id="current_dir_dot"),
+        pytest.param("/./././", "/", id="only_dots_and_slashes"),
+        pytest.param("/a/./b/../../c/", "/c", id="complex_up_and_down"),
+        pytest.param("/a/b/c/../../../", "/", id="back_to_root"),
+        pytest.param("/", "/", id="root_only"),
+        pytest.param("/.", "/", id="root_with_dot"),
+        pytest.param("/..", "", id="root_with_double_dot"),
+        pytest.param("/...", "/...", id="triple_dot_as_name"),
+        pytest.param("/..a", "/..a", id="dot_dot_a_as_name"),
+        pytest.param("/a.b/c.d", "/a.b/c.d", id="names_with_dots"),
+        pytest.param("/a//b////c/d//././/..", "/a/b/c", id="messy_path"),
+        pytest.param("/a/./b/./c/./d", "/a/b/c/d", id="dots_everywhere"),
+        pytest.param("/a/./b/../../c/./d/", "/c/d", id="up_down_with_dots"),
+        pytest.param("/../foo", "", id="up_then_valid"),
+        pytest.param("/../../foo", "", id="multiple_up_then_valid"),
+        pytest.param("/../../../", "", id="three_up_from_root"),
+        pytest.param("/home/foo/./../../../", "", id="too_many_up"),
+        pytest.param("/_a.b/c__1/..", "/_a.b", id="names_with_underscores_and_dots"),
+    ],
+)
 def test_simplify_path(path, expected):
-    assert simplify_path(path) == expected
\ No newline at end of file
+    assert simplify_path(path) == expected
diff --git a/deprecated_tests/sem01/tests/test_lesson06_tasks.py b/deprecated_tests/sem01/tests/test_lesson06_tasks.py
index 707d6609f..e20a8dd81 100644
--- a/deprecated_tests/sem01/tests/test_lesson06_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson06_tasks.py
@@ -1,4 +1,4 @@
-import pytest 
+import pytest
 
 from solutions.sem01.lesson06.task1 import int_to_roman
 from solutions.sem01.lesson06.task2 import get_len_of_longest_substring
@@ -6,103 +6,119 @@
 from solutions.sem01.lesson06.task4 import count_unique_words
 
 
-@pytest.mark.parametrize("num, expected", [
-    pytest.param(1, "I", id="one"),
-    pytest.param(2, "II", id="two"),
-    pytest.param(3, "III", id="three"),
-    pytest.param(4, "IV", id="four"),
-    pytest.param(5, "V", id="five"),
-    pytest.param(6, "VI", id="six"),
-    pytest.param(9, "IX", id="nine"),
-    pytest.param(10, "X", id="ten"),
-    pytest.param(11, "XI", id="eleven"),
-    pytest.param(14, "XIV", id="fourteen"),
-    pytest.param(19, "XIX", id="nineteen"),
-    pytest.param(27, "XXVII", id="twenty_seven"),
-    pytest.param(40, "XL", id="forty"),
-    pytest.param(44, "XLIV", id="forty_four"),
-    pytest.param(50, "L", id="fifty"),
-    pytest.param(58, "LVIII", id="fifty_eight"),
-    pytest.param(90, "XC", id="ninety"),
-    pytest.param(99, "XCIX", id="ninety_nine"),
-    pytest.param(100, "C", id="hundred"),
-    pytest.param(400, "CD", id="four_hundred"),
-    pytest.param(500, "D", id="five_hundred"),
-    pytest.param(900, "CM", id="nine_hundred"),
-    pytest.param(1000, "M", id="thousand"),
-    pytest.param(1994, "MCMXCIV", id="mcmxciv"),
-    pytest.param(3999, "MMMCMXCIX", id="max_value"),
-    pytest.param(2023, "MMXXIII", id="current_year"),
-    pytest.param(1984, "MCMLXXXIV", id="classic"),
-])
+@pytest.mark.parametrize(
+    "num, expected",
+    [
+        pytest.param(1, "I", id="one"),
+        pytest.param(2, "II", id="two"),
+        pytest.param(3, "III", id="three"),
+        pytest.param(4, "IV", id="four"),
+        pytest.param(5, "V", id="five"),
+        pytest.param(6, "VI", id="six"),
+        pytest.param(9, "IX", id="nine"),
+        pytest.param(10, "X", id="ten"),
+        pytest.param(11, "XI", id="eleven"),
+        pytest.param(14, "XIV", id="fourteen"),
+        pytest.param(19, "XIX", id="nineteen"),
+        pytest.param(27, "XXVII", id="twenty_seven"),
+        pytest.param(40, "XL", id="forty"),
+        pytest.param(44, "XLIV", id="forty_four"),
+        pytest.param(50, "L", id="fifty"),
+        pytest.param(58, "LVIII", id="fifty_eight"),
+        pytest.param(90, "XC", id="ninety"),
+        pytest.param(99, "XCIX", id="ninety_nine"),
+        pytest.param(100, "C", id="hundred"),
+        pytest.param(400, "CD", id="four_hundred"),
+        pytest.param(500, "D", id="five_hundred"),
+        pytest.param(900, "CM", id="nine_hundred"),
+        pytest.param(1000, "M", id="thousand"),
+        pytest.param(1994, "MCMXCIV", id="mcmxciv"),
+        pytest.param(3999, "MMMCMXCIX", id="max_value"),
+        pytest.param(2023, "MMXXIII", id="current_year"),
+        pytest.param(1984, "MCMLXXXIV", id="classic"),
+    ],
+)
 def test_int_to_roman(num, expected):
     assert int_to_roman(num) == expected
 
-@pytest.mark.parametrize("s, expected", [
-    pytest.param("", 0, id="empty_string"),
-    pytest.param("a", 1, id="single_char"),
-    pytest.param("aa", 1, id="two_same_chars"),
-    pytest.param("ab", 2, id="two_different_chars"),
-    pytest.param("abcabcbb", 3, id="classic_example_abc"),
-    pytest.param("bbbbb", 1, id="all_same"),
-    pytest.param("pwwkew", 3, id="pwwkew_example"),
-    pytest.param("abcdef", 6, id="all_unique"),
-    pytest.param("abcabcbbxyz", 4, id="long_tail_unique"),
-    pytest.param("aab", 2, id="aab"),
-    pytest.param("dvdf", 3, id="dvdf"),
-    pytest.param(" ", 1, id="single_space"),
-    pytest.param("a b c", 3, id="letters_and_spaces_unique"),
-    pytest.param("a b a", 3, id="space_in_middle_with_repeat"),
-    pytest.param("1234567890", 10, id="digits_all_unique"),
-    pytest.param("112233", 2, id="repeating_digits"),
-    pytest.param("abcdefghijklmnopqrstuvwxyz", 26, id="all_lowercase_letters"),
-    pytest.param("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ", 63, id="max_unique_set"),
-    pytest.param("a" * 10000, 1, id="ten_thousand_same"),
-    pytest.param("abc" * 3333 + "d", 4, id="long_repeating_with_new_char"),
-])
+
+@pytest.mark.parametrize(
+    "s, expected",
+    [
+        pytest.param("", 0, id="empty_string"),
+        pytest.param("a", 1, id="single_char"),
+        pytest.param("aa", 1, id="two_same_chars"),
+        pytest.param("ab", 2, id="two_different_chars"),
+        pytest.param("abcabcbb", 3, id="classic_example_abc"),
+        pytest.param("bbbbb", 1, id="all_same"),
+        pytest.param("pwwkew", 3, id="pwwkew_example"),
+        pytest.param("abcdef", 6, id="all_unique"),
+        pytest.param("abcabcbbxyz", 4, id="long_tail_unique"),
+        pytest.param("aab", 2, id="aab"),
+        pytest.param("dvdf", 3, id="dvdf"),
+        pytest.param(" ", 1, id="single_space"),
+        pytest.param("a b c", 3, id="letters_and_spaces_unique"),
+        pytest.param("a b a", 3, id="space_in_middle_with_repeat"),
+        pytest.param("1234567890", 10, id="digits_all_unique"),
+        pytest.param("112233", 2, id="repeating_digits"),
+        pytest.param("abcdefghijklmnopqrstuvwxyz", 26, id="all_lowercase_letters"),
+        pytest.param(
+            "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789 ",
+            63,
+            id="max_unique_set",
+        ),
+        pytest.param("a" * 10000, 1, id="ten_thousand_same"),
+        pytest.param("abc" * 3333 + "d", 4, id="long_repeating_with_new_char"),
+    ],
+)
 def test_get_len_of_longest_substring(s, expected):
     assert get_len_of_longest_substring(s) == expected
 
-@pytest.mark.parametrize("nums, k, expected", [
-    pytest.param([23, 2, 4, 6, 7], 6, True, id="subarray_2_4_sum_6"),
-    pytest.param([23, 2, 6, 4, 7], 6, True, id="total_sum_42_div_by_6"),
-    pytest.param([23, 2, 6, 4, 7], 13, False, id="no_valid_subarray"),
-    pytest.param([0, 0], 1, True, id="two_zeros_any_k"),
-    pytest.param([1, 0], 2, False, id="length_2_sum_1_not_div_by_2"),
-    pytest.param([1, 2, 3], 5, True, id="subarray_2_3_sum_5"),
-    pytest.param([1], 1, False, id="single_element_too_short"),
-    pytest.param([5, 0, 0], 3, True, id="zeros_after_nonzero"),
-    pytest.param([1, 2], 3, True, id="exact_sum_equals_k"),
-    pytest.param([1, 2], 4, False, id="sum_not_divisible_by_k"),
-    pytest.param([0], 1, False, id="single_zero_too_short"),
-    pytest.param([1, 0, 2], 2, True, id="subarray_0_2_sum_2"),
-    pytest.param([4, 2, 4], 6, True, id="first_two_sum_6"),
-    pytest.param([1, 1, 1], 2, True, id="first_two_ones_sum_2"),
-    pytest.param([1, 2, 4, 8], 8, False, id="no_subarray_divisible_by_8"),
-    pytest.param([0, 1, 0], 2, False, id="zeros_with_one_sum_1"),
-    pytest.param([0, 1, 0, 0], 2, True, id="last_two_zeros_sum_0_div_by_any"),
-])
+
+@pytest.mark.parametrize(
+    "nums, k, expected",
+    [
+        pytest.param([23, 2, 4, 6, 7], 6, True, id="subarray_2_4_sum_6"),
+        pytest.param([23, 2, 6, 4, 7], 6, True, id="total_sum_42_div_by_6"),
+        pytest.param([23, 2, 6, 4, 7], 13, False, id="no_valid_subarray"),
+        pytest.param([0, 0], 1, True, id="two_zeros_any_k"),
+        pytest.param([1, 0], 2, False, id="length_2_sum_1_not_div_by_2"),
+        pytest.param([1, 2, 3], 5, True, id="subarray_2_3_sum_5"),
+        pytest.param([1], 1, False, id="single_element_too_short"),
+        pytest.param([5, 0, 0], 3, True, id="zeros_after_nonzero"),
+        pytest.param([1, 2], 3, True, id="exact_sum_equals_k"),
+        pytest.param([1, 2], 4, False, id="sum_not_divisible_by_k"),
+        pytest.param([0], 1, False, id="single_zero_too_short"),
+        pytest.param([1, 0, 2], 2, True, id="subarray_0_2_sum_2"),
+        pytest.param([4, 2, 4], 6, True, id="first_two_sum_6"),
+        pytest.param([1, 1, 1], 2, True, id="first_two_ones_sum_2"),
+        pytest.param([1, 2, 4, 8], 8, False, id="no_subarray_divisible_by_8"),
+        pytest.param([0, 1, 0], 2, False, id="zeros_with_one_sum_1"),
+        pytest.param([0, 1, 0, 0], 2, True, id="last_two_zeros_sum_0_div_by_any"),
+    ],
+)
 def test_is_there_any_good_subarray(nums, k, expected):
     assert is_there_any_good_subarray(nums, k) == expected
 
 
-import pytest
-
-@pytest.mark.parametrize("text, expected", [
-    pytest.param("", 0, id="empty_string"),
-    pytest.param("   ", 0, id="only_spaces"),
-    pytest.param("hello", 1, id="single_word"),
-    pytest.param("Hello hello", 1, id="case_insensitive"),
-    pytest.param("Hello, world!", 2, id="punctuation_around"),
-    pytest.param("Hello, hello, world!", 2, id="duplicates_with_punct"),
-    pytest.param("The quick brown fox jumps over the lazy dog.", 8, id="classic_pangram"),
-    pytest.param("!!! ???", 0, id="only_punctuation"),
-    pytest.param("word1 word2 word1", 2, id="digits_in_words"),
-    pytest.param("Don't stop believing!", 3, id="apostrophe_inside"),
-    pytest.param("   Hello ,   World !   ", 2, id="extra_whitespace"),
-    pytest.param("A a A a", 1, id="repeated_case_variants"),
-    pytest.param("word... word!!!", 1, id="multiple_punct_at_end"),
-    pytest.param("123 456 123", 2, id="numbers_as_words"),
-])
+@pytest.mark.parametrize(
+    "text, expected",
+    [
+        pytest.param("", 0, id="empty_string"),
+        pytest.param("   ", 0, id="only_spaces"),
+        pytest.param("hello", 1, id="single_word"),
+        pytest.param("Hello hello", 1, id="case_insensitive"),
+        pytest.param("Hello, world!", 2, id="punctuation_around"),
+        pytest.param("Hello, hello, world!", 2, id="duplicates_with_punct"),
+        pytest.param("The quick brown fox jumps over the lazy dog.", 8, id="classic_pangram"),
+        pytest.param("!!! ???", 0, id="only_punctuation"),
+        pytest.param("word1 word2 word1", 2, id="digits_in_words"),
+        pytest.param("Don't stop believing!", 3, id="apostrophe_inside"),
+        pytest.param("   Hello ,   World !   ", 2, id="extra_whitespace"),
+        pytest.param("A a A a", 1, id="repeated_case_variants"),
+        pytest.param("word... word!!!", 1, id="multiple_punct_at_end"),
+        pytest.param("123 456 123", 2, id="numbers_as_words"),
+    ],
+)
 def test_count_unique_words(text, expected):
-    assert count_unique_words(text) == expected
\ No newline at end of file
+    assert count_unique_words(text) == expected
diff --git a/deprecated_tests/sem01/tests/test_lesson08_tasks.py b/deprecated_tests/sem01/tests/test_lesson08_tasks.py
index 962ba4bd2..06f04319d 100644
--- a/deprecated_tests/sem01/tests/test_lesson08_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson08_tasks.py
@@ -1,10 +1,10 @@
-import pytest 
 import math
 import time
 
 from solutions.sem01.lesson08.task1 import make_averager
 from solutions.sem01.lesson08.task2 import collect_statistic
 
+
 def test_make_averager():
     get_avg = make_averager(2)
 
@@ -15,6 +15,7 @@ def test_make_averager():
     assert math.isclose(get_avg(5), 1)
     assert math.isclose(get_avg(5), 5)
 
+
 def test_make_averager2():
     get_avg = make_averager(5)
 
@@ -27,6 +28,7 @@ def test_make_averager2():
     assert math.isclose(get_avg(-7), 0)
     assert math.isclose(get_avg(-2), -1)
 
+
 def test_collect_statistic():
     statistics: list[str, list[float, int]] = {}
 
@@ -37,7 +39,7 @@ def func1() -> None:
     @collect_statistic(statistics)
     def func2() -> None:
         time.sleep(0.1)
-    
+
     for _ in range(3):
         func1()
 
@@ -58,10 +60,11 @@ def test_collect_statistic_inout():
     @collect_statistic(statistics)
     def func(a, b, *, c, d):
         return a + b + c + d
-    
+
     assert func(1, 2, c=3, d=4) == 10
     assert statistics[func.__name__][1] == 1
 
+
 def test_collect_statistic_count_call():
     statistics: list[str, list[float, int]] = {}
 
@@ -76,7 +79,7 @@ def func():
             count_call += 1
 
         return func
-    
+
     func = func_fab()
     func()
-    assert statistics[func.__name__][1] == 1
\ No newline at end of file
+    assert statistics[func.__name__][1] == 1
diff --git a/deprecated_tests/sem01/tests/test_lesson11_tasks.py b/deprecated_tests/sem01/tests/test_lesson11_tasks.py
index d0cd02efc..941eed777 100644
--- a/deprecated_tests/sem01/tests/test_lesson11_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson11_tasks.py
@@ -1,9 +1,8 @@
-import pytest
-
 import math
 import sys
 from io import StringIO
 
+import pytest
 
 from solutions.sem01.lesson11.task1 import Vector2D
 
@@ -84,13 +83,12 @@ def test_print():
     sys.stdout = old_stdout
     output = captured_output.getvalue()
     assert (
-        output == "Vector2D(abscissa=1, ordinate=-2)" 
+        output == "Vector2D(abscissa=1, ordinate=-2)"
         or output == "Vector2D(abscissa=1., ordinate=-2.)"
-        or output == "Vector2D(abscissa=1.0, ordinate=-2.0)" 
+        or output == "Vector2D(abscissa=1.0, ordinate=-2.0)"
     )
 
 
-
 @pytest.mark.parametrize(
     "abscissa1, ordinate1, abscissa2, ordinate2, expected",
     [
diff --git a/deprecated_tests/sem01/tests_hw/test_hw1_tasks.py b/deprecated_tests/sem01/tests_hw/test_hw1_tasks.py
index 0ecf8a108..c600f76d5 100644
--- a/deprecated_tests/sem01/tests_hw/test_hw1_tasks.py
+++ b/deprecated_tests/sem01/tests_hw/test_hw1_tasks.py
@@ -1,17 +1,15 @@
-import pytest
 import uuid
-from unittest.mock import MagicMock, patch, Mock
+from unittest.mock import MagicMock, Mock, patch
+
+import pytest
 
-from homeworks.sem01.hw1.aggregate_segmentation import aggregate_segmentation, ALLOWED_TYPES
+from homeworks.sem01.hw1.aggregate_segmentation import ALLOWED_TYPES, aggregate_segmentation
 from homeworks.sem01.hw1.backoff import backoff
 from homeworks.sem01.hw1.cache import lru_cache
 from homeworks.sem01.hw1.convert_exception import convert_exceptions_to_api_compitable_ones
-from .hw1_test_data.cache_test_data import (
-    TESTCASE_DATA,
-    TESTCASE_IDS,
-)
 
-NAME_BACKOFF_MODULE = "homeworks.hw1.backoff" # название модуля с backoff
+NAME_BACKOFF_MODULE = "homeworks.hw1.backoff"  # название модуля с backoff
+
 
 def test_valid_segments() -> None:
     """Тест: валидные сегменты."""
@@ -32,53 +30,53 @@ def test_valid_segments() -> None:
             "segment_id": segment_id_1,
             "segment_start": 0.0,
             "segment_end": 1.0,
-            "type": list_allow_types[0]
+            "type": list_allow_types[0],
         },
         {
             "audio_id": audio_id_1,
             "segment_id": segment_id_2,
             "segment_start": 2.5,
             "segment_end": 3.5,
-            "type": list_allow_types[1]
+            "type": list_allow_types[1],
         },
         {
             "audio_id": audio_id_2,
             "segment_id": segment_id_3,
             "segment_start": 4.5,
             "segment_end": 4.6,
-            "type": list_allow_types[0]
+            "type": list_allow_types[0],
         },
         {
             "audio_id": audio_id_2,
             "segment_id": segment_id_4,
             "segment_start": 5.5,
             "segment_end": 6.5,
-            "type": list_allow_types[1]
+            "type": list_allow_types[1],
         },
         {
             "audio_id": audio_id_3,
             "segment_id": segment_id_5,
             "segment_start": None,
             "segment_end": None,
-            "type": None
+            "type": None,
         },
         {
             "audio_id": "audio3",
             "segment_id": "seg5",
             "segment_start": 0.0,
             "segment_end": 1.0,
-            "type": "invalid_type"
+            "type": "invalid_type",
         },
     ]
 
     expected_valid = {
         audio_id_1: {
             segment_id_1: {"start": 0.0, "end": 1.0, "type": list_allow_types[0]},
-            segment_id_2: {"start": 2.5, "end": 3.5, "type": list_allow_types[1]}
+            segment_id_2: {"start": 2.5, "end": 3.5, "type": list_allow_types[1]},
         },
         audio_id_2: {
             segment_id_3: {"start": 4.5, "end": 4.6, "type": list_allow_types[0]},
-            segment_id_4: {"start": 5.5, "end": 6.5, "type": list_allow_types[1]}
+            segment_id_4: {"start": 5.5, "end": 6.5, "type": list_allow_types[1]},
         },
         audio_id_3: {},
     }
@@ -88,6 +86,7 @@ def test_valid_segments() -> None:
     assert result_valid == expected_valid
     assert result_forbidden == expected_forbidden
 
+
 def test_convert_matching_exception() -> None:
     """Тест: исключение заменяется на API-совместимое."""
 
@@ -97,7 +96,7 @@ class ApiValueError(Exception):
     @convert_exceptions_to_api_compitable_ones({ValueError: ApiValueError})
     def func():
         raise ValueError("Внутренняя ошибка")
-    
+
     @convert_exceptions_to_api_compitable_ones({ValueError: ApiValueError})
     def func2():
         raise KeyError("Внутренняя ошибка")
@@ -108,7 +107,8 @@ def func2():
     with pytest.raises(KeyError):
         func2()
 
-@patch(NAME_BACKOFF_MODULE + '.sleep')
+
+@patch(NAME_BACKOFF_MODULE + ".sleep")
 def test_exponential_backoff_and_jitter(mock_sleep: MagicMock) -> None:
     """Тест: задержки увеличиваются, но не выше timeout_max и к ним добавляется дрожь."""
     attempts = 0
@@ -116,12 +116,7 @@ def test_exponential_backoff_and_jitter(mock_sleep: MagicMock) -> None:
     retry_amount = 4
     timeouts = [1, 2, 4, 4]
 
-    @backoff(
-        retry_amount=retry_amount,
-        timeout_start=1,
-        timeout_max=timeout_max,
-        backoff_scale=2.0
-    )
+    @backoff(retry_amount=retry_amount, timeout_start=1, timeout_max=timeout_max, backoff_scale=2.0)
     def func():
         nonlocal attempts
         attempts += 1
@@ -138,22 +133,23 @@ def func():
     for av_time, args in zip(timeouts, args_list):
         count_more_av_time += args > av_time
         assert av_time <= args <= av_time + 0.5
-    
-    assert count_more_av_time   # есть добавление "дрожи"
+
+    assert count_more_av_time  # есть добавление "дрожи"
+
 
 def test_success() -> None:
     capacity = 2
-    call_args =  [
+    call_args = [
         (1, 2),
         (1, 2),
         (2, 2),
     ]
     call_count_expected = 2
-    
+
     mock_func = Mock()
     func_cached = lru_cache(capacity=capacity)(mock_func)
 
     for args in call_args:
         func_cached(args)
 
-    assert mock_func.call_count == call_count_expected
\ No newline at end of file
+    assert mock_func.call_count == call_count_expected
diff --git a/deprecated_tests/sem02/tests/task4/test_lesson04_tasks.py b/deprecated_tests/sem02/tests/task4/test_lesson04_tasks.py
index 37d249b77..81312dea0 100644
--- a/deprecated_tests/sem02/tests/task4/test_lesson04_tasks.py
+++ b/deprecated_tests/sem02/tests/task4/test_lesson04_tasks.py
@@ -333,12 +333,8 @@ class TestTask2:
             ),
         ],
     )
-    def test_get_dominant_color_info(
-        self, image, threshold, expected_color, expected_ratio
-    ):
-        color, ratio_percent = get_dominant_color_info(
-            image.astype(np.uint8), threshold
-        )
+    def test_get_dominant_color_info(self, image, threshold, expected_color, expected_ratio):
+        color, ratio_percent = get_dominant_color_info(image.astype(np.uint8), threshold)
 
         assert color in expected_color
         assert (abs(ratio_percent - expected_ratio * 100) < 1e-6) or (
diff --git a/deprecated_tests/sem02/tests/task5/test_lesson05_tasks.py b/deprecated_tests/sem02/tests/task5/test_lesson05_tasks.py
index aeb37ebcc..4cc9188d4 100644
--- a/deprecated_tests/sem02/tests/task5/test_lesson05_tasks.py
+++ b/deprecated_tests/sem02/tests/task5/test_lesson05_tasks.py
@@ -89,9 +89,7 @@ class TestTask1:
             ),
         ],
     )
-    def test_can_satisfy_demand(
-        self, costs, resource_amounts, demand_expected, expected
-    ):
+    def test_can_satisfy_demand(self, costs, resource_amounts, demand_expected, expected):
         assert can_satisfy_demand(costs, resource_amounts, demand_expected) == expected
 
     def test_can_satisfy_demand_validate(self):
@@ -172,9 +170,7 @@ class TestTask2:
             ),
         ],
     )
-    def test_get_projections_components(
-        self, matrix, vector, proj_expected, orth_expected
-    ):
+    def test_get_projections_components(self, matrix, vector, proj_expected, orth_expected):
         projections, orthogonals = get_projections_components(matrix, vector)
 
         if proj_expected is None:
diff --git a/homeworks/.DS_Store b/homeworks/.DS_Store
new file mode 100644
index 000000000..999bef935
Binary files /dev/null and b/homeworks/.DS_Store differ
diff --git a/homeworks/sem01/hw1/backoff.py b/homeworks/sem01/hw1/backoff.py
index 696ffa73a..a3373a982 100644
--- a/homeworks/sem01/hw1/backoff.py
+++ b/homeworks/sem01/hw1/backoff.py
@@ -1,5 +1,3 @@
-from random import uniform
-from time import sleep
 from typing import (
     Callable,
     ParamSpec,
diff --git a/labyrinth.gif b/labyrinth.gif
new file mode 100644
index 000000000..453fece3c
Binary files /dev/null and b/labyrinth.gif differ
diff --git a/loaded_labyrinth.gif b/loaded_labyrinth.gif
new file mode 100644
index 000000000..082cc2a00
Binary files /dev/null and b/loaded_labyrinth.gif differ
diff --git a/requirements-ci.txt b/requirements-ci.txt
index 581b008d7..d2248db8b 100644
--- a/requirements-ci.txt
+++ b/requirements-ci.txt
@@ -1,6 +1,6 @@
-matplotlib==3.8.0
-numpy==1.26.1
-pandas==2.2.2
+matplotlib
+numpy
+pandas
 
 pytest==8.4.2
 pytest-cov==7.0.0
diff --git a/solutions/.DS_Store b/solutions/.DS_Store
new file mode 100644
index 000000000..2efaf3045
Binary files /dev/null and b/solutions/.DS_Store differ
diff --git a/solutions/sem01/lesson02/task3.py b/solutions/sem01/lesson02/task3.py
index ee2a84ecf..e997f8054 100644
--- a/solutions/sem01/lesson02/task3.py
+++ b/solutions/sem01/lesson02/task3.py
@@ -1,4 +1,4 @@
 def get_amount_of_ways_to_climb(stair_amount: int) -> int:
-    step_prev, step_curr = 1, 1
+    _step_prev, step_curr = 1, 1
     # ваш код
     return step_curr
diff --git a/solutions/sem01/lesson03/task1.py b/solutions/sem01/lesson03/task1.py
index f1d8fe26b..7b048e654 100644
--- a/solutions/sem01/lesson03/task1.py
+++ b/solutions/sem01/lesson03/task1.py
@@ -1,3 +1,3 @@
 def flip_bits_in_range(num: int, left_bit: int, right_bit: int) -> int:
     # ваш код
-    return num
\ No newline at end of file
+    return num
diff --git a/solutions/sem01/lesson03/task2.py b/solutions/sem01/lesson03/task2.py
index a3a738c2a..5cf2b6316 100644
--- a/solutions/sem01/lesson03/task2.py
+++ b/solutions/sem01/lesson03/task2.py
@@ -1,3 +1,3 @@
 def get_cube_root(n: float, eps: float) -> float:
     # ваш код
-    return n
\ No newline at end of file
+    return n
diff --git a/solutions/sem01/lesson04/task1.py b/solutions/sem01/lesson04/task1.py
index 47384423a..0135e399b 100644
--- a/solutions/sem01/lesson04/task1.py
+++ b/solutions/sem01/lesson04/task1.py
@@ -1,3 +1,3 @@
 def is_arithmetic_progression(lst: list[list[int]]) -> bool:
     # ваш код
-    return False
\ No newline at end of file
+    return False
diff --git a/solutions/sem01/lesson04/task2.py b/solutions/sem01/lesson04/task2.py
index 4591d0a3e..5d6f8ee8a 100644
--- a/solutions/sem01/lesson04/task2.py
+++ b/solutions/sem01/lesson04/task2.py
@@ -1,3 +1,3 @@
 def merge_intervals(intervals: list[list[int, int]]) -> list[list[int, int]]:
     # ваш код
-    return [[0,0]]
\ No newline at end of file
+    return [[0, 0]]
diff --git a/solutions/sem01/lesson04/task4.py b/solutions/sem01/lesson04/task4.py
index b21bc5a39..2664384d8 100644
--- a/solutions/sem01/lesson04/task4.py
+++ b/solutions/sem01/lesson04/task4.py
@@ -1,3 +1,3 @@
 def move_zeros_to_end(nums: list[int]) -> list[int]:
     # ваш код
-    return 0
\ No newline at end of file
+    return 0
diff --git a/solutions/sem01/lesson04/task5.py b/solutions/sem01/lesson04/task5.py
index 02d7742bb..ec6932ee4 100644
--- a/solutions/sem01/lesson04/task5.py
+++ b/solutions/sem01/lesson04/task5.py
@@ -1,3 +1,3 @@
 def find_row_with_most_ones(matrix: list[list[int]]) -> int:
     # ваш код
-    return 0
\ No newline at end of file
+    return 0
diff --git a/solutions/sem01/lesson04/task6.py b/solutions/sem01/lesson04/task6.py
index 16df27ca6..d16e77dda 100644
--- a/solutions/sem01/lesson04/task6.py
+++ b/solutions/sem01/lesson04/task6.py
@@ -1,3 +1,3 @@
-def count_cycles(arr: list[int]) -> int: 
+def count_cycles(arr: list[int]) -> int:
     # ваш код
-    return 0
\ No newline at end of file
+    return 0
diff --git a/solutions/sem01/lesson05/task1.py b/solutions/sem01/lesson05/task1.py
index 9a17211e5..fdf3b5488 100644
--- a/solutions/sem01/lesson05/task1.py
+++ b/solutions/sem01/lesson05/task1.py
@@ -1,3 +1,3 @@
 def is_palindrome(text: str) -> bool:
     # ваш код
-    return False
\ No newline at end of file
+    return False
diff --git a/solutions/sem01/lesson05/task2.py b/solutions/sem01/lesson05/task2.py
index 367503802..c70b40298 100644
--- a/solutions/sem01/lesson05/task2.py
+++ b/solutions/sem01/lesson05/task2.py
@@ -1,3 +1,3 @@
 def are_anagrams(word1: str, word2: str) -> bool:
     # ваш код
-    return False
\ No newline at end of file
+    return False
diff --git a/solutions/sem01/lesson05/task4.py b/solutions/sem01/lesson05/task4.py
index 4c4e9086e..7c2c26f17 100644
--- a/solutions/sem01/lesson05/task4.py
+++ b/solutions/sem01/lesson05/task4.py
@@ -1,3 +1,3 @@
 def unzip(compress_text: str) -> str:
     # ваш код
-    return compress_text
\ No newline at end of file
+    return compress_text
diff --git a/solutions/sem01/lesson05/task5.py b/solutions/sem01/lesson05/task5.py
index 076c5bb6c..da9e6d08c 100644
--- a/solutions/sem01/lesson05/task5.py
+++ b/solutions/sem01/lesson05/task5.py
@@ -1,3 +1,3 @@
-def reg_validator(reg_expr: str, text: str) -> bool:  
+def reg_validator(reg_expr: str, text: str) -> bool:
     # ваш код
-    return False
\ No newline at end of file
+    return False
diff --git a/solutions/sem01/lesson05/task6.py b/solutions/sem01/lesson05/task6.py
index 1b914ada7..63207797d 100644
--- a/solutions/sem01/lesson05/task6.py
+++ b/solutions/sem01/lesson05/task6.py
@@ -1,3 +1,3 @@
 def simplify_path(path: str) -> str:
     # ваш код
-    return path
\ No newline at end of file
+    return path
diff --git a/solutions/sem01/lesson06/task1.py b/solutions/sem01/lesson06/task1.py
index 2d1e30e96..353cb3616 100644
--- a/solutions/sem01/lesson06/task1.py
+++ b/solutions/sem01/lesson06/task1.py
@@ -1,3 +1,3 @@
 def int_to_roman(num: int) -> str:
     # ваш код
-    return ""
\ No newline at end of file
+    return ""
diff --git a/solutions/sem01/lesson06/task2.py b/solutions/sem01/lesson06/task2.py
index f535b5a0c..f1034e24e 100644
--- a/solutions/sem01/lesson06/task2.py
+++ b/solutions/sem01/lesson06/task2.py
@@ -1,3 +1,3 @@
 def get_len_of_longest_substring(text: str) -> int:
     # ваш код
-    return 0
\ No newline at end of file
+    return 0
diff --git a/solutions/sem01/lesson06/task3.py b/solutions/sem01/lesson06/task3.py
index 7449a1e72..b160d615a 100644
--- a/solutions/sem01/lesson06/task3.py
+++ b/solutions/sem01/lesson06/task3.py
@@ -2,6 +2,5 @@ def is_there_any_good_subarray(
     nums: list[int],
     k: int,
 ) -> bool:
-    
     # ваш код
     return False
diff --git a/solutions/sem01/lesson06/task4.py b/solutions/sem01/lesson06/task4.py
index 5b75a110c..95a7098e4 100644
--- a/solutions/sem01/lesson06/task4.py
+++ b/solutions/sem01/lesson06/task4.py
@@ -1,3 +1,3 @@
 def count_unique_words(text: str) -> int:
     # ваш код
-    return 0
\ No newline at end of file
+    return 0
diff --git a/solutions/sem01/lesson08/task1.py b/solutions/sem01/lesson08/task1.py
index 4390f6c84..7fa724ef8 100644
--- a/solutions/sem01/lesson08/task1.py
+++ b/solutions/sem01/lesson08/task1.py
@@ -1,5 +1,6 @@
 from typing import Callable
 
+
 def make_averager(accumulation_period: int) -> Callable[[float], float]:
     # ваш код
-    pass
\ No newline at end of file
+    pass
diff --git a/solutions/sem01/lesson08/task2.py b/solutions/sem01/lesson08/task2.py
index 6e4af8707..cc2ae4303 100644
--- a/solutions/sem01/lesson08/task2.py
+++ b/solutions/sem01/lesson08/task2.py
@@ -2,9 +2,7 @@
 
 T = TypeVar("T")
 
-def collect_statistic(
-    statistics: dict[str, list[float, int]]
-) -> Callable[[T], T]:
-    
+
+def collect_statistic(statistics: dict[str, list[float, int]]) -> Callable[[T], T]:
     # ваш код
-    pass
\ No newline at end of file
+    pass
diff --git a/solutions/sem01/lesson12/task3.py b/solutions/sem01/lesson12/task3.py
index 64c112ccc..58b0986e1 100644
--- a/solutions/sem01/lesson12/task3.py
+++ b/solutions/sem01/lesson12/task3.py
@@ -1,6 +1,3 @@
-import sys
-
-
 class FileOut:
     def __init__(
         self,
diff --git a/solutions/sem02/lesson03/task1.py b/solutions/sem02/lesson03/task1.py
index 2c3fc0b58..dfb9e601e 100644
--- a/solutions/sem02/lesson03/task1.py
+++ b/solutions/sem02/lesson03/task1.py
@@ -8,13 +8,23 @@ class ShapeMismatchError(Exception):
 def sum_arrays_vectorized(
     lhs: np.ndarray,
     rhs: np.ndarray,
-) -> np.ndarray: ...
+) -> np.ndarray:
+    if lhs.shape != rhs.shape:
+        raise ShapeMismatchError
 
+    return lhs + rhs
 
-def compute_poly_vectorized(abscissa: np.ndarray) -> np.ndarray: ...
+
+def compute_poly_vectorized(abscissa: np.ndarray) -> np.ndarray:
+    return 3 * (abscissa**2) + 2 * abscissa + 1
 
 
 def get_mutual_l2_distances_vectorized(
     lhs: np.ndarray,
     rhs: np.ndarray,
-) -> np.ndarray: ...
+) -> np.ndarray:
+    if lhs.shape[-1] != rhs.shape[-1]:
+        raise ShapeMismatchError
+
+    d = lhs[:, np.newaxis, :] - rhs
+    return np.sqrt(np.sum(d**2, axis=2))
diff --git a/solutions/sem02/lesson03/task2.py b/solutions/sem02/lesson03/task2.py
index fc823c1d6..bde7700f3 100644
--- a/solutions/sem02/lesson03/task2.py
+++ b/solutions/sem02/lesson03/task2.py
@@ -9,11 +9,30 @@ def convert_from_sphere(
     distances: np.ndarray,
     azimuth: np.ndarray,
     inclination: np.ndarray,
-) -> tuple[np.ndarray, np.ndarray, np.ndarray]: ...
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    if not (distances.shape == azimuth.shape == inclination.shape):
+        raise ShapeMismatchError
+
+    z = distances * np.cos(inclination)
+    x = distances * np.sin(inclination) * np.cos(azimuth)
+    y = distances * np.sin(inclination) * np.sin(azimuth)
+
+    return x, y, z
 
 
 def convert_to_sphere(
     abscissa: np.ndarray,
     ordinates: np.ndarray,
     applicates: np.ndarray,
-) -> tuple[np.ndarray, np.ndarray, np.ndarray]: ...
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    x, y, z = abscissa, ordinates, applicates
+
+    if not (x.shape == y.shape == z.shape):
+        raise ShapeMismatchError
+
+    r = np.sqrt(x**2 + y**2 + z**2)
+    phi = np.arctan2(y, x)
+    r_xy = np.sqrt(x**2 + y**2)
+    theta = np.arctan2(r_xy, z)
+
+    return r, phi, theta
diff --git a/solutions/sem02/lesson03/task3.py b/solutions/sem02/lesson03/task3.py
index 477acd0ce..3fc85c4c2 100644
--- a/solutions/sem02/lesson03/task3.py
+++ b/solutions/sem02/lesson03/task3.py
@@ -3,4 +3,16 @@
 
 def get_extremum_indices(
     ordinates: np.ndarray,
-) -> tuple[np.ndarray, np.ndarray]: ...
+) -> tuple[np.ndarray, np.ndarray]:
+    if ordinates.size < 3:
+        raise ValueError
+
+    left = ordinates[:-2]
+    mid = ordinates[1:-1]
+    right = ordinates[2:]
+
+    max_e = (left < mid) & (mid > right)
+    min_e = (left > mid) & (mid < right)
+    ans = np.arange(1, ordinates.size - 1)
+
+    return ans[min_e], ans[max_e]
diff --git a/solutions/sem02/lesson04/task1.py b/solutions/sem02/lesson04/task1.py
index 1b5526c1f..6f469e803 100644
--- a/solutions/sem02/lesson04/task1.py
+++ b/solutions/sem02/lesson04/task1.py
@@ -2,16 +2,43 @@
 
 
 def pad_image(image: np.ndarray, pad_size: int) -> np.ndarray:
-    # ваш код
-    return image
+    if pad_size < 1:
+        raise ValueError
+
+    new_shape = list(image.shape)
+
+    new_shape[0] += 2 * pad_size
+    new_shape[1] += 2 * pad_size
+
+    ans = np.zeros(new_shape, dtype=image.dtype)
+
+    ans[pad_size : image.shape[0] + pad_size, pad_size : image.shape[1] + pad_size] = image
+
+    return ans
 
 
 def blur_image(
     image: np.ndarray,
     kernel_size: int,
 ) -> np.ndarray:
-    # ваш код
-    return image
+    if kernel_size % 2 == 0 or kernel_size < 1:
+        raise ValueError
+
+    N = image.shape[0]
+    M = image.shape[1]
+
+    pad_size = kernel_size // 2
+    if pad_size == 0:
+        return image
+
+    new_image = pad_image(image, pad_size)
+    sum_in_window = np.zeros(image.shape, dtype=np.float64)
+
+    for i in range(kernel_size):
+        for j in range(kernel_size):
+            sum_in_window += new_image[i : i + N, j : j + M]
+
+    return (sum_in_window / kernel_size**2).astype(np.uint8)
 
 
 if __name__ == "__main__":
diff --git a/solutions/sem02/lesson04/task2.py b/solutions/sem02/lesson04/task2.py
index be9a2288f..fd8ce2dcb 100644
--- a/solutions/sem02/lesson04/task2.py
+++ b/solutions/sem02/lesson04/task2.py
@@ -2,9 +2,34 @@
 
 
 def get_dominant_color_info(
-    image: np.ndarray[np.uint8],
+    image: np.ndarray,
     threshold: int = 5,
 ) -> tuple[np.uint8, float]:
-    # ваш код
+    if threshold < 1:
+        raise ValueError("threshold must be positive")
 
-    return 0, 0
+    image = image.ravel()
+    counts = np.zeros(256, dtype=np.int64)
+
+    for color in range(256):
+        counts[color] = np.sum(image == color)
+
+    cnt_colors = np.zeros(257, dtype=np.int64)
+    cnt_colors[1:] = np.cumsum(counts)
+
+    max_sum, color_for_ans = -1.0, 0
+
+    for curr_color in range(256):
+        if counts[curr_color] == 0:
+            continue
+
+        left = max(0, curr_color - threshold + 1)
+        right = min(255, curr_color + threshold - 1)
+
+        curr_sum = float(cnt_colors[right + 1] - cnt_colors[left])
+
+        if curr_sum > max_sum:
+            max_sum = curr_sum
+            color_for_ans = curr_color
+
+    return np.uint8(color_for_ans), (max_sum / image.size) * 100
diff --git a/solutions/sem02/lesson05/task1.py b/solutions/sem02/lesson05/task1.py
index e9c7c3c56..fb09b25cc 100644
--- a/solutions/sem02/lesson05/task1.py
+++ b/solutions/sem02/lesson05/task1.py
@@ -9,4 +9,8 @@ def can_satisfy_demand(
     costs: np.ndarray,
     resource_amounts: np.ndarray,
     demand_expected: np.ndarray,
-) -> bool: ...
+) -> bool:
+    if costs.shape != (resource_amounts.size, demand_expected.size):
+        raise ShapeMismatchError
+
+    return np.all(np.sum(costs * demand_expected, axis=1) <= resource_amounts)
diff --git a/solutions/sem02/lesson05/task2.py b/solutions/sem02/lesson05/task2.py
index be1fb9d2b..8219851b4 100644
--- a/solutions/sem02/lesson05/task2.py
+++ b/solutions/sem02/lesson05/task2.py
@@ -8,4 +8,19 @@ class ShapeMismatchError(Exception):
 def get_projections_components(
     matrix: np.ndarray,
     vector: np.ndarray,
-) -> tuple[np.ndarray | None, np.ndarray | None]: ...
+) -> tuple[np.ndarray | None, np.ndarray | None]:
+    if matrix.shape[0] != matrix.shape[1]:
+        raise ShapeMismatchError
+
+    if matrix.shape[1] != vector.shape[0]:
+        raise ShapeMismatchError
+
+    if np.linalg.matrix_rank(matrix) != matrix.shape[0]:
+        return (None, None)
+
+    dot_pr = (matrix @ vector).reshape(-1, 1)
+    abs_ma = abs(np.sum(matrix**2, axis=1)).reshape(-1, 1)
+    ort_pr = (dot_pr / abs_ma) * matrix
+    ort_comp = vector - ort_pr
+
+    return (ort_pr, ort_comp)
diff --git a/solutions/sem02/lesson05/task3.py b/solutions/sem02/lesson05/task3.py
index 0c66906cb..f7b5bfb11 100644
--- a/solutions/sem02/lesson05/task3.py
+++ b/solutions/sem02/lesson05/task3.py
@@ -9,4 +9,14 @@ def adaptive_filter(
     Vs: np.ndarray,
     Vj: np.ndarray,
     diag_A: np.ndarray,
-) -> np.ndarray: ...
+) -> np.ndarray:
+    if Vs.shape[0] != Vj.shape[0]:
+        raise ShapeMismatchError
+
+    if Vj.shape[1] != diag_A.size:
+        raise ShapeMismatchError
+
+    Vjh = np.conj(Vj).T
+    y = Vs - Vj @ np.linalg.solve(np.eye(Vj.shape[1]) + Vjh @ (Vj * diag_A), Vjh @ Vs)
+
+    return y
diff --git a/solutions/sem02/lesson07/task1.py b/solutions/sem02/lesson07/task1.py
index 3a505d89b..262f96538 100644
--- a/solutions/sem02/lesson07/task1.py
+++ b/solutions/sem02/lesson07/task1.py
@@ -1,8 +1,11 @@
+# %%
 from typing import Any
 
 import matplotlib.pyplot as plt
 import numpy as np
 
+plt.style.use("ggplot")
+
 
 class ShapeMismatchError(Exception):
     pass
@@ -13,8 +16,52 @@ def visualize_diagrams(
     ordinates: np.ndarray,
     diagram_type: Any,
 ) -> None:
-    # ваш код
-    pass
+    if abscissa.shape != ordinates.shape:
+        raise ShapeMismatchError
+
+    if diagram_type not in ["hist", "violin", "box"]:
+        raise ValueError
+
+    colors = ["#69b3a2", "#404080"]
+    labels = ["X data", "Y data"]
+
+    fig, ax = plt.subplots(figsize=(10, 6))
+
+    if diagram_type == "hist":
+        ax.hist(abscissa, bins=50, alpha=0.5, label=labels[0], color=colors[0])
+        ax.hist(ordinates, bins=50, alpha=0.5, label=labels[1], color=colors[1])
+        ax.set_title("Гистограмма распределений")
+
+    if diagram_type == "violin":
+        if diagram_type == "violin":
+            violin_parts = ax.violinplot([abscissa, ordinates], vert=False, showmedians=True)
+
+            for i, body in enumerate(violin_parts["bodies"]):
+                body.set_facecolor(colors[i])
+                body.set_edgecolor(colors[i])
+                body.set_alpha(0.6)
+
+            for part_name in violin_parts:
+                if part_name != "bodies":
+                    violin_parts[part_name].set_edgecolor(colors)
+                    violin_parts[part_name].set_linewidth(1.5)
+
+            violin_parts["cmedians"].set_linewidth(2.5)
+
+            ax.set_yticks([1, 2])
+            ax.set_yticklabels(labels)
+            ax.set_title("Плотность распределения")
+
+    if diagram_type == "box":
+        box_parts = ax.boxplot(
+            [abscissa, ordinates], labels=labels, vert=False, patch_artist=True, notch=True
+        )
+
+        for patch, color in zip(box_parts["boxes"], colors):
+            patch.set_facecolor(color)
+            patch.set_alpha(0.7)
+
+        ax.set_title("Анализ выбросов")
 
 
 if __name__ == "__main__":
@@ -25,4 +72,7 @@ def visualize_diagrams(
     abscissa, ordinates = np.random.multivariate_normal(mean, cov, size=1000).T
 
     visualize_diagrams(abscissa, ordinates, "hist")
+    visualize_diagrams(abscissa, ordinates, "violin")
+    visualize_diagrams(abscissa, ordinates, "box")
     plt.show()
+# %%
diff --git a/solutions/sem02/lesson07/task2.py b/solutions/sem02/lesson07/task2.py
index decd607ef..49bedde03 100644
--- a/solutions/sem02/lesson07/task2.py
+++ b/solutions/sem02/lesson07/task2.py
@@ -1 +1,41 @@
-# ваш код (используйте функции или классы для решения данной задачи)
+# %%
+import json
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def visualize_medic_data(f_path: str):
+    with open(f_path, "r") as f:
+        data = json.load(f)
+
+    plt.style.use("ggplot")
+    fig, ax = plt.subplots(figsize=(10, 6))
+
+    degrees_of_mitral_regurgitation = ["I", "II", "III", "IV"]
+
+    before_implant_installation = [data["before"].count(i) for i in degrees_of_mitral_regurgitation]
+    after_implant_installation = [data["after"].count(i) for i in degrees_of_mitral_regurgitation]
+
+    x = np.arange(len(degrees_of_mitral_regurgitation))
+
+    column1 = ax.bar(
+        x - 0.2, before_implant_installation, 0.4, label="До установки импланта", color="#69b3a2"
+    )
+    column2 = ax.bar(
+        x + 0.2, after_implant_installation, 0.4, label="После установки импланта", color="#404080"
+    )
+
+    ax.set_title("Эффективность импланта при митральной недостаточности")
+    ax.set_ylabel("Количество пациентов")
+    ax.set_xticks(x)
+    ax.set_xticklabels(degrees_of_mitral_regurgitation)
+    ax.legend()
+
+    ax.bar_label(column1)
+    ax.bar_label(column2)
+    plt.show()
+
+
+visualize_medic_data("medic_data.json")
+# %%
diff --git a/solutions/sem02/lesson08/task1.py b/solutions/sem02/lesson08/task1.py
index 89f88572f..b70a2199a 100644
--- a/solutions/sem02/lesson08/task1.py
+++ b/solutions/sem02/lesson08/task1.py
@@ -1,34 +1,81 @@
-from functools import partial
-
 import matplotlib.pyplot as plt
 import numpy as np
-
 from IPython.display import HTML
 from matplotlib.animation import FuncAnimation
 
 
+class SignalAnimator:
+    def __init__(self, modulation, fc, num_frames, plot_duration, animation_step) -> None:
+        self.modulation = modulation
+        self.fc = fc
+        self.plot_duration = plot_duration
+        self.animation_step = animation_step
+        self.fig, self.ax = plt.subplot()
+        (self.line,) = self.ax.plot([], [], lw=2, label="Сигнал")
+
+    def graphics_design(self):
+        self.ax.set_title("Анимация модулированного сигнала")
+        self.ax.set_xlim(0, self.plot_duration)
+        self.ax.set_xlabel("Время (с)")
+        self.ax.set_ylim(-2, 2)
+        self.ax.set_ylabel("Амплитуда")
+        self.ax.legend()
+
+    def modulated_signal_formula(self, points):
+        return self.modulation(points) * np.cos(2 * np.pi * fc * points)
+
+    def frame_update(self, frame):
+        start_time = frame * self.animation_step
+        end_time = start_time + plot_duration
+
+        points = np.linspace(start_time, end_time, 1000)
+        signal = self.modulation(points) * np.cos(2 * np.pi * fc * points)
+        self.line.set_data(points, signal)
+        self.ax.set_xlim(start_time, end_time)
+        return self.line
+
+
 def create_modulation_animation(
-    modulation, 
-    fc, 
-    num_frames, 
-    plot_duration, 
-    time_step=0.001, 
-    animation_step=0.01,
-    save_path=""
+    modulation, fc, num_frames, plot_duration, time_step=0.001, animation_step=0.01, save_path=""
 ) -> FuncAnimation:
-    # ваш код
-    return FuncAnimation()
+    fig, ax = plt.subplots()
+    ax.set_title("Анимация модулированного сигнала")
+    (line,) = ax.plot([], [], lw=2)
+
+    x = np.linspace(0, 10, 1000)
+    y = np.cos(x)
+
+    line.set_data(x, y)
+
+    ax.set_xlim(0, plot_duration)
+    ax.set_xlabel("Время (с)")
+    ax.set_ylim(-2, 2)
+    ax.set_ylabel("Амплитуда")
+    ax.legend(["Сигнал"])
+
+    def update(frame):
+        start_time = frame * animation_step
+        end_time = start_time + plot_duration
+
+        points = np.linspace(start_time, end_time, 1000)
+        signal = modulation(points) * np.cos(2 * np.pi * fc * points)
+        line.set_data(points, signal)
+        ax.set_xlim(start_time, end_time)
+        return line
+
+    return FuncAnimation(fig, update, frames=num_frames, interval=30)
 
 
 if __name__ == "__main__":
+
     def modulation_function(t):
-        return np.cos(t * 6) 
+        return np.cos(t * 6)
 
-    num_frames = 100  
-    plot_duration = np.pi / 2 
-    time_step = 0.001  
-    animation_step = np.pi / 200 
-    fc = 50  
+    num_frames = 200
+    plot_duration = np.pi / 2
+    time_step = 0.01
+    animation_step = np.pi / 200
+    fc = 50
     save_path_with_modulation = "modulated_signal.gif"
 
     animation = create_modulation_animation(
@@ -38,6 +85,8 @@ def modulation_function(t):
         plot_duration=plot_duration,
         time_step=time_step,
         animation_step=animation_step,
-        save_path=save_path_with_modulation
+        save_path=save_path_with_modulation,
     )
-    HTML(animation.to_jshtml())
\ No newline at end of file
+    HTML(animation.to_jshtml())
+
+    plt.show()
diff --git a/solutions/sem02/lesson08/task2.py b/solutions/sem02/lesson08/task2.py
index b677c0702..906b74de2 100644
--- a/solutions/sem02/lesson08/task2.py
+++ b/solutions/sem02/lesson08/task2.py
@@ -1,53 +1,96 @@
-from functools import partial
-
 import matplotlib.pyplot as plt
 import numpy as np
-
-from IPython.display import HTML
 from matplotlib.animation import FuncAnimation
+from matplotlib.colors import ListedColormap
+
+
+def bfs(maze, start, end):
+    rows, cols = maze.shape
+    parents = {start: None}
+    levels = [{start}]
+
+    while levels[-1] and (end not in levels[-1]):
+        next_level = set()
+        for x, y in levels[-1]:
+            for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]:
+                new_x, new_y = x + dx, y + dy
+                if (
+                    (0 <= new_x < rows and 0 <= new_y < cols)
+                    and (maze[new_x, new_y] != 0)
+                    and ((new_x, new_y) not in parents)
+                ):
+                    parents[(new_x, new_y)] = (x, y)
+                    next_level.add((new_x, new_y))
+        if not next_level:
+            break
+        levels.append(next_level)
+
+    path = []
+    cur = end if end in parents else None
+    while cur is not None:
+        path.append(cur)
+        cur = parents[cur]
+    path.reverse()
+
+    return levels, path
 
 
+def animate_wave_algorithm(maze, start, end, save_path=""):
+    rows, cols = maze.shape
+    levels, path = bfs(maze, start, end)
 
+    fig, ax = plt.subplots(figsize=(5, 5))
+    ax.imshow(maze, cmap=ListedColormap(["hotpink", "lavenderblush"]))
+    ax.set(xticks=[], yticks=[])
+    ax.set_xticks(np.arange(-0.5, cols), minor=True)
+    ax.set_yticks(np.arange(-0.5, rows), minor=True)
+    ax.grid(which="minor", color="hotpink", linewidth=0.5)
+
+    (dots,) = ax.plot(
+        [], [], "o", color="white", markersize=22, markeredgecolor="hotpink", markeredgewidth=2
+    )
+    (line,) = ax.plot([], [], "-", color="hotpink", linewidth=5)
+
+    def update(i):
+        if i < len(levels):
+            cells = levels[i]
+            dots.set_data([c for r, c in cells], [r for r, c in cells])
+            line.set_data([], [])
+        else:
+            dots.set_data([], [])
+            line.set_data([c for r, c in path], [r for r, c in path])
+        return dots, line
+
+    anim = FuncAnimation(
+        fig, update, frames=len(levels) + 15, interval=400, blit=False, repeat=False
+    )
+    if save_path:
+        anim.save(save_path, writer="pillow", fps=3)
+    return anim
 
-def animate_wave_algorithm(
-    maze: np.ndarray, 
-    start: tuple[int, int], 
-    end: tuple[int, int], 
-    save_path: str = ""
-)  -> FuncAnimation:
-    # ваш код
-    return FuncAnimation()
 
 if __name__ == "__main__":
-    # Пример 1
-    maze = np.array([
-        [0, 0, 0, 0, 0, 0, 0],
-        [0, 1, 1, 1, 1, 1, 0],
-        [1, 1, 0, 1, 0, 1, 0],
-        [0, 0, 1, 1, 0, 1, 0],
-        [0, 0, 0, 0, 0, 1, 0],
-        [1, 1, 1, 1, 1, 1, 0],
-        [0, 0, 0, 0, 0, 0, 0],
-    ])
-
-    start = (2, 0)
-    end = (5, 0)
-    save_path = "labyrinth.gif"  # Укажите путь для сохранения анимации
-
-    animation = animate_wave_algorithm(maze, start, end, save_path)
-    HTML(animation.to_jshtml())
-    
-    # Пример 2
-    
-    maze_path = "./data/maze.npy"
-    loaded_maze = np.load(maze_path)
-
-    # можете поменять, если захотите запустить из других точек
-    start = (2, 0)
-    end = (5, 0)
-    loaded_save_path = "loaded_labyrinth.gif"
-
-    loaded_animation = animate_wave_algorithm(loaded_maze, start, end, loaded_save_path)
-    HTML(loaded_animation.to_jshtml())
-    
-    
\ No newline at end of file
+    maze_small = np.array(
+        [
+            [0, 0, 0, 0, 0, 0, 0],
+            [0, 1, 1, 1, 1, 1, 0],
+            [1, 1, 0, 1, 0, 1, 0],
+            [0, 0, 1, 1, 0, 1, 0],
+            [0, 0, 0, 0, 0, 1, 0],
+            [1, 1, 1, 1, 1, 1, 0],
+            [0, 0, 0, 0, 0, 0, 0],
+        ]
+    )
+
+    animate_wave_algorithm(maze_small, start=(2, 0), end=(5, 0), save_path="labyrinth.gif")
+
+    loaded_maze = np.load(
+        "/Users/varvara/Developer/python_mipt_dafe_tasks/solutions/sem02/lesson08/data/maze.npy"
+    )
+    print("Размер загруженного лабиринта:", loaded_maze.shape)
+
+    animate_wave_algorithm(
+        loaded_maze, start=(18, 1), end=(37, 21), save_path="loaded_labyrinth.gif"
+    )
+
+    plt.show()
diff --git a/solutions/sem02/lesson08/tempCodeRunnerFile.py b/solutions/sem02/lesson08/tempCodeRunnerFile.py
new file mode 100644
index 000000000..e69de29bb