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..07d128052 100644
--- a/deprecated_tests/sem01/tests/test_lesson04_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson04_tasks.py
@@ -1,4 +1,4 @@
-import pytest 
+import pytest
 import random
 
 from solutions.sem01.lesson04.task1 import is_arithmetic_progression
@@ -8,62 +8,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 +98,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..f2f6a282b 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,122 @@
 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..0284e8233 100644
--- a/deprecated_tests/sem01/tests/test_lesson08_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson08_tasks.py
@@ -1,10 +1,11 @@
-import pytest 
+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 +16,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 +29,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 +40,7 @@ def func1() -> None:
     @collect_statistic(statistics)
     def func2() -> None:
         time.sleep(0.1)
-    
+
     for _ in range(3):
         func1()
 
@@ -58,10 +61,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 +80,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..16f3d70f1 100644
--- a/deprecated_tests/sem01/tests/test_lesson11_tasks.py
+++ b/deprecated_tests/sem01/tests/test_lesson11_tasks.py
@@ -84,13 +84,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..6f53b96eb 100644
--- a/deprecated_tests/sem01/tests_hw/test_hw1_tasks.py
+++ b/deprecated_tests/sem01/tests_hw/test_hw1_tasks.py
@@ -11,7 +11,8 @@
     TESTCASE_IDS,
 )
 
-NAME_BACKOFF_MODULE = "homeworks.hw1.backoff" # название модуля с backoff
+NAME_BACKOFF_MODULE = "homeworks.hw1.backoff"  # название модуля с backoff
+
 
 def test_valid_segments() -> None:
     """Тест: валидные сегменты."""
@@ -32,53 +33,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 +89,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 +99,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 +110,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 +119,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 +136,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/labyrinth.gif b/labyrinth.gif
new file mode 100644
index 000000000..96f2607be
Binary files /dev/null and b/labyrinth.gif differ
diff --git a/modulated_signal.gif b/modulated_signal.gif
new file mode 100644
index 000000000..b1d8e8df7
Binary files /dev/null and b/modulated_signal.gif differ
diff --git a/requirements-ci.txt b/requirements-ci.txt
index 581b008d7..9f6047f2d 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
+numpy
+pandas
 
 pytest==8.4.2
 pytest-cov==7.0.0
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..c02bc2a16 100644
--- a/solutions/sem01/lesson06/task3.py
+++ b/solutions/sem01/lesson06/task3.py
@@ -2,6 +2,6 @@ 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..d101344c1 100644
--- a/solutions/sem01/lesson08/task2.py
+++ b/solutions/sem01/lesson08/task2.py
@@ -2,9 +2,8 @@
 
 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/sem02/lesson03/task1.py b/solutions/sem02/lesson03/task1.py
index 2c3fc0b58..111423741 100644
--- a/solutions/sem02/lesson03/task1.py
+++ b/solutions/sem02/lesson03/task1.py
@@ -8,13 +8,21 @@ class ShapeMismatchError(Exception):
 def sum_arrays_vectorized(
     lhs: np.ndarray,
     rhs: np.ndarray,
-) -> np.ndarray: ...
+) -> np.ndarray:
+    if lhs.size != rhs.size:
+        raise ShapeMismatchError
+    return lhs + rhs
 
 
-def compute_poly_vectorized(abscissa: np.ndarray) -> np.ndarray: ...
+def compute_poly_vectorized(abscissa: np.ndarray) -> np.ndarray:
+    return ((abscissa**2) * 3 + abscissa * 2) + 1
 
 
 def get_mutual_l2_distances_vectorized(
     lhs: np.ndarray,
     rhs: np.ndarray,
-) -> np.ndarray: ...
+) -> np.ndarray:
+    if len(lhs) != len(rhs):
+        raise ShapeMismatchError
+
+    return (np.sqrt(np.sum((lhs[:, np.newaxis, :] - rhs) ** 2, axis=2))).tolist()
diff --git a/solutions/sem02/lesson03/task2.py b/solutions/sem02/lesson03/task2.py
index fc823c1d6..a4c359007 100644
--- a/solutions/sem02/lesson03/task2.py
+++ b/solutions/sem02/lesson03/task2.py
@@ -9,11 +9,34 @@ 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
+
+    return (
+        distances * np.sin(inclination) * np.cos(azimuth),
+        distances * np.sin(inclination) * np.sin(azimuth),
+        distances * np.cos(inclination),
+    )
 
 
 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]:
+    if not (abscissa.shape == ordinates.shape == applicates.shape):
+        raise ShapeMismatchError
+
+    r = np.sqrt(abscissa**2 + ordinates**2 + applicates**2)
+
+    phi = np.arctan2(ordinates, abscissa)
+
+    teta = np.zeros(r.shape)
+    mask = r != 0
+    teta[mask] = np.arccos(applicates[mask] / r[mask])
+
+    return (r, phi, teta)
+
+
+print(convert_to_sphere(np.zeros(2), np.zeros(2), np.zeros(2)))
diff --git a/solutions/sem02/lesson03/task3.py b/solutions/sem02/lesson03/task3.py
index 477acd0ce..ba453f330 100644
--- a/solutions/sem02/lesson03/task3.py
+++ b/solutions/sem02/lesson03/task3.py
@@ -3,4 +3,18 @@
 
 def get_extremum_indices(
     ordinates: np.ndarray,
-) -> tuple[np.ndarray, np.ndarray]: ...
+) -> tuple[np.ndarray, np.ndarray]:
+    if ordinates.size < 3:
+        raise ValueError
+
+    num_left = ordinates[:-2]
+    num_right = ordinates[2:]
+    num = ordinates[1:-1]
+
+    mask_max = (num > num_left) & (num > num_right)
+    mask_min = (num < num_left) & (num < num_right)
+
+    index_max = np.arange(1, len(ordinates) - 1)[mask_max]
+    index_min = np.arange(1, len(ordinates) - 1)[mask_min]
+
+    return index_min, index_max
diff --git a/solutions/sem02/lesson04/requirements.txt b/solutions/sem02/lesson04/requirements.txt
index 039f1d503..de11c1b8b 100644
--- a/solutions/sem02/lesson04/requirements.txt
+++ b/solutions/sem02/lesson04/requirements.txt
@@ -1,3 +1,3 @@
-matplotlib==3.8.0
-numpy==1.26.1
-opencv-python-headless==4.9.0.80
+matplotlib
+numpy
+opencv-python-headles
\ No newline at end of file
diff --git a/solutions/sem02/lesson04/task1.py b/solutions/sem02/lesson04/task1.py
index 1b5526c1f..4357670cd 100644
--- a/solutions/sem02/lesson04/task1.py
+++ b/solutions/sem02/lesson04/task1.py
@@ -2,16 +2,48 @@
 
 
 def pad_image(image: np.ndarray, pad_size: int) -> np.ndarray:
-    # ваш код
-    return image
+    if pad_size < 1:
+        raise ValueError
+
+    if image.ndim == 2:
+        height, width = image.shape
+        pad_height, pad_width = height + pad_size * 2, pad_size * 2 + width
+
+        pad = np.zeros(shape=(pad_height, pad_width), dtype=image.dtype)
+        pad[pad_size : pad_size + height, pad_size : pad_size + width] = image
+        return pad
+
+    if image.ndim == 3:
+        height, width, channels = image.shape
+        pad_height, pad_width = height + pad_size * 2, pad_size * 2 + width
+
+        pad = np.zeros(shape=(pad_height, pad_width, channels), dtype=image.dtype)
+        pad[pad_size : pad_size + height, pad_size : pad_size + width, :] = image
+        return pad
 
 
 def blur_image(
     image: np.ndarray,
     kernel_size: int,
 ) -> np.ndarray:
-    # ваш код
-    return image
+    if kernel_size % 2 == 0 or kernel_size < 1:
+        raise ValueError
+
+    padd_image = pad_image(image, kernel_size // 2)
+
+    res = np.zeros(image.shape, dtype=image.dtype)
+    height, width = image.shape[:2]
+
+    for i in range(height):
+        for j in range(width):
+            if image.ndim == 2:
+                kernel = padd_image[i : i + kernel_size, j : j + kernel_size]
+                res[i, j] = np.mean(kernel)
+            else:
+                kernel = padd_image[i : i + kernel_size, j : j + kernel_size, :]
+                res[i, j, :] = np.mean(kernel, axis=(0, 1))
+
+    return res.astype(image.dtype)
 
 
 if __name__ == "__main__":
diff --git a/solutions/sem02/lesson04/task2.py b/solutions/sem02/lesson04/task2.py
index be9a2288f..5addb8af1 100644
--- a/solutions/sem02/lesson04/task2.py
+++ b/solutions/sem02/lesson04/task2.py
@@ -5,6 +5,25 @@ def get_dominant_color_info(
     image: np.ndarray[np.uint8],
     threshold: int = 5,
 ) -> tuple[np.uint8, float]:
-    # ваш код
 
-    return 0, 0
+    if threshold < 1:
+        raise ValueError
+
+    max_count = -1
+    often_color = 0
+    image_int = image.astype(int)
+
+    for color in range(256):
+        check_mask = image == color
+        if not np.any(check_mask):
+            continue
+
+        count_color = np.sum((np.abs(image_int - color)) < threshold)
+
+        if count_color > max_count:
+            max_count = count_color
+            often_color = color
+
+    procent = max_count / image.size
+
+    return (np.uint8(often_color), float(procent))
diff --git a/solutions/sem02/lesson05/task1.py b/solutions/sem02/lesson05/task1.py
index e9c7c3c56..3cdfe135f 100644
--- a/solutions/sem02/lesson05/task1.py
+++ b/solutions/sem02/lesson05/task1.py
@@ -9,4 +9,14 @@ def can_satisfy_demand(
     costs: np.ndarray,
     resource_amounts: np.ndarray,
     demand_expected: np.ndarray,
-) -> bool: ...
+) -> bool:
+
+    M, N = costs.shape
+
+    if resource_amounts.size != M or demand_expected.size != N:
+        raise ShapeMismatchError
+
+    need_resurses = costs @ demand_expected
+    check_mask = need_resurses <= resource_amounts
+
+    return np.all(check_mask)
diff --git a/solutions/sem02/lesson05/task2.py b/solutions/sem02/lesson05/task2.py
index be1fb9d2b..358cfef7b 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]:
+    rows, coloms = matrix.shape
+
+    if rows != coloms:
+        raise ShapeMismatchError
+    if coloms != vector.size:
+        raise ShapeMismatchError
+
+    if np.linalg.matrix_rank(matrix) != rows:
+        return (None, None)
+
+    coeff = ((matrix @ vector) / np.sum(matrix**2, axis=1))[:, np.newaxis]
+    projections = coeff * matrix
+    components = vector - projections
+
+    return projections, components
diff --git a/solutions/sem02/lesson05/task3.py b/solutions/sem02/lesson05/task3.py
index 0c66906cb..70a99748e 100644
--- a/solutions/sem02/lesson05/task3.py
+++ b/solutions/sem02/lesson05/task3.py
@@ -9,4 +9,21 @@ def adaptive_filter(
     Vs: np.ndarray,
     Vj: np.ndarray,
     diag_A: np.ndarray,
-) -> np.ndarray: ...
+) -> np.ndarray:
+
+    Vj_H = Vj.conj().T
+
+    M, K = Vj.shape
+
+    if Vs.shape[0] != M:
+        raise ShapeMismatchError
+
+    if diag_A.size != K:
+        raise ShapeMismatchError
+
+    part_inner = np.eye(K, dtype=complex) + (Vj_H @ Vj) * diag_A
+    part_inner_invert = np.linalg.inv(part_inner)
+    part_out = part_out = Vj_H @ Vs
+    y = Vs - Vj @ (part_inner_invert @ part_out)
+
+    return y
diff --git a/solutions/sem02/lesson07/medic_info.png b/solutions/sem02/lesson07/medic_info.png
new file mode 100644
index 000000000..cde7b96b2
Binary files /dev/null and b/solutions/sem02/lesson07/medic_info.png differ
diff --git a/solutions/sem02/lesson07/plot.png b/solutions/sem02/lesson07/plot.png
new file mode 100644
index 000000000..4f5a63f4c
Binary files /dev/null and b/solutions/sem02/lesson07/plot.png differ
diff --git a/solutions/sem02/lesson07/task1.py b/solutions/sem02/lesson07/task1.py
index 3a505d89b..a1455ad89 100644
--- a/solutions/sem02/lesson07/task1.py
+++ b/solutions/sem02/lesson07/task1.py
@@ -1,5 +1,8 @@
 from typing import Any
 
+import matplotlib
+
+matplotlib.use("Agg")
 import matplotlib.pyplot as plt
 import numpy as np
 
@@ -13,8 +16,87 @@ def visualize_diagrams(
     ordinates: np.ndarray,
     diagram_type: Any,
 ) -> None:
-    # ваш код
-    pass
+
+    if diagram_type not in {"box", "violin", "hist"}:
+        raise ValueError
+    if abscissa.shape != ordinates.shape:
+        raise ShapeMismatchError
+
+    space = 0.2
+    figure = plt.figure(figsize=(8, 8))
+    grid = plt.GridSpec(4, 4, wspace=space, hspace=space)
+
+    axis_scatter = figure.add_subplot(grid[:-1, 1:])
+
+    axis_vert = figure.add_subplot(
+        grid[:-1, 0],
+        sharey=axis_scatter,
+    )
+
+    axis_hor = figure.add_subplot(
+        grid[-1, 1:],
+        sharex=axis_scatter,
+    )
+
+    axis_scatter.scatter(abscissa, ordinates, color="darkred", alpha=0.5)
+
+    if diagram_type == "hist":
+        axis_hor.hist(
+            abscissa,
+            bins=100,
+            color="orange",
+            density=True,
+            alpha=0.5,
+        )
+        axis_vert.hist(
+            ordinates,
+            orientation="horizontal",
+            bins=100,
+            color="red",
+            density=True,
+            alpha=0.5,
+        )
+
+        axis_hor.invert_yaxis()
+        axis_vert.invert_xaxis()
+
+    elif diagram_type == "box":
+        axis_hor.boxplot(
+            abscissa,
+            vert=False,
+            patch_artist=True,
+            boxprops=dict(facecolor="yellow", color="orange"),
+            medianprops=dict(color="red"),
+        )
+        axis_vert.boxplot(
+            ordinates,
+            patch_artist=True,
+            boxprops=dict(facecolor="yellow", color="orange"),
+            medianprops=dict(color="red"),
+        )
+
+        axis_hor.invert_yaxis()
+        axis_vert.invert_xaxis()
+
+    else:
+        v_hor = axis_hor.violinplot(abscissa, vert=False)
+        v_vert = axis_vert.violinplot(ordinates, vert=True)
+
+        for v in [v_hor, v_vert]:
+            for body in v["bodies"]:
+                body.set_facecolor("red")
+                body.set_edgecolor("darkred")
+                body.set_alpha(0.5)
+
+        for v in [v_hor, v_vert]:
+            for part in v:
+                if part == "bodies":
+                    continue
+
+                v[part].set_edgecolor("red")
+
+    axis_hor.invert_yaxis()
+    axis_vert.invert_xaxis()
 
 
 if __name__ == "__main__":
@@ -24,5 +106,8 @@ def visualize_diagrams(
 
     abscissa, ordinates = np.random.multivariate_normal(mean, cov, size=1000).T
 
+    plt.style.use("ggplot")
     visualize_diagrams(abscissa, ordinates, "hist")
-    plt.show()
+
+    plt.savefig("plot.png")
+    # plt.show()
diff --git a/solutions/sem02/lesson07/task2.py b/solutions/sem02/lesson07/task2.py
index decd607ef..22943166c 100644
--- a/solutions/sem02/lesson07/task2.py
+++ b/solutions/sem02/lesson07/task2.py
@@ -1 +1,54 @@
-# ваш код (используйте функции или классы для решения данной задачи)
+import matplotlib
+
+matplotlib.use("Agg")
+import json
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def get_info(file: str):
+    with open(file, "r") as f:
+        info = json.load(f)
+
+    before = np.array(info["before"])
+    after = np.array(info["after"])
+    return before, after
+
+
+classes = ["I", "II", "III", "IV"]
+
+befor, after = get_info("data/medic_data.json")
+
+sum_befor, sum_after = {}, {}
+for class_ in classes:
+    sum_befor[class_] = np.sum(befor == class_)
+    sum_after[class_] = np.sum(after == class_)
+
+
+figure, axis = plt.subplots(figsize=(16, 9))
+axis: plt.Axes
+
+plt.style.use("ggplot")
+
+x = np.arange(len(classes))
+width = 0.4
+
+bar1 = axis.bar(
+    x - width / 2, sum_befor.values(), width, label="Before", color="cadetblue", edgecolor="grey"
+)
+
+bar2 = axis.bar(
+    x + width / 2, sum_after.values(), width, label="After", color="lightcoral", edgecolor="grey"
+)
+
+axis.set_title("Mitral disease stages", fontsize=12, fontweight="bold", color="grey")
+axis.set_ylabel("amount of people", fontsize=10, fontweight="bold", color="grey")
+
+axis.set_xticks(x)
+axis.set_xticklabels(classes, fontweight="bold")
+
+
+axis.legend()
+plt.savefig("medic_info.png")
+# plt.show()
diff --git a/solutions/sem02/lesson08/task1.py b/solutions/sem02/lesson08/task1.py
index 89f88572f..b05bf79dc 100644
--- a/solutions/sem02/lesson08/task1.py
+++ b/solutions/sem02/lesson08/task1.py
@@ -1,5 +1,9 @@
 from functools import partial
 
+import matplotlib
+
+matplotlib.use("Agg")
+
 import matplotlib.pyplot as plt
 import numpy as np
 
@@ -7,28 +11,85 @@
 from matplotlib.animation import FuncAnimation
 
 
+def signal(abscissa, fc, modulation):
+    if modulation:
+        m_t = modulation(abscissa)
+    else:
+        m_t = 1.0
+    return m_t * np.sin(2 * np.pi * fc * abscissa)
+
+
+def update(num_frame, line, fc, modulation, plot_duration, time_step, animation_step):
+
+    t_start = num_frame * animation_step
+    t_end = t_start + plot_duration
+
+    abscissa = np.arange(t_start, t_end, time_step)
+    ordinates = signal(abscissa, fc, modulation)
+
+    line.set_xdata(abscissa - t_start)
+    line.set_ydata(ordinates)
+    return [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()
+
+    figure, axis = plt.subplots(figsize=(16, 9))
+    axis: plt.Axes
+
+    abscissa = np.arange(0, plot_duration, time_step)
+    ordinates = signal(abscissa, fc, modulation=modulation)
+
+    axis.set_ylim(ordinates.min() * 1, 25, ordinates.max() * 1, 25)
+    axis.set_xlim(0, plot_duration)
+
+    line, *_ = axis.plot(
+        abscissa,
+        ordinates,
+        c="red",
+        label="Сигнал",
+    )
+
+    axis.set_xlabel("Время (с)", fontsize=14)
+    axis.set_ylabel("Амплитуда", fontsize=14)
+    axis.set_title("Визуализация модулированного сигнала", fontsize=20, fontweight="bold")
+
+    axis.legend(fontsize=12)
+
+    animation = FuncAnimation(
+        figure,
+        partial(
+            update,
+            line=line,
+            fc=fc,
+            modulation=modulation,
+            plot_duration=plot_duration,
+            time_step=time_step,
+            animation_step=animation_step,
+        ),
+        num_frames,
+        interval=50,
+        blit=True,
+    )
+
+    if save_path:
+        animation.save(save_path, writer="pillow", fps=24)
+
+    return animation
 
 
 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 = 100
+    plot_duration = np.pi / 2
+    time_step = 0.001
+    animation_step = np.pi / 200
+    fc = 50
     save_path_with_modulation = "modulated_signal.gif"
 
     animation = create_modulation_animation(
@@ -38,6 +99,6 @@ 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())
diff --git a/solutions/sem02/lesson08/task2.py b/solutions/sem02/lesson08/task2.py
index b677c0702..37f99e642 100644
--- a/solutions/sem02/lesson08/task2.py
+++ b/solutions/sem02/lesson08/task2.py
@@ -1,5 +1,9 @@
 from functools import partial
 
+import matplotlib
+
+matplotlib.use("Agg")
+
 import matplotlib.pyplot as plt
 import numpy as np
 
@@ -7,28 +11,130 @@
 from matplotlib.animation import FuncAnimation
 
 
+def update(rows, cols, texts, frame):
+    new = []
+
+    for i in range(rows):
+        for j in range(cols):
+            if frame[i, j] >= 0:
+                new_text = str(int(frame[i, j]))
+            else:
+                new_text = ""
+
+            if texts[i][j].get_text() != new_text:
+                texts[i][j].set_text(new_text)
+                new.append(texts[i][j])
+
+    return new
 
 
 def animate_wave_algorithm(
-    maze: np.ndarray, 
-    start: tuple[int, int], 
-    end: tuple[int, int], 
-    save_path: str = ""
-)  -> FuncAnimation:
-    # ваш код
-    return FuncAnimation()
+    maze: np.ndarray, start: tuple[int, int], end: tuple[int, int], save_path: str = ""
+) -> FuncAnimation:
+
+    rows, cols = maze.shape
+    dist = np.full((rows, cols), -1)
+    frames = []
+
+    dist[start] = 0
+    now_front = [start]
+
+    directions = [(-1, 0), (1, 0), (0, -1), (0, 1)]
+
+    step = 0
+
+    while now_front:
+        frames.append(dist.copy())
+        next_front = []
+
+        for x, y in now_front:
+            if (x, y) == end:
+                now_front = []
+                break
+
+            for dx, dy in directions:
+                nx, ny = x + dx, y + dy
+
+                if 0 <= nx < rows and 0 <= ny < cols and maze[nx, ny] == 1 and dist[nx, ny] == -1:
+                    dist[nx, ny] = step + 1
+                    next_front.append((nx, ny))
+
+        now_front = next_front
+        step += 1
+
+    path = []
+    if dist[end] != -1:
+        c = end
+        path.append(c)
+
+        while c != start:
+            x, y = c
+            for dx, dy in directions:
+                nx, ny = x + dx, y + dy
+                if 0 <= nx < rows and 0 <= ny < cols and dist[nx, ny] == dist[x, y] - 1:
+                    c = (nx, ny)
+                    path.append(c)
+                    break
+        path.reverse()
+
+    if path:
+        final = dist.copy()
+        for x, y in path:
+            final[x, y] = np.max(final) + 2
+        frames.append(final)
+
+    fig, ax = plt.subplots()
+
+    base = np.zeros_like(maze, dtype=float)
+    base[maze == 0] = 1
+
+    img = ax.imshow(base, cmap="gray")
+
+    ax.set_xticks(np.arange(-0.5, cols, 1), minor=True)
+    ax.set_yticks(np.arange(-0.5, rows, 1), minor=True)
+    ax.grid(which="minor", color="black", linewidth=2)
+
+    ax.set_xticks([])
+    ax.set_yticks([])
+
+    ax.set_title("Волновой алгоритм")
+
+    texts = []
+    for i in range(rows):
+        row = []
+        for j in range(cols):
+            t = ax.text(j, i, "", color="blue", fontsize=14, fontweight="bold")
+            row.append(t)
+        texts.append(row)
+
+    animation = FuncAnimation(
+        fig,
+        partial(update, rows, cols, texts),
+        frames=frames,
+        interval=300,
+        blit=True,
+        repeat=False,
+    )
+
+    if save_path:
+        animation.save(save_path, writer="pillow", fps=24)
+
+    return animation
+
 
 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],
-    ])
+    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)
@@ -36,9 +142,9 @@ def animate_wave_algorithm(
 
     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)
 
@@ -49,5 +155,3 @@ def animate_wave_algorithm(
 
     loaded_animation = animate_wave_algorithm(loaded_maze, start, end, loaded_save_path)
     HTML(loaded_animation.to_jshtml())
-    
-    
\ No newline at end of file