diff --git a/.coverage b/.coverage
new file mode 100644
index 00000000..743d4a5e
Binary files /dev/null and b/.coverage differ
diff --git a/deprecated_tests/sem01/tests/test_lesson02_tasks.py b/deprecated_tests/sem01/tests/test_lesson02_tasks.py
index f11403f4..b7febe4b 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 4110bdcc..c98b6f22 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 72ad6bc8..a43a2a45 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 707d6609..f2f6a282 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 962ba4bd..06f04319 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 d0cd02ef..941eed77 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 0ecf8a10..c600f76d 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 37d249b7..81312dea 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 aeb37ebc..4cc9188d 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/sem01/hw1/backoff.py b/homeworks/sem01/hw1/backoff.py
index 696ffa73..a3373a98 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/solutions/sem01/lesson02/task3.py b/solutions/sem01/lesson02/task3.py
index ee2a84ec..e997f805 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 f1d8fe26..7b048e65 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 a3a738c2..5cf2b631 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 47384423..0135e399 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 4591d0a3..5d6f8ee8 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 b21bc5a3..2664384d 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 02d7742b..ec6932ee 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 16df27ca..d16e77dd 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 9a17211e..fdf3b548 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 36750380..c70b4029 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 4c4e9086..7c2c26f1 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 076c5bb6..da9e6d08 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 1b914ada..63207797 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 2d1e30e9..353cb361 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 f535b5a0..f1034e24 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 7449a1e7..b160d615 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 5b75a110..95a7098e 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 4390f6c8..7fa724ef 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 6e4af870..cc2ae430 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 64c112cc..58b0986e 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 2c3fc0b5..0752986c 100644
--- a/solutions/sem02/lesson03/task1.py
+++ b/solutions/sem02/lesson03/task1.py
@@ -8,13 +8,22 @@ 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 np.add(lhs, rhs)
 
-def compute_poly_vectorized(abscissa: np.ndarray) -> np.ndarray: ...
+
+def compute_poly_vectorized(abscissa: np.ndarray) -> np.ndarray:
+    return np.add(np.add(np.multiply(np.power(abscissa, 2), 3), np.multiply(abscissa, 2)), 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
+
+    return np.sqrt(np.sum((lhs[:, None, :] - rhs[None, :, :]) ** 2, axis=2))
diff --git a/solutions/sem02/lesson03/task2.py b/solutions/sem02/lesson03/task2.py
index fc823c1d..d4b75137 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
+
+    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 = (abscissa**2 + ordinates**2 + applicates**2) ** 0.5
+    inclination = np.arccos(applicates / r)
+
+    return (
+        (abscissa**2 + ordinates**2 + applicates**2) ** 0.5,
+        np.arctan2(ordinates, abscissa),
+        np.nan_to_num(inclination, nan=0),
+    )
diff --git a/solutions/sem02/lesson03/task3.py b/solutions/sem02/lesson03/task3.py
index 477acd0c..43907af8 100644
--- a/solutions/sem02/lesson03/task3.py
+++ b/solutions/sem02/lesson03/task3.py
@@ -3,4 +3,12 @@
 
 def get_extremum_indices(
     ordinates: np.ndarray,
-) -> tuple[np.ndarray, np.ndarray]: ...
+) -> tuple[np.ndarray, np.ndarray]:
+    if ordinates.size < 3:
+        raise ValueError
+
+    max_ind = (ordinates[:-2] < ordinates[1:-1]) & (ordinates[1:-1] > ordinates[2:])
+
+    min_ind = (ordinates[:-2] > ordinates[1:-1]) & (ordinates[1:-1] < ordinates[2:])
+
+    return np.where(min_ind)[0] + 1, np.where(max_ind)[0] + 1
diff --git a/solutions/sem02/lesson04/task1.py b/solutions/sem02/lesson04/task1.py
index 1b5526c1..7bea644e 100644
--- a/solutions/sem02/lesson04/task1.py
+++ b/solutions/sem02/lesson04/task1.py
@@ -2,16 +2,40 @@
 
 
 def pad_image(image: np.ndarray, pad_size: int) -> np.ndarray:
-    # ваш код
-    return image
+    if pad_size < 1:
+        raise ValueError
 
+    height, width = image.shape[:2]
+    height += 2 * pad_size
+    width += 2 * pad_size
 
-def blur_image(
-    image: np.ndarray,
-    kernel_size: int,
-) -> np.ndarray:
-    # ваш код
-    return image
+    img_new = np.zeros((height, width) + image.shape[2:], dtype=image.dtype)
+
+    if len(image.shape) == 2:
+        img_new[pad_size:-pad_size, pad_size:-pad_size] = image
+    else:
+        image.shape[2]
+        img_new[pad_size:-pad_size, pad_size:-pad_size, :] = image
+
+    return img_new
+
+
+def blur_image(image: np.ndarray, kernel_size: int) -> np.ndarray:
+    if kernel_size < 1 or kernel_size % 2 == 0:
+        raise ValueError
+    if kernel_size == 1:
+        return image
+
+    pad_img = pad_image(image, kernel_size // 2)
+    height, width = image.shape[:2]
+    result = np.zeros((height, width) + image.shape[2:], dtype=image.dtype)
+
+    for i in range(height):
+        for j in range(width):
+            region = pad_img[i : i + kernel_size, j : j + kernel_size]
+            result[i, j] = region.mean(axis=(0, 1))
+
+    return result
 
 
 if __name__ == "__main__":
@@ -22,6 +46,6 @@ def blur_image(
 
     current_directory = Path(__file__).resolve().parent
     image = get_image(os.path.join(current_directory, "images", "circle.jpg"))
-    image_blured = blur_image(image, kernel_size=21)
+    image_blured = blur_image(image, kernel_size=51)
 
     compare_images(image, image_blured)
diff --git a/solutions/sem02/lesson04/task2.py b/solutions/sem02/lesson04/task2.py
index be9a2288..b1ea52dd 100644
--- a/solutions/sem02/lesson04/task2.py
+++ b/solutions/sem02/lesson04/task2.py
@@ -5,6 +5,38 @@ def get_dominant_color_info(
     image: np.ndarray[np.uint8],
     threshold: int = 5,
 ) -> tuple[np.uint8, float]:
-    # ваш код
+    if threshold < 1:
+        # добавил сообщение об ошибки, т.к. иначе тест не проходит
+        raise ValueError("threshold must be positive")
 
-    return 0, 0
+    hist = np.zeros(256, dtype=int)
+
+    for i in image:
+        for j in i:
+            hist[int(j)] += 1
+
+    all_pixels = image.shape[0] * image.shape[1]
+
+    prefix = np.zeros(257, dtype=int)
+    for i in range(256):
+        prefix[i + 1] = prefix[i] + hist[i]
+
+    res_color = 0
+    res_count = 0
+
+    for j in range(256):
+        if hist[j] == 0:
+            continue
+
+        left = max(0, j - threshold + 1)
+        right = min(255, j + threshold - 1)
+
+        count = prefix[right + 1] - prefix[left]
+
+        if count > res_count:
+            res_count = count
+            res_color = j
+
+    percent = res_count / all_pixels * 100
+
+    return np.uint8(res_color), percent
diff --git a/solutions/sem02/lesson05/task1.py b/solutions/sem02/lesson05/task1.py
index e9c7c3c5..3eb03e6d 100644
--- a/solutions/sem02/lesson05/task1.py
+++ b/solutions/sem02/lesson05/task1.py
@@ -9,4 +9,9 @@ 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
+
+    need = costs @ demand_expected
+    return np.all(need <= resource_amounts)
diff --git a/solutions/sem02/lesson05/task2.py b/solutions/sem02/lesson05/task2.py
index be1fb9d2..07f23d1b 100644
--- a/solutions/sem02/lesson05/task2.py
+++ b/solutions/sem02/lesson05/task2.py
@@ -8,4 +8,16 @@ 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[1] != matrix.shape[0] or matrix.shape[0] != vector.size:
+        raise ShapeMismatchError
+
+    if np.linalg.det(matrix) == 0:
+        return None, None
+
+    scal = matrix @ vector.T
+    share = scal / np.linalg.norm(matrix, axis=1) ** 2
+    result1 = matrix * share.reshape(-1, 1)
+    result2 = vector - result1
+
+    return result1, result2
diff --git a/solutions/sem02/lesson05/task3.py b/solutions/sem02/lesson05/task3.py
index 0c66906c..cf794321 100644
--- a/solutions/sem02/lesson05/task3.py
+++ b/solutions/sem02/lesson05/task3.py
@@ -9,4 +9,11 @@ def adaptive_filter(
     Vs: np.ndarray,
     Vj: np.ndarray,
     diag_A: np.ndarray,
-) -> np.ndarray: ...
+) -> np.ndarray:
+    if Vs.shape[0] != Vj.shape[0] or Vj.shape[1] != diag_A.shape[0]:
+        raise ShapeMismatchError
+
+    Vhj = Vj.conj().T  # неуверен, что проходили этот метод, но не вижу другого способа
+    B = np.eye(diag_A.size) + (Vhj @ Vj) * diag_A
+    y = Vs - Vj @ np.linalg.solve(B, Vhj @ Vs)
+    return y
diff --git a/solutions/sem02/lesson07/task1.py b/solutions/sem02/lesson07/task1.py
index 3a505d89..2151c693 100644
--- a/solutions/sem02/lesson07/task1.py
+++ b/solutions/sem02/lesson07/task1.py
@@ -13,8 +13,80 @@ def visualize_diagrams(
     ordinates: np.ndarray,
     diagram_type: Any,
 ) -> None:
-    # ваш код
-    pass
+    if abscissa.size != ordinates.size:
+        raise ShapeMismatchError
+    if diagram_type not in ("hist", "violin", "box"):
+        raise ValueError
+
+    figure = plt.figure(figsize=(8, 8))
+    grid = plt.GridSpec(4, 4, wspace=space, hspace=space)
+
+    axis_scatter = figure.add_subplot(grid[:-1, 1:])
+    axis_hist_vert = figure.add_subplot(
+        grid[:-1, 0],
+        sharey=axis_scatter,
+    )
+    axis_hist_hor = figure.add_subplot(
+        grid[-1, 1:],
+        sharex=axis_scatter,
+    )
+
+    if diagram_type == "hist":
+        axis_scatter.scatter(abscissa, ordinates, color="green", alpha=0.5)
+        axis_hist_hor.hist(
+            abscissa,
+            bins=50,
+            color="green",
+            density=True,
+            alpha=0.5,
+        )
+        axis_hist_vert.hist(
+            ordinates,
+            bins=50,
+            color="green",
+            orientation="horizontal",
+            density=True,
+            alpha=0.5,
+        )
+        axis_hist_hor.invert_yaxis()
+        axis_hist_vert.invert_xaxis()
+
+    elif diagram_type == "violin":
+        axis_scatter.scatter(abscissa, ordinates, color="green", alpha=0.5)
+        hist_hor = axis_hist_hor.violinplot(abscissa, vert=False)
+        hist_vert = axis_hist_vert.violinplot(ordinates, vert=True)
+
+        for body in hist_vert["bodies"]:
+            body.set_facecolor("green")
+            body.set_edgecolor("black")
+        for parts in hist_vert:
+            if parts == "bodies":
+                continue
+            hist_vert[parts].set_edgecolor("black")
+        for body in hist_hor["bodies"]:
+            body.set_facecolor("green")
+            body.set_edgecolor("black")
+        for parts in hist_hor:
+            if parts == "bodies":
+                continue
+            hist_hor[parts].set_edgecolor("black")
+
+    elif diagram_type == "box":
+        axis_scatter.scatter(abscissa, ordinates, color="green", alpha=0.5)
+        axis_hist_hor.boxplot(
+            abscissa,
+            vert=False,
+            patch_artist=True,
+            boxprops=dict(facecolor="lightgreen"),
+            medianprops=dict(color="k"),
+        )
+        axis_hist_vert.boxplot(
+            ordinates,
+            vert=True,
+            patch_artist=True,
+            boxprops=dict(facecolor="lightgreen"),
+            medianprops=dict(color="k"),
+        )
 
 
 if __name__ == "__main__":
@@ -24,5 +96,5 @@ def visualize_diagrams(
 
     abscissa, ordinates = np.random.multivariate_normal(mean, cov, size=1000).T
 
-    visualize_diagrams(abscissa, ordinates, "hist")
+    visualize_diagrams(abscissa, ordinates, "box")
     plt.show()
diff --git a/solutions/sem02/lesson07/task2.py b/solutions/sem02/lesson07/task2.py
index decd607e..ce95df91 100644
--- a/solutions/sem02/lesson07/task2.py
+++ b/solutions/sem02/lesson07/task2.py
@@ -1 +1,74 @@
-# ваш код (используйте функции или классы для решения данной задачи)
+import json
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+def create_diagram(before: np.ndarray, after: np.ndarray, degree: np.ndarray):
+    poses = np.arange(len(degree))
+    width = 0.52 / 1.5
+
+    axes = plt.subplots(figsize=(9, 9))[1]
+    axes.bar(poses - width / 2, before, width, label="До", color="cornflowerblue", edgecolor="blue")
+    axes.bar(poses + width / 2, after, width, label="После", color="indianred", edgecolor="red")
+    axes.set_xticks(poses)
+    axes.set_xticklabels(degree)
+    axes.set_ylabel("Количество пациентов")
+    axes.set_title("Степени митральной недостаточности")
+    axes.legend()
+
+
+def create_arrays(path: str) -> tuple[np.ndarray, np.ndarray]:
+    with open(path, "r") as f:
+        data = json.load(f)
+
+    before = np.array(data["before"])
+    after = np.array(data["after"])
+    return before, after
+
+
+def count_degree(arr: np.ndarray, degree: np.ndarray) -> np.ndarray:
+    return np.sum(arr[:, None] == degree, axis=0)
+
+
+def save_diagram(filename: str):
+    plt.savefig(filename, dpi=300, bbox_inches="tight")
+
+
+def main():
+    degree = np.array(["I", "II", "III", "IV"])
+    before, after = create_arrays("solutions/sem02/lesson07/data/medic_data.json")
+    before_count = count_degree(before, degree)
+    after_count = count_degree(after, degree)
+    create_diagram(before_count, after_count, degree)
+    save_diagram("result.png")
+    plt.show()
+
+
+if __name__ == "__main__":
+    main()
+
+
+"""
+Выводы:
+Ключевые наблюдения:
+Тяжёлые стадии (III–IV) заметно уменьшились после имплантации:
+III стадия: существенно снизилась
+IV стадия: тоже уменьшилась
+Лёгкая стадия (I) немного выросла — это положительная динамика.
+Однако II стадия резко увеличилась и стала доминирующей после лечения.
+
+Вывод об эффективности импланта:
+Имплант в целом оказывает положительный эффект, потому что наблюдается 
+явный сдвиг пациентов из тяжёлых состояний (III–IV) в более лёгкие 
+(в основном II и частично I стадии).
+
+Но эффект не является полным излечением:
+большинство пациентов не переходят в I стадию,
+а «улучшение» часто выражается в переходе из тяжёлой стадии в умеренную (II).
+
+Итог:
+Имплант эффективен в снижении числа тяжёлых случаев митральной недостаточности, 
+но в основном переводит пациентов в среднюю (II) стадию, 
+а не в полностью здоровое состояние.
+"""
diff --git a/solutions/sem02/lesson08/task1.py b/solutions/sem02/lesson08/task1.py
index 89f88572..7c44b1c8 100644
--- a/solutions/sem02/lesson08/task1.py
+++ b/solutions/sem02/lesson08/task1.py
@@ -1,34 +1,108 @@
-from functools import partial
-
 import matplotlib.pyplot as plt
 import numpy as np
-
 from IPython.display import HTML
 from matplotlib.animation import FuncAnimation
 
 
+class SignalModulation:
+    def __init__(self, modulation, fc):
+        self.modulation = modulation
+        self.fc = fc
+
+    def signal_function(self, t):
+        formula = np.sin(2 * np.pi * self.fc * t)
+        if self.modulation is None:
+            return formula
+        return self.modulation(t) * formula
+
+
+class SignalDisplay:
+    def __init__(
+        self, signal, num_frames, plot_duration, time_step=0.001, animation_step=0.01, save_path=""
+    ):
+        self.signal = signal
+        self.num_frames = num_frames
+        self.plot_duration = plot_duration
+        self.time_step = time_step
+        self.animation_step = animation_step
+        self.save_path = save_path
+        self.figure = None
+        self.axis = None
+        self.line = None
+
+    def animate(self):
+        self._setup_plot()
+
+        animation = FuncAnimation(
+            self.figure, self._update_frame, frames=self.num_frames, blit=True
+        )
+
+        if self.save_path:
+            self._save(animation)
+
+        return animation
+
+    def _generate_time(self, start):
+        return np.arange(start, start + self.plot_duration, self.time_step)
+
+    def _signal_function(self, t):
+        return self.signal.signal_function(t)
+
+    def _setup_plot(self):
+        self.figure, self.axis = plt.subplots(figsize=(16, 9))
+        (self.line,) = self.axis.plot([], [])
+
+        self.axis.set_ylim(-1.5, 1.5)
+        self.axis.set_xlabel("время (секунды)")
+        self.axis.set_ylabel("амплитуда")
+
+    def _update_plot(self, t, y):
+        self.line.set_data(t, y)
+        self.axis.set_xlim(t[0], t[-1])
+
+    def _update_frame(self, frame):
+        start = frame * self.animation_step
+
+        t = self._generate_time(start)
+        y = self._signal_function(t)
+
+        self._update_plot(t, y)
+
+        return (self.line,)
+
+    def _save(self, anim):
+        anim.save(self.save_path, writer="pillow", fps=52)
+
+
 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()
+    signal = SignalModulation(modulation, fc)
+
+    animator = SignalDisplay(
+        signal=signal,
+        num_frames=num_frames,
+        plot_duration=plot_duration,
+        time_step=time_step,
+        animation_step=animation_step,
+        save_path=save_path,
+    )
+    anim = animator.animate()
+    plt.show()
+
+    return anim
 
 
 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 = 150
+    plot_duration = np.pi / 2
+    time_step = 0.001
+    animation_step = np.pi / 200
+    fc = 5
     save_path_with_modulation = "modulated_signal.gif"
 
     animation = create_modulation_animation(
@@ -38,6 +112,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 b677c070..4e972922 100644
--- a/solutions/sem02/lesson08/task2.py
+++ b/solutions/sem02/lesson08/task2.py
@@ -1,34 +1,28 @@
-from functools import partial
-
-import matplotlib.pyplot as plt
 import numpy as np
-
 from IPython.display import HTML
 from matplotlib.animation import FuncAnimation
 
 
-
-
 def animate_wave_algorithm(
-    maze: np.ndarray, 
-    start: tuple[int, int], 
-    end: tuple[int, int], 
-    save_path: str = ""
-)  -> FuncAnimation:
+    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],
-    ])
+    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 +30,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 +43,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