From 4a31cfe3121c1437f669b13050a79987ed8bcc7b Mon Sep 17 00:00:00 2001
From: Vitaly Kozlov <vitserkozlov@edu.hse.ru>
Date: Sat, 16 May 2026 01:41:14 +0300
Subject: [PATCH 01/17] Add new tasks

---
 .../arrays/largest_perimeter_triangle.toml    | 186 +++++++
 tasks/easy/arrays/max_stock_profit.toml       | 197 ++++++++
 tasks/easy/arrays/maximum_altitude.toml       | 183 +++++++
 tasks/easy/arrays/permutation_period.toml     | 185 +++++++
 tasks/easy/arrays/summary_ranges.toml         | 195 +++++++
 tasks/easy/arrays/toeplitz_matrix.toml        | 199 ++++++++
 tasks/easy/arrays/town_judge.toml             | 215 ++++++++
 .../easy/hash_maps/peak_performance_sum.toml  | 184 +++++++
 tasks/easy/math/custom_fibonacci.toml         | 198 ++++++++
 tasks/easy/math/expanded_notation_array.toml  | 175 +++++++
 .../math/primes_with_prime_digit_sum.toml     | 178 +++++++
 tasks/easy/math/self_dividing_numbers.toml    | 182 +++++++
 tasks/easy/strings/center_strings.toml        | 205 ++++++++
 tasks/easy/strings/digit_snake_formatter.toml | 207 ++++++++
 .../strings/longest_balanced_substring.toml   | 198 ++++++++
 tasks/easy/strings/longest_common_prefix.toml | 186 +++++++
 .../strings/string_blocks_transposition.toml  | 204 ++++++++
 tasks/medium/algo/insert_interval.toml        | 236 +++++++++
 tasks/medium/dp/turtle_max_path_sum.toml      | 179 +++++++
 tasks/medium/games/game_of_life_step.toml     | 210 ++++++++
 tasks/medium/games/valid_sudoku.toml          | 477 ++++++++++++++++++
 tasks/medium/graphs/flood_fill.toml           | 226 +++++++++
 .../graphs/topological_sort_possible.toml     | 206 ++++++++
 .../greedy/minimum_bracket_reversals.toml     | 216 ++++++++
 24 files changed, 5027 insertions(+)
 create mode 100644 tasks/easy/arrays/largest_perimeter_triangle.toml
 create mode 100644 tasks/easy/arrays/max_stock_profit.toml
 create mode 100644 tasks/easy/arrays/maximum_altitude.toml
 create mode 100644 tasks/easy/arrays/permutation_period.toml
 create mode 100644 tasks/easy/arrays/summary_ranges.toml
 create mode 100644 tasks/easy/arrays/toeplitz_matrix.toml
 create mode 100644 tasks/easy/arrays/town_judge.toml
 create mode 100644 tasks/easy/hash_maps/peak_performance_sum.toml
 create mode 100644 tasks/easy/math/custom_fibonacci.toml
 create mode 100644 tasks/easy/math/expanded_notation_array.toml
 create mode 100644 tasks/easy/math/primes_with_prime_digit_sum.toml
 create mode 100644 tasks/easy/math/self_dividing_numbers.toml
 create mode 100644 tasks/easy/strings/center_strings.toml
 create mode 100644 tasks/easy/strings/digit_snake_formatter.toml
 create mode 100644 tasks/easy/strings/longest_balanced_substring.toml
 create mode 100644 tasks/easy/strings/longest_common_prefix.toml
 create mode 100644 tasks/easy/strings/string_blocks_transposition.toml
 create mode 100644 tasks/medium/algo/insert_interval.toml
 create mode 100644 tasks/medium/dp/turtle_max_path_sum.toml
 create mode 100644 tasks/medium/games/game_of_life_step.toml
 create mode 100644 tasks/medium/games/valid_sudoku.toml
 create mode 100644 tasks/medium/graphs/flood_fill.toml
 create mode 100644 tasks/medium/graphs/topological_sort_possible.toml
 create mode 100644 tasks/medium/greedy/minimum_bracket_reversals.toml

diff --git a/tasks/easy/arrays/largest_perimeter_triangle.toml b/tasks/easy/arrays/largest_perimeter_triangle.toml
new file mode 100644
index 0000000..75be510
--- /dev/null
+++ b/tasks/easy/arrays/largest_perimeter_triangle.toml
@@ -0,0 +1,186 @@
+level             = "easy"
+name              = "largest_perimeter_triangle"
+tags              = ["arrays", "math", "geometry", "sorting"]
+time_to_solve_sec = 200
+
+description_en = """
+Given an integer array `nums` representing the lengths of line segments, return the largest perimeter of a triangle with a non-zero area, formed from three of these lengths.
+
+If it is impossible to form any triangle, return `0`.
+
+A triangle can be formed by three segments of lengths $a$, $b$, and $c$ if and only if the sum of the lengths of any two segments is strictly greater than the length of the third segment (i.e., $a + b > c$).
+"""
+
+description_ru = """
+Дан массив целых чисел `nums`, представляющий длины отрезков. Верните наибольший периметр треугольника с ненулевой площадью, который можно составить из трех таких отрезков.
+
+Если составить треугольник невозможно, верните `0`.
+
+Треугольник можно составить из трех отрезков с длинами $a$, $b$ и $c$, если и только если сумма длин любых двух отрезков строго больше длины третьего отрезка (то есть $a + b > c$).
+"""
+
+limits = """
+- $3 \\leq \\text{len}(nums) \\leq 10^4$
+- $1 \\leq nums[i] \\leq 10^6$
+"""
+
+solution = """
+def solution(nums: list) -> int:
+    nums.sort(reverse=True)
+    for i in range(len(nums) - 2):
+        if nums[i] < nums[i+1] + nums[i+2]:
+            return nums[i] + nums[i+1] + nums[i+2]
+    return 0
+"""
+
+examples = """
+solution([1, 2, 1]) == 0
+solution([2, 1, 2]) == 5
+solution([3, 6, 2, 3]) == 8
+solution([3, 2, 3, 4]) == 10
+"""
+
+[[input_signature]]
+argument_name = "nums"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "integer"
+
+[output_signature.type]
+name = "integer"
+
+[[asserts]]
+arguments = [[2, 1, 2]]
+comment   = "Simple valid triangle"
+expected  = 5
+
+[[asserts]]
+arguments = [[1, 2, 1]]
+comment   = "Degenerate triangle (impossible)"
+expected  = 0
+
+[[asserts]]
+arguments = [[3, 2, 3, 4]]
+comment   = "Multiple elements, forms 3, 3, 4"
+expected  = 10
+
+[[asserts]]
+arguments = [[3, 6, 2, 3]]
+comment   = "Elements form 3, 3, 2"
+expected  = 8
+
+[[asserts]]
+arguments = [[3, 4, 5]]
+comment   = "Exact 3 elements, right triangle"
+expected  = 12
+
+[[asserts]]
+arguments = [[1, 1, 1]]
+comment   = "Equilateral triangle"
+expected  = 3
+
+[[asserts]]
+arguments = [[2, 2, 2, 2]]
+comment   = "Four equal elements"
+expected  = 6
+
+[[asserts]]
+arguments = [[10, 9, 8, 2, 1]]
+comment   = "Descending sequence"
+expected  = 27
+
+[[asserts]]
+arguments = [[100, 1, 1, 1]]
+comment   = "One huge element, rest forms small triangle"
+expected  = 3
+
+[[asserts]]
+arguments = [[10, 5, 4, 3]]
+comment   = "Largest element skipped"
+expected  = 12
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 5, 6]]
+comment   = "Consecutive numbers"
+expected  = 15
+
+[[asserts]]
+arguments = [[1, 1, 2, 3, 5, 8, 13]]
+comment   = "Fibonacci sequence (no triangle possible)"
+expected  = 0
+
+[[asserts]]
+arguments = [[1, 1, 2, 3, 5, 8, 13, 20]]
+comment   = "Slightly modified Fibonacci (valid)"
+expected  = 41
+
+[[asserts]]
+arguments = [[5, 5, 10, 10, 20]]
+comment   = "Repeated elements, skips 20"
+expected  = 25
+
+[[asserts]]
+arguments = [[7, 8, 9, 100, 101, 102]]
+comment   = "Two distinct groups, largest group works"
+expected  = 303
+
+[[asserts]]
+arguments = [[10, 10, 10, 100, 100, 100]]
+comment   = "Two distinct groups of equal elements"
+expected  = 300
+
+[[asserts]]
+arguments = [[10, 10, 100, 100]]
+comment   = "Isosceles triangle from large elements"
+expected  = 210
+
+[[asserts]]
+arguments = [[1, 2, 1, 10]]
+comment   = "Impossible even with more elements"
+expected  = 0
+
+[[asserts]]
+arguments = [[9, 8, 7, 6, 5]]
+comment   = "Descending sequence starting at 9"
+expected  = 24
+
+[[asserts]]
+arguments = [[1000, 1000, 1000]]
+comment   = "Large values"
+expected  = 3000
+
+[[asserts]]
+arguments = [[5, 12, 13]]
+comment   = "Pythagorean triple"
+expected  = 30
+
+[[asserts]]
+arguments = [[3, 4, 5, 6, 8, 10]]
+comment   = "Multiple triples"
+expected  = 24
+
+[[asserts]]
+arguments = [[2, 3, 4, 5, 10]]
+comment   = "Largest element cannot be used"
+expected  = 12
+
+[[asserts]]
+arguments = [[1, 1, 1, 1000]]
+comment   = "One huge outlier"
+expected  = 3
+
+[[asserts]]
+arguments = [[100, 10, 10, 10]]
+comment   = "One huge, three identical smaller"
+expected  = 30
+
+[[asserts]]
+arguments = [[2, 2, 3]]
+comment   = "Valid isosceles"
+expected  = 7
+
+[[asserts]]
+arguments = [[1, 10, 100, 1000, 10000]]
+comment   = "Powers of 10 (no triangle possible)"
+expected  = 0
\ No newline at end of file
diff --git a/tasks/easy/arrays/max_stock_profit.toml b/tasks/easy/arrays/max_stock_profit.toml
new file mode 100644
index 0000000..df69af7
--- /dev/null
+++ b/tasks/easy/arrays/max_stock_profit.toml
@@ -0,0 +1,197 @@
+level             = "easy"
+name              = "max_stock_profit"
+tags              = ["arrays", "greedy", "math"]
+time_to_solve_sec = 250
+
+description_en = """
+Given an array `prices` where `prices[i]` is the price of a given stock on the $i$-th day.
+
+You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock.
+
+Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return `0`.
+"""
+
+description_ru = """
+Дан массив `prices`, где `prices[i]` — это цена акции в $i$-й день.
+
+Вы хотите максимизировать свою прибыль, выбрав один день для покупки одной акции и другой день в будущем для ее продажи.
+
+Верните максимальную прибыль, которую вы можете получить от этой сделки. Если получить прибыль невозможно, верните `0`.
+"""
+
+limits = """
+- $1 \\leq \\text{len}(\\text{prices}) \\leq 10^5$
+- $0 \\leq \\text{prices}[i] \\leq 10^4$
+"""
+
+solution = """
+def solution(prices: list) -> int:
+    max_p, min_p = 0, float('inf')
+    for price in prices:
+        min_p = min(min_p, price)
+        max_p = max(max_p, price - min_p)
+    return max_p
+"""
+
+examples = """
+solution([1]) == 0
+solution([1, 2]) == 1
+solution([2, 1]) == 0
+solution([7, 6, 4, 3, 1]) == 0
+solution([7, 1, 5, 3, 6, 4]) == 5
+"""
+
+[[input_signature]]
+argument_name = "prices"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "integer"
+
+[output_signature.type]
+name = "integer"
+
+[[asserts]]
+arguments = [[7, 1, 5, 3, 6, 4]]
+comment   = "Buy on day 2, sell on day 5"
+expected  = 5
+
+[[asserts]]
+arguments = [[7, 6, 4, 3, 1]]
+comment   = "Decreasing prices, no profit possible"
+expected  = 0
+
+[[asserts]]
+arguments = [[1, 2]]
+comment   = "Two days, profit possible"
+expected  = 1
+
+[[asserts]]
+arguments = [[2, 1]]
+comment   = "Two days, decreasing prices"
+expected  = 0
+
+[[asserts]]
+arguments = [[1]]
+comment   = "Single day, no transaction possible"
+expected  = 0
+
+[[asserts]]
+arguments = [[1, 1, 1, 1]]
+comment   = "Constant prices"
+expected  = 0
+
+[[asserts]]
+arguments = [[2, 4, 1]]
+comment   = "Max price before min price"
+expected  = 2
+
+[[asserts]]
+arguments = [[3, 2, 6, 5, 0, 3]]
+comment   = "Multiple peaks and valleys"
+expected  = 4
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 5]]
+comment   = "Increasing prices"
+expected  = 4
+
+[[asserts]]
+arguments = [[5, 4, 3, 2, 1]]
+comment   = "Strictly decreasing prices"
+expected  = 0
+
+[[asserts]]
+arguments = [[1, 5, 1, 5, 1, 5]]
+comment   = "Alternating low and high"
+expected  = 4
+
+[[asserts]]
+arguments = [[10000, 0]]
+comment   = "Max possible value then 0"
+expected  = 0
+
+[[asserts]]
+arguments = [[0, 10000]]
+comment   = "0 then max possible value"
+expected  = 10000
+
+[[asserts]]
+arguments = [[3, 3, 5, 0, 0, 3, 1, 4]]
+comment   = "Mixed elements with zeroes"
+expected  = 4
+
+[[asserts]]
+arguments = [[7, 2, 5, 1, 6, 4]]
+comment   = "Best buy is later in the array"
+expected  = 5
+
+[[asserts]]
+arguments = [[8, 9, 2, 5, 4, 7, 1]]
+comment   = "Highest peak at start, best profit in middle"
+expected  = 5
+
+[[asserts]]
+arguments = [[5, 1, 5, 1, 5]]
+comment   = "Repeating pattern"
+expected  = 4
+
+[[asserts]]
+arguments = [[10, 20, 30, 40, 50, 60, 70, 80, 90, 100]]
+comment   = "Long increasing sequence"
+expected  = 90
+
+[[asserts]]
+arguments = [[100, 90, 80, 70, 60, 50, 40, 30, 20, 10]]
+comment   = "Long decreasing sequence"
+expected  = 0
+
+[[asserts]]
+arguments = [[1, 2, 10, 1, 20]]
+comment   = "Two distinct upward trends"
+expected  = 19
+
+[[asserts]]
+arguments = [[20, 1, 10, 2, 11]]
+comment   = "Buy at absolute min, sell at local max"
+expected  = 10
+
+[[asserts]]
+arguments = [[10, 8, 7, 5, 2]]
+comment   = "No profit, all decreasing"
+expected  = 0
+
+[[asserts]]
+arguments = [[2, 2, 2, 2, 3]]
+comment   = "Flat then small increase"
+expected  = 1
+
+[[asserts]]
+arguments = [[3, 2, 1, 4, 5, 6]]
+comment   = "Drop to min, then steady increase"
+expected  = 5
+
+[[asserts]]
+arguments = [[1, 100]]
+comment   = "Simple max gain"
+expected  = 99
+
+[[asserts]]
+arguments = [[5, 8, 2, 10]]
+comment   = "Two possible buy days"
+expected  = 8
+
+[[asserts]]
+arguments = [[10, 2, 8, 1, 7]]
+comment   = "Profit 6 on both valid transactions, best is 6"
+expected  = 6
+
+[[asserts]]
+arguments = [[1, 2, 4, 2, 5, 7, 2, 4, 9, 0, 8]]
+comment   = "Complex long array"
+expected  = 8
+
+[[asserts]]
+arguments = [[0, 0, 0, 0]]
+comment   = "All zeroes"
+expected  = 0
\ No newline at end of file
diff --git a/tasks/easy/arrays/maximum_altitude.toml b/tasks/easy/arrays/maximum_altitude.toml
new file mode 100644
index 0000000..752a7a4
--- /dev/null
+++ b/tasks/easy/arrays/maximum_altitude.toml
@@ -0,0 +1,183 @@
+level             = "easy"
+name              = "maximum_altitude"
+tags              = ["arrays", "math"]
+time_to_solve_sec = 200
+
+description_en = """
+A cyclist starts their journey at an altitude of $0$. You are given an integer array `gain` of length $n$, where `gain[i]` represents the net altitude gain between point $i$ and point $i + 1$. 
+
+Return the highest altitude the cyclist reaches during their journey.
+"""
+
+description_ru = """
+Велосипедист начинает свой путь на высоте $0$. Вам дан целочисленный массив `gain` длины $n$, где `gain[i]` — это изменение высоты между точкой $i$ и точкой $i + 1$. 
+
+Верните максимальную высоту, которой достигнет велосипедист за время пути.
+"""
+
+limits = """
+- $1 \\leq \text{len}(\text{gain}) \\leq 100$
+- $-100 \\leq \text{gain}[i] \\leq 100$
+"""
+
+solution = """
+def solution(gain: list) -> int:
+    curr = max_alt = 0
+    for g in gain:
+        curr += g
+        max_alt = max(max_alt, curr)
+    return max_alt
+"""
+
+examples = """
+solution([0]) == 0
+solution([1]) == 1
+solution([-4, -3, -2, -1, 4, 3, 2]) == 0
+solution([-5, 1, 5, 0, -7]) == 1
+solution([10, -5, 10, -5]) == 15
+"""
+
+[[input_signature]]
+argument_name = "gain"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "integer"
+
+[output_signature.type]
+name = "integer"
+
+[[asserts]]
+arguments = [[-5, 1, 5, 0, -7]]
+comment   = "Max altitude reached in the middle"
+expected  = 1
+
+[[asserts]]
+arguments = [[-4, -3, -2, -1, 4, 3, 2]]
+comment   = "Never goes above starting altitude"
+expected  = 0
+
+[[asserts]]
+arguments = [[10, -5, 10, -5]]
+comment   = "Fluctuating altitude"
+expected  = 15
+
+[[asserts]]
+arguments = [[1]]
+comment   = "Single positive element"
+expected  = 1
+
+[[asserts]]
+arguments = [[-1]]
+comment   = "Single negative element"
+expected  = 0
+
+[[asserts]]
+arguments = [[0]]
+comment   = "Single zero element"
+expected  = 0
+
+[[asserts]]
+arguments = [[0, 0, 0]]
+comment   = "All zeros"
+expected  = 0
+
+[[asserts]]
+arguments = [[5, 5, 5]]
+comment   = "Constantly ascending"
+expected  = 15
+
+[[asserts]]
+arguments = [[-5, -5, -5]]
+comment   = "Constantly descending"
+expected  = 0
+
+[[asserts]]
+arguments = [[100, 100, -200, 50]]
+comment   = "Large peak then drop"
+expected  = 200
+
+[[asserts]]
+arguments = [[-100, 50, 60, -20]]
+comment   = "Large drop then peak"
+expected  = 10
+
+[[asserts]]
+arguments = [[10, 20, 30, 40, 50]]
+comment   = "Monotonically increasing"
+expected  = 150
+
+[[asserts]]
+arguments = [[-10, -20, -30, -40, -50]]
+comment   = "Monotonically decreasing"
+expected  = 0
+
+[[asserts]]
+arguments = [[50, -50, 50, -50]]
+comment   = "Oscillating starting positive"
+expected  = 50
+
+[[asserts]]
+arguments = [[-50, 50, -50, 50]]
+comment   = "Oscillating starting negative"
+expected  = 0
+
+[[asserts]]
+arguments = [[1, -1, 1, -1, 1, -1]]
+comment   = "Small oscillations starting positive"
+expected  = 1
+
+[[asserts]]
+arguments = [[-1, 1, -1, 1, -1, 1]]
+comment   = "Small oscillations starting negative"
+expected  = 0
+
+[[asserts]]
+arguments = [[100]]
+comment   = "Max possible single value"
+expected  = 100
+
+[[asserts]]
+arguments = [[-100]]
+comment   = "Min possible single value"
+expected  = 0
+
+[[asserts]]
+arguments = [[0, 1, -1, 0, 2, -2]]
+comment   = "Mixed with zeros"
+expected  = 2
+
+[[asserts]]
+arguments = [[5, 4, 3, 2, 1]]
+comment   = "Decreasing positive steps"
+expected  = 15
+
+[[asserts]]
+arguments = [[-5, 4, 3, 2, 1]]
+comment   = "Starts with dip, then recovers"
+expected  = 5
+
+[[asserts]]
+arguments = [[-10, 2, 3, 4, 5]]
+comment   = "Starts with big dip, recovers over time"
+expected  = 4
+
+[[asserts]]
+arguments = [[2, 3, -10, 4, 5]]
+comment   = "Dip in the middle"
+expected  = 5
+
+[[asserts]]
+arguments = [[10, -20, 30, -40, 50]]
+comment   = "Increasing oscillation amplitudes"
+expected  = 30
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 5, -15, 20]]
+comment   = "Drops completely then rises again"
+expected  = 20
+
+[[asserts]]
+arguments = [[50, 50, -100, 1, 2]]
+comment   = "Peak at the start, drop, small rise"
+expected  = 100
\ No newline at end of file
diff --git a/tasks/easy/arrays/permutation_period.toml b/tasks/easy/arrays/permutation_period.toml
new file mode 100644
index 0000000..ce6a314
--- /dev/null
+++ b/tasks/easy/arrays/permutation_period.toml
@@ -0,0 +1,185 @@
+level             = "easy"
+name              = "permutation_period"
+tags              = ["arrays", "math", "simulation"]
+time_to_solve_sec = 250
+
+description_en = """
+You are given an array `p` of length $n$ containing integers from $0$ to $n - 1$.
+
+Imagine we have an initial array $\\text{arr} = [0, 1, 2, \\dots, n - 1]$.
+In one step, we permute the elements of $\\text{arr}$ such that the new array is $\\text{new\\_arr}$, where $\\text{new\\_arr}[i] = \\text{arr}[p[i]]$.
+
+Return the minimum number of steps required to return $\\text{arr}$ to its initial state $[0, 1, 2, \\dots, n - 1]$. 
+If it is impossible to ever return to the initial state, return $-1$.
+"""
+
+description_ru = """
+Вам дан массив `p` длины $n$, содержащий целые числа от $0$ до $n - 1$.
+
+Представьте, что у нас есть исходный массив $\\text{arr} = [0, 1, 2, \\dots, n - 1]$.
+За один шаг мы переставляем элементы $\\text{arr}$ так, что получается новый массив $\\text{new\\_arr}$, где $\\text{new\\_arr}[i] = \\text{arr}[p[i]]$.
+
+Верните минимальное количество шагов, за которое массив $\\text{arr}$ вернется в свое исходное состояние $[0, 1, 2, \\dots, n - 1]$. 
+Если вернуться в исходное состояние невозможно, верните $-1$.
+"""
+
+limits = """
+- $1 \\leq \\text{len}(p) \\leq 30$
+- $0 \\leq p[i] < \\text{len}(p)$
+"""
+
+solution = """
+def solution(p: list[int]) -> int:
+    if len(set(p)) != len(p): return -1
+    curr, target, steps = list(p), list(range(len(p))), 1
+    while curr != target: curr, steps = [curr[i] for i in p], steps + 1
+    return steps
+"""
+
+examples = """
+solution([0]) == 1
+solution([1, 0]) == 2
+solution([1, 2, 0]) == 3
+solution([0, 1, 1]) == -1
+solution([1, 2, 0, 4, 3]) == 6
+"""
+
+[[input_signature]]
+argument_name = "p"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "integer"
+
+[output_signature.type]
+name = "integer"
+
+[[asserts]]
+arguments = [[0]]
+comment   = "Length 1, identical"
+expected  = 1
+
+[[asserts]]
+arguments = [[1, 0]]
+comment   = "Length 2, swap"
+expected  = 2
+
+[[asserts]]
+arguments = [[0, 1]]
+comment   = "Length 2, identical"
+expected  = 1
+
+[[asserts]]
+arguments = [[1, 2, 0]]
+comment   = "Cycle of 3"
+expected  = 3
+
+[[asserts]]
+arguments = [[0, 1, 2]]
+comment   = "Length 3, identical"
+expected  = 1
+
+[[asserts]]
+arguments = [[1, 0, 2]]
+comment   = "Cycle of 2 and 1"
+expected  = 2
+
+[[asserts]]
+arguments = [[1, 2, 3, 0]]
+comment   = "Cycle of 4"
+expected  = 4
+
+[[asserts]]
+arguments = [[1, 0, 3, 2]]
+comment   = "Two cycles of 2"
+expected  = 2
+
+[[asserts]]
+arguments = [[1, 2, 0, 4, 3]]
+comment   = "Cycles of 3 and 2 (LCM = 6)"
+expected  = 6
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 0]]
+comment   = "Cycle of 5"
+expected  = 5
+
+[[asserts]]
+arguments = [[0, 0, 0]]
+comment   = "Invalid permutation"
+expected  = -1
+
+[[asserts]]
+arguments = [[1, 1]]
+comment   = "Invalid permutation"
+expected  = -1
+
+[[asserts]]
+arguments = [[2, 0, 1, 4, 3, 5]]
+comment   = "Cycles of 3, 2, 1"
+expected  = 6
+
+[[asserts]]
+arguments = [[1, 2, 3, 0, 5, 6, 4]]
+comment   = "Cycles of 4 and 3 (LCM = 12)"
+expected  = 12
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 0, 6, 7, 8, 5]]
+comment   = "Cycles of 5 and 4 (LCM = 20)"
+expected  = 20
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 5, 0, 7, 8, 9, 6]]
+comment   = "Cycles of 6 and 4 (LCM = 12)"
+expected  = 12
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 5, 6, 0, 8, 9, 7]]
+comment   = "Cycles of 7 and 3 (LCM = 21)"
+expected  = 21
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 5, 6, 7, 0, 9, 8]]
+comment   = "Cycles of 8 and 2"
+expected  = 8
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 5, 6, 7, 8, 0, 9]]
+comment   = "Cycles of 9 and 1"
+expected  = 9
+
+[[asserts]]
+arguments = [[1, 2, 0, 4, 5, 6, 7, 3, 9, 10, 11, 12, 13, 8, 15, 14]]
+comment   = "Cycles of 3, 5, 6, 2 (LCM = 30)"
+expected  = 30
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 0, 6, 7, 8, 9, 10, 11, 5, 13, 14, 12]]
+comment   = "Cycles of 5, 7, 3 (LCM = 105)"
+expected  = 105
+
+[[asserts]]
+arguments = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 8]]
+comment   = "Not a permutation"
+expected  = -1
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0]]
+comment   = "Not a permutation with 0 duplicates"
+expected  = -1
+
+[[asserts]]
+arguments = [[2, 2, 2, 2, 2]]
+comment   = "All same elements"
+expected  = -1
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 15]]
+comment   = "Two cycles of 15"
+expected  = 15
+
+[[asserts]]
+arguments = [[1, 0, 3, 4, 2, 6, 7, 8, 5, 10, 11, 12, 13, 9]]
+comment   = "Cycles of 2, 3, 4, 5 (LCM = 60)"
+expected  = 60
\ No newline at end of file
diff --git a/tasks/easy/arrays/summary_ranges.toml b/tasks/easy/arrays/summary_ranges.toml
new file mode 100644
index 0000000..1e9cc36
--- /dev/null
+++ b/tasks/easy/arrays/summary_ranges.toml
@@ -0,0 +1,195 @@
+level             = "easy"
+name              = "summary_ranges"
+tags              = ["arrays", "strings"]
+time_to_solve_sec = 300
+
+description_en = """
+You are given a sorted array of unique integers `nums`.
+
+Return the smallest sorted list of ranges that cover all the numbers in the array exactly. That is, each element of `nums` is covered by exactly one of the ranges, and there is no integer `x` such that `x` is in one of the ranges but not in `nums`.
+
+Each range `[a, b]` in the list should be formatted as:
+- `"a->b"` if $a \\neq b$
+- `"a"` if $a = b$
+"""
+
+description_ru = """
+Вам дан отсортированный массив уникальных целых чисел `nums`.
+
+Верните минимальный отсортированный список диапазонов, которые в точности покрывают все числа в массиве. Это означает, что каждый элемент `nums` покрыт ровно одним диапазоном, и не существует такого целого числа `x`, которое находится в одном из диапазонов, но отсутствует в `nums`.
+
+Каждый диапазон `[a, b]` в списке должен быть отформатирован как:
+- `"a->b"`, если $a \\neq b$
+- `"a"`, если $a = b$
+"""
+
+limits = """
+- $0 \\leq \\text{len}(nums) \\leq 10^4$
+- $-10^9 \\leq nums[i] \\leq 10^9$
+- $nums$ is strictly increasing
+"""
+
+solution = """
+def solution(nums: list[int]) -> list[str]:
+    res = []
+    for n in nums:
+        if res and res[-1][1] == n - 1:
+            res[-1][1] = n
+        else:
+            res.append([n, n])
+    return [f"{s}->{e}" if s != e else str(s) for s, e in res]
+"""
+
+examples = """
+solution([]) == []
+solution([-1]) == ["-1"]
+solution([0, 1, 2, 4, 5, 7]) == ["0->2", "4->5", "7"]
+solution([0, 2, 3, 4, 6, 8, 9]) == ["0", "2->4", "6", "8->9"]
+"""
+
+[[input_signature]]
+argument_name = "nums"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "integer"
+
+[output_signature.type]
+name = "array"
+[output_signature.type.nested]
+name = "string"
+
+[[asserts]]
+arguments = [[]]
+comment   = "Empty array"
+expected  = []
+
+[[asserts]]
+arguments = [[0]]
+comment   = "Single element zero"
+expected  = ["0"]
+
+[[asserts]]
+arguments = [[-1]]
+comment   = "Single negative element"
+expected  = ["-1"]
+
+[[asserts]]
+arguments = [[1, 2]]
+comment   = "Single pair"
+expected  = ["1->2"]
+
+[[asserts]]
+arguments = [[1, 3]]
+comment   = "Two disconnected elements"
+expected  = ["1", "3"]
+
+[[asserts]]
+arguments = [[0, 1, 2, 4, 5, 7]]
+comment   = "Mix of intervals and single elements"
+expected  = ["0->2", "4->5", "7"]
+
+[[asserts]]
+arguments = [[0, 2, 3, 4, 6, 8, 9]]
+comment   = "Another mix from examples"
+expected  = ["0", "2->4", "6", "8->9"]
+
+[[asserts]]
+arguments = [[1, 2, 3, 4, 5]]
+comment   = "One single interval"
+expected  = ["1->5"]
+
+[[asserts]]
+arguments = [[2, 4, 6, 8]]
+comment   = "All isolated elements"
+expected  = ["2", "4", "6", "8"]
+
+[[asserts]]
+arguments = [[-5, -4, -3, -1, 0, 1]]
+comment   = "Negative to positive transition"
+expected  = ["-5->-3", "-1->1"]
+
+[[asserts]]
+arguments = [[-2, -1, 1, 2]]
+comment   = "Symmetric around zero"
+expected  = ["-2->-1", "1->2"]
+
+[[asserts]]
+arguments = [[10, 11, 12, 13, 14, 15]]
+comment   = "Larger strictly consecutive range"
+expected  = ["10->15"]
+
+[[asserts]]
+arguments = [[-10, -9, -8, 0, 1, 2, 8, 9, 10]]
+comment   = "Multiple separate continuous intervals"
+expected  = ["-10->-8", "0->2", "8->10"]
+
+[[asserts]]
+arguments = [[-1000000000, 1000000000]]
+comment   = "Extreme values without overflow issues"
+expected  = ["-1000000000", "1000000000"]
+
+[[asserts]]
+arguments = [[100, 101, 102, 103, 105, 106, 107]]
+comment   = "Two large consecutive ranges"
+expected  = ["100->103", "105->107"]
+
+[[asserts]]
+arguments = [[1, 2, 3, 5, 6, 7, 9, 10, 11]]
+comment   = "Triplets"
+expected  = ["1->3", "5->7", "9->11"]
+
+[[asserts]]
+arguments = [[-50, -49, -48]]
+comment   = "Negative sequence"
+expected  = ["-50->-48"]
+
+[[asserts]]
+arguments = [[0, 1]]
+comment   = "Smallest consecutive positive"
+expected  = ["0->1"]
+
+[[asserts]]
+arguments = [[-1, 0]]
+comment   = "Zero included"
+expected  = ["-1->0"]
+
+[[asserts]]
+arguments = [[-3, -2, -1]]
+comment   = "Small negative sequence"
+expected  = ["-3->-1"]
+
+[[asserts]]
+arguments = [[10, 20, 30, 40]]
+comment   = "Tens apart"
+expected  = ["10", "20", "30", "40"]
+
+[[asserts]]
+arguments = [[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]]
+comment   = "Long zero to nine sequence"
+expected  = ["0->9"]
+
+[[asserts]]
+arguments = [[-100, -99, -98, -96, -95, -94]]
+comment   = "Two negative chunks"
+expected  = ["-100->-98", "-96->-94"]
+
+[[asserts]]
+arguments = [[7, 8, 9, 10, 12, 13]]
+comment   = "Two differently sized chunks"
+expected  = ["7->10", "12->13"]
+
+[[asserts]]
+arguments = [[4, 6, 8, 10, 12]]
+comment   = "Even numbers"
+expected  = ["4", "6", "8", "10", "12"]
+
+[[asserts]]
+arguments = [[1, 3, 5, 7, 9]]
+comment   = "Odd numbers"
+expected  = ["1", "3", "5", "7", "9"]
+
+[[asserts]]
+arguments = [[-10, -5, 0, 5, 10]]
+comment   = "Step of 5"
+expected  = ["-10", "-5", "0", "5", "10"]
\ No newline at end of file
diff --git a/tasks/easy/arrays/toeplitz_matrix.toml b/tasks/easy/arrays/toeplitz_matrix.toml
new file mode 100644
index 0000000..7f51e6a
--- /dev/null
+++ b/tasks/easy/arrays/toeplitz_matrix.toml
@@ -0,0 +1,199 @@
+level             = "easy"
+name              = "toeplitz_matrix"
+tags              = ["arrays", "matrices"]
+time_to_solve_sec = 200
+
+description_en = """
+Given an $m \\times n$ `matrix`, return `True` if the matrix is Toeplitz. Otherwise, return `False`.
+
+A matrix is **Toeplitz** if every diagonal from top-left to bottom-right has the same elements.
+"""
+
+description_ru = """
+Дана матрица `matrix` размером $m \\times n$. Верните `True`, если матрица является Тёплицевой. В противном случае верните `False`.
+
+Матрица называется **Тёплицевой**, если каждая диагональ от верхнего левого угла до нижнего правого состоит из одинаковых элементов.
+"""
+
+limits = """
+- $1 \\leq m, n \\leq 20$
+- $0 \\leq \\text{matrix}[i][j] \\leq 100$
+"""
+
+solution = """
+def solution(matrix: list[list[int]]) -> bool:
+    for i in range(1, len(matrix)):
+        for j in range(1, len(matrix[0])):
+            if matrix[i][j] != matrix[i-1][j-1]:
+                return False
+    return True
+"""
+
+examples = """
+solution([[1]]) == True
+solution([[1, 2], [3, 1]]) == True
+solution([[1, 2], [2, 2]]) == False
+solution([[1, 2, 3], [4, 1, 2], [5, 4, 1]]) == True
+"""
+
+[[input_signature]]
+argument_name = "matrix"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "array"
+[input_signature.type.nested.nested]
+name = "integer"
+
+[output_signature.type]
+name = "boolean"
+
+[[asserts]]
+arguments = [[[1]]]
+comment   = "1x1 matrix is always Toeplitz"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 2, 3, 4]]]
+comment   = "1xN matrix is always Toeplitz"
+expected  = true
+
+[[asserts]]
+arguments = [[[1], [2], [3], [4]]]
+comment   = "Mx1 matrix is always Toeplitz"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 2], [3, 1]]]
+comment   = "2x2 Toeplitz matrix"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 2], [2, 2]]]
+comment   = "2x2 non-Toeplitz matrix"
+expected  = false
+
+[[asserts]]
+arguments = [[[1, 2, 3, 4], [5, 1, 2, 3], [9, 5, 1, 2]]]
+comment   = "3x4 Toeplitz matrix"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 2, 3, 4], [5, 1, 9, 3], [9, 5, 1, 2]]]
+comment   = "3x4 non-Toeplitz matrix with one incorrect element"
+expected  = false
+
+[[asserts]]
+arguments = [[[1, 2], [1, 2]]]
+comment   = "Columns are identical, but diagonals are not"
+expected  = false
+
+[[asserts]]
+arguments = [[[0, 0], [0, 0]]]
+comment   = "Matrix with all zeros"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]
+comment   = "Sequential matrix is not Toeplitz"
+expected  = false
+
+[[asserts]]
+arguments = [[[3, 3, 3], [3, 3, 3], [3, 3, 3]]]
+comment   = "Matrix with all identical elements"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 2, 3], [2, 1, 2], [3, 2, 1]]]
+comment   = "Symmetric Toeplitz matrix"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 2, 3], [2, 1, 4], [3, 2, 1]]]
+comment   = "Almost symmetric but non-Toeplitz"
+expected  = false
+
+[[asserts]]
+arguments = [[[9, 8, 7, 6], [5, 9, 8, 7], [4, 5, 9, 8], [3, 4, 5, 9]]]
+comment   = "4x4 Toeplitz matrix"
+expected  = true
+
+[[asserts]]
+arguments = [[[9, 8, 7, 6], [5, 9, 8, 7], [4, 5, 9, 8], [3, 4, 5, 1]]]
+comment   = "4x4 non-Toeplitz matrix, last element wrong"
+expected  = false
+
+[[asserts]]
+arguments = [[[1, 2, 3, 4, 5], [6, 1, 2, 3, 4], [7, 6, 1, 2, 3]]]
+comment   = "3x5 Toeplitz matrix"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 2, 3, 4, 5], [6, 1, 2, 3, 4], [7, 6, 1, 2, 9]]]
+comment   = "3x5 non-Toeplitz matrix"
+expected  = false
+
+[[asserts]]
+arguments = [[[1, 1], [2, 1], [3, 2], [4, 3]]]
+comment   = "4x2 Toeplitz matrix"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 1], [2, 1], [3, 2], [4, 4]]]
+comment   = "4x2 non-Toeplitz matrix"
+expected  = false
+
+[[asserts]]
+arguments = [[[5, 4, 3], [6, 5, 4], [7, 6, 5], [8, 7, 6]]]
+comment   = "4x3 Toeplitz matrix"
+expected  = true
+
+[[asserts]]
+arguments = [[[5, 4, 3], [6, 5, 4], [7, 6, 5], [8, 7, 5]]]
+comment   = "4x3 non-Toeplitz matrix"
+expected  = false
+
+[[asserts]]
+arguments = [[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]]
+comment   = "Identity matrix is Toeplitz"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 0]]]
+comment   = "Slightly modified identity matrix"
+expected  = false
+
+[[asserts]]
+arguments = [[[8, 8, 8, 8], [8, 8, 8, 8], [8, 8, 8, 8], [8, 8, 8, 8]]]
+comment   = "4x4 matrix of 8s"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 2], [3, 1], [4, 3], [5, 4], [6, 5]]]
+comment   = "5x2 Toeplitz matrix"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 2, 3, 4, 5, 6]]]
+comment   = "1x6 matrix"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 2], [2, 1], [1, 2]]]
+comment   = "Alternating elements form a valid Toeplitz pattern"
+expected  = true
+
+[[asserts]]
+arguments = [[[1, 1, 1, 1], [2, 2, 2, 2]]]
+comment   = "Rows are internally identical but diagonals are not"
+expected  = false
+
+[[asserts]]
+arguments = [[[1, 1, 1, 1], [2, 1, 1, 1]]]
+comment   = "Shifted identical rows form a Toeplitz matrix"
+expected  = true
+
+[[asserts]]
+arguments = [[[3, 4, 5, 6], [2, 3, 4, 5], [1, 2, 3, 4]]]
+comment   = "Another valid 3x4 Toeplitz matrix"
+expected  = true
\ No newline at end of file
diff --git a/tasks/easy/arrays/town_judge.toml b/tasks/easy/arrays/town_judge.toml
new file mode 100644
index 0000000..5cc930b
--- /dev/null
+++ b/tasks/easy/arrays/town_judge.toml
@@ -0,0 +1,215 @@
+level             = "easy"
+name              = "town_judge"
+tags              = ["arrays", "graphs"]
+time_to_solve_sec = 250
+
+description_en = """
+In a town, there are $n$ people labeled from $1$ to $n$. There is a rumor that one of these people is secretly the town judge.
+
+The town judge satisfies two properties:
+1. The town judge trusts nobody.
+2. Everybody (except for the town judge) trusts the town judge.
+
+You are given an array `trust` where `trust[i] = [a, b]` representing that the person labeled `a` trusts the person labeled `b`.
+
+Return the label of the town judge if they exist and can be identified, or return `-1` otherwise.
+"""
+
+description_ru = """
+В городе живут $n$ людей, пронумерованных от $1$ до $n$. Ходят слухи, что один из них — городской судья.
+
+Судья должен соответствовать двум условиям:
+1. Судья никому не доверяет.
+2. Все остальные жители города (кроме самого судьи) доверяют судье.
+
+Вам дан массив пар `trust`, где `trust[i] = [a, b]` означает, что человек `a` доверяет человеку `b`.
+
+Верните номер городского судьи, если он существует, иначе верните `-1`.
+"""
+
+limits = """
+- $1 \\leq n \\leq 1000$
+- $0 \\leq \\text{len}(\\text{trust}) \\leq 10^4$
+- $\\text{trust}[i][0] \\neq \\text{trust}[i][1]$
+"""
+
+solution = """
+def solution(n: int, trust: list) -> int:
+    d = [0] * (n + 1)
+    for a, b in trust:
+        d[a] -= 1
+        d[b] += 1
+    for i in range(1, n + 1):
+        if d[i] == n - 1:
+            return i
+    return -1
+"""
+
+examples = """
+solution(2, [[1, 2]]) == 2
+solution(3, [[1, 3], [2, 3]]) == 3
+solution(3, [[1, 3], [2, 3], [3, 1]]) == -1
+solution(3, [[1, 2], [2, 3]]) == -1
+"""
+
+[[input_signature]]
+argument_name = "n"
+[input_signature.type]
+name = "integer"
+
+[[input_signature]]
+argument_name = "trust"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "array"
+[input_signature.type.nested.nested]
+name = "integer"
+
+[output_signature.type]
+name = "integer"
+
+[[asserts]]
+arguments = [2, [[1, 2]]]
+comment   = "Simple case: 1 trusts 2"
+expected  = 2
+
+[[asserts]]
+arguments = [3, [[1, 3], [2, 3]]]
+comment   = "Everyone trusts 3"
+expected  = 3
+
+[[asserts]]
+arguments = [3, [[1, 3], [2, 3], [3, 1]]]
+comment   = "Judge trusts someone (invalid)"
+expected  = -1
+
+[[asserts]]
+arguments = [3, [[1, 2], [2, 3]]]
+comment   = "No one is trusted by everyone else"
+expected  = -1
+
+[[asserts]]
+arguments = [4, [[1, 3], [1, 4], [2, 3], [2, 4], [4, 3]]]
+comment   = "3 is trusted by 1, 2, 4 and trusts no one"
+expected  = 3
+
+[[asserts]]
+arguments = [1, []]
+comment   = "Single person is the judge by default"
+expected  = 1
+
+[[asserts]]
+arguments = [2, []]
+comment   = "Two people, no trust"
+expected  = -1
+
+[[asserts]]
+arguments = [4, [[1, 2], [1, 3], [2, 1], [2, 3], [4, 1], [4, 2], [4, 3]]]
+comment   = "3 is trusted by everyone"
+expected  = 3
+
+[[asserts]]
+arguments = [4, [[1, 4], [2, 4], [3, 4], [4, 1]]]
+comment   = "Judge trusts someone"
+expected  = -1
+
+[[asserts]]
+arguments = [3, [[1, 2], [2, 1]]]
+comment   = "Cyclic trust with no clear judge"
+expected  = -1
+
+[[asserts]]
+arguments = [2, [[2, 1]]]
+comment   = "2 trusts 1"
+expected  = 1
+
+[[asserts]]
+arguments = [5, [[1, 5], [2, 5], [3, 5], [4, 5]]]
+comment   = "Everyone trusts 5"
+expected  = 5
+
+[[asserts]]
+arguments = [5, [[1, 5], [2, 5], [3, 5], [4, 5], [5, 4]]]
+comment   = "5 trusts 4, cannot be judge"
+expected  = -1
+
+[[asserts]]
+arguments = [3, [[1, 3], [1, 2], [2, 3]]]
+comment   = "3 is the judge"
+expected  = 3
+
+[[asserts]]
+arguments = [4, [[1, 2], [2, 3], [3, 4]]]
+comment   = "No one trusted by all"
+expected  = -1
+
+[[asserts]]
+arguments = [5, [[1, 2], [2, 3], [3, 4], [4, 5], [5, 1]]]
+comment   = "Trust cycle"
+expected  = -1
+
+[[asserts]]
+arguments = [6, [[1, 6], [2, 6], [3, 6], [4, 6], [5, 6]]]
+comment   = "6 is judge"
+expected  = 6
+
+[[asserts]]
+arguments = [6, [[1, 6], [2, 6], [3, 6], [4, 6], [5, 6], [1, 2]]]
+comment   = "Extra trust between non-judges"
+expected  = 6
+
+[[asserts]]
+arguments = [3, [[1, 2], [2, 3], [3, 2]]]
+comment   = "2 is trusted by 1 and 3, but 2 trusts 3"
+expected  = -1
+
+[[asserts]]
+arguments = [4, [[1, 4], [2, 4], [3, 4], [1, 2], [2, 1]]]
+comment   = "Complex non-judge trust"
+expected  = 4
+
+[[asserts]]
+arguments = [2, [[1, 2], [2, 1]]]
+comment   = "Mutual trust"
+expected  = -1
+
+[[asserts]]
+arguments = [5, [[1, 3], [2, 3], [4, 3], [5, 3], [1, 2], [2, 4]]]
+comment   = "3 is judge, others have complex relations"
+expected  = 3
+
+[[asserts]]
+arguments = [10, [[1, 10], [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10]]]
+comment   = "Large group judge"
+expected  = 10
+
+[[asserts]]
+arguments = [4, [[1, 4], [2, 4]]]
+comment   = "Not everyone trusts 4"
+expected  = -1
+
+[[asserts]]
+arguments = [3, [[1, 2], [1, 3]]]
+comment   = "No one trusted by 2 people"
+expected  = -1
+
+[[asserts]]
+arguments = [5, [[1, 2], [1, 3], [1, 4], [1, 5], [2, 3], [2, 4], [2, 5], [3, 4], [3, 5], [4, 5]]]
+comment   = "5 is the judge"
+expected  = 5
+
+[[asserts]]
+arguments = [3, [[1, 3], [2, 3], [2, 1]]]
+comment   = "3 is the judge"
+expected  = 3
+
+[[asserts]]
+arguments = [4, [[2, 1], [3, 1], [4, 1]]]
+comment   = "1 is judge, others trust 1"
+expected  = 1
+
+[[asserts]]
+arguments = [3, [[1, 3], [2, 3], [1, 2]]]
+comment   = "1 trusts 2 and 3, 2 trusts 3"
+expected  = 3
\ No newline at end of file
diff --git a/tasks/easy/hash_maps/peak_performance_sum.toml b/tasks/easy/hash_maps/peak_performance_sum.toml
new file mode 100644
index 0000000..39fde24
--- /dev/null
+++ b/tasks/easy/hash_maps/peak_performance_sum.toml
@@ -0,0 +1,184 @@
+level             = "easy"
+name              = "peak_performance_sum"
+tags              = ["hashmaps", "arrays"]
+time_to_solve_sec = 250
+
+description_en = """
+You are given two arrays of the same length: `teams` and `scores`.
+For each index $i$, `teams[i]` is the name of a team, and `scores[i]` is the score they achieved in a specific match.
+
+A team can participate in multiple matches. Find the **highest** score achieved by each unique team across all their matches, and return the sum of these highest scores.
+
+If the input arrays are empty, return $0$.
+"""
+
+description_ru = """
+Вам даны два массива одинаковой длины: `teams` и `scores`.
+Для каждого индекса $i$, `teams[i]` — это название команды, а `scores[i]` — количество баллов, которые она получила в конкретном матче.
+
+Команда может участвовать в нескольких матчах. Найдите **наивысший** балл, полученный каждой уникальной командой за все её матчи, и верните сумму этих наивысших баллов.
+
+Если входные массивы пусты, верните $0$.
+"""
+
+limits = """
+- $0 \\leq \\text{len}(\\text{teams}) = \\text{len}(\\text{scores}) \\leq 10^4$
+- $-10^4 \\leq \\text{scores}[i] \\leq 10^4$
+"""
+
+solution = """
+def solution(teams: list, scores: list) -> int:
+    best = {}
+    for t, s in zip(teams, scores):
+        best[t] = max(best.get(t, s), s)
+    return sum(best.values())
+"""
+
+examples = """
+solution([], []) == 0
+solution(["A", "A"], [-10, -5]) == -5
+solution(["A", "B"], [10, 20]) == 30
+solution(["A", "B", "A"], [10, 20, 30]) == 50
+"""
+
+[[input_signature]]
+argument_name = "teams"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "string"
+
+[[input_signature]]
+argument_name = "scores"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "integer"
+
+[output_signature.type]
+name = "integer"
+
+[[asserts]]
+arguments = [[], []]
+comment   = "Empty arrays"
+expected  = 0
+
+[[asserts]]
+arguments = [["A"], [10]]
+comment   = "Single team, single score"
+expected  = 10
+
+[[asserts]]
+arguments = [["A", "A"], [10, 20]]
+comment   = "Single team, multiple increasing scores"
+expected  = 20
+
+[[asserts]]
+arguments = [["A", "A"], [20, 10]]
+comment   = "Single team, multiple decreasing scores"
+expected  = 20
+
+[[asserts]]
+arguments = [["A", "A"], [-10, -5]]
+comment   = "Single team, negative increasing scores"
+expected  = -5
+
+[[asserts]]
+arguments = [["A", "A"], [-5, -10]]
+comment   = "Single team, negative decreasing scores"
+expected  = -5
+
+[[asserts]]
+arguments = [["A", "B"], [10, 20]]
+comment   = "Two distinct teams"
+expected  = 30
+
+[[asserts]]
+arguments = [["A", "B", "A"], [10, 20, 30]]
+comment   = "Two teams, one improves"
+expected  = 50
+
+[[asserts]]
+arguments = [["A", "B", "A", "B"], [5, 5, 5, 5]]
+comment   = "Multiple teams with identical scores"
+expected  = 10
+
+[[asserts]]
+arguments = [["Red", "Blue", "Green"], [-10, -20, -30]]
+comment   = "Distinct teams with negative scores"
+expected  = -60
+
+[[asserts]]
+arguments = [["T1", "T2", "T1", "T2"], [100, -100, -50, 50]]
+comment   = "Mix of negative and positive improvements"
+expected  = 150
+
+[[asserts]]
+arguments = [["X"], [0]]
+comment   = "Single zero score"
+expected  = 0
+
+[[asserts]]
+arguments = [["X", "X", "X"], [0, 0, 0]]
+comment   = "Multiple zero scores for one team"
+expected  = 0
+
+[[asserts]]
+arguments = [["TeamA", "TeamB", "TeamC", "TeamA"], [15, 25, 35, 10]]
+comment   = "Later score is lower"
+expected  = 75
+
+[[asserts]]
+arguments = [["Alpha", "Beta", "Alpha", "Beta", "Gamma"], [1, 2, 3, 4, 5]]
+comment   = "Various teams interleaving"
+expected  = 12
+
+[[asserts]]
+arguments = [["Z", "Y", "X", "W"], [10, 10, 10, 10]]
+comment   = "All distinct teams, same score"
+expected  = 40
+
+[[asserts]]
+arguments = [["T1", "T1", "T1", "T1", "T1"], [-1, -2, -3, -4, -5]]
+comment   = "Strictly decreasing negative sequence"
+expected  = -1
+
+[[asserts]]
+arguments = [["T1", "T1", "T1", "T1", "T1"], [-5, -4, -3, -2, -1]]
+comment   = "Strictly increasing negative sequence"
+expected  = -1
+
+[[asserts]]
+arguments = [["One"], [9999]]
+comment   = "Large single value"
+expected  = 9999
+
+[[asserts]]
+arguments = [["A", "B", "C", "D", "E"], [1, -1, 2, -2, 3]]
+comment   = "Alternating positive and negative base line"
+expected  = 3
+
+[[asserts]]
+arguments = [["Cats", "Dogs", "Cats", "Dogs"], [13, 14, 13, 15]]
+comment   = "Minor score adjustments"
+expected  = 28
+
+[[asserts]]
+arguments = [["A", "a"], [10, 20]]
+comment   = "Case sensitivity test"
+expected  = 30
+
+[[asserts]]
+arguments = [["Team1", "Team2", "Team3", "Team1"], [-1000, 500, 0, -500]]
+comment   = "Deep negative improvement"
+expected  = 0
+
+[[asserts]]
+arguments = [["Same", "Same", "Different"], [50, 50, 100]]
+comment   = "Duplicate scores on same team"
+expected  = 150
+
+[[asserts]]
+arguments = [["A", "B", "C", "A", "B", "C"], [1, 2, 3, 4, 5, 6]]
+comment   = "Double pass of the same teams"
+expected  = 15
\ No newline at end of file
diff --git a/tasks/easy/math/custom_fibonacci.toml b/tasks/easy/math/custom_fibonacci.toml
new file mode 100644
index 0000000..1279dc7
--- /dev/null
+++ b/tasks/easy/math/custom_fibonacci.toml
@@ -0,0 +1,198 @@
+level             = "easy"
+name              = "custom_fibonacci"
+tags              = ["math", "algorithms"]
+time_to_solve_sec = 200
+
+description_en = """
+Given three integers `f0`, `f1`, and `n`. 
+
+Consider a sequence where the first two elements are `f0` and `f1`, and every subsequent element is the sum of the two preceding elements. 
+
+Return `True` if `n` belongs to this sequence, and `False` otherwise.
+"""
+
+description_ru = """
+Даны три целых числа `f0`, `f1` и `n`. 
+
+Рассмотрим последовательность, первые два элемента которой равны `f0` и `f1`, а каждый последующий элемент равен сумме двух предыдущих. 
+
+Верните `True`, если `n` принадлежит этой последовательности, и `False` в противном случае.
+"""
+
+limits = """
+- $0 \\leq f_0, f_1 \\leq 1000$
+- $0 \\leq n \\leq 10^9$
+"""
+
+solution = """
+def solution(f0: int, f1: int, n: int) -> bool:
+    if n in (f0, f1): return True
+    if f0 == 0 and f1 == 0: return False
+    while f1 < n:
+        f0, f1 = f1, f0 + f1
+    return f1 == n
+"""
+
+examples = """
+solution(0, 1, 5) == True
+solution(2, 1, 4) == True
+solution(10, 20, 100) == False
+"""
+
+[[input_signature]]
+argument_name = "f0"
+[input_signature.type]
+name = "integer"
+
+[[input_signature]]
+argument_name = "f1"
+[input_signature.type]
+name = "integer"
+
+[[input_signature]]
+argument_name = "n"
+[input_signature.type]
+name = "integer"
+
+[output_signature.type]
+name = "boolean"
+
+[[asserts]]
+arguments = [0, 1, 5]
+comment   = "Classic Fibonacci, n = 5 is in the sequence"
+expected  = true
+
+[[asserts]]
+arguments = [0, 1, 8]
+comment   = "Classic Fibonacci, n = 8 is in the sequence"
+expected  = true
+
+[[asserts]]
+arguments = [0, 1, 4]
+comment   = "Classic Fibonacci, n = 4 is NOT in the sequence"
+expected  = false
+
+[[asserts]]
+arguments = [2, 1, 3]
+comment   = "Lucas numbers, 3 is in (2, 1, 3)"
+expected  = true
+
+[[asserts]]
+arguments = [2, 1, 4]
+comment   = "Lucas numbers, 4 is in (2, 1, 3, 4)"
+expected  = true
+
+[[asserts]]
+arguments = [2, 1, 7]
+comment   = "Lucas numbers, 7 is in (2, 1, 3, 4, 7)"
+expected  = true
+
+[[asserts]]
+arguments = [2, 1, 10]
+comment   = "Lucas numbers, 10 is NOT in sequence"
+expected  = false
+
+[[asserts]]
+arguments = [0, 0, 0]
+comment   = "Zero sequence, n = 0"
+expected  = true
+
+[[asserts]]
+arguments = [0, 0, 5]
+comment   = "Zero sequence, n = 5 is NOT in sequence"
+expected  = false
+
+[[asserts]]
+arguments = [5, 5, 10]
+comment   = "Equal starting numbers, 10 is in sequence"
+expected  = true
+
+[[asserts]]
+arguments = [5, 5, 15]
+comment   = "Equal starting numbers, 15 is in sequence"
+expected  = true
+
+[[asserts]]
+arguments = [5, 5, 20]
+comment   = "Equal starting numbers, 20 is NOT in sequence"
+expected  = false
+
+[[asserts]]
+arguments = [10, 20, 30]
+comment   = "Multiples of 10, 30 is in sequence"
+expected  = true
+
+[[asserts]]
+arguments = [10, 20, 50]
+comment   = "Multiples of 10, 50 is in sequence"
+expected  = true
+
+[[asserts]]
+arguments = [10, 20, 80]
+comment   = "Multiples of 10, 80 is in sequence"
+expected  = true
+
+[[asserts]]
+arguments = [10, 20, 130]
+comment   = "Multiples of 10, 130 is in sequence"
+expected  = true
+
+[[asserts]]
+arguments = [10, 20, 100]
+comment   = "Multiples of 10, 100 is NOT in sequence"
+expected  = false
+
+[[asserts]]
+arguments = [100, 1, 101]
+comment   = "Decreasing start, 101 is in sequence"
+expected  = true
+
+[[asserts]]
+arguments = [100, 1, 102]
+comment   = "Decreasing start, 102 is in sequence"
+expected  = true
+
+[[asserts]]
+arguments = [100, 1, 203]
+comment   = "Decreasing start, 203 is in sequence"
+expected  = true
+
+[[asserts]]
+arguments = [100, 1, 200]
+comment   = "Decreasing start, 200 is NOT in sequence"
+expected  = false
+
+[[asserts]]
+arguments = [5, 10, 5]
+comment   = "n is equal to f0"
+expected  = true
+
+[[asserts]]
+arguments = [5, 10, 10]
+comment   = "n is equal to f1"
+expected  = true
+
+[[asserts]]
+arguments = [50, 60, 10]
+comment   = "n is smaller than both f0 and f1"
+expected  = false
+
+[[asserts]]
+arguments = [0, 1, 102334155]
+comment   = "Large Fibonacci number"
+expected  = true
+
+[[asserts]]
+arguments = [0, 1, 102334156]
+comment   = "Large number NOT in Fibonacci sequence"
+expected  = false
+
+[[asserts]]
+arguments = [0, 1, 701408733]
+comment   = "Another large Fibonacci number"
+expected  = true
+
+[[asserts]]
+arguments = [13, 21, 5]
+comment   = "n is smaller than f0, f1 with Fibonacci sequence"
+expected  = false
\ No newline at end of file
diff --git a/tasks/easy/math/expanded_notation_array.toml b/tasks/easy/math/expanded_notation_array.toml
new file mode 100644
index 0000000..961bb2d
--- /dev/null
+++ b/tasks/easy/math/expanded_notation_array.toml
@@ -0,0 +1,175 @@
+level             = "easy"
+name              = "expanded_notation_array"
+tags              = ["math", "strings", "parsing", "arrays"]
+time_to_solve_sec = 250
+
+description_en = """
+Expanded Notation means an integer is written as the sum of its digits multiplied with its place value (in strictly descending powers of $10$). 
+
+For example, $85063 = 8 \\times 10000 + 5 \\times 1000 + 6 \\times 10 + 3$. 
+
+You are given an array of strings `arr`, where each string represents a natural number in expanded notation. The strings use `"x"` for multiplication and `"+"` for addition, with no spaces. Your task is to compute the sum for each string and return an array of these numbers in their normal integer form.
+"""
+
+description_ru = """
+Развернутая запись означает, что целое число записано в виде суммы его цифр, умноженных на их разрядное значение (в строго убывающих степенях $10$).
+
+Например, $85063 = 8 \\times 10000 + 5 \\times 1000 + 6 \\times 10 + 3$.
+
+Вам дан массив строк `arr`, где каждая строка представляет натуральное число в развернутой записи. В строках используется `"x"` для умножения и `"+"` для сложения, без пробелов. Ваша задача — вычислить сумму для каждой строки и вернуть массив этих чисел в обычном целом виде.
+"""
+
+limits = """
+- $1 \\leq \\text{len}(arr) \\leq 100$
+- $3 \\leq \\text{len}(arr[i]) \\leq 100$
+- $arr[i]$ contains only digits, `"x"`, and `"+"`
+- Place values are powers of $10$
+"""
+
+solution = """
+def solution(arr: list) -> list:
+    return [sum(int(part.split('x')[0]) * int(part.split('x')[1]) for part in s.split('+')) for s in arr]
+"""
+
+examples = """
+solution(["1x1"]) == [1]
+solution(["9x10", "1x1"]) == [90, 1]
+solution(["7x100+2x1", "8x10000+5x1000+6x10+3"]) == [702, 85063]
+"""
+
+[[input_signature]]
+argument_name = "arr"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "string"
+
+[output_signature.type]
+name = "array"
+[output_signature.type.nested]
+name = "integer"
+
+[[asserts]]
+arguments = [["8x10000+5x1000+6x10+3x1"]]
+comment   = "Complex example from description"
+expected  = [85063]
+
+[[asserts]]
+arguments = [["7x100+2x1", "1x1"]]
+comment   = "Multiple elements"
+expected  = [702, 1]
+
+[[asserts]]
+arguments = [["1x1"]]
+comment   = "Single digit"
+expected  = [1]
+
+[[asserts]]
+arguments = [["9x10", "4x100000+2x100"]]
+comment   = "Varying lengths"
+expected  = [90, 400200]
+
+[[asserts]]
+arguments = [["1x1000+1x1"]]
+comment   = "One thousand and one"
+expected  = [1001]
+
+[[asserts]]
+arguments = [["1x10", "1x100", "1x1000"]]
+comment   = "Increasing powers of ten"
+expected  = [10, 100, 1000]
+
+[[asserts]]
+arguments = [["5x1000+5x10", "6x10000+6x100+6x1", "7x1000000"]]
+comment   = "Array with three different complexities"
+expected  = [5050, 60606, 7000000]
+
+[[asserts]]
+arguments = [["9x1000+9x100+9x10+9x1"]]
+comment   = "All nines"
+expected  = [9999]
+
+[[asserts]]
+arguments = [["1x100000000+2x10000000+3x1000000+4x100000+5x10000+6x1000+7x100+8x10+9x1"]]
+comment   = "Consecutive digits"
+expected  = [123456789]
+
+[[asserts]]
+arguments = [["2x1000000+1x1", "3x10"]]
+comment   = "Millions and tens"
+expected  = [2000001, 30]
+
+[[asserts]]
+arguments = [["4x100+4x1", "5x100+5x10"]]
+comment   = "Hundreds"
+expected  = [404, 550]
+
+[[asserts]]
+arguments = [["5x10000+5x1000"]]
+comment   = "Fifty five thousand"
+expected  = [55000]
+
+[[asserts]]
+arguments = [["8x100000000", "9x100000000+9x1000000+9x10000+9x100+9x1"]]
+comment   = "Alternating nines and zeros"
+expected  = [800000000, 909090909]
+
+[[asserts]]
+arguments = [["1x10000+1x1000+1x100+1x10+1x1", "2x100+2x10+2x1"]]
+comment   = "All ones and all twos"
+expected  = [11111, 222]
+
+[[asserts]]
+arguments = [["3x10+3x1", "4x1"]]
+comment   = "All threes and fours"
+expected  = [33, 4]
+
+[[asserts]]
+arguments = [["1x1000000000"]]
+comment   = "One billion"
+expected  = [1000000000]
+
+[[asserts]]
+arguments = [["1x1000000000+1x10000000+1x100000+1x1000+1x10"]]
+comment   = "Alternating ones and zeros"
+expected  = [1010101010]
+
+[[asserts]]
+arguments = [["5x10000+4x1000+3x100+2x10+1x1", "1x1"]]
+comment   = "Descending digits"
+expected  = [54321, 1]
+
+[[asserts]]
+arguments = [["9x100000000+8x10000000+7x1000000+6x100000+5x10000+4x1000+3x100+2x10+1x1"]]
+comment   = "Long descending digits"
+expected  = [987654321]
+
+[[asserts]]
+arguments = [["9x100+9x10+9x1", "8x100+8x10+8x1"]]
+comment   = "Nines and eights"
+expected  = [999, 888]
+
+[[asserts]]
+arguments = [["7x1000+2x1", "6x1000+3x10", "5x1000+4x100"]]
+comment   = "Zeros in different positions"
+expected  = [7002, 6030, 5400]
+
+[[asserts]]
+arguments = [["1x10000", "2x10000", "3x10000"]]
+comment   = "Same order of magnitude"
+expected  = [10000, 20000, 30000]
+
+[[asserts]]
+arguments = [["1x100000", "2x1000000"]]
+comment   = "Powers of ten variations"
+expected  = [100000, 2000000]
+
+[[asserts]]
+arguments = [["1x1000000+2x100000+3x10000", "4x1000+5x100+6x10+7x1"]]
+comment   = "Split full number across array elements"
+expected  = [1230000, 4567]
+
+[[asserts]]
+arguments = [["8x100000+5x100+3x1", "2x10000+4x100+1x1"]]
+comment   = "Various missing place values"
+expected  = [800503, 20401]
\ No newline at end of file
diff --git a/tasks/easy/math/primes_with_prime_digit_sum.toml b/tasks/easy/math/primes_with_prime_digit_sum.toml
new file mode 100644
index 0000000..0595507
--- /dev/null
+++ b/tasks/easy/math/primes_with_prime_digit_sum.toml
@@ -0,0 +1,178 @@
+level             = "easy"
+name              = "primes_with_prime_digit_sum"
+tags              = ["math", "numbers"]
+time_to_solve_sec = 250
+
+description_en = """
+Find all prime numbers in the inclusive range $[a, b]$ such that the sum of their digits is also a prime number. Return the result as an array.
+"""
+
+description_ru = """
+Найдите все простые числа на отрезке $[a, b]$ (включительно), сумма цифр которых также является простым числом. Верните результат в виде массива.
+"""
+
+limits = """
+- $1 \\leq a \\leq b \\leq 10^4$
+"""
+
+solution = """
+def solution(a: int, b: int) -> list:
+    P = lambda n: n > 1 and all(n % i for i in range(2, int(n**0.5) + 1))
+    return [x for x in range(a, b + 1) if P(x) and P(sum(map(int, str(x))))]
+"""
+
+examples = """
+solution(30, 40) == []
+solution(10, 20) == [11]
+solution(1, 10) == [2, 3, 5, 7]
+"""
+
+[[input_signature]]
+argument_name = "a"
+[input_signature.type]
+name = "integer"
+
+[[input_signature]]
+argument_name = "b"
+[input_signature.type]
+name = "integer"
+
+[output_signature.type]
+name = "array"
+[output_signature.type.nested]
+name = "integer"
+
+[[asserts]]
+arguments = [1, 10]
+comment   = "Single digit primes"
+expected  = [2, 3, 5, 7]
+
+[[asserts]]
+arguments = [10, 20]
+comment   = "First two-digit numbers"
+expected  = [11]
+
+[[asserts]]
+arguments = [20, 30]
+comment   = "Twenties"
+expected  = [23, 29]
+
+[[asserts]]
+arguments = [30, 40]
+comment   = "No matching primes in this range"
+expected  = []
+
+[[asserts]]
+arguments = [40, 50]
+comment   = "Forties"
+expected  = [41, 43, 47]
+
+[[asserts]]
+arguments = [50, 60]
+comment   = "Fifties without matches"
+expected  = []
+
+[[asserts]]
+arguments = [60, 70]
+comment   = "Sixties"
+expected  = [61, 67]
+
+[[asserts]]
+arguments = [70, 80]
+comment   = "Seventies without matches"
+expected  = []
+
+[[asserts]]
+arguments = [80, 90]
+comment   = "Eighties"
+expected  = [83, 89]
+
+[[asserts]]
+arguments = [90, 100]
+comment   = "Nineties without matches"
+expected  = []
+
+[[asserts]]
+arguments = [100, 120]
+comment   = "Early hundreds"
+expected  = [101, 113]
+
+[[asserts]]
+arguments = [130, 140]
+comment   = "Range with consecutive valid primes"
+expected  = [131, 137, 139]
+
+[[asserts]]
+arguments = [190, 200]
+comment   = "Late hundreds"
+expected  = [191, 193, 197, 199]
+
+[[asserts]]
+arguments = [200, 210]
+comment   = "Early two-hundreds with no valid primes"
+expected  = []
+
+[[asserts]]
+arguments = [200, 250]
+comment   = "Larger slice in two-hundreds"
+expected  = [223, 227, 229, 241]
+
+[[asserts]]
+arguments = [300, 320]
+comment   = "Early three-hundreds"
+expected  = [311, 313, 317]
+
+[[asserts]]
+arguments = [400, 420]
+comment   = "Early four-hundreds"
+expected  = [401, 409]
+
+[[asserts]]
+arguments = [500, 520]
+comment   = "Early five-hundreds without matches"
+expected  = []
+
+[[asserts]]
+arguments = [600, 620]
+comment   = "Early six-hundreds"
+expected  = [601, 607]
+
+[[asserts]]
+arguments = [700, 720]
+comment   = "Early seven-hundreds"
+expected  = [719]
+
+[[asserts]]
+arguments = [800, 820]
+comment   = "Early eight-hundreds"
+expected  = [809]
+
+[[asserts]]
+arguments = [900, 920]
+comment   = "Early nine-hundreds"
+expected  = [911, 919]
+
+[[asserts]]
+arguments = [990, 1000]
+comment   = "Approaching one thousand"
+expected  = [991]
+
+[[asserts]]
+arguments = [1, 1]
+comment   = "Single value 1 (not prime)"
+expected  = []
+
+[[asserts]]
+arguments = [2, 2]
+comment   = "Single value 2 (prime)"
+expected  = [2]
+
+[[asserts]]
+arguments = [11, 11]
+comment   = "Single value boundary check"
+expected  = [11]
+
+[[asserts]]
+arguments = [1000, 1010]
+comment   = "Past one thousand without matches"
+expected  = []
\ No newline at end of file
diff --git a/tasks/easy/math/self_dividing_numbers.toml b/tasks/easy/math/self_dividing_numbers.toml
new file mode 100644
index 0000000..e3f913a
--- /dev/null
+++ b/tasks/easy/math/self_dividing_numbers.toml
@@ -0,0 +1,182 @@
+level             = "easy"
+name              = "self_dividing_numbers"
+tags              = ["math", "loops"]
+time_to_solve_sec = 240
+
+description_en = """
+A self-dividing number is a number that is divisible by every digit it contains. 
+For example, `128` is a self-dividing number because $128 \\pmod 1 = 0$, $128 \\pmod 2 = 0$, and $128 \\pmod 8 = 0$.
+
+A self-dividing number is not allowed to contain the digit `0`.
+
+Given two integers `left` and `right`, return an array of all the self-dividing numbers in the range `[left, right]` (inclusive).
+"""
+
+description_ru = """
+Самоделящееся число — это число, которое без остатка делится на каждую из своих цифр. 
+Например, `128` является самоделящимся числом, так как $128 \\pmod 1 = 0$, $128 \\pmod 2 = 0$ и $128 \\pmod 8 = 0$.
+
+Самоделящееся число не должно содержать цифру `0`.
+
+Даны два целых числа `left` и `right`. Верните массив всех самоделящихся чисел в диапазоне `[left, right]` (включительно).
+"""
+
+limits = """
+- $1 \\leq \\text{left} \\leq \\text{right} \\leq 10^4$
+"""
+
+solution = """
+def solution(left: int, right: int) -> list[int]:
+    return [n for n in range(left, right + 1) if all(int(d) != 0 and n % int(d) == 0 for d in str(n))]
+"""
+
+examples = """
+solution(47, 49) == [48]
+solution(10, 15) == [11, 12, 15]
+solution(1, 10) == [1, 2, 3, 4, 5, 6, 7, 8, 9]
+"""
+
+[[input_signature]]
+argument_name = "left"
+[input_signature.type]
+name = "integer"
+
+[[input_signature]]
+argument_name = "right"
+[input_signature.type]
+name = "integer"
+
+[output_signature.type]
+name = "array"
+[output_signature.type.nested]
+name = "integer"
+
+[[asserts]]
+arguments = [1, 10]
+comment   = "Single digits"
+expected  = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+
+[[asserts]]
+arguments = [10, 15]
+comment   = "Small range with zero"
+expected  = [11, 12, 15]
+
+[[asserts]]
+arguments = [47, 49]
+comment   = "Short range with one match"
+expected  = [48]
+
+[[asserts]]
+arguments = [1, 22]
+comment   = "Range across two tens"
+expected  = [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]
+
+[[asserts]]
+arguments = [13, 14]
+comment   = "Range with no self-dividing numbers"
+expected  = []
+
+[[asserts]]
+arguments = [47, 85]
+comment   = "Mid-size range"
+expected  = [48, 55, 66, 77]
+
+[[asserts]]
+arguments = [128, 128]
+comment   = "Three-digit match"
+expected  = [128]
+
+[[asserts]]
+arguments = [100, 110]
+comment   = "Range full of zeros"
+expected  = []
+
+[[asserts]]
+arguments = [111, 115]
+comment   = "Range with small identical digits"
+expected  = [111, 112, 115]
+
+[[asserts]]
+arguments = [15, 21]
+comment   = "Cross-tens range with one match"
+expected  = [15]
+
+[[asserts]]
+arguments = [33, 33]
+comment   = "Identical digits self-dividing"
+expected  = [33]
+
+[[asserts]]
+arguments = [23, 23]
+comment   = "Single number, non self-dividing"
+expected  = []
+
+[[asserts]]
+arguments = [312, 312]
+comment   = "Three-digit match check"
+expected  = [312]
+
+[[asserts]]
+arguments = [41, 45]
+comment   = "Check divisibility logic"
+expected  = [44]
+
+[[asserts]]
+arguments = [80, 90]
+comment   = "High two-digits range"
+expected  = [88]
+
+[[asserts]]
+arguments = [300, 311]
+comment   = "Zeros and non-dividing"
+expected  = []
+
+[[asserts]]
+arguments = [200, 212]
+comment   = "Zeros jumping to valid"
+expected  = [212]
+
+[[asserts]]
+arguments = [72, 73]
+comment   = "Exact bounds"
+expected  = []
+
+[[asserts]]
+arguments = [1000, 1010]
+comment   = "Thousands with zeros"
+expected  = []
+
+[[asserts]]
+arguments = [120, 130]
+comment   = "Hundreds range"
+expected  = [122, 124, 126, 128]
+
+[[asserts]]
+arguments = [999, 999]
+comment   = "Maximum triple digits"
+expected  = [999]
+
+[[asserts]]
+arguments = [24, 25]
+comment   = "Adjacent values"
+expected  = [24]
+
+[[asserts]]
+arguments = [104, 104]
+comment   = "Contains zero, despite other checks"
+expected  = []
+
+[[asserts]]
+arguments = [61, 65]
+comment   = "Range with no matches"
+expected  = []
+
+[[asserts]]
+arguments = [25, 30]
+comment   = "Range leading to zero"
+expected  = []
+
+[[asserts]]
+arguments = [300, 315]
+comment   = "Wider range in hundreds"
+expected  = [312, 315]
\ No newline at end of file
diff --git a/tasks/easy/strings/center_strings.toml b/tasks/easy/strings/center_strings.toml
new file mode 100644
index 0000000..7ec3828
--- /dev/null
+++ b/tasks/easy/strings/center_strings.toml
@@ -0,0 +1,205 @@
+level             = "easy"
+name              = "center_strings"
+tags              = ["strings", "formatting"]
+time_to_solve_sec = 200
+
+description_en = """
+Given an array of strings, return a new array where each string is centered to the length of the longest string in the original array, padded with spaces (`" "`).
+
+If the padding is uneven (i.e., the difference between the maximum length and the current string's length is odd), apply the standard Python `str.center()` behavior:
+- If the target width is odd and the margin is odd, the extra space goes to the **left**.
+- Otherwise, the extra space goes to the **right**.
+
+If the input array is empty, return an empty array.
+"""
+
+description_ru = """
+Дан массив строк. Верните новый массив, в котором каждая строка отцентрирована по длине самой длинной строки в исходном массиве и дополнена пробелами (`" "`).
+
+Если количество добавляемых пробелов нечетное, используйте стандартное поведение метода `str.center()` в Python:
+- Если целевая ширина нечетная и общая разница нечетная, дополнительный пробел добавляется **слева**.
+- Во всех остальных случаях дополнительный пробел добавляется **справа**.
+
+Если исходный массив пуст, верните пустой массив.
+"""
+
+limits = """
+- $0 \\leq \\text{len}(strings) \\leq 100$
+- $0 \\leq \\text{len}(strings[i]) \\leq 100$
+"""
+
+solution = """
+def solution(strings: list[str]) -> list[str]:
+    if not strings:
+        return []
+    max_len = max(len(s) for s in strings)
+    return [s.center(max_len) for s in strings]
+"""
+
+examples = """
+solution([]) == []
+solution(["hi", "hello"]) == ["  hi ", "hello"]
+solution(["a", "abc", "a"]) == [" a ", "abc", " a "]
+"""
+
+[[input_signature]]
+argument_name = "strings"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "string"
+
+[output_signature.type]
+name = "array"
+[output_signature.type.nested]
+name = "string"
+
+[[asserts]]
+arguments = [[]]
+comment   = "Empty array"
+expected  = []
+
+[[asserts]]
+arguments = [["hello"]]
+comment   = "Single string"
+expected  = ["hello"]
+
+[[asserts]]
+arguments = [["a", "abc"]]
+comment   = "Odd max len, odd string, even margin -> equal padding"
+expected  = [" a ", "abc"]
+
+[[asserts]]
+arguments = [["ab", "abcd"]]
+comment   = "Even max len, even string, even margin -> equal padding"
+expected  = [" ab ", "abcd"]
+
+[[asserts]]
+arguments = [["a", "abcd"]]
+comment   = "Even max len, odd string, odd margin -> extra space right"
+expected  = [" a  ", "abcd"]
+
+[[asserts]]
+arguments = [["abc", "a"]]
+comment   = "Max string first"
+expected  = ["abc", " a "]
+
+[[asserts]]
+arguments = [["hi", "hello"]]
+comment   = "Odd max len, even string, odd margin -> extra space left"
+expected  = ["  hi ", "hello"]
+
+[[asserts]]
+arguments = [["", "a"]]
+comment   = "Odd max len, empty string, odd margin"
+expected  = [" ", "a"]
+
+[[asserts]]
+arguments = [["", "ab"]]
+comment   = "Even max len, empty string, even margin"
+expected  = ["  ", "ab"]
+
+[[asserts]]
+arguments = [["A", "BB", "CCC", "DDDD"]]
+comment   = "Multiple lengths with max 4"
+expected  = [" A  ", " BB ", "CCC ", "DDDD"]
+
+[[asserts]]
+arguments = [["*", "***", "*****"]]
+comment   = "Stars with max 5"
+expected  = ["  *  ", " *** ", "*****"]
+
+[[asserts]]
+arguments = [["python", "is", "fun"]]
+comment   = "Words with max 6"
+expected  = ["python", "  is  ", " fun  "]
+
+[[asserts]]
+arguments = [["short", "loooong"]]
+comment   = "Words with max 7"
+expected  = [" short ", "loooong"]
+
+[[asserts]]
+arguments = [["1", "123456789"]]
+comment   = "1 char to 9 chars"
+expected  = ["    1    ", "123456789"]
+
+[[asserts]]
+arguments = [["12", "123456789"]]
+comment   = "2 chars to 9 chars (extra space left)"
+expected  = ["    12   ", "123456789"]
+
+[[asserts]]
+arguments = [["123", "123456789"]]
+comment   = "3 chars to 9 chars"
+expected  = ["   123   ", "123456789"]
+
+[[asserts]]
+arguments = [["1234", "123456789"]]
+comment   = "4 chars to 9 chars (extra space left)"
+expected  = ["   1234  ", "123456789"]
+
+[[asserts]]
+arguments = [["12345", "123456789"]]
+comment   = "5 chars to 9 chars"
+expected  = ["  12345  ", "123456789"]
+
+[[asserts]]
+arguments = [["123456", "123456789"]]
+comment   = "6 chars to 9 chars (extra space left)"
+expected  = ["  123456 ", "123456789"]
+
+[[asserts]]
+arguments = [["1234567", "123456789"]]
+comment   = "7 chars to 9 chars"
+expected  = [" 1234567 ", "123456789"]
+
+[[asserts]]
+arguments = [["12345678", "123456789"]]
+comment   = "8 chars to 9 chars (extra space left)"
+expected  = [" 12345678", "123456789"]
+
+[[asserts]]
+arguments = [["word", ""]]
+comment   = "Empty string padded to even length"
+expected  = ["word", "    "]
+
+[[asserts]]
+arguments = [["even", "odd lengths"]]
+comment   = "4 chars to 11 chars (extra space left)"
+expected  = ["    even   ", "odd lengths"]
+
+[[asserts]]
+arguments = [["same", "size"]]
+comment   = "Already same size"
+expected  = ["same", "size"]
+
+[[asserts]]
+arguments = [["a", "a", "a"]]
+comment   = "All identical"
+expected  = ["a", "a", "a"]
+
+[[asserts]]
+arguments = [[" ", "   "]]
+comment   = "Spaces only"
+expected  = ["   ", "   "]
+
+[[asserts]]
+arguments = [["x", "y", "longword"]]
+comment   = "Single chars to even max length"
+expected  = ["   x    ", "   y    ", "longword"]
+
+[[asserts]]
+arguments = [["", "", ""]]
+comment   = "All empty strings"
+expected  = ["", "", ""]
+
+[[asserts]]
+arguments = [["align", "me", "please", "to", "center"]]
+comment   = "Multiple mixed strings, max 6"
+expected  = ["align ", "  me  ", "please", "  to  ", "center"]
+
+[[asserts]]
+arguments = [["12345", "1234", "123", "12", "1", ""]]
+comment   = "Decreasing lengths, max 5"
+expected  = ["12345", " 1234", " 123 ", "  12 ", "  1  ", "     "]
\ No newline at end of file
diff --git a/tasks/easy/strings/digit_snake_formatter.toml b/tasks/easy/strings/digit_snake_formatter.toml
new file mode 100644
index 0000000..613a116
--- /dev/null
+++ b/tasks/easy/strings/digit_snake_formatter.toml
@@ -0,0 +1,207 @@
+level             = "easy"
+name              = "digit_snake_formatter"
+tags              = ["strings", "formatting"]
+time_to_solve_sec = 250
+
+description_en = """
+Transform a digit string `n` into a "snake" format based on an integer `c`:
+
+1. Extract the first `c` digits from string `n`. If `c` exceeds the length of `n`, use all available digits.
+2. Split the resulting substring into chunks of $8$ characters.
+3. Pad the final chunk with the character `X` on the right until it reaches a length of $8$.
+4. Reverse chunks located at odd indices ($1, 3, 5, \\dots$). Keep chunks at even indices ($0, 2, 4, \\dots$) as they are.
+5. Return the chunks joined by newline characters (`\\n`).
+"""
+
+description_ru = """
+Преобразуйте строку цифр `n` в формат «змейки» на основе целого числа `c`:
+
+1. Возьмите первые `c` цифр из строки `n`. Если `c` больше длины `n`, используйте все имеющиеся цифры.
+2. Разделите полученную подстроку на блоки по $8$ символов.
+3. Дополните последний блок символом `X` справа, пока его длина не станет равной $8$.
+4. Разверните блоки, находящиеся на нечетных индексах ($1, 3, 5, \\dots$). Блоки на четных индексах ($0, 2, 4, \\dots$) оставьте без изменений.
+5. Верните блоки, объединенные символом переноса строки (`\\n`).
+"""
+
+limits = """
+- $0 \\leq \\text{len}(n) \\leq 1000$
+- $0 \\leq c \\leq 1000$
+- $n$ contains only digits $0-9$
+"""
+
+solution = """
+def solution(n: str, c: int) -> str:
+    s = n[:c]
+    chunks = [s[i:i+8].ljust(8, 'X') for i in range(0, len(s), 8)]
+    return "\\n".join(x[::-1] if i % 2 else x for i, x in enumerate(chunks))
+"""
+
+examples = """
+solution("", 5) == ""
+solution("123", 0) == ""
+solution("123", 2) == "12XXXXXX"
+solution("1234567890", 10) == "12345678\\nXXXXXX09"
+"""
+
+[[input_signature]]
+argument_name = "n"
+[input_signature.type]
+name = "string"
+
+[[input_signature]]
+argument_name = "c"
+[input_signature.type]
+name = "integer"
+
+[output_signature.type]
+name = "string"
+
+[[asserts]]
+arguments = ["", 10]
+comment   = "Empty string input"
+expected  = ""
+
+[[asserts]]
+arguments = ["12345", 0]
+comment   = "Zero characters requested"
+expected  = ""
+
+[[asserts]]
+arguments = ["1", 1]
+comment   = "Single character padding"
+expected  = "1XXXXXXX"
+
+[[asserts]]
+arguments = ["12345678", 8]
+comment   = "Exactly one full chunk"
+expected  = "12345678"
+
+[[asserts]]
+arguments = ["123456789", 9]
+comment   = "Two chunks, second needs padding and reversal"
+expected  = "12345678\nXXXXXXX9"
+
+[[asserts]]
+arguments = ["1234567890123456", 16]
+comment   = "Two full chunks, second reversed"
+expected  = "12345678\n65432109"
+
+[[asserts]]
+arguments = ["111111112222222233333333", 24]
+comment   = "Three full chunks"
+expected  = "11111111\n22222222\n33333333"
+
+[[asserts]]
+arguments = ["123", 5]
+comment   = "c is greater than string length"
+expected  = "123XXXXX"
+
+[[asserts]]
+arguments = ["0000000000000000", 16]
+comment   = "Identical digits"
+expected  = "00000000\n00000000"
+
+[[asserts]]
+arguments = ["12345678123456781234567812345678", 32]
+comment   = "Four full chunks"
+expected  = "12345678\n87654321\n12345678\n87654321"
+
+[[asserts]]
+arguments = ["987654321", 5]
+comment   = "c is smaller than first chunk size"
+expected  = "98765XXX"
+
+[[asserts]]
+arguments = ["1234567890", 11]
+comment   = "c is larger than length, but logic handles it"
+expected  = "12345678\nXXXXXX09"
+
+[[asserts]]
+arguments = ["123456781", 9]
+comment   = "Last chunk is single digit"
+expected  = "12345678\nXXXXXXX1"
+
+[[asserts]]
+arguments = ["123456781234567", 15]
+comment   = "Last chunk is almost full"
+expected  = "12345678\nX7654321"
+
+[[asserts]]
+arguments = ["1234567887654321", 16]
+comment   = "Reversing a reversed sequence"
+expected  = "12345678\n12345678"
+
+[[asserts]]
+arguments = ["01234567890123456789", 20]
+comment   = "Three chunks, middle one full reversed"
+expected  = "01234567\n54321098\n6789XXXX"
+
+[[asserts]]
+arguments = ["12121212", 8]
+comment   = "Repeating pattern"
+expected  = "12121212"
+
+[[asserts]]
+arguments = ["1234123412341234", 16]
+comment   = "Repeating chunks"
+expected  = "12341234\n43214321"
+
+[[asserts]]
+arguments = ["1111111100000000", 16]
+comment   = "Switching values between chunks"
+expected  = "11111111\n00000000"
+
+[[asserts]]
+arguments = ["5555", 2]
+comment   = "c limits string to less than original"
+expected  = "55XXXXXX"
+
+[[asserts]]
+arguments = ["123456789012345678901234567890", 25]
+comment   = "Multiple chunks with padding at the very end"
+expected  = "12345678\n65432109\n78901234\nXXXXXXX5"
+
+[[asserts]]
+arguments = ["888888887777777766666666", 20]
+comment   = "Non-full third chunk"
+expected  = "88888888\n77777777\n6666XXXX"
+
+[[asserts]]
+arguments = ["0000000100000002", 16]
+comment   = "Check specific digit placement"
+expected  = "00000001\n20000000"
+
+[[asserts]]
+arguments = ["123456789999999912345678", 24]
+comment   = "Middle chunk all 9s"
+expected  = "12345678\n99999999\n12345678"
+
+[[asserts]]
+arguments = ["1000000020000000", 16]
+comment   = "Zeros and specific digits"
+expected  = "10000000\n00000002"
+
+[[asserts]]
+arguments = ["1234567812345678123456781234567812345678", 40]
+comment   = "Five chunks check"
+expected  = "12345678\n87654321\n12345678\n87654321\n12345678"
+
+[[asserts]]
+arguments = ["111122223333444455556666", 24]
+comment   = "Alternating even/odd reversal"
+expected  = "11112222\n44443333\n55556666"
+
+[[asserts]]
+arguments = ["12345678", 9]
+comment   = "c slightly larger than len(n)"
+expected  = "12345678"
+
+[[asserts]]
+arguments = ["9", 1]
+comment   = "Min non-zero case"
+expected  = "9XXXXXXX"
+
+[[asserts]]
+arguments = ["12345678901234567890", 17]
+comment   = "Last chunk is single char, index 2 (even)"
+expected  = "12345678\n65432109\n7XXXXXXX"
\ No newline at end of file
diff --git a/tasks/easy/strings/longest_balanced_substring.toml b/tasks/easy/strings/longest_balanced_substring.toml
new file mode 100644
index 0000000..3da20f0
--- /dev/null
+++ b/tasks/easy/strings/longest_balanced_substring.toml
@@ -0,0 +1,198 @@
+level             = "easy"
+name              = "longest_balanced_segment"
+tags              = ["strings", "hash-map", "algorithms"]
+time_to_solve_sec = 250
+
+description_en = """
+A binary segment is called balanced if it contains the same number of `$0$`s and `$1$`s.
+
+Given a binary string `$s$`, determine the length of the longest balanced contiguous segment. If no such segment exists, return `$0$`.
+"""
+
+description_ru = """
+Бинарный сегмент называется сбалансированным, если он содержит одинаковое количество `$0$` и `$1$`.
+
+Дана бинарная строка `$s$`. Определите длину самого длинного сбалансированного непрерывного сегмента. Если такого сегмента не существует, верните `$0$`.
+"""
+
+limits = """
+- $0 \\leq \\text{len}(s) \\leq 10^5$
+- $s[i] \\in \\{0, 1\\}$
+"""
+
+solution = """
+def solution(s: str) -> int:
+    d, c, r = {0: -1}, 0, 0
+    for i, v in enumerate(s):
+        c += 1 if v == '1' else -1
+        if c in d: r = max(r, i - d[c])
+        else: d[c] = i
+    return r
+"""
+
+examples = """
+solution("0") == 0
+solution("01") == 2
+solution("111") == 0
+solution("1100") == 4
+solution("11010") == 4
+solution("101010") == 6
+"""
+
+[[input_signature]]
+argument_name = "s"
+[input_signature.type]
+name = "string"
+
+[output_signature.type]
+name = "integer"
+
+[[asserts]]
+arguments = [""]
+comment   = "Empty string case"
+expected  = 0
+
+[[asserts]]
+arguments = ["0"]
+comment   = "Single character zero"
+expected  = 0
+
+[[asserts]]
+arguments = ["1"]
+comment   = "Single character one"
+expected  = 0
+
+[[asserts]]
+arguments = ["01"]
+comment   = "Smallest balanced segment"
+expected  = 2
+
+[[asserts]]
+arguments = ["10"]
+comment   = "Smallest balanced reversed"
+expected  = 2
+
+[[asserts]]
+arguments = ["000"]
+comment   = "Multiple zeros, no balance"
+expected  = 0
+
+[[asserts]]
+arguments = ["111"]
+comment   = "Multiple ones, no balance"
+expected  = 0
+
+[[asserts]]
+arguments = ["001"]
+comment   = "Balanced part at the end"
+expected  = 2
+
+[[asserts]]
+arguments = ["110"]
+comment   = "Balanced part at the end with one"
+expected  = 2
+
+[[asserts]]
+arguments = ["100"]
+comment   = "Balanced part at the start"
+expected  = 2
+
+[[asserts]]
+arguments = ["011"]
+comment   = "Balanced part at the start with zero"
+expected  = 2
+
+[[asserts]]
+arguments = ["0011"]
+comment   = "Fully balanced symmetric"
+expected  = 4
+
+[[asserts]]
+arguments = ["1100"]
+comment   = "Fully balanced symmetric reversed"
+expected  = 4
+
+[[asserts]]
+arguments = ["0101"]
+comment   = "Alternating fully balanced"
+expected  = 4
+
+[[asserts]]
+arguments = ["1010"]
+comment   = "Alternating fully balanced starting with one"
+expected  = 4
+
+[[asserts]]
+arguments = ["000111"]
+comment   = "Longer fully balanced symmetric"
+expected  = 6
+
+[[asserts]]
+arguments = ["111000"]
+comment   = "Longer fully balanced symmetric reversed"
+expected  = 6
+
+[[asserts]]
+arguments = ["11010"]
+comment   = "Balanced segment within unbalanced string"
+expected  = 4
+
+[[asserts]]
+arguments = ["10101"]
+comment   = "Alternating with trailing extra char"
+expected  = 4
+
+[[asserts]]
+arguments = ["001100"]
+comment   = "Balanced segment embedded in zeros"
+expected  = 4
+
+[[asserts]]
+arguments = ["01110"]
+comment   = "Short balanced segments at edges"
+expected  = 2
+
+[[asserts]]
+arguments = ["00001"]
+comment   = "Large imbalance, small result"
+expected  = 2
+
+[[asserts]]
+arguments = ["11110"]
+comment   = "Large imbalance with ones"
+expected  = 2
+
+[[asserts]]
+arguments = ["00011"]
+comment   = "Imbalanced prefix"
+expected  = 4
+
+[[asserts]]
+arguments = ["11100"]
+comment   = "Imbalanced prefix with ones"
+expected  = 4
+
+[[asserts]]
+arguments = ["010101"]
+comment   = "Long alternating balanced"
+expected  = 6
+
+[[asserts]]
+arguments = ["101010"]
+comment   = "Long alternating balanced starting with one"
+expected  = 6
+
+[[asserts]]
+arguments = ["0000111"]
+comment   = "Large imbalance at start"
+expected  = 6
+
+[[asserts]]
+arguments = ["1111000"]
+comment   = "Large imbalance at start with ones"
+expected  = 6
+
+[[asserts]]
+arguments = ["01101100"]
+comment   = "Full string is balanced with internal patterns"
+expected  = 8
\ No newline at end of file
diff --git a/tasks/easy/strings/longest_common_prefix.toml b/tasks/easy/strings/longest_common_prefix.toml
new file mode 100644
index 0000000..3072986
--- /dev/null
+++ b/tasks/easy/strings/longest_common_prefix.toml
@@ -0,0 +1,186 @@
+level             = "easy"
+name              = "longest_common_prefix"
+tags              = ["strings", "arrays"]
+time_to_solve_sec = 250
+
+description_en = """
+Write a function to find the longest common prefix string amongst an array of strings.
+
+If there is no common prefix, return an empty string `""`.
+"""
+
+description_ru = """
+Напишите функцию для поиска самого длинного общего префикса среди массива строк.
+
+Если общего префикса нет, верните пустую строку `""`.
+"""
+
+limits = """
+- $1 \\leq \\text{len}(\\text{strs}) \\leq 200$
+- $0 \\leq \\text{len}(\\text{strs}[i]) \\leq 200$
+"""
+
+solution = """
+def solution(strs: list[str]) -> str:
+    res = ""
+    for chars in zip(*strs):
+        if len(set(chars)) != 1: break
+        res += chars[0]
+    return res
+"""
+
+examples = """
+solution(["a"]) == "a"
+solution(["dog", "racecar", "car"]) == ""
+solution(["flower", "flow", "flight"]) == "fl"
+"""
+
+[[input_signature]]
+argument_name = "strs"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "string"
+
+[output_signature.type]
+name = "string"
+
+[[asserts]]
+arguments = [["flower", "flow", "flight"]]
+comment   = "Standard case with a common prefix"
+expected  = "fl"
+
+[[asserts]]
+arguments = [["dog", "racecar", "car"]]
+comment   = "No common prefix"
+expected  = ""
+
+[[asserts]]
+arguments = [["a"]]
+comment   = "Single string"
+expected  = "a"
+
+[[asserts]]
+arguments = [[""]]
+comment   = "Single empty string"
+expected  = ""
+
+[[asserts]]
+arguments = [["", "b"]]
+comment   = "First string is empty"
+expected  = ""
+
+[[asserts]]
+arguments = [["a", ""]]
+comment   = "Last string is empty"
+expected  = ""
+
+[[asserts]]
+arguments = [["ab", "a"]]
+comment   = "Longest prefix is the entire second string"
+expected  = "a"
+
+[[asserts]]
+arguments = [["a", "ab"]]
+comment   = "Longest prefix is the entire first string"
+expected  = "a"
+
+[[asserts]]
+arguments = [["abc", "abc", "abc"]]
+comment   = "All strings are identical"
+expected  = "abc"
+
+[[asserts]]
+arguments = [["abc", "abcd", "abcde"]]
+comment   = "Strings in increasing length"
+expected  = "abc"
+
+[[asserts]]
+arguments = [["abcde", "abcd", "abc"]]
+comment   = "Strings in decreasing length"
+expected  = "abc"
+
+[[asserts]]
+arguments = [["ab", "a", "abc"]]
+comment   = "Shortest string is in the middle"
+expected  = "a"
+
+[[asserts]]
+arguments = [["inters", "interstellar", "internet", "internal"]]
+comment   = "Long prefix"
+expected  = "inter"
+
+[[asserts]]
+arguments = [["throne", "throne"]]
+comment   = "Two identical strings"
+expected  = "throne"
+
+[[asserts]]
+arguments = [["throne", "dungeon"]]
+comment   = "Two completely different strings"
+expected  = ""
+
+[[asserts]]
+arguments = [["prefix", "prefixes", "preform"]]
+comment   = "Prefix variation"
+expected  = "pref"
+
+[[asserts]]
+arguments = [["apple", "ape", "april"]]
+comment   = "Common starting letters"
+expected  = "ap"
+
+[[asserts]]
+arguments = [["car", "cir"]]
+comment   = "Single common character"
+expected  = "c"
+
+[[asserts]]
+arguments = [["c", "c"]]
+comment   = "Identical single characters"
+expected  = "c"
+
+[[asserts]]
+arguments = [["c", "d"]]
+comment   = "Different single characters"
+expected  = ""
+
+[[asserts]]
+arguments = [["alone", "aloof", "albatross"]]
+comment   = "Common start"
+expected  = "al"
+
+[[asserts]]
+arguments = [["zebra", "z", "zephyr"]]
+comment   = "Single character bounds the prefix"
+expected  = "z"
+
+[[asserts]]
+arguments = [["same", "same", "same", "same", "same"]]
+comment   = "Many identical strings"
+expected  = "same"
+
+[[asserts]]
+arguments = [["a", "a", "b"]]
+comment   = "One string breaks the prefix at the end"
+expected  = ""
+
+[[asserts]]
+arguments = [["abcdefgh", "abcdefghij", "abcdefghijk", "abcdefghijkl"]]
+comment   = "Increasing length with long common prefix"
+expected  = "abcdefgh"
+
+[[asserts]]
+arguments = [["x", "x", "x", "y"]]
+comment   = "Break at last string single character"
+expected  = ""
+
+[[asserts]]
+arguments = [["hello", "helloworld", "hell"]]
+comment   = "Substring in middle"
+expected  = "hell"
+
+[[asserts]]
+arguments = [["python", "pyramid", "pyrite", "pyre"]]
+comment   = "Another normal case"
+expected  = "py"
\ No newline at end of file
diff --git a/tasks/easy/strings/string_blocks_transposition.toml b/tasks/easy/strings/string_blocks_transposition.toml
new file mode 100644
index 0000000..14c1782
--- /dev/null
+++ b/tasks/easy/strings/string_blocks_transposition.toml
@@ -0,0 +1,204 @@
+level             = "easy"
+name              = "string_blocks_transposition"
+tags              = ["strings", "formatting"]
+time_to_solve_sec = 200
+
+description_en = """
+You are given a string `s` and an integer `k`.
+
+If the length of the string `s` is not divisible by `k`, return an empty string `""`.
+Otherwise, split the string into blocks of length `k`. Construct and return a new string by taking the first character from each block, then the second character from each block, and so on, up to the `k`-th character.
+"""
+
+description_ru = """
+Дана строка `s` и целое число `k`.
+
+Если длина строки `s` не делится на `k`, верните пустую строку `""`.
+В противном случае разбейте строку на блоки длины `k`. Сформируйте и верните новую строку, беря сначала первый символ из каждого блока, затем второй символ из каждого блока, и так далее, вплоть до `k`-го символа.
+"""
+
+limits = """
+- $0 \\leq \\text{len}(s) \\leq 100$
+- $1 \\leq k \\leq 100$
+"""
+
+solution = """
+def solution(s: str, k: int) -> str:
+    if len(s) % k != 0:
+        return ""
+    return "".join(s[i::k] for i in range(k))
+"""
+
+examples = """
+solution("abcdef", 2) == "acebdf"
+solution("abcdef", 3) == "adbecf"
+solution("abc", 2) == ""
+"""
+
+[[input_signature]]
+argument_name = "s"
+[input_signature.type]
+name = "string"
+
+[[input_signature]]
+argument_name = "k"
+[input_signature.type]
+name = "integer"
+
+[output_signature.type]
+name = "string"
+
+[[asserts]]
+arguments = ["abcdef", 2]
+comment   = "Even length, divided into blocks of 2"
+expected  = "acebdf"
+
+[[asserts]]
+arguments = ["abcdef", 3]
+comment   = "Length 6, divided into blocks of 3"
+expected  = "adbecf"
+
+[[asserts]]
+arguments = ["abc", 2]
+comment   = "Length not divisible by k"
+expected  = ""
+
+[[asserts]]
+arguments = ["abcdef", 1]
+comment   = "k equals 1"
+expected  = "abcdef"
+
+[[asserts]]
+arguments = ["abcdef", 6]
+comment   = "k equals string length"
+expected  = "abcdef"
+
+[[asserts]]
+arguments = ["abcdef", 4]
+comment   = "Length not divisible by 4"
+expected  = ""
+
+[[asserts]]
+arguments = ["", 1]
+comment   = "Empty string"
+expected  = ""
+
+[[asserts]]
+arguments = ["", 5]
+comment   = "Empty string with larger k"
+expected  = ""
+
+[[asserts]]
+arguments = ["a", 1]
+comment   = "Single character string"
+expected  = "a"
+
+[[asserts]]
+arguments = ["ab", 1]
+comment   = "Length 2, k=1"
+expected  = "ab"
+
+[[asserts]]
+arguments = ["ab", 2]
+comment   = "Length 2, k=2"
+expected  = "ab"
+
+[[asserts]]
+arguments = ["hello", 5]
+comment   = "String length equals k"
+expected  = "hello"
+
+[[asserts]]
+arguments = ["hello", 2]
+comment   = "Length 5, k=2 (not divisible)"
+expected  = ""
+
+[[asserts]]
+arguments = ["helloworld", 2]
+comment   = "Longer string, k=2"
+expected  = "hloolelwrd"
+
+[[asserts]]
+arguments = ["123456789", 3]
+comment   = "Numeric string, blocks of 3"
+expected  = "147258369"
+
+[[asserts]]
+arguments = ["1234567890", 5]
+comment   = "Numeric string, blocks of 5"
+expected  = "1627384950"
+
+[[asserts]]
+arguments = ["aabbcc", 2]
+comment   = "Pairs of characters, k=2"
+expected  = "abcabc"
+
+[[asserts]]
+arguments = ["ababab", 2]
+comment   = "Repeating pattern, k=2"
+expected  = "aaabbb"
+
+[[asserts]]
+arguments = ["abcdefgh", 4]
+comment   = "Length 8, blocks of 4"
+expected  = "aebfcgdh"
+
+[[asserts]]
+arguments = ["abcdefgh", 8]
+comment   = "Length 8, k=8"
+expected  = "abcdefgh"
+
+[[asserts]]
+arguments = ["x", 5]
+comment   = "Length 1, k=5 (not divisible)"
+expected  = ""
+
+[[asserts]]
+arguments = ["xxxxxxxx", 2]
+comment   = "Homogeneous string"
+expected  = "xxxxxxxx"
+
+[[asserts]]
+arguments = ["python", 2]
+comment   = "Length 6, k=2"
+expected  = "ptoyhn"
+
+[[asserts]]
+arguments = ["python", 3]
+comment   = "Length 6, k=3"
+expected  = "phyotn"
+
+[[asserts]]
+arguments = ["programming", 1]
+comment   = "Length 11, k=1"
+expected  = "programming"
+
+[[asserts]]
+arguments = ["programming", 2]
+comment   = "Length 11, k=2 (not divisible)"
+expected  = ""
+
+[[asserts]]
+arguments = ["coder", 5]
+comment   = "Length 5, k=5"
+expected  = "coder"
+
+[[asserts]]
+arguments = ["xyzxyzxyz", 3]
+comment   = "Repeating pattern, k=3"
+expected  = "xxxyyyzzz"
+
+[[asserts]]
+arguments = ["ABCDEFGHIJKLMNOPQRST", 4]
+comment   = "Length 20, k=4"
+expected  = "AEIMQBFJNRCGKOSDHLPT"
+
+[[asserts]]
+arguments = ["abcabcabc", 3]
+comment   = "Repeating triplets, k=3"
+expected  = "aaabbbccc"
+
+[[asserts]]
+arguments = ["12345678", 2]
+comment   = "Sequence of 8 numbers, k=2"
+expected  = "13572468"
\ No newline at end of file
diff --git a/tasks/medium/algo/insert_interval.toml b/tasks/medium/algo/insert_interval.toml
new file mode 100644
index 0000000..4d6605b
--- /dev/null
+++ b/tasks/medium/algo/insert_interval.toml
@@ -0,0 +1,236 @@
+level             = "medium"
+name              = "insert_interval"
+tags              = ["algo", "intervals", "sorting"]
+time_to_solve_sec = 400
+
+description_en = """
+You are given an array of non-overlapping `intervals` where $\\text{intervals}[i] = [start_i, end_i]$ represent the start and the end of the $i$-th interval. The array `intervals` is sorted in ascending order by $start_i$.
+
+You are also given an array $\\text{new\\_interval} = [start, end]$ that represents the start and end of another interval.
+
+Insert $\\text{new\\_interval}$ into `intervals` such that `intervals` is still sorted in ascending order by $start_i$ and `intervals` still does not have any overlapping intervals (merge overlapping intervals if necessary).
+
+Return `intervals` after the insertion.
+"""
+
+description_ru = """
+Вам дан массив непересекающихся интервалов `intervals`, где $\\text{intervals}[i] = [start_i, end_i]$ представляют начало и конец $i$-го интервала. Массив `intervals` отсортирован по возрастанию $start_i$.
+
+Вам также дан массив $\\text{new\\_interval} = [start, end]$, который представляет собой начало и конец другого интервала.
+
+Вставьте $\\text{new\\_interval}$ в `intervals` так, чтобы `intervals` оставался отсортированным по возрастанию $start_i$ и не содержал пересекающихся интервалов (при необходимости объедините пересекающиеся интервалы).
+
+Верните `intervals` после вставки.
+"""
+
+limits = """
+- $0 \\leq \\text{len}(\\text{intervals}) \\leq 10^4$
+- $\\text{len}(\\text{intervals}[i]) == 2$
+- $\\text{len}(\\text{new\\_interval}) == 2$
+- $0 \\leq \\text{start}_i \\leq \\text{end}_i \\leq 10^5$
+- $0 \\leq \\text{new\\_interval}[0] \\leq \\text{new\\_interval}[1] \\leq 10^5$
+"""
+
+solution = """
+def solution(intervals: list[list[int]], new_interval: list[int]) -> list[list[int]]:
+    res = []
+    i = 0
+    n = len(intervals)
+    
+    while i < n and intervals[i][1] < new_interval[0]:
+        res.append(intervals[i])
+        i += 1
+        
+    start, end = new_interval[0], new_interval[1]
+    while i < n and intervals[i][0] <= end:
+        start = min(start, intervals[i][0])
+        end = max(end, intervals[i][1])
+        i += 1
+    res.append([start, end])
+    
+    while i < n:
+        res.append(intervals[i])
+        i += 1
+        
+    return res
+"""
+
+examples = """
+solution([], [5, 7]) == [[5, 7]]
+solution([[1, 5]], [2, 3]) == [[1, 5]]
+solution([[1, 3], [6, 9]], [2, 5]) == [[1, 5], [6, 9]]
+solution([[1, 2], [3, 5], [6, 7], [8, 10], [12, 16]], [4, 8]) == [[1, 2], [3, 10], [12, 16]]
+"""
+
+[[input_signature]]
+argument_name = "intervals"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "array"
+[input_signature.type.nested.nested]
+name = "integer"
+
+[[input_signature]]
+argument_name = "new_interval"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "integer"
+
+[output_signature.type]
+name = "array"
+[output_signature.type.nested]
+name = "array"
+[output_signature.type.nested.nested]
+name = "integer"
+
+[[asserts]]
+arguments = [[], [5, 7]]
+comment   = "Empty intervals"
+expected  = [[5, 7]]
+
+[[asserts]]
+arguments = [[[1, 3], [6, 9]], [2, 5]]
+comment   = "Merge with first interval"
+expected  = [[1, 5], [6, 9]]
+
+[[asserts]]
+arguments = [[[1, 2], [3, 5], [6, 7], [8, 10], [12, 16]], [4, 8]]
+comment   = "Merge multiple intervals"
+expected  = [[1, 2], [3, 10], [12, 16]]
+
+[[asserts]]
+arguments = [[[1, 5]], [2, 3]]
+comment   = "New interval completely inside"
+expected  = [[1, 5]]
+
+[[asserts]]
+arguments = [[[1, 5]], [0, 6]]
+comment   = "New interval covers all"
+expected  = [[0, 6]]
+
+[[asserts]]
+arguments = [[[1, 5]], [6, 8]]
+comment   = "Insert at the end without merge"
+expected  = [[1, 5], [6, 8]]
+
+[[asserts]]
+arguments = [[[3, 5]], [1, 2]]
+comment   = "Insert at the beginning without merge"
+expected  = [[1, 2], [3, 5]]
+
+[[asserts]]
+arguments = [[[1, 2], [5, 6]], [3, 4]]
+comment   = "Insert in the middle without merge"
+expected  = [[1, 2], [3, 4], [5, 6]]
+
+[[asserts]]
+arguments = [[[1, 2], [5, 6]], [2, 5]]
+comment   = "Merge exactly touching boundaries"
+expected  = [[1, 6]]
+
+[[asserts]]
+arguments = [[[1, 2], [3, 4], [5, 6]], [2, 5]]
+comment   = "Merge touching multiple boundaries"
+expected  = [[1, 6]]
+
+[[asserts]]
+arguments = [[[1, 5], [6, 9]], [1, 5]]
+comment   = "Exact duplicate interval"
+expected  = [[1, 5], [6, 9]]
+
+[[asserts]]
+arguments = [[[1, 5]], [1, 5]]
+comment   = "Duplicate single interval"
+expected  = [[1, 5]]
+
+[[asserts]]
+arguments = [[[1, 5], [8, 9]], [5, 8]]
+comment   = "Bridge two intervals"
+expected  = [[1, 9]]
+
+[[asserts]]
+arguments = [[[1, 2], [4, 5], [7, 8]], [2, 7]]
+comment   = "Bridge three intervals exactly"
+expected  = [[1, 8]]
+
+[[asserts]]
+arguments = [[[1, 2], [3, 4], [5, 6], [7, 8], [9, 10]], [1, 10]]
+comment   = "Swallow many small intervals"
+expected  = [[1, 10]]
+
+[[asserts]]
+arguments = [[[2, 3], [5, 6], [8, 9]], [0, 1]]
+comment   = "Insert completely before all"
+expected  = [[0, 1], [2, 3], [5, 6], [8, 9]]
+
+[[asserts]]
+arguments = [[[2, 3], [5, 6], [8, 9]], [10, 11]]
+comment   = "Insert completely after all"
+expected  = [[2, 3], [5, 6], [8, 9], [10, 11]]
+
+[[asserts]]
+arguments = [[[2, 4], [7, 9]], [4, 7]]
+comment   = "Exact fill the gap"
+expected  = [[2, 9]]
+
+[[asserts]]
+arguments = [[[1, 1]], [1, 2]]
+comment   = "Point interval merged"
+expected  = [[1, 2]]
+
+[[asserts]]
+arguments = [[[1, 3], [6, 9]], [3, 6]]
+comment   = "Connect two intervals perfectly"
+expected  = [[1, 9]]
+
+[[asserts]]
+arguments = [[[0, 0], [2, 2], [4, 4]], [0, 4]]
+comment   = "Merge multiple points"
+expected  = [[0, 4]]
+
+[[asserts]]
+arguments = [[[0, 2], [4, 6], [8, 10]], [3, 7]]
+comment   = "Merge with partial overlaps"
+expected  = [[0, 2], [3, 7], [8, 10]]
+
+[[asserts]]
+arguments = [[[1, 3], [5, 7], [9, 11]], [4, 8]]
+comment   = "Merge middle elements"
+expected  = [[1, 3], [4, 8], [9, 11]]
+
+[[asserts]]
+arguments = [[[1, 100]], [50, 60]]
+comment   = "New interval is a subsegment"
+expected  = [[1, 100]]
+
+[[asserts]]
+arguments = [[[10, 20], [30, 40], [50, 60]], [15, 55]]
+comment   = "Merge all with offsets"
+expected  = [[10, 60]]
+
+[[asserts]]
+arguments = [[[1, 2], [3, 4], [5, 6]], [3, 3]]
+comment   = "New interval is a point inside existing"
+expected  = [[1, 2], [3, 4], [5, 6]]
+
+[[asserts]]
+arguments = [[[1, 2], [4, 5]], [3, 3]]
+comment   = "New interval is an isolated point"
+expected  = [[1, 2], [3, 3], [4, 5]]
+
+[[asserts]]
+arguments = [[[1, 5], [10, 15], [20, 25]], [6, 9]]
+comment   = "Insert large gap without merge"
+expected  = [[1, 5], [6, 9], [10, 15], [20, 25]]
+
+[[asserts]]
+arguments = [[[1, 5], [10, 15], [20, 25]], [12, 22]]
+comment   = "Merge last two partially"
+expected  = [[1, 5], [10, 25]]
+
+[[asserts]]
+arguments = [[[0, 1000]], [0, 1000]]
+comment   = "Same exact large bounds"
+expected  = [[0, 1000]]
\ No newline at end of file
diff --git a/tasks/medium/dp/turtle_max_path_sum.toml b/tasks/medium/dp/turtle_max_path_sum.toml
new file mode 100644
index 0000000..7c178d0
--- /dev/null
+++ b/tasks/medium/dp/turtle_max_path_sum.toml
@@ -0,0 +1,179 @@
+level             = "medium"
+name              = "turtle_max_path_sum"
+tags              = ["dp", "matrix", "arrays"]
+time_to_solve_sec = 400
+
+description_en = """
+You are given an $m \\times n$ matrix of integers. A turtle starts its journey in the top-left corner $(0, 0)$ and wants to reach the bottom-right corner $(m-1, n-1)$. 
+
+The turtle can only move **right** or **down**. 
+
+Return the maximum sum of the elements along its path.
+"""
+
+description_ru = """
+Дана матрица целых чисел размером $m \\times n$. Черепашка начинает свой путь в левом верхнем углу $(0, 0)$ и хочет добраться до правого нижнего угла $(m-1, n-1)$. 
+
+Черепашка может двигаться только **вправо** или **вниз**. 
+
+Верните максимальную сумму элементов на ее пути.
+"""
+
+limits = """
+- $1 \\leq m, n \\leq 100$
+- $-1000 \\leq \\text{matrix}[i][j] \\leq 1000$
+"""
+
+solution = """
+def solution(matrix: list[list[int]]) -> int:
+    for i in range(len(matrix)):
+        for j in range(len(matrix[0])):
+            if i > 0 and j > 0: matrix[i][j] += max(matrix[i-1][j], matrix[i][j-1])
+            elif i > 0: matrix[i][j] += matrix[i-1][j]
+            elif j > 0: matrix[i][j] += matrix[i][j-1]
+    return matrix[-1][-1]
+"""
+
+examples = """
+solution([[0]]) == 0
+solution([[1, 2], [3, 4]]) == 8
+solution([[-1, -2], [-3, -4]]) == -7
+solution([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) == 29
+"""
+
+[[input_signature]]
+argument_name = "matrix"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "array"
+[input_signature.type.nested.nested]
+name = "integer"
+
+[output_signature.type]
+name = "integer"
+
+[[asserts]]
+arguments = [[[1]]]
+comment   = "Single element matrix"
+expected  = 1
+
+[[asserts]]
+arguments = [[[0]]]
+comment   = "Single zero"
+expected  = 0
+
+[[asserts]]
+arguments = [[[-5]]]
+comment   = "Single negative element"
+expected  = -5
+
+[[asserts]]
+arguments = [[[1, 2, 3]]]
+comment   = "Single row"
+expected  = 6
+
+[[asserts]]
+arguments = [[[1], [2], [3]]]
+comment   = "Single column"
+expected  = 6
+
+[[asserts]]
+arguments = [[[1, 2], [3, 4]]]
+comment   = "2x2 positive matrix"
+expected  = 8
+
+[[asserts]]
+arguments = [[[-1, -2], [-3, -4]]]
+comment   = "2x2 negative matrix"
+expected  = -7
+
+[[asserts]]
+arguments = [[[0, 0], [0, 0]]]
+comment   = "2x2 zero matrix"
+expected  = 0
+
+[[asserts]]
+arguments = [[[1, 2, 3], [4, 5, 6], [7, 8, 9]]]
+comment   = "3x3 sequential numbers"
+expected  = 29
+
+[[asserts]]
+arguments = [[[-1, -2, -3], [-4, -5, -6], [-7, -8, -9]]]
+comment   = "3x3 sequential negative numbers"
+expected  = -21
+
+[[asserts]]
+arguments = [[[5, 5, 5], [1, 1, 5], [1, 1, 5]]]
+comment   = "Path along the right edge is optimal"
+expected  = 25
+
+[[asserts]]
+arguments = [[[1, 5, 1], [1, 5, 1], [1, 5, 1]]]
+comment   = "Path down the middle"
+expected  = 17
+
+[[asserts]]
+arguments = [[[9, 9, 9], [1, 1, 9], [1, 1, 9]]]
+comment   = "Path making an L-shape"
+expected  = 45
+
+[[asserts]]
+arguments = [[[1, 1, 1], [9, 9, 1], [1, 9, 9]]]
+comment   = "Optimal path zigzags"
+expected  = 37
+
+[[asserts]]
+arguments = [[[100, -100, -100], [-100, 100, -100], [-100, -100, 100]]]
+comment   = "Diagonal positive numbers surrounded by negative"
+expected  = 100
+
+[[asserts]]
+arguments = [[[1, -1, 1], [-1, 1, -1], [1, -1, 1]]]
+comment   = "Alternating 1s and -1s"
+expected  = 1
+
+[[asserts]]
+arguments = [[[0, 10, 0], [0, 10, 0], [0, 10, 0]]]
+comment   = "Straight vertical high values"
+expected  = 30
+
+[[asserts]]
+arguments = [[[10, 0, 0], [0, 10, 0], [0, 0, 10]]]
+comment   = "Diagonal values"
+expected  = 30
+
+[[asserts]]
+arguments = [[[1, 1, 1, 1], [1, 1, 1, 1]]]
+comment   = "Uniform 2x4 matrix"
+expected  = 5
+
+[[asserts]]
+arguments = [[[2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2]]]
+comment   = "Uniform 3x4 matrix"
+expected  = 12
+
+[[asserts]]
+arguments = [[[1, 2], [3, 4], [5, 6], [7, 8]]]
+comment   = "Narrow 4x2 matrix"
+expected  = 24
+
+[[asserts]]
+arguments = [[[1, 3, 5, 7], [2, 4, 6, 8]]]
+comment   = "Wide 2x4 matrix"
+expected  = 24
+
+[[asserts]]
+arguments = [[[1, 2, 3, 4, 5]]]
+comment   = "1x5 matrix"
+expected  = 15
+
+[[asserts]]
+arguments = [[[5], [4], [3], [2], [1]]]
+comment   = "5x1 matrix"
+expected  = 15
+
+[[asserts]]
+arguments = [[[0, -1, -2], [-3, -4, -5], [-6, -7, -8]]]
+comment   = "Negative sequence starting with zero"
+expected  = -16
\ No newline at end of file
diff --git a/tasks/medium/games/game_of_life_step.toml b/tasks/medium/games/game_of_life_step.toml
new file mode 100644
index 0000000..deba89b
--- /dev/null
+++ b/tasks/medium/games/game_of_life_step.toml
@@ -0,0 +1,210 @@
+level             = "medium"
+name              = "game_of_life_step"
+tags              = ["games", "simulation", "algorithms"]
+time_to_solve_sec = 600
+
+description_en = """
+You are given a 2D integer array `grid` representing the current state of a grid in Conway's Game of Life. `1` represents a live cell and `0` represents a dead cell.
+
+Calculate and return the next state of the grid after exactly one step.
+
+The rules are:
+1. A live cell with fewer than `2` live neighbors dies (underpopulation).
+2. A live cell with `2` or `3` live neighbors lives on.
+3. A live cell with more than `3` live neighbors dies (overpopulation).
+4. A dead cell with exactly `3` live neighbors becomes a live cell (reproduction).
+
+Neighbors are the 8 cells horizontally, vertically, or diagonally adjacent.
+"""
+
+description_ru = """
+Вам дан двумерный массив целых чисел `grid`, представляющий текущее состояние сетки в «Игре Жизнь» Конвея, где `1` представляет живую клетку, а `0` — мертвую.
+
+Рассчитайте и верните следующее состояние сетки ровно через один шаг.
+
+Правила:
+1. Живая клетка, у которой меньше `2` живых соседей, умирает (от недонаселения).
+2. Живая клетка с `2` или `3` живыми соседями продолжает жить.
+3. Живая клетка, у которой больше `3` живых соседей, умирает (от перенаселения).
+4. Мертвая клетка, у которой ровно `3` живых соседа, становится живой (размножение).
+
+Соседями считаются 8 клеток по горизонтали, вертикали и диагонали.
+"""
+
+limits = """
+- $1 \\leq \\text{len}(grid) \\leq 50$
+- $1 \\leq \\text{len}(grid[0]) \\leq 50$
+- $grid[i][j] \\in \\{0, 1\\}$
+"""
+
+solution = """
+def solution(grid: list) -> list:
+    m, n = len(grid), len(grid[0])
+    res = [[0] * n for _ in range(m)]
+    for i in range(m):
+        for j in range(n):
+            lives = sum(grid[r][c] for r in range(max(0, i-1), min(m, i+2)) 
+                                   for c in range(max(0, j-1), min(n, j+2))) - grid[i][j]
+            if grid[i][j] == 1 and lives in (2, 3):
+                res[i][j] = 1
+            if grid[i][j] == 0 and lives == 3:
+                res[i][j] = 1
+    return res
+"""
+
+examples = """
+solution([[1]]) == [[0]]
+solution([[0, 1, 0], [0, 1, 0], [0, 1, 0]]) == [[0, 0, 0], [1, 1, 1], [0, 0, 0]]
+solution([[1, 1], [1, 1]]) == [[1, 1], [1, 1]]
+"""
+
+[[input_signature]]
+argument_name = "grid"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "array"
+[input_signature.type.nested.nested]
+name = "integer"
+
+[output_signature.type]
+name = "array"
+[output_signature.type.nested]
+name = "array"
+[output_signature.type.nested.nested]
+name = "integer"
+
+[[asserts]]
+arguments = [[[0]]]
+comment   = "1x1 dead"
+expected  = [[0]]
+
+[[asserts]]
+arguments = [[[1]]]
+comment   = "1x1 live"
+expected  = [[0]]
+
+[[asserts]]
+arguments = [[[0, 0]]]
+comment   = "1x2 dead"
+expected  = [[0, 0]]
+
+[[asserts]]
+arguments = [[[1, 1]]]
+comment   = "1x2 live"
+expected  = [[0, 0]]
+
+[[asserts]]
+arguments = [[[1], [1]]]
+comment   = "2x1 live"
+expected  = [[0], [0]]
+
+[[asserts]]
+arguments = [[[0, 0], [0, 0]]]
+comment   = "2x2 dead"
+expected  = [[0, 0], [0, 0]]
+
+[[asserts]]
+arguments = [[[1, 1], [1, 1]]]
+comment   = "2x2 block (Still life)"
+expected  = [[1, 1], [1, 1]]
+
+[[asserts]]
+arguments = [[[1, 0], [0, 0]]]
+comment   = "2x2 single live"
+expected  = [[0, 0], [0, 0]]
+
+[[asserts]]
+arguments = [[[1, 1], [0, 0]]]
+comment   = "2x2 two live"
+expected  = [[0, 0], [0, 0]]
+
+[[asserts]]
+arguments = [[[1, 1], [1, 0]]]
+comment   = "2x2 three live (creates block)"
+expected  = [[1, 1], [1, 1]]
+
+[[asserts]]
+arguments = [[[0, 0, 0], [0, 0, 0], [0, 0, 0]]]
+comment   = "3x3 dead"
+expected  = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
+
+[[asserts]]
+arguments = [[[0, 0, 0], [0, 1, 0], [0, 0, 0]]]
+comment   = "3x3 center live"
+expected  = [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
+
+[[asserts]]
+arguments = [[[0, 0, 0], [1, 1, 1], [0, 0, 0]]]
+comment   = "3x3 blinker horizontal (Oscillator)"
+expected  = [[0, 1, 0], [0, 1, 0], [0, 1, 0]]
+
+[[asserts]]
+arguments = [[[0, 1, 0], [0, 1, 0], [0, 1, 0]]]
+comment   = "3x3 blinker vertical (Oscillator)"
+expected  = [[0, 0, 0], [1, 1, 1], [0, 0, 0]]
+
+[[asserts]]
+arguments = [[[0, 1, 0], [1, 0, 1], [0, 1, 0]]]
+comment   = "3x3 tub (Still life)"
+expected  = [[0, 1, 0], [1, 0, 1], [0, 1, 0]]
+
+[[asserts]]
+arguments = [[[1, 1, 1], [1, 1, 1], [1, 1, 1]]]
+comment   = "3x3 all live"
+expected  = [[1, 0, 1], [0, 0, 0], [1, 0, 1]]
+
+[[asserts]]
+arguments = [[[0, 1, 0], [1, 1, 1], [0, 1, 0]]]
+comment   = "3x3 cross"
+expected  = [[1, 1, 1], [1, 0, 1], [1, 1, 1]]
+
+[[asserts]]
+arguments = [[[1, 0, 0], [1, 1, 0], [0, 0, 0]]]
+comment   = "3x3 L-shape"
+expected  = [[1, 1, 0], [1, 1, 0], [0, 0, 0]]
+
+[[asserts]]
+arguments = [[[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]]]
+comment   = "4x4 block in center"
+expected  = [[0, 0, 0, 0], [0, 1, 1, 0], [0, 1, 1, 0], [0, 0, 0, 0]]
+
+[[asserts]]
+arguments = [[[0, 0, 0, 0], [0, 1, 1, 1], [1, 1, 1, 0], [0, 0, 0, 0]]]
+comment   = "4x4 toad phase 1 (Oscillator)"
+expected  = [[0, 0, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 0]]
+
+[[asserts]]
+arguments = [[[0, 0, 1, 0], [1, 0, 0, 1], [1, 0, 0, 1], [0, 1, 0, 0]]]
+comment   = "4x4 toad phase 2 (Oscillator)"
+expected  = [[0, 0, 0, 0], [0, 1, 1, 1], [1, 1, 1, 0], [0, 0, 0, 0]]
+
+[[asserts]]
+arguments = [[[1, 1, 0, 0], [1, 1, 0, 0], [0, 0, 1, 1], [0, 0, 1, 1]]]
+comment   = "4x4 beacon (Oscillator)"
+expected  = [[1, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, 1, 1]]
+
+[[asserts]]
+arguments = [[[1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1], [1, 1, 1, 1]]]
+comment   = "4x4 all live"
+expected  = [[1, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 1]]
+
+[[asserts]]
+arguments = [[[0, 1, 0], [0, 0, 1], [1, 1, 1], [0, 0, 0]]]
+comment   = "4x3 glider step 1"
+expected  = [[0, 0, 0], [1, 0, 1], [0, 1, 1], [0, 1, 0]]
+
+[[asserts]]
+arguments = [[[0, 0, 0, 0], [1, 1, 1, 1], [0, 0, 0, 0]]]
+comment   = "3x4 horizontal line"
+expected  = [[0, 1, 1, 0], [0, 1, 1, 0], [0, 1, 1, 0]]
+
+[[asserts]]
+arguments = [[[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]]
+comment   = "5x5 3x3 square in center"
+expected  = [[0, 0, 1, 0, 0], [0, 1, 0, 1, 0], [1, 0, 0, 0, 1], [0, 1, 0, 1, 0], [0, 0, 1, 0, 0]]
+
+[[asserts]]
+arguments = [[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]]
+comment   = "5x5 completely empty"
+expected  = [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
\ No newline at end of file
diff --git a/tasks/medium/games/valid_sudoku.toml b/tasks/medium/games/valid_sudoku.toml
new file mode 100644
index 0000000..ff6dd66
--- /dev/null
+++ b/tasks/medium/games/valid_sudoku.toml
@@ -0,0 +1,477 @@
+level             = "medium"
+name              = "valid_sudoku"
+tags              = ["arrays", "matrix", "hash"]
+time_to_solve_sec = 600
+
+description_en = """
+Determine if a $9 \\times 9$ Sudoku board is valid. Only the filled cells need to be validated according to the following rules:
+
+1. Each row must contain the digits `"1"`-`"9"` without repetition.
+2. Each column must contain the digits `"1"`-`"9"` without repetition.
+3. Each of the nine $3 \\times 3$ sub-boxes of the grid must contain the digits `"1"`-`"9"` without repetition.
+
+The Sudoku board could be partially filled, where empty cells are filled with the character `"."`.
+"""
+
+description_ru = """
+Определите, является ли поле для судоку $9 \\times 9$ валидным. Только заполненные ячейки необходимо проверять в соответствии со следующими правилами:
+
+1. Каждая строка должна содержать цифры от `"1"` до `"9"` без повторений.
+2. Каждый столбец должен содержать цифры от `"1"` до `"9"` без повторений.
+3. Каждый из девяти подквадратов $3 \\times 3$ должен содержать цифры от `"1"` до `"9"` без повторений.
+
+Поле судоку может быть частично заполнено, пустые ячейки обозначаются символом `"."`.
+"""
+
+limits = """
+- $\\text{len}(\\text{board}) = 9$
+- $\\text{len}(\\text{board}[i]) = 9$
+- $\\text{board}[i][j] \\in \\{"1", \\dots, "9", "."\\}$
+"""
+
+solution = """
+def solution(board: list) -> bool:
+    r = [set() for _ in range(9)]
+    c = [set() for _ in range(9)]
+    b = [set() for _ in range(9)]
+    
+    for i in range(9):
+        for j in range(9):
+            v = board[i][j]
+            if v != ".":
+                k = (i // 3) * 3 + j // 3
+                if v in r[i] or v in c[j] or v in b[k]:
+                    return False
+                r[i].add(v)
+                c[j].add(v)
+                b[k].add(v)
+    return True
+"""
+
+examples = """
+solution([
+  ["5","3",".",".","7",".",".",".","."],
+  ["6",".",".","1","9","5",".",".","."],
+  [".","9","8",".",".",".",".","6","."],
+  ["8",".",".",".","6",".",".",".","3"],
+  ["4",".",".","8",".","3",".",".","1"],
+  ["7",".",".",".","2",".",".",".","6"],
+  [".","6",".",".",".",".","2","8","."],
+  [".",".",".","4","1","9",".",".","5"],
+  [".",".",".",".","8",".",".","7","9"]
+]) == True
+
+solution([
+  ["8","3",".",".","7",".",".",".","."],
+  ["6",".",".","1","9","5",".",".","."],
+  [".","9","8",".",".",".",".","6","."],
+  ["8",".",".",".","6",".",".",".","3"],
+  ["4",".",".","8",".","3",".",".","1"],
+  ["7",".",".",".","2",".",".",".","6"],
+  [".","6",".",".",".",".","2","8","."],
+  [".",".",".","4","1","9",".",".","5"],
+  [".",".",".",".","8",".",".","7","9"]
+]) == False
+"""
+
+[[input_signature]]
+argument_name = "board"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "array"
+[input_signature.type.nested.nested]
+name = "string"
+
+[output_signature.type]
+name = "boolean"
+
+[[asserts]]
+arguments = [[
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Completely empty board"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  ["5","3",".",".","7",".",".",".","."],
+  ["6",".",".","1","9","5",".",".","."],
+  [".","9","8",".",".",".",".","6","."],
+  ["8",".",".",".","6",".",".",".","3"],
+  ["4",".",".","8",".","3",".",".","1"],
+  ["7",".",".",".","2",".",".",".","6"],
+  [".","6",".",".",".",".","2","8","."],
+  [".",".",".","4","1","9",".",".","5"],
+  [".",".",".",".","8",".",".","7","9"]
+]]
+comment   = "Valid partial board"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  ["8","3",".",".","7",".",".",".","."],
+  ["6",".",".","1","9","5",".",".","."],
+  [".","9","8",".",".",".",".","6","."],
+  ["8",".",".",".","6",".",".",".","3"],
+  ["4",".",".","8",".","3",".",".","1"],
+  ["7",".",".",".","2",".",".",".","6"],
+  [".","6",".",".",".",".","2","8","."],
+  [".",".",".","4","1","9",".",".","5"],
+  [".",".",".",".","8",".",".","7","9"]
+]]
+comment   = "Invalid partial board (two '8's in first column)"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  ["1","2","3","4","5","6","7","8","9"],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Valid single row"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  ["1","2","3","4","5","6","7","8","1"],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Invalid single row (duplicate '1')"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  ["1",".",".",".",".",".",".",".","."],
+  ["2",".",".",".",".",".",".",".","."],
+  ["3",".",".",".",".",".",".",".","."],
+  ["4",".",".",".",".",".",".",".","."],
+  ["5",".",".",".",".",".",".",".","."],
+  ["6",".",".",".",".",".",".",".","."],
+  ["7",".",".",".",".",".",".",".","."],
+  ["8",".",".",".",".",".",".",".","."],
+  ["9",".",".",".",".",".",".",".","."]
+]]
+comment   = "Valid single column"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  ["1",".",".",".",".",".",".",".","."],
+  ["2",".",".",".",".",".",".",".","."],
+  ["3",".",".",".",".",".",".",".","."],
+  ["4",".",".",".",".",".",".",".","."],
+  ["5",".",".",".",".",".",".",".","."],
+  ["6",".",".",".",".",".",".",".","."],
+  ["7",".",".",".",".",".",".",".","."],
+  ["8",".",".",".",".",".",".",".","."],
+  ["1",".",".",".",".",".",".",".","."]
+]]
+comment   = "Invalid single column (duplicate '1')"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  ["1","2","3",".",".",".",".",".","."],
+  ["4","5","6",".",".",".",".",".","."],
+  ["7","8","9",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Valid single box"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  ["1","2","3",".",".",".",".",".","."],
+  ["4","5","6",".",".",".",".",".","."],
+  ["7","8","1",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Invalid single box (duplicate '1')"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  ["5","3","4","6","7","8","9","1","2"],
+  ["6","7","2","1","9","5","3","4","8"],
+  ["1","9","8","3","4","2","5","6","7"],
+  ["8","5","9","7","6","1","4","2","3"],
+  ["4","2","6","8","5","3","7","9","1"],
+  ["7","1","3","9","2","4","8","5","6"],
+  ["9","6","1","5","3","7","2","8","4"],
+  ["2","8","7","4","1","9","6","3","5"],
+  ["3","4","5","2","8","6","1","7","9"]
+]]
+comment   = "Fully solved valid board"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  ["5","3","4","6","7","8","9","1","2"],
+  ["6","7","2","1","9","5","3","4","8"],
+  ["1","9","8","3","4","2","5","6","7"],
+  ["8","5","9","7","6","1","4","2","3"],
+  ["4","2","6","8","5","3","7","9","1"],
+  ["7","1","3","9","2","4","8","5","6"],
+  ["9","6","1","5","3","7","2","8","4"],
+  ["2","8","7","4","1","9","6","3","5"],
+  ["3","4","5","2","8","6","1","7","3"]
+]]
+comment   = "Invalid fully filled board (duplicate '3' in bottom right)"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  [".",".",".",".",".",".",".",".","."],
+  [".","1",".",".",".",".",".","2","."],
+  [".",".",".",".","3",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".","4",".",".",".","5",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".","6",".",".",".","."],
+  [".","7",".",".",".",".",".","8","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Valid sparse board"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  [".",".",".",".",".",".",".",".","."],
+  [".","1",".",".",".",".",".","2","."],
+  [".",".",".",".","3",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".","4",".",".",".","5",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".","6",".",".",".","."],
+  [".","1",".",".",".",".",".","8","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Invalid sparse board (duplicate '1' in column 1)"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  ["9",".",".",".",".",".",".",".","9"],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  ["9",".",".",".",".",".",".",".","9"]
+]]
+comment   = "9 in all corners (invalid due to row/col sharing)"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  [".",".",".",".",".",".",".",".","9"],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  ["9",".",".",".",".",".",".",".","."]
+]]
+comment   = "Two 9s in different corners (valid)"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  ["1",".",".",".",".",".",".",".","."],
+  [".","2",".",".",".",".",".",".","."],
+  [".",".","3",".",".",".",".",".","."],
+  [".",".",".","4",".",".",".",".","."],
+  [".",".",".",".","5",".",".",".","."],
+  [".",".",".",".",".","6",".",".","."],
+  [".",".",".",".",".",".","7",".","."],
+  [".",".",".",".",".",".",".","8","."],
+  [".",".",".",".",".",".",".",".","9"]
+]]
+comment   = "Valid main diagonal"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  ["1",".",".",".",".",".",".",".","."],
+  [".","2",".",".",".",".",".",".","."],
+  [".",".","1",".",".",".",".",".","."],
+  [".",".",".","4",".",".",".",".","."],
+  [".",".",".",".","5",".",".",".","."],
+  [".",".",".",".",".","6",".",".","."],
+  [".",".",".",".",".",".","7",".","."],
+  [".",".",".",".",".",".",".","8","."],
+  [".",".",".",".",".",".",".",".","9"]
+]]
+comment   = "Invalid diagonal (top-left box has duplicate '1')"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  [".",".",".",".",".",".","1","2","3"],
+  [".",".",".",".",".",".","4","5","6"],
+  [".",".",".",".",".",".","7","8","9"],
+  ["1","2","3",".",".",".",".",".","."],
+  ["4","5","6",".",".",".",".",".","."],
+  ["7","8","9",".",".",".",".",".","."],
+  [".",".",".","1","2","3",".",".","."],
+  [".",".",".","4","5","6",".",".","."],
+  [".",".",".","7","8","9",".",".","."]
+]]
+comment   = "Valid blocks staggered across grid"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  [".",".",".",".",".",".","1","2","3"],
+  [".",".",".",".",".",".","4","5","6"],
+  [".",".",".",".",".",".","7","8","9"],
+  ["1","2","3",".",".",".",".",".","."],
+  ["4","5","6",".",".",".",".",".","."],
+  ["7","8","9",".",".",".",".",".","."],
+  [".",".",".","1","2","3",".",".","."],
+  [".",".",".","4","5","6",".",".","."],
+  [".",".",".","7","8","1",".",".","."]
+]]
+comment   = "Invalid staggered blocks (duplicate '1' in bottom-middle box)"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  [".",".","4",".",".",".","6","3","."],
+  [".",".",".",".",".",".",".",".","."],
+  ["5",".",".",".",".","9",".",".","."],
+  [".",".",".","5","6",".",".",".","."],
+  ["4",".","3",".",".",".",".",".","1"],
+  [".",".",".","7",".",".",".",".","."],
+  [".",".",".","5",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Invalid due to two 5s in the middle column (col 3)"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  [".","1",".",".",".",".",".",".","."],
+  ["1",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Two identical numbers in the same box, but different row/col"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  [".",".",".","1",".",".","1",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Two identical numbers in the same row, but different box/col"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  [".",".",".","1",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".","1",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Two identical numbers in the same col, but different box/row"
+expected  = false
+
+[[asserts]]
+arguments = [[
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".","5",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."],
+  [".",".",".",".",".",".",".",".","."]
+]]
+comment   = "Single element is always valid"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  ["3",".","6","5",".","8","4",".","."],
+  ["5","2",".",".",".",".",".",".","."],
+  [".","8","7",".",".",".",".","3","1"],
+  [".",".","3",".","1",".",".","8","."],
+  ["9",".",".","8","6","3",".",".","5"],
+  [".","5",".",".","9",".","6",".","."],
+  ["1","3",".",".",".",".","2","5","."],
+  [".",".",".",".",".",".",".","7","4"],
+  [".",".","5","2",".","6","3",".","."]
+]]
+comment   = "Complex real valid puzzle"
+expected  = true
+
+[[asserts]]
+arguments = [[
+  ["3",".","6","5",".","8","4",".","."],
+  ["5","2",".",".",".",".",".",".","."],
+  [".","8","7",".",".",".",".","3","1"],
+  [".",".","3",".","1",".",".","8","."],
+  ["9",".",".","8","6","3",".",".","5"],
+  [".","5",".",".","9",".","6",".","."],
+  ["1","3",".",".",".",".","2","5","."],
+  [".",".",".",".",".",".",".","7","4"],
+  [".",".","5","2",".","6","3",".","8"]
+]]
+comment   = "Complex real valid puzzle"
+expected  = true
\ No newline at end of file
diff --git a/tasks/medium/graphs/flood_fill.toml b/tasks/medium/graphs/flood_fill.toml
new file mode 100644
index 0000000..298c197
--- /dev/null
+++ b/tasks/medium/graphs/flood_fill.toml
@@ -0,0 +1,226 @@
+level             = "medium"
+name              = "flood_fill"
+tags              = ["graphs"]
+time_to_solve_sec = 400
+
+description_en = """
+An image is represented by a 2D integer array `image`, where `image[i][j]` represents the pixel value of the image.
+
+You are also given three integers `sr`, `sc`, and `color`. You should perform a flood fill on the image starting from the pixel `image[sr][sc]`.
+
+To perform a flood fill, consider the starting pixel, plus any pixels connected 4-directionally to the starting pixel of the same color as the starting pixel, plus any pixels connected 4-directionally to those pixels (also with the same color), and so on. Replace the color of all of the aforementioned pixels with `color`.
+
+Return the modified image after performing the flood fill.
+"""
+
+description_ru = """
+Изображение представлено в виде двумерного массива целых чисел `image`, где `image[i][j]` — это значение пикселя.
+
+Вам также даны три целых числа: `sr`, `sc` и `color`. Вы должны выполнить заливку (flood fill) изображения, начиная с пикселя `image[sr][sc]`.
+
+Для выполнения заливки возьмите начальный пиксель, а также все соседние по вертикали и горизонтали пиксели того же цвета, что и начальный. Затем возьмите соседние пиксели для добавленных пикселей (также того же цвета), и так далее. Замените цвет всех этих пикселей на новый `color`.
+
+Верните измененное изображение после выполнения заливки.
+"""
+
+limits = """
+- $1 \\leq \\text{len}(\\text{image}) \\leq 50$
+- $1 \\leq \\text{len}(\\text{image}[0]) \\leq 50$
+- $0 \\leq \\text{image}[i][j], \\text{color} \\leq 100$
+- $0 \\leq \\text{sr} < \\text{len}(\\text{image})$
+- $0 \\leq \\text{sc} < \\text{len}(\\text{image}[0])$
+"""
+
+solution = """
+def solution(image: list[list[int]], sr: int, sc: int, color: int) -> list[list[int]]:
+    old = image[sr][sc]
+    if old == color: return image
+    def dfs(r, c):
+        if 0 <= r < len(image) and 0 <= c < len(image[0]) and image[r][c] == old:
+            image[r][c] = color
+            dfs(r + 1, c); dfs(r - 1, c); dfs(r, c + 1); dfs(r, c - 1)
+    dfs(sr, sc)
+    return image
+"""
+
+examples = """
+solution([[1]], 0, 0, 2) == [[2]]
+solution([[0, 0], [0, 0]], 0, 0, 2) == [[2, 2], [2, 2]]
+solution([[1, 1, 1], [1, 1, 0], [1, 0, 1]], 1, 1, 2) == [[2, 2, 2], [2, 2, 0], [2, 0, 1]]
+"""
+
+[[input_signature]]
+argument_name = "image"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "array"
+[input_signature.type.nested.nested]
+name = "integer"
+
+[[input_signature]]
+argument_name = "sr"
+[input_signature.type]
+name = "integer"
+
+[[input_signature]]
+argument_name = "sc"
+[input_signature.type]
+name = "integer"
+
+[[input_signature]]
+argument_name = "color"
+[input_signature.type]
+name = "integer"
+
+[output_signature.type]
+name = "array"
+[output_signature.type.nested]
+name = "array"
+[output_signature.type.nested.nested]
+name = "integer"
+
+[[asserts]]
+arguments = [[[1]], 0, 0, 2]
+comment   = "1x1 grid, standard fill"
+expected  = [[2]]
+
+[[asserts]]
+arguments = [[[2]], 0, 0, 2]
+comment   = "1x1 grid, same color no change"
+expected  = [[2]]
+
+[[asserts]]
+arguments = [[[1, 1], [1, 1]], 0, 0, 3]
+comment   = "2x2 grid, all same color"
+expected  = [[3, 3], [3, 3]]
+
+[[asserts]]
+arguments = [[[1, 2], [3, 4]], 0, 0, 5]
+comment   = "2x2 grid, distinct colors, start top-left"
+expected  = [[5, 2], [3, 4]]
+
+[[asserts]]
+arguments = [[[1, 2], [3, 4]], 1, 1, 5]
+comment   = "2x2 grid, distinct colors, start bottom-right"
+expected  = [[1, 2], [3, 5]]
+
+[[asserts]]
+arguments = [[[1, 1, 1], [1, 1, 0], [1, 0, 1]], 1, 1, 2]
+comment   = "Classic connected component shape"
+expected  = [[2, 2, 2], [2, 2, 0], [2, 0, 1]]
+
+[[asserts]]
+arguments = [[[0, 0, 0], [0, 0, 0]], 0, 0, 0]
+comment   = "Grid already the target color"
+expected  = [[0, 0, 0], [0, 0, 0]]
+
+[[asserts]]
+arguments = [[[1, 2, 1], [2, 1, 2], [1, 2, 1]], 1, 1, 3]
+comment   = "Checkerboard, isolated center"
+expected  = [[1, 2, 1], [2, 3, 2], [1, 2, 1]]
+
+[[asserts]]
+arguments = [[[1, 2, 1], [2, 1, 2], [1, 2, 1]], 0, 0, 3]
+comment   = "Checkerboard, isolated corner"
+expected  = [[3, 2, 1], [2, 1, 2], [1, 2, 1]]
+
+[[asserts]]
+arguments = [[[1, 1, 1], [2, 2, 2], [1, 1, 1]], 1, 1, 3]
+comment   = "Horizontal stripe"
+expected  = [[1, 1, 1], [3, 3, 3], [1, 1, 1]]
+
+[[asserts]]
+arguments = [[[1, 2, 1], [1, 2, 1], [1, 2, 1]], 1, 1, 3]
+comment   = "Vertical stripe"
+expected  = [[1, 3, 1], [1, 3, 1], [1, 3, 1]]
+
+[[asserts]]
+arguments = [[[0, 0, 0], [0, 1, 0], [0, 0, 0]], 1, 1, 2]
+comment   = "Single central pixel different from background"
+expected  = [[0, 0, 0], [0, 2, 0], [0, 0, 0]]
+
+[[asserts]]
+arguments = [[[0, 0, 0], [0, 1, 0], [0, 0, 0]], 0, 0, 2]
+comment   = "Surrounding background avoiding center"
+expected  = [[2, 2, 2], [2, 1, 2], [2, 2, 2]]
+
+[[asserts]]
+arguments = [[[1, 0, 0], [0, 1, 0], [0, 0, 1]], 0, 0, 2]
+comment   = "Diagonal connection (does not spread)"
+expected  = [[2, 0, 0], [0, 1, 0], [0, 0, 1]]
+
+[[asserts]]
+arguments = [[[1, 1, 1, 1]], 0, 2, 5]
+comment   = "1D horizontal row"
+expected  = [[5, 5, 5, 5]]
+
+[[asserts]]
+arguments = [[[1], [1], [1], [1]], 2, 0, 5]
+comment   = "1D vertical column"
+expected  = [[5], [5], [5], [5]]
+
+[[asserts]]
+arguments = [[[1, 1, 1], [1, 0, 1], [1, 1, 1]], 0, 0, 2]
+comment   = "Ring shape, fill outside"
+expected  = [[2, 2, 2], [2, 0, 2], [2, 2, 2]]
+
+[[asserts]]
+arguments = [[[1, 1, 1], [1, 0, 1], [1, 1, 1]], 1, 1, 2]
+comment   = "Ring shape, fill inside"
+expected  = [[1, 1, 1], [1, 2, 1], [1, 1, 1]]
+
+[[asserts]]
+arguments = [[[0, 1, 0], [1, 0, 1], [0, 1, 0]], 1, 1, 2]
+comment   = "Hollow cross, fill center"
+expected  = [[0, 1, 0], [1, 2, 1], [0, 1, 0]]
+
+[[asserts]]
+arguments = [[[0, 1, 0], [1, 1, 1], [0, 1, 0]], 1, 1, 2]
+comment   = "Filled cross, fill cross"
+expected  = [[0, 2, 0], [2, 2, 2], [0, 2, 0]]
+
+[[asserts]]
+arguments = [[[7, 7, 8], [7, 8, 8], [9, 9, 9]], 0, 0, 1]
+comment   = "Asymmetric blob shape"
+expected  = [[1, 1, 8], [1, 8, 8], [9, 9, 9]]
+
+[[asserts]]
+arguments = [[[2, 2, 2, 2], [2, 3, 3, 2], [2, 3, 3, 2], [2, 2, 2, 2]], 1, 1, 4]
+comment   = "Square inside a square"
+expected  = [[2, 2, 2, 2], [2, 4, 4, 2], [2, 4, 4, 2], [2, 2, 2, 2]]
+
+[[asserts]]
+arguments = [[[5, 5, 5], [5, 5, 5], [5, 5, 5]], 2, 2, 5]
+comment   = "3x3 all same, target color is same"
+expected  = [[5, 5, 5], [5, 5, 5], [5, 5, 5]]
+
+[[asserts]]
+arguments = [[[1, 2, 3], [4, 5, 6], [7, 8, 9]], 2, 2, 0]
+comment   = "All distinct numbers"
+expected  = [[1, 2, 3], [4, 5, 6], [7, 8, 0]]
+
+[[asserts]]
+arguments = [[[1, 1], [0, 1]], 1, 1, 3]
+comment   = "L-shape component"
+expected  = [[3, 3], [0, 3]]
+
+[[asserts]]
+arguments = [[[0, 1], [1, 1]], 0, 1, 3]
+comment   = "Reverse L-shape component"
+expected  = [[0, 3], [3, 3]]
+
+[[asserts]]
+arguments = [[[1, 1], [1, 1], [1, 1]], 0, 0, 2]
+comment   = "3x2 full block"
+expected  = [[2, 2], [2, 2], [2, 2]]
+
+[[asserts]]
+arguments = [[[1, 1, 1, 1, 1], [1, 0, 0, 0, 1], [1, 0, 1, 0, 1], [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]], 2, 2, 2]
+comment   = "Nested rings, center isolated pixel"
+expected  = [[1, 1, 1, 1, 1], [1, 0, 0, 0, 1], [1, 0, 2, 0, 1], [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]]
+
+[[asserts]]
+arguments = [[[1, 1, 1, 1, 1], [1, 0, 0, 0, 1], [1, 0, 1, 0, 1], [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]], 0, 0, 2]
+comment   = "Nested rings, outer boundary"
+expected  = [[2, 2, 2, 2, 2], [2, 0, 0, 0, 2], [2, 0, 1, 0, 2], [2, 0, 0, 0, 2], [2, 2, 2, 2, 2]]
\ No newline at end of file
diff --git a/tasks/medium/graphs/topological_sort_possible.toml b/tasks/medium/graphs/topological_sort_possible.toml
new file mode 100644
index 0000000..46bce1d
--- /dev/null
+++ b/tasks/medium/graphs/topological_sort_possible.toml
@@ -0,0 +1,206 @@
+level             = "medium"
+name              = "topological_sort_possible"
+tags              = ["graphs", "algorithms", "topological_sort"]
+time_to_solve_sec = 400
+
+description_en = """
+You are given `n` nodes labeled from $0$ to $n - 1$ and a list of directed `edges`.
+
+Each edge $[u, v]$ indicates that node $u$ must appear before node $v$ in a topological ordering. 
+
+Return `True` if it is possible to topologically sort the graph (i.e., it contains no directed cycles), and `False` otherwise.
+"""
+
+description_ru = """
+Вам дано `n` вершин, пронумерованных от $0$ до $n - 1$, и список ориентированных ребер `edges`. 
+
+Каждое ребро $[u, v]$ означает, что вершина $u$ должна идти перед вершиной $v$ в топологической сортировке. 
+
+Верните `True`, если граф можно отсортировать топологически (то есть в нем нет ориентированных циклов), и `False` в противном случае.
+"""
+
+limits = """
+- $1 \\leq n \\leq 10^4$
+- $0 \\leq \\text{len}(\\text{edges}) \\leq 10^4$
+- $\\text{edges}[i] = [u, v]$
+- $0 \\leq u, v < n$
+"""
+
+solution = """
+def solution(n: int, edges: list) -> bool:
+    from graphlib import TopologicalSorter, CycleError
+    
+    graph = {i: set() for i in range(n)}
+    for u, v in edges:
+        graph[v].add(u)
+        
+    try:
+        TopologicalSorter(graph).prepare()
+        return True
+    except CycleError:
+        return False
+"""
+
+examples = """
+solution(1, []) == True
+solution(2, [[0, 1]]) == True
+solution(2, [[0, 1], [1, 0]]) == False
+solution(4, [[0, 1], [1, 2], [2, 3]]) == True
+"""
+
+[[input_signature]]
+argument_name = "n"
+[input_signature.type]
+name = "integer"
+
+[[input_signature]]
+argument_name = "edges"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "array"
+[input_signature.type.nested.nested]
+name = "integer"
+
+[output_signature.type]
+name = "boolean"
+
+[[asserts]]
+arguments = [1, []]
+comment   = "Single node without edges"
+expected  = true
+
+[[asserts]]
+arguments = [2, [[0, 1]]]
+comment   = "Two nodes, simple directed edge"
+expected  = true
+
+[[asserts]]
+arguments = [2, [[0, 1], [1, 0]]]
+comment   = "Two nodes, cycle"
+expected  = false
+
+[[asserts]]
+arguments = [3, [[0, 1], [1, 2]]]
+comment   = "Three nodes, straight line"
+expected  = true
+
+[[asserts]]
+arguments = [3, [[0, 1], [1, 2], [2, 0]]]
+comment   = "Three nodes, simple cycle"
+expected  = false
+
+[[asserts]]
+arguments = [4, [[0, 1], [1, 2], [2, 3]]]
+comment   = "Four nodes, straight line"
+expected  = true
+
+[[asserts]]
+arguments = [4, [[0, 1], [1, 2], [2, 3], [3, 0]]]
+comment   = "Four nodes, full cycle"
+expected  = false
+
+[[asserts]]
+arguments = [4, [[0, 1], [2, 3]]]
+comment   = "Disconnected components, no cycles"
+expected  = true
+
+[[asserts]]
+arguments = [5, [[0, 1], [1, 2], [3, 4], [4, 3]]]
+comment   = "Disconnected components, one has a cycle"
+expected  = false
+
+[[asserts]]
+arguments = [3, [[0, 1], [0, 2]]]
+comment   = "Tree pointing outwards"
+expected  = true
+
+[[asserts]]
+arguments = [3, [[1, 0], [2, 0]]]
+comment   = "Tree pointing inwards"
+expected  = true
+
+[[asserts]]
+arguments = [4, [[0, 1], [0, 2], [1, 3], [2, 3]]]
+comment   = "Diamond shape, acyclic"
+expected  = true
+
+[[asserts]]
+arguments = [4, [[0, 1], [1, 3], [3, 2], [2, 0]]]
+comment   = "Cycle of 4 nodes"
+expected  = false
+
+[[asserts]]
+arguments = [1, [[0, 0]]]
+comment   = "Self-loop edge"
+expected  = false
+
+[[asserts]]
+arguments = [5, [[0, 1], [1, 2], [2, 3], [3, 4], [1, 3]]]
+comment   = "DAG with a forward edge"
+expected  = true
+
+[[asserts]]
+arguments = [5, [[0, 1], [1, 2], [2, 3], [3, 4], [3, 1]]]
+comment   = "Line with a back edge (cycle of 3)"
+expected  = false
+
+[[asserts]]
+arguments = [6, [[0, 1], [1, 2], [3, 4], [4, 5]]]
+comment   = "Two separate paths"
+expected  = true
+
+[[asserts]]
+arguments = [6, [[0, 1], [1, 2], [2, 0], [3, 4], [4, 5], [5, 3]]]
+comment   = "Two separate cyclic components"
+expected  = false
+
+[[asserts]]
+arguments = [2, [[0, 1], [0, 1]]]
+comment   = "Duplicate edges, no cycles"
+expected  = true
+
+[[asserts]]
+arguments = [3, [[0, 1], [1, 2], [2, 0], [0, 1]]]
+comment   = "Cycle with duplicate edges"
+expected  = false
+
+[[asserts]]
+arguments = [5, []]
+comment   = "Multiple nodes with no edges"
+expected  = true
+
+[[asserts]]
+arguments = [7, [[0, 1], [0, 2], [1, 3], [1, 4], [2, 5], [2, 6]]]
+comment   = "Binary tree structure"
+expected  = true
+
+[[asserts]]
+arguments = [7, [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 0]]]
+comment   = "Large cycle of 7 nodes"
+expected  = false
+
+[[asserts]]
+arguments = [4, [[0, 1], [0, 2], [0, 3], [1, 2], [1, 3], [2, 3]]]
+comment   = "Complete DAG"
+expected  = true
+
+[[asserts]]
+arguments = [4, [[0, 1], [1, 2], [2, 3], [3, 1]]]
+comment   = "Lollipop graph (line going into a cycle)"
+expected  = false
+
+[[asserts]]
+arguments = [5, [[0, 4], [1, 4], [2, 4], [3, 4]]]
+comment   = "Star graph directed to center"
+expected  = true
+
+[[asserts]]
+arguments = [5, [[4, 0], [4, 1], [4, 2], [4, 3]]]
+comment   = "Star graph directed from center"
+expected  = true
+
+[[asserts]]
+arguments = [8, [[0, 1], [1, 2], [3, 4], [4, 5], [6, 7], [7, 6]]]
+comment   = "Large forest with one cycle hidden"
+expected  = false
\ No newline at end of file
diff --git a/tasks/medium/greedy/minimum_bracket_reversals.toml b/tasks/medium/greedy/minimum_bracket_reversals.toml
new file mode 100644
index 0000000..9ec881c
--- /dev/null
+++ b/tasks/medium/greedy/minimum_bracket_reversals.toml
@@ -0,0 +1,216 @@
+level             = "medium"
+name              = "minimum_bracket_reversals"
+tags              = ["greedy", "strings"]
+time_to_solve_sec = 400
+
+description_en = """
+Given a string `s` consisting only of curly brackets `{` and `}`, determine the minimum number of bracket reversals required to make the string balanced.
+
+A reversal changes `{` to `}` or `}` to `{`.
+If it is impossible to balance the string, return `-1`.
+"""
+
+description_ru = """
+Дана строка `s`, состоящая только из фигурных скобок `{` и `}`, определите минимальное количество переворотов скобок, необходимое для того, чтобы сделать строку сбалансированной.
+
+Переворот меняет `{` на `}` или `}` на `{`.
+Если сбалансировать строку невозможно, верните `-1`.
+"""
+
+limits = """
+- $0 \\leq \\text{len}(s) \\leq 10^5$
+"""
+
+solution = """
+def solution(s: str) -> int:
+    if len(s) % 2 != 0:
+        return -1
+    
+    open_brackets = 0
+    close_brackets = 0
+    
+    for char in s:
+        if char == '{':
+            open_brackets += 1
+        else:
+            if open_brackets > 0:
+                open_brackets -= 1
+            else:
+                close_brackets += 1
+                
+    return (open_brackets + 1) // 2 + (close_brackets + 1) // 2
+"""
+
+examples = """
+solution("}{") == 2
+solution("{{{") == -1
+solution("{{{}") == 1
+"""
+
+[[input_signature]]
+argument_name = "s"
+[input_signature.type]
+name = "string"
+
+[output_signature.type]
+name = "integer"
+
+[[asserts]]
+arguments = [""]
+comment   = "Empty string"
+expected  = 0
+
+[[asserts]]
+arguments = ["{}"]
+comment   = "Already balanced"
+expected  = 0
+
+[[asserts]]
+arguments = ["}{"]
+comment   = "Two reversals needed"
+expected  = 2
+
+[[asserts]]
+arguments = ["{"]
+comment   = "Odd length string"
+expected  = -1
+
+[[asserts]]
+arguments = ["}"]
+comment   = "Odd length string"
+expected  = -1
+
+[[asserts]]
+arguments = ["{{{"]
+comment   = "Odd length string with all opens"
+expected  = -1
+
+[[asserts]]
+arguments = ["{{}}"]
+comment   = "Balanced nested brackets"
+expected  = 0
+
+[[asserts]]
+arguments = ["{}{}"]
+comment   = "Balanced consecutive brackets"
+expected  = 0
+
+[[asserts]]
+arguments = ["{{{{"]
+comment   = "All open brackets"
+expected  = 2
+
+[[asserts]]
+arguments = ["}}}}"]
+comment   = "All close brackets"
+expected  = 2
+
+[[asserts]]
+arguments = ["{{{{}}"]
+comment   = "More open than close"
+expected  = 1
+
+[[asserts]]
+arguments = ["}}}{{{"]
+comment   = "Fully inverted"
+expected  = 4
+
+[[asserts]]
+arguments = ["}}}{{"]
+comment   = "Odd length mixed"
+expected  = -1
+
+[[asserts]]
+arguments = ["}{{}}{{{"]
+comment   = "Complex mixed string"
+expected  = 3
+
+[[asserts]]
+arguments = ["{}{}{}{}{}{}{}{}{}{}{}{}"]
+comment   = "Long balanced string"
+expected  = 0
+
+[[asserts]]
+arguments = ["}}}}}}}}}}}}}}}}}}}}}}}}"]
+comment   = "Long all closing"
+expected  = 12
+
+[[asserts]]
+arguments = ["{{{{{{{{{{{{{{{{{{{{{{{{"]
+comment   = "Long all opening"
+expected  = 12
+
+[[asserts]]
+arguments = ["{}}}{{}}{{}}{{}}"]
+comment   = "Almost balanced"
+expected  = 1
+
+[[asserts]]
+arguments = ["}}{{}}{{}}{{}}{{"]
+comment   = "Repeated inverted pairs"
+expected  = 2
+
+[[asserts]]
+arguments = ["{{{{{{{{{{}}}}}}}}}}"]
+comment   = "Deep nesting"
+expected  = 0
+
+[[asserts]]
+arguments = ["}}}}{{{{"]
+comment   = "Symmetric inverted"
+expected  = 4
+
+[[asserts]]
+arguments = ["}{{}}}"]
+comment   = "Needs one open flip"
+expected  = 1
+
+[[asserts]]
+arguments = ["}}}}}}"]
+comment   = "Six closing"
+expected  = 3
+
+[[asserts]]
+arguments = ["{{"]
+comment   = "Two opening"
+expected  = 1
+
+[[asserts]]
+arguments = ["}}"]
+comment   = "Two closing"
+expected  = 1
+
+[[asserts]]
+arguments = ["}}}{"]
+comment   = "Three close one open"
+expected  = 3
+
+[[asserts]]
+arguments = ["}{{{"]
+comment   = "One close three open"
+expected  = 3
+
+[[asserts]]
+arguments = ["{}}}"]
+comment   = "One open three close"
+expected  = 1
+
+[[asserts]]
+arguments = ["{{}{"]
+comment   = "Three open one close"
+expected  = 1
+
+[[asserts]]
+arguments = ["}{}{"]
+comment   = "Alternating inverted"
+expected  = 2
+
+[[asserts]]
+arguments = ["{}{}{}{}{}{}{}{}{}{}{}{{"]
+comment   = "Balanced with two opens at end"
+expected  = 1
+
+[[asserts]]
+arguments = ["}}{}{}{}{}{}{}{}{}{}{}{}"]
+comment   = "Balanced with two closes at start"
+expected  = 1
\ No newline at end of file

From 95b126466d593b9351fb23f3aacec3ec87b5a5ea Mon Sep 17 00:00:00 2001
From: Vitaly Kozlov <vitserkozlov@edu.hse.ru>
Date: Sat, 16 May 2026 10:35:52 +0300
Subject: [PATCH 02/17] fix mismatched filename

---
 ...gest_balanced_substring.toml => longest_balanced_segment.toml} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename tasks/easy/strings/{longest_balanced_substring.toml => longest_balanced_segment.toml} (100%)

diff --git a/tasks/easy/strings/longest_balanced_substring.toml b/tasks/easy/strings/longest_balanced_segment.toml
similarity index 100%
rename from tasks/easy/strings/longest_balanced_substring.toml
rename to tasks/easy/strings/longest_balanced_segment.toml

From b46427e87fc8688838041d4a28f6fe230b0c597e Mon Sep 17 00:00:00 2001
From: Vitaly Kozlov <vitserkozlov@edu.hse.ru>
Date: Sat, 16 May 2026 10:45:21 +0300
Subject: [PATCH 03/17] update minimum_bracket_reversals

---
 .../greedy/minimum_bracket_reversals.toml     | 111 ++++++++----------
 1 file changed, 51 insertions(+), 60 deletions(-)

diff --git a/tasks/medium/greedy/minimum_bracket_reversals.toml b/tasks/medium/greedy/minimum_bracket_reversals.toml
index 9ec881c..8839ce8 100644
--- a/tasks/medium/greedy/minimum_bracket_reversals.toml
+++ b/tasks/medium/greedy/minimum_bracket_reversals.toml
@@ -1,19 +1,19 @@
 level             = "medium"
 name              = "minimum_bracket_reversals"
-tags              = ["greedy", "strings"]
+tags              = ["strings", "greedy", "stack"]
 time_to_solve_sec = 400
 
 description_en = """
-Given a string `s` consisting only of curly brackets `{` and `}`, determine the minimum number of bracket reversals required to make the string balanced.
+Given a string `s` consisting only of parentheses `(` and `)`, determine the minimum number of parentheses reversals required to make the string balanced.
 
-A reversal changes `{` to `}` or `}` to `{`.
+A reversal changes `(` to `)` or `)` to `(`.
 If it is impossible to balance the string, return `-1`.
 """
 
 description_ru = """
-Дана строка `s`, состоящая только из фигурных скобок `{` и `}`, определите минимальное количество переворотов скобок, необходимое для того, чтобы сделать строку сбалансированной.
+Дана строка `s`, состоящая только из круглых скобок `(` и `)`, определите минимальное количество переворотов скобок, необходимое для того, чтобы сделать строку сбалансированной.
 
-Переворот меняет `{` на `}` или `}` на `{`.
+Переворот меняет `(` на `)` или `)` на `(`.
 Если сбалансировать строку невозможно, верните `-1`.
 """
 
@@ -25,26 +25,22 @@ solution = """
 def solution(s: str) -> int:
     if len(s) % 2 != 0:
         return -1
-    
-    open_brackets = 0
-    close_brackets = 0
-    
-    for char in s:
-        if char == '{':
-            open_brackets += 1
+    o = c = 0
+    for x in s:
+        if x == '(':
+            o += 1
+        elif o > 0:
+            o -= 1
         else:
-            if open_brackets > 0:
-                open_brackets -= 1
-            else:
-                close_brackets += 1
-                
-    return (open_brackets + 1) // 2 + (close_brackets + 1) // 2
+            c += 1
+    return (o + 1) // 2 + (c + 1) // 2
 """
 
 examples = """
-solution("}{") == 2
-solution("{{{") == -1
-solution("{{{}") == 1
+solution("()") == 0
+solution(")(") == 2
+solution("(((") == -1
+solution(")))(((") == 4
 """
 
 [[input_signature]]
@@ -61,156 +57,151 @@ comment   = "Empty string"
 expected  = 0
 
 [[asserts]]
-arguments = ["{}"]
-comment   = "Already balanced"
-expected  = 0
-
-[[asserts]]
-arguments = ["}{"]
+arguments = [")("]
 comment   = "Two reversals needed"
 expected  = 2
 
 [[asserts]]
-arguments = ["{"]
+arguments = ["("]
 comment   = "Odd length string"
 expected  = -1
 
 [[asserts]]
-arguments = ["}"]
+arguments = [")"]
 comment   = "Odd length string"
 expected  = -1
 
 [[asserts]]
-arguments = ["{{{"]
+arguments = ["((("]
 comment   = "Odd length string with all opens"
 expected  = -1
 
 [[asserts]]
-arguments = ["{{}}"]
+arguments = ["(())"]
 comment   = "Balanced nested brackets"
 expected  = 0
 
 [[asserts]]
-arguments = ["{}{}"]
+arguments = ["()()"]
 comment   = "Balanced consecutive brackets"
 expected  = 0
 
 [[asserts]]
-arguments = ["{{{{"]
+arguments = ["(((("]
 comment   = "All open brackets"
 expected  = 2
 
 [[asserts]]
-arguments = ["}}}}"]
+arguments = ["))))"]
 comment   = "All close brackets"
 expected  = 2
 
 [[asserts]]
-arguments = ["{{{{}}"]
+arguments = ["(((())"]
 comment   = "More open than close"
 expected  = 1
 
 [[asserts]]
-arguments = ["}}}{{{"]
+arguments = [")))((("]
 comment   = "Fully inverted"
 expected  = 4
 
 [[asserts]]
-arguments = ["}}}{{"]
+arguments = [")))(("]
 comment   = "Odd length mixed"
 expected  = -1
 
 [[asserts]]
-arguments = ["}{{}}{{{"]
+arguments = [")(())((("]
 comment   = "Complex mixed string"
 expected  = 3
 
 [[asserts]]
-arguments = ["{}{}{}{}{}{}{}{}{}{}{}{}"]
+arguments = ["()()()()()()()()()()()()"]
 comment   = "Long balanced string"
 expected  = 0
 
 [[asserts]]
-arguments = ["}}}}}}}}}}}}}}}}}}}}}}}}"]
+arguments = ["))))))))))))))))))))))))"]
 comment   = "Long all closing"
 expected  = 12
 
 [[asserts]]
-arguments = ["{{{{{{{{{{{{{{{{{{{{{{{{"]
+arguments = ["(((((((((((((((((((((((("]
 comment   = "Long all opening"
 expected  = 12
 
 [[asserts]]
-arguments = ["{}}}{{}}{{}}{{}}"]
+arguments = ["()))(())())(()"]
 comment   = "Almost balanced"
-expected  = 1
+expected  = 3
 
 [[asserts]]
-arguments = ["}}{{}}{{}}{{}}{{"]
+arguments = ["))(())(())())(("]
 comment   = "Repeated inverted pairs"
-expected  = 2
+expected  = -1
 
 [[asserts]]
-arguments = ["{{{{{{{{{{}}}}}}}}}}"]
+arguments = ["(((((((((())))))))))"]
 comment   = "Deep nesting"
 expected  = 0
 
 [[asserts]]
-arguments = ["}}}}{{{{"]
+arguments = ["))))(((("]
 comment   = "Symmetric inverted"
 expected  = 4
 
 [[asserts]]
-arguments = ["}{{}}}"]
+arguments = [")(()))"]
 comment   = "Needs one open flip"
 expected  = 1
 
 [[asserts]]
-arguments = ["}}}}}}"]
+arguments = ["))))))"]
 comment   = "Six closing"
 expected  = 3
 
 [[asserts]]
-arguments = ["{{"]
+arguments = ["(("]
 comment   = "Two opening"
 expected  = 1
 
 [[asserts]]
-arguments = ["}}"]
+arguments = ["))"]
 comment   = "Two closing"
 expected  = 1
 
 [[asserts]]
-arguments = ["}}}{"]
+arguments = [")))("]
 comment   = "Three close one open"
 expected  = 3
 
 [[asserts]]
-arguments = ["}{{{"]
+arguments = [")((("]
 comment   = "One close three open"
 expected  = 3
 
 [[asserts]]
-arguments = ["{}}}"]
-comment   = "One open three close"
-expected  = 1
+arguments = ["())))"]
+comment   = "One open four close"
+expected  = -1
 
 [[asserts]]
-arguments = ["{{}{"]
+arguments = ["(()("]
 comment   = "Three open one close"
 expected  = 1
 
 [[asserts]]
-arguments = ["}{}{"]
+arguments = [")()("]
 comment   = "Alternating inverted"
 expected  = 2
 
 [[asserts]]
-arguments = ["{}{}{}{}{}{}{}{}{}{}{}{{"]
+arguments = ["()()()()()()()()()()()()(("]
 comment   = "Balanced with two opens at end"
 expected  = 1
 
 [[asserts]]
-arguments = ["}}{}{}{}{}{}{}{}{}{}{}{}"]
+arguments = ["))()()()()()()()()()()()()"]
 comment   = "Balanced with two closes at start"
 expected  = 1
\ No newline at end of file

From b7c66b19932ae6917db86a6e2e0c9ca3cfd43375 Mon Sep 17 00:00:00 2001
From: Dmitrii Ushakov <uda2011@mail.ru>
Date: Fri, 22 May 2026 02:52:19 +0300
Subject: [PATCH 04/17] Fixed test with trailing zeros

---
 tasks/medium/regex/log_ip_sanitizer.toml | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/tasks/medium/regex/log_ip_sanitizer.toml b/tasks/medium/regex/log_ip_sanitizer.toml
index d0f9777..a9bf000 100644
--- a/tasks/medium/regex/log_ip_sanitizer.toml
+++ b/tasks/medium/regex/log_ip_sanitizer.toml
@@ -44,10 +44,12 @@ solution("1.1.1.1 2.2.2.2") == "[REDACTED] [REDACTED]"
 solution = """
 import re
 
+def replace(p):
+    ip = p.group()
+    return "[REDACTED]" if all(0 <= int(x) <= 255 for x in ip.split(".")) else ip
+
 def solution(s: str) -> str:
-    octet = r'(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)'
-    ipv4 = rf'(?<!\\d){octet}(?:\\.{octet}){{3}}(?!\\d)'
-    return re.sub(ipv4, '[REDACTED]', s)
+    return re.sub("(\\d+\\.){3}\\d+", replace, s)
 """
 
 [[input_signature]]
@@ -111,8 +113,8 @@ arguments = ["x1.2.3.4y"]
 expected  = "x[REDACTED]y"
 
 [[asserts]]
-arguments = ["a1.2.3.400"]
-expected  = "a1.2.3.400"
+arguments = ["a11.2.3.400"]
+expected  = "a11.2.3.400"
 
 [[asserts]]
 arguments = ["1.2.3"]
@@ -148,7 +150,7 @@ expected  = "[REDACTED]:end"
 
 [[asserts]]
 arguments = ["0255.255.255.255"]
-expected  = "0255.255.255.255"
+expected  = "[REDACTED]"
 
 [[asserts]]
 arguments = ["10.10.10.256"]

From da88aa0db943cc6eccccd879aa50c4fcf08f4ddb Mon Sep 17 00:00:00 2001
From: Dmitrii Ushakov <uda2011@mail.ru>
Date: Fri, 22 May 2026 03:28:45 +0300
Subject: [PATCH 05/17] Minor fixes

---
 tasks/medium/{strings => regex}/underscore.toml | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)
 rename tasks/medium/{strings => regex}/underscore.toml (95%)

diff --git a/tasks/medium/strings/underscore.toml b/tasks/medium/regex/underscore.toml
similarity index 95%
rename from tasks/medium/strings/underscore.toml
rename to tasks/medium/regex/underscore.toml
index 43400ed..58b5205 100644
--- a/tasks/medium/strings/underscore.toml
+++ b/tasks/medium/regex/underscore.toml
@@ -16,13 +16,12 @@ limits = """
 """
 
 solution = """
+import re
+
 def solution(text: str) -> str:
-    import re
-    s = text.replace('-', '_')
-    s = re.sub(r'([a-z\\d])([A-Z])', r'\\1_\\2', s)
-    s = re.sub(r'([A-Z]+)([A-Z][a-z])', r'\\1_\\2', s)
-    s = s.replace('::', '/')
-    return s.lower()
+    for pattern in ['([a-z])([A-Z])', '([A-Z]+)([A-Z][a-z])']:
+        text = re.sub(pattern, r'\\1_\\2', text)
+    return text.replace('-', '_').replace('::', '/').lower()
 """
 
 examples = """

From fab3fed2b66f433812c3e4f38cf345d116a81b9b Mon Sep 17 00:00:00 2001
From: Dmitrii Ushakov <uda2011@mail.ru>
Date: Tue, 26 May 2026 17:08:56 +0300
Subject: [PATCH 06/17] Change multiline to inline style in one of the asserts

---
 tasks/easy/arrays/loot_merge.toml | 39 +------------------------------
 1 file changed, 1 insertion(+), 38 deletions(-)

diff --git a/tasks/easy/arrays/loot_merge.toml b/tasks/easy/arrays/loot_merge.toml
index 39b6712..fc4910d 100644
--- a/tasks/easy/arrays/loot_merge.toml
+++ b/tasks/easy/arrays/loot_merge.toml
@@ -136,44 +136,7 @@ expected  = [[3, 4]]
 [[asserts]]
 arguments = [[2, 4, 6, 8], [1, 3, 5, 7, 9]]
 comment = "Fully interleaved values"
-expected = [
-  [
-    1,
-    1,
-  ],
-  [
-    2,
-    1,
-  ],
-  [
-    3,
-    1,
-  ],
-  [
-    4,
-    1,
-  ],
-  [
-    5,
-    1,
-  ],
-  [
-    6,
-    1,
-  ],
-  [
-    7,
-    1,
-  ],
-  [
-    8,
-    1,
-  ],
-  [
-    9,
-    1,
-  ],
-]
+expected = [[1, 1], [2, 1], [3, 1], [4, 1], [5, 1], [6, 1], [7, 1], [8, 1], [9, 1]]
 
 [[asserts]]
 arguments = [[1, 2, 10], [3, 4, 5, 6]]

From 29ed344413b4843db96238ffee6eedfd20202c70 Mon Sep 17 00:00:00 2001
From: Dmitrii Ushakov <uda2011@mail.ru>
Date: Tue, 26 May 2026 17:51:53 +0300
Subject: [PATCH 07/17] Major fixes in file structure

---
 tasks/easy/dp/rum_thirst.toml | 206 +++++++---------------------------
 1 file changed, 38 insertions(+), 168 deletions(-)

diff --git a/tasks/easy/dp/rum_thirst.toml b/tasks/easy/dp/rum_thirst.toml
index 9fb00da..6317f6f 100644
--- a/tasks/easy/dp/rum_thirst.toml
+++ b/tasks/easy/dp/rum_thirst.toml
@@ -1,9 +1,21 @@
-description_en = "A pirate walks along a deck lined with barrels of rum. Each barrel contains a certain number of liters (given as an array of non‑negative integers). The pirate cannot take rum from two adjacent barrels (that would make noise). What is the maximum total amount of rum he can drink unnoticed?\n"
-description_ru = "Пират идет по палубе, заставленной бочками с ромом. В каждой бочке разное количество литров (задано массивом неотрицательных целых чисел). Он не может брать ром из двух соседних бочек (поднимется шум). Какое максимальное количество рома он может выпить незаметно?\n"
-examples = "solution([]) == 0\nsolution([5]) == 5\nsolution([5, 3]) == 5\nsolution([5, 3, 7]) == 12\nsolution([2, 7, 9, 3, 1]) == 12\n"
-level = "easy"
-limits = "- $0 \\leq \\text{len}(\\text{barrels}) \\leq 1000$\n- $0 \\leq \\text{barrels}[i] \\leq 1000$\n"
-name = "rum_thirst"
+level             = "easy"
+name              = "rum_thirst"
+tags              = ["dp", "algo", "collections"]
+time_to_solve_sec = 180
+
+description_en = """
+A pirate walks along a deck lined with barrels of rum. Each barrel contains a certain number of liters (given as an array of non‑negative integers). The pirate cannot take rum from two adjacent barrels (that would make noise). What is the maximum total amount of rum he can drink unnoticed?
+"""
+
+description_ru = """
+Пират идет по палубе вдоль ряда бочек с ромом. В каждой бочке есть некоторое количество литров (задано массивом неотрицательных целых чисел). Он не может брать ром из двух соседних бочек (поднимется шум). Какое максимальное количество рома он может выпить незаметно?
+"""
+
+limits = """
+- $0 \\leq \\text{len}(\\text{barrels}) \\leq 1000$
+- $0 \\leq \\text{barrels}[i] \\leq 1000$
+"""
+
 solution = """
 def solution(barrels: list[int]) -> int:
     prev2 = prev1 = 0
@@ -11,15 +23,25 @@ def solution(barrels: list[int]) -> int:
         prev2, prev1 = prev1, max(prev1, prev2 + x)
     return prev1
 """
-tags = ["dp", "algo", "collections"]
-time_to_solve_sec = 180
+
+examples = """
+solution([]) == 0
+solution([5]) == 5
+solution([5, 3]) == 5
+solution([5, 3, 7]) == 12
+solution([2, 7, 9, 3, 1]) == 12
+"""
+
 [[input_signature]]
 argument_name = "barrels"
-
 [input_signature.type]
 name = "array"
 [input_signature.type.nested]
 name = "integer"
+
+[output_signature.type]
+name = "integer"
+
 [[asserts]]
 arguments = [[]]
 comment   = "Test 1"
@@ -76,52 +98,12 @@ comment   = "Test 11"
 expected  = 243
 
 [[asserts]]
-arguments = [
-  [
-    241,
-    310,
-    105,
-    738,
-    405,
-    490,
-    158,
-    92,
-    68,
-    20,
-    411,
-    562,
-    939,
-    296,
-    819,
-    783,
-    60,
-    227,
-  ],
-]
+arguments = [[241, 310, 105, 738, 405, 490, 158, 92, 68, 20, 411, 562, 939, 296, 819, 783, 60, 227]]
 comment = "Test 12"
 expected = 4026
 
 [[asserts]]
-arguments = [
-  [
-    637,
-    261,
-    759,
-    367,
-    814,
-    707,
-    965,
-    861,
-    757,
-    667,
-    944,
-    542,
-    29,
-    860,
-    476,
-    794,
-  ],
-]
+arguments = [[637, 261, 759, 367, 814, 707, 965, 861, 757, 667, 944, 542, 29, 860, 476, 794]]
 comment = "Test 13"
 expected = 6530
 
@@ -151,28 +133,7 @@ comment   = "Test 18"
 expected  = 1079
 
 [[asserts]]
-arguments = [
-  [
-    463,
-    886,
-    573,
-    877,
-    946,
-    799,
-    476,
-    462,
-    520,
-    875,
-    601,
-    194,
-    189,
-    823,
-    524,
-    487,
-    644,
-    628,
-  ],
-]
+arguments = [[463, 886, 573, 877, 946, 799, 476, 462, 520, 875, 601, 194, 189, 823, 524, 487, 644, 628]]
 comment = "Test 19"
 expected = 6031
 
@@ -192,30 +153,7 @@ comment   = "Test 22"
 expected  = 1403
 
 [[asserts]]
-arguments = [
-  [
-    988,
-    213,
-    11,
-    533,
-    753,
-    37,
-    161,
-    934,
-    244,
-    17,
-    56,
-    900,
-    824,
-    697,
-    150,
-    877,
-    711,
-    376,
-    245,
-    119,
-  ],
-]
+arguments = [[988, 213, 11, 533, 753, 37, 161, 934, 244, 17, 56, 900, 824, 697, 150, 877, 711, 376, 245, 119]]
 comment = "Test 23"
 expected = 5672
 
@@ -230,27 +168,7 @@ comment   = "Test 25"
 expected  = 2639
 
 [[asserts]]
-arguments = [
-  [
-    185,
-    125,
-    677,
-    459,
-    342,
-    245,
-    202,
-    974,
-    501,
-    643,
-    505,
-    187,
-    491,
-    302,
-    469,
-    908,
-    270,
-  ],
-]
+arguments = [[185, 125, 677, 459, 342, 245, 202, 974, 501, 643, 505, 187, 491, 302, 469, 908, 270]]
 comment = "Test 26"
 expected = 4220
 
@@ -260,59 +178,11 @@ comment   = "Test 27"
 expected  = 2028
 
 [[asserts]]
-arguments = [
-  [
-    927,
-    740,
-    702,
-    805,
-    784,
-    901,
-    926,
-    154,
-    266,
-    690,
-    650,
-    869,
-    926,
-    103,
-    893,
-    335,
-  ],
-]
+arguments = [[927, 740, 702, 805, 784, 901, 926, 154, 266, 690, 650, 869, 926, 103, 893, 335]]
 comment = "Test 28"
 expected = 6074
 
 [[asserts]]
-arguments = [
-  [
-    168,
-    428,
-    706,
-    428,
-    650,
-    288,
-    490,
-    863,
-    221,
-    811,
-    486,
-    827,
-    986,
-    524,
-    187,
-    517,
-    540,
-    241,
-  ],
-]
+arguments = [[168, 428, 706, 428, 650, 288, 490, 863, 221, 811, 486, 827, 986, 524, 187, 517, 540, 241]]
 comment = "Test 29"
 expected = 5307
-
-[[asserts]]
-arguments = [[]]
-comment   = "Test 30"
-expected  = 0
-
-[output_signature.type]
-name = "integer"

From 9d79130d323cda98b594674b52f620b459a2240b Mon Sep 17 00:00:00 2001
From: Dmitrii Ushakov <uda2011@mail.ru>
Date: Wed, 27 May 2026 00:09:09 +0300
Subject: [PATCH 08/17] Major fixes in file structure

---
 tasks/medium/dp/black_mark.toml | 239 +++++++++-----------------------
 1 file changed, 66 insertions(+), 173 deletions(-)

diff --git a/tasks/medium/dp/black_mark.toml b/tasks/medium/dp/black_mark.toml
index d4b6bd1..f8e76b3 100644
--- a/tasks/medium/dp/black_mark.toml
+++ b/tasks/medium/dp/black_mark.toml
@@ -1,12 +1,25 @@
-description_en = "You have a list of $n$ pirates ($n \\leq 20$) and $n$ dangerous tasks. Each pirate has a fear level for each task, given as an $n \\times n$ matrix `fear` where `fear[i][j]` is the fear of pirate $i$ for task $j$. You need to assign each pirate exactly one distinct task so that the total sum of fear levels is minimized. Return the minimal possible total.\n"
-description_ru = "У вас есть список из $n$ пиратов ($n \\leq 20$) и $n$ опасных заданий. Каждый пират имеет свой уровень страха перед каждым заданием, заданный матрицей `fear` размером $n \\times n$, где `fear[i][j]` — уровень страха пирата $i$ перед заданием $j$. Необходимо назначить каждому пирату ровно одно уникальное задание так, чтобы суммарный уровень страха был минимальным. Верните минимально возможную сумму.\n"
-examples = "solution([[5]]) == 5\nsolution([[1,2],[3,4]]) == 5\nsolution([[10,1],[1,10]]) == 2\n"
-level = "medium"
+level             = "medium"
+name              = "black_mark"
+tags              = ["dp", "algo", "scheduling"]
+time_to_solve_sec = 400
+
+description_en = """
+You have a list of $n$ pirates ($n \\leq 20$) and $n$ dangerous tasks. Each pirate has a fear level for each task, given as an $n \\times n$ matrix `fear` where `fear[i][j]` is the fear of pirate $i$ for task $j$.
+
+You have to assign each pirate exactly one distinct task so that the total sum of fear levels is minimized. Return the minimal possible total.
+"""
+
+description_ru = """
+У вас есть список из $n$ пиратов ($n \\leq 20$) и $n$ опасных заданий. Каждый пират имеет свой уровень страха перед каждым заданием, заданный матрицей `fear` размером $n \\times n$, где `fear[i][j]` — уровень страха пирата $i$ перед заданием $j$.
+
+Необходимо назначить каждому пирату ровно одно уникальное задание так, чтобы суммарный уровень страха был минимальным. Верните минимально возможную сумму.
+"""
+
 limits = """
 - $1 \\leq n \\leq 20$
 - $0 \\leq \\text{fear}[i][j] \\leq 1000$
 """
-name = "black_mark"
+
 solution = """
 def solution(fear: list[list[int]]) -> int:
     n = len(fear)
@@ -21,17 +34,25 @@ def solution(fear: list[list[int]]) -> int:
                 dp[new_mask] = min(dp[new_mask], dp[mask] + fear[i][j])
     return dp[(1 << n) - 1]
 """
-tags = ["dp", "algo", "scheduling"]
-time_to_solve_sec = 400
+
+examples = """
+solution([[5]]) == 5
+solution([[1, 2], [3, 4]]) == 5
+solution([[10, 1], [1, 10]]) == 2
+"""
+
 [[input_signature]]
 argument_name = "fear"
-
 [input_signature.type]
 name = "array"
 [input_signature.type.nested]
 name = "array"
 [input_signature.type.nested.nested]
 name = "integer"
+
+[output_signature.type]
+name = "integer"
+
 [[asserts]]
 arguments = [[[5]]]
 comment   = "Test 1"
@@ -62,211 +83,83 @@ arguments = [[[979]]]
 comment   = "Test 6"
 expected  = 979
 
-[[asserts]]
-arguments = [[[244]]]
-comment   = "Test 7"
-expected  = 244
-
 [[asserts]]
 arguments = [
   [
-    [
-      242,
-      311,
-      106,
-      739,
-      406,
-    ],
-    [
-      491,
-      159,
-      93,
-      69,
-      21,
-    ],
-    [
-      412,
-      563,
-      940,
-      297,
-      820,
-    ],
-    [
-      784,
-      61,
-      228,
-      533,
-      550,
-    ],
-    [
-      369,
-      284,
-      799,
-      177,
-      847,
-    ],
-  ],
+    [242, 311, 106, 739, 406],
+    [491, 159, 93, 69, 21],
+    [412, 563, 940, 297, 820],
+    [784, 61, 228, 533, 550],
+    [369, 284, 799, 177, 847]
+  ]
 ]
-comment = "Test 8"
-expected = 777
-
-[[asserts]]
-arguments = [[[638]]]
-comment   = "Test 9"
-expected  = 638
+comment   = "Test 7"
+expected  = 777
 
 [[asserts]]
 arguments = [[[813, 588, 842], [83, 497, 781], [268, 38, 1]]]
-comment   = "Test 10"
+comment   = "Test 8"
 expected  = 672
 
 [[asserts]]
 arguments = [[[332, 971], [155, 405]]]
-comment   = "Test 11"
+comment   = "Test 9"
 expected  = 737
 
-[[asserts]]
-arguments = [[[233]]]
-comment   = "Test 12"
-expected  = 233
-
 [[asserts]]
 arguments = [[[475, 628, 383], [274, 142, 191], [888, 693, 7]]]
-comment   = "Test 13"
+comment   = "Test 10"
 expected  = 624
 
 [[asserts]]
 arguments = [[[586, 34, 440], [495, 592, 16], [212, 474, 833]]]
-comment   = "Test 14"
+comment   = "Test 11"
 expected  = 262
 
 [[asserts]]
 arguments = [
   [
-    [
-      464,
-      887,
-      574,
-      878,
-    ],
-    [
-      947,
-      800,
-      477,
-      463,
-    ],
-    [
-      521,
-      876,
-      602,
-      195,
-    ],
-    [
-      190,
-      824,
-      525,
-      488,
-    ],
-  ],
+    [464, 887, 574, 878],
+    [947, 800, 477, 463],
+    [521, 876, 602, 195],
+    [190, 824, 525, 488]
+  ]
 ]
-comment = "Test 15"
-expected = 1749
+comment   = "Test 12"
+expected  = 1749
 
 [[asserts]]
 arguments = [
   [
-    [
-      486,
-      276,
-      674,
-      542,
-      683,
-    ],
-    [
-      359,
-      147,
-      391,
-      12,
-      384,
-    ],
-    [
-      495,
-      281,
-      659,
-      830,
-      472,
-    ],
-    [
-      708,
-      886,
-      616,
-      234,
-      572,
-    ],
-    [
-      2,
-      678,
-      640,
-      149,
-      451,
-    ],
-  ],
+    [486, 276, 674, 542, 683],
+    [359, 147, 391, 12, 384],
+    [495, 281, 659, 830, 472],
+    [708, 886, 616, 234, 572],
+    [2, 678, 640, 149, 451]
+  ]
 ]
-comment = "Test 16"
-expected = 1375
+comment   = "Test 13"
+expected  = 1375
 
 [[asserts]]
 arguments = [[[266, 298, 702], [932, 701, 822], [870, 912, 191]]]
-comment   = "Test 17"
+comment   = "Test 14"
 expected  = 1158
 
 [[asserts]]
 arguments = [[[110, 631], [720, 774]]]
-comment   = "Test 18"
+comment   = "Test 15"
 expected  = 884
 
 [[asserts]]
 arguments = [
   [
-    [
-      989,
-      214,
-      12,
-      534,
-      754,
-    ],
-    [
-      38,
-      162,
-      935,
-      245,
-      18,
-    ],
-    [
-      57,
-      901,
-      825,
-      698,
-      151,
-    ],
-    [
-      878,
-      712,
-      377,
-      246,
-      120,
-    ],
-    [
-      347,
-      478,
-      726,
-      365,
-      288,
-    ],
-  ],
+    [989, 214, 12, 534, 754],
+    [38, 162, 935, 245, 18],
+    [57, 901, 825, 698, 151],
+    [878, 712, 377, 246, 120],
+    [347, 478, 726, 365, 288]
+  ]
 ]
-comment = "Test 19"
-expected = 716
-
-[output_signature.type]
-name = "integer"
+comment   = "Test 16"
+expected  = 716

From 3aa2564576541d3658c3fd27c4b1685d0b0b6207 Mon Sep 17 00:00:00 2001
From: Dmitrii Ushakov <uda2011@mail.ru>
Date: Wed, 27 May 2026 00:16:58 +0300
Subject: [PATCH 09/17] Minor fix

---
 tasks/medium/games/feeding_kraken.toml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tasks/medium/games/feeding_kraken.toml b/tasks/medium/games/feeding_kraken.toml
index 320571d..a1a320a 100644
--- a/tasks/medium/games/feeding_kraken.toml
+++ b/tasks/medium/games/feeding_kraken.toml
@@ -13,15 +13,15 @@ description_ru = """
 
 limits = """
 - $0 \\leq a, b, c \\leq 1000$
+- $a + b + c \\geq 1$
 """
 
 solution = """
 def solution(a: int, b: int, c: int) -> bool:
-    return (a ^ b ^ c) != 0
+    return a ^ b ^ c != 0
 """
 
 examples = """
-solution(0, 0, 0) == False
 solution(1, 0, 0) == True
 solution(1, 1, 0) == False
 solution(1, 2, 3) == False

From 8c5babcf3f2aa4a8312d7633c56ba481535b83d4 Mon Sep 17 00:00:00 2001
From: Dmitrii Ushakov <uda2011@mail.ru>
Date: Wed, 27 May 2026 00:23:51 +0300
Subject: [PATCH 10/17] Change multiline to inline style in asserts

---
 .../medium/greedy/lone_whetstone_dilemma.toml | 476 +-----------------
 1 file changed, 26 insertions(+), 450 deletions(-)

diff --git a/tasks/medium/greedy/lone_whetstone_dilemma.toml b/tasks/medium/greedy/lone_whetstone_dilemma.toml
index 8adc630..007ca16 100644
--- a/tasks/medium/greedy/lone_whetstone_dilemma.toml
+++ b/tasks/medium/greedy/lone_whetstone_dilemma.toml
@@ -142,32 +142,8 @@ expected  = 230
 
 [[asserts]]
 arguments = [
-  [
-    9,
-    8,
-    4,
-    10,
-    9,
-    10,
-    6,
-    1,
-    7,
-    9,
-    7,
-  ],
-  [
-    9,
-    10,
-    8,
-    9,
-    7,
-    6,
-    9,
-    1,
-    3,
-    2,
-    8,
-  ],
+  [9, 8, 4, 10, 9, 10, 6, 1, 7, 9, 7],
+  [9, 10, 8, 9, 7, 6, 9, 1, 3, 2, 8]
 ]
 comment = "Test 10"
 expected = 2383
@@ -179,36 +155,8 @@ expected  = 760
 
 [[asserts]]
 arguments = [
-  [
-    9,
-    9,
-    1,
-    5,
-    8,
-    4,
-    9,
-    8,
-    3,
-    3,
-    9,
-    8,
-    7,
-  ],
-  [
-    8,
-    1,
-    1,
-    3,
-    8,
-    4,
-    1,
-    5,
-    6,
-    5,
-    7,
-    7,
-    1,
-  ],
+  [9, 9, 1, 5, 8, 4, 9, 8, 3, 3, 9, 8, 7],
+  [8, 1, 1, 3, 8, 4, 1, 5, 6, 5, 7, 7, 1]
 ]
 comment = "Test 12"
 expected = 1703
@@ -220,94 +168,16 @@ expected  = 150
 
 [[asserts]]
 arguments = [
-  [
-    7,
-    2,
-    9,
-    7,
-    1,
-    6,
-    5,
-    8,
-    1,
-    9,
-    6,
-    7,
-    6,
-    1,
-    3,
-    7,
-    2,
-    3,
-  ],
-  [
-    6,
-    4,
-    2,
-    1,
-    9,
-    7,
-    9,
-    5,
-    3,
-    5,
-    7,
-    6,
-    3,
-    9,
-    6,
-    9,
-    2,
-    3,
-  ],
+  [7, 2, 9, 7, 1, 6, 5, 8, 1, 9, 6, 7, 6, 1, 3, 7, 2, 3],
+  [6, 4, 2, 1, 9, 7, 9, 5, 3, 5, 7, 6, 3, 9, 6, 9, 2, 3]
 ]
 comment = "Test 14"
 expected = 2669
 
 [[asserts]]
 arguments = [
-  [
-    7,
-    7,
-    1,
-    3,
-    8,
-    1,
-    6,
-    8,
-    8,
-    5,
-    7,
-    1,
-    3,
-    9,
-    6,
-    9,
-    9,
-    9,
-    3,
-  ],
-  [
-    6,
-    9,
-    2,
-    9,
-    6,
-    4,
-    10,
-    6,
-    2,
-    5,
-    9,
-    4,
-    4,
-    6,
-    5,
-    7,
-    1,
-    9,
-    2,
-  ],
+  [7, 7, 1, 3, 8, 1, 6, 8, 8, 5, 7, 1, 3, 9, 6, 9, 9, 9, 3],
+  [6, 9, 2, 9, 6, 4, 10, 6, 2, 5, 9, 4, 4, 6, 5, 7, 1, 9, 2]
 ]
 comment = "Test 15"
 expected = 4262
@@ -324,112 +194,24 @@ expected  = 468
 
 [[asserts]]
 arguments = [
-  [
-    4,
-    9,
-    3,
-    10,
-    1,
-    10,
-    10,
-    8,
-    6,
-    10,
-    2,
-    1,
-    6,
-  ],
-  [
-    8,
-    6,
-    7,
-    6,
-    6,
-    4,
-    8,
-    6,
-    4,
-    3,
-    7,
-    1,
-    7,
-  ],
+  [4, 9, 3, 10, 1, 10, 10, 8, 6, 10, 2, 1, 6],
+  [8, 6, 7, 6, 6, 4, 8, 6, 4, 3, 7, 1, 7]
 ]
 comment = "Test 18"
 expected = 2048
 
 [[asserts]]
 arguments = [
-  [
-    9,
-    5,
-    3,
-    9,
-    7,
-    6,
-    2,
-    5,
-    2,
-    5,
-    9,
-    10,
-    6,
-  ],
-  [
-    1,
-    7,
-    1,
-    10,
-    7,
-    5,
-    2,
-    8,
-    10,
-    6,
-    4,
-    8,
-    5,
-  ],
+  [9, 5, 3, 9, 7, 6, 2, 5, 2, 5, 9, 10, 6],
+  [1, 7, 1, 10, 7, 5, 2, 8, 10, 6, 4, 8, 5]
 ]
 comment = "Test 19"
 expected = 2130
 
 [[asserts]]
 arguments = [
-  [
-    10,
-    10,
-    6,
-    4,
-    8,
-    9,
-    10,
-    5,
-    6,
-    1,
-    3,
-    2,
-    1,
-    7,
-    8,
-  ],
-  [
-    3,
-    8,
-    9,
-    1,
-    8,
-    9,
-    3,
-    6,
-    6,
-    4,
-    10,
-    1,
-    8,
-    9,
-    10,
-  ],
+  [10, 10, 6, 4, 8, 9, 10, 5, 6, 1, 3, 2, 1, 7, 8],
+  [3, 8, 9, 1, 8, 9, 3, 6, 6, 4, 10, 1, 8, 9, 10]
 ]
 comment = "Test 20"
 expected = 2995
@@ -441,44 +223,8 @@ expected  = 738
 
 [[asserts]]
 arguments = [
-  [
-    3,
-    9,
-    4,
-    5,
-    8,
-    8,
-    4,
-    5,
-    9,
-    2,
-    2,
-    8,
-    10,
-    9,
-    9,
-    5,
-    4,
-  ],
-  [
-    9,
-    2,
-    7,
-    7,
-    8,
-    2,
-    1,
-    10,
-    7,
-    7,
-    9,
-    6,
-    3,
-    8,
-    3,
-    4,
-    4,
-  ],
+  [3, 9, 4, 5, 8, 8, 4, 5, 9, 2, 2, 8, 10, 9, 9, 5, 4],
+  [9, 2, 7, 7, 8, 2, 1, 10, 7, 7, 9, 6, 3, 8, 3, 4, 4]
 ]
 comment = "Test 22"
 expected = 3105
@@ -505,74 +251,16 @@ expected  = 504
 
 [[asserts]]
 arguments = [
-  [
-    4,
-    7,
-    1,
-    2,
-    9,
-    2,
-    10,
-    6,
-    2,
-    4,
-    7,
-    3,
-  ],
-  [
-    7,
-    3,
-    8,
-    3,
-    1,
-    3,
-    2,
-    6,
-    1,
-    2,
-    3,
-    4,
-  ],
+  [4, 7, 1, 2, 9, 2, 10, 6, 2, 4, 7, 3],
+  [7, 3, 8, 3, 1, 3, 2, 6, 1, 2, 3, 4]
 ]
 comment = "Test 27"
 expected = 675
 
 [[asserts]]
 arguments = [
-  [
-    7,
-    4,
-    7,
-    1,
-    1,
-    3,
-    2,
-    8,
-    2,
-    3,
-    1,
-    6,
-    8,
-    4,
-    4,
-  ],
-  [
-    4,
-    7,
-    6,
-    3,
-    2,
-    1,
-    5,
-    6,
-    7,
-    6,
-    4,
-    1,
-    1,
-    9,
-    2,
-  ],
+  [7, 4, 7, 1, 1, 3, 2, 8, 2, 3, 1, 6, 8, 4, 4],
+  [4, 7, 6, 3, 2, 1, 5, 6, 7, 6, 4, 1, 1, 9, 2]
 ]
 comment = "Test 28"
 expected = 1146
@@ -594,136 +282,24 @@ expected  = 512
 
 [[asserts]]
 arguments = [
-  [
-    8,
-    5,
-    9,
-    9,
-    3,
-    7,
-    1,
-    5,
-    1,
-    3,
-    4,
-    6,
-    3,
-    2,
-  ],
-  [
-    3,
-    10,
-    2,
-    5,
-    2,
-    2,
-    6,
-    1,
-    5,
-    6,
-    3,
-    5,
-    7,
-    2,
-  ],
+  [8, 5, 9, 9, 3, 7, 1, 5, 1, 3, 4, 6, 3, 2],
+  [3, 10, 2, 5, 2, 2, 6, 1, 5, 6, 3, 5, 7, 2]
 ]
 comment = "Test 32"
 expected = 1107
 
 [[asserts]]
 arguments = [
-  [
-    5,
-    9,
-    9,
-    2,
-    9,
-    2,
-    6,
-    5,
-    5,
-    8,
-    4,
-    1,
-    2,
-    2,
-    10,
-    2,
-    8,
-    7,
-    6,
-    3,
-  ],
-  [
-    3,
-    7,
-    1,
-    7,
-    4,
-    4,
-    1,
-    7,
-    3,
-    2,
-    3,
-    9,
-    5,
-    7,
-    3,
-    7,
-    5,
-    2,
-    1,
-    2,
-  ],
+  [5, 9, 9, 2, 9, 2, 6, 5, 5, 8, 4, 1, 2, 2, 10, 2, 8, 7, 6, 3],
+  [3, 7, 1, 7, 4, 4, 1, 7, 3, 2, 3, 9, 5, 7, 3, 7, 5, 2, 1, 2]
 ]
 comment = "Test 33"
 expected = 2180
 
 [[asserts]]
 arguments = [
-  [
-    7,
-    5,
-    10,
-    1,
-    9,
-    4,
-    5,
-    5,
-    10,
-    9,
-    6,
-    1,
-    3,
-    5,
-    5,
-    4,
-    7,
-    4,
-    8,
-  ],
-  [
-    1,
-    7,
-    2,
-    3,
-    3,
-    1,
-    9,
-    4,
-    2,
-    8,
-    10,
-    4,
-    7,
-    10,
-    7,
-    9,
-    6,
-    2,
-    4,
-  ],
+  [7, 5, 10, 1, 9, 4, 5, 5, 10, 9, 6, 1, 3, 5, 5, 4, 7, 4, 8],
+  [1, 7, 2, 3, 3, 1, 9, 4, 2, 8, 10, 4, 7, 10, 7, 9, 6, 2, 4]
 ]
 comment = "Test 34"
 expected = 3220

From f8768f25b2fa803f7228a418264b36f60ecb6477 Mon Sep 17 00:00:00 2001
From: Dmitrii Ushakov <uda2011@mail.ru>
Date: Wed, 27 May 2026 00:37:00 +0300
Subject: [PATCH 11/17] Order examples

---
 tasks/medium/stack/broadside_salvo.toml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tasks/medium/stack/broadside_salvo.toml b/tasks/medium/stack/broadside_salvo.toml
index cc925cb..65ab64c 100644
--- a/tasks/medium/stack/broadside_salvo.toml
+++ b/tasks/medium/stack/broadside_salvo.toml
@@ -33,10 +33,10 @@ def solution(heights: list[int]) -> int:
 """
 
 examples = """
-solution([2,1,5,6,2,3]) == 10
-solution([2,4]) == 4
-solution([1]) == 1
 solution([]) == 0
+solution([1]) == 1
+solution([2, 4]) == 4
+solution([2, 1, 5, 6, 2, 3]) == 10
 """
 
 [[input_signature]]

From ca57f0f475b46b97b33e44e9898f066e73a1b4c9 Mon Sep 17 00:00:00 2001
From: Dmitrii Ushakov <uda2011@mail.ru>
Date: Fri, 5 Jun 2026 16:25:17 +0300
Subject: [PATCH 12/17] Rewrited description

---
 tasks/easy/strings/fancy_number.toml | 20 +++++++++++++-------
 1 file changed, 13 insertions(+), 7 deletions(-)

diff --git a/tasks/easy/strings/fancy_number.toml b/tasks/easy/strings/fancy_number.toml
index 0533905..7772596 100644
--- a/tasks/easy/strings/fancy_number.toml
+++ b/tasks/easy/strings/fancy_number.toml
@@ -4,19 +4,25 @@ tags              = ["strings", "games"]
 time_to_solve_sec = 300
 
 description_en = """
-Given a number, find whether it is fancy or not.
+Given a number, find whether it is **fancy** or not.
 
-A fancy number is one which when rotated $180$ degrees is the same.
+A number is called **fancy** if it does not change when rotated $180$ degrees.
 
-When rotated: $6$ becomes $9$, $9$ becomes $6$, and $8$, $1$, $0$ remain themselves (do not change).
+With this rotation:
+- $6$ becomes $9$;
+- $9$ becomes $6$;
+- $0$, $1$, $8$ remain themselves;
+- other digits break.
 """
 
 description_ru = """
-Дано число, определите причудливое оно или нет.
+Дано число. Определите, **причудливое** оно или нет.
 
-Число является причудливым, если при развороте на $180$ градусов остается самим собой.
-
-При повороте: $6$ становится $9$, $9$ становится $6$, а $8$, $1$ и $0$ остаются сами собой (не меняются).
+Число называется **причудливым**, если при перевороте на $180$ градусов остается самим собой. При таком перевороте:
+- $6$ становится $9$;
+- $9$ становится $6$;
+- $0$, $1$ и $8$ остаются сами собой;
+- остальные цифры перестают быть цифрами.
 """
 
 limits = """

From 4f7f77f2170664904d62c16c121064371b89dc3b Mon Sep 17 00:00:00 2001
From: Dmitrii Ushakov <uda2011@mail.ru>
Date: Sat, 6 Jun 2026 15:12:33 +0300
Subject: [PATCH 13/17] Changed input type from string to int + allowed digits
 23457 + added new asserts

---
 tasks/easy/strings/fancy_number.toml | 167 +++++++++++++++------------
 1 file changed, 90 insertions(+), 77 deletions(-)

diff --git a/tasks/easy/strings/fancy_number.toml b/tasks/easy/strings/fancy_number.toml
index 7772596..b4802da 100644
--- a/tasks/easy/strings/fancy_number.toml
+++ b/tasks/easy/strings/fancy_number.toml
@@ -6,9 +6,7 @@ time_to_solve_sec = 300
 description_en = """
 Given a number, find whether it is **fancy** or not.
 
-A number is called **fancy** if it does not change when rotated $180$ degrees.
-
-With this rotation:
+A number is called **fancy** if it does not change when rotated $180$ degrees. With this rotation:
 - $6$ becomes $9$;
 - $9$ becomes $6$;
 - $0$, $1$, $8$ remain themselves;
@@ -26,168 +24,183 @@ description_ru = """
 """
 
 limits = """
-- $1 \\leq \\text{len}(\\text{num\\_str}) \\leq 10$
-- $\\text{num\\_str} \\in \\{0, 1, 6, 8, 9\\}^*$
+- $-10^9 \\leq \\text{number} \\leq 10^9
 """
 
 solution = """
-def solution(num_str: str) -> bool:
-    mapping = {'0': '0', '1': '1', '6': '9', '8': '8', '9': '6'}
-    rotated = ''
-    for char in reversed(num_str):
-        if char not in mapping:
+def solution(number: int) -> bool:
+    num_str = str(number)
+    mapping = {"0": "0", "1": "1", "6": "9", "8": "8", "9": "6"}
+    rotated = ""
+    for digit in reversed(num_str):
+        if digit not in mapping:
             return False
-        rotated += mapping[char]
+        rotated += mapping[digit]
     return rotated == num_str
 """
 
 examples = """
-solution("96") == True
-solution("916") == True
-solution("996") == False
-solution("9081806") == True
-solution("9088806") == True
+solution(69) == True
+solution(369) == False
+solution(996) == False
+solution(9788) == False
+solution(9081806) == True
 """
 
 [[input_signature]]
-argument_name = "num_str"
+argument_name = "number"
 [input_signature.type]
-name = "string"
+name = "int"
 
 [output_signature.type]
 name = "boolean"
 
 [[asserts]]
-arguments = ["9081806"]
-comment   = "Fancy seven digit"
-expected  = true
+arguments = [-369]
+comment   = "Not fancy"
+expected  = false
 
 [[asserts]]
-arguments = ["916"]
+arguments = [916]
 comment   = "Fancy three digit"
 expected  = true
 
 [[asserts]]
-arguments = ["9088806"]
-comment   = "Fancy with eights"
-expected  = true
+arguments = [926]
+comment   = "Not fancy three digit"
+expected  = false
 
 [[asserts]]
-arguments = ["996"]
+arguments = [996]
 comment   = "Not symmetric"
 expected  = false
 
 [[asserts]]
-arguments = ["96"]
-comment   = "Simple fancy pair"
-expected  = true
-
-[[asserts]]
-arguments = ["0"]
+arguments = [0]
 comment   = "Single zero"
 expected  = true
 
 [[asserts]]
-arguments = ["1"]
+arguments = [1]
 comment   = "Single one"
 expected  = true
 
 [[asserts]]
-arguments = ["8"]
+arguments = [8]
 comment   = "Single eight"
 expected  = true
 
 [[asserts]]
-arguments = ["6"]
+arguments = [6]
 comment   = "Single six not fancy"
 expected  = false
 
 [[asserts]]
-arguments = ["9"]
+arguments = [9]
 comment   = "Single nine not fancy"
 expected  = false
 
 [[asserts]]
-arguments = ["69"]
+arguments = [69]
 comment   = "Sixty-nine fancy"
 expected  = true
 
 [[asserts]]
-arguments = ["88"]
+arguments = [88]
 comment   = "Double eight"
 expected  = true
 
 [[asserts]]
-arguments = ["11"]
-comment   = "Double one"
-expected  = true
+arguments = [417]
+comment   = "Bad digits"
+expected  = false
 
 [[asserts]]
-arguments = ["00"]
-comment   = "Double zero"
-expected  = true
+arguments = [404]
+comment   = "Error code"
+expected  = false
 
 [[asserts]]
-arguments = ["101"]
-comment   = "One zero one"
-expected  = true
+arguments = [848]
+comment   = "Eight four eight"
+expected  = false
 
 [[asserts]]
-arguments = ["808"]
-comment   = "Eight zero eight"
-expected  = true
+arguments = [602]
+comment   = "Six zero two"
+expected  = false
 
 [[asserts]]
-arguments = ["609"]
-comment   = "Six zero nine"
-expected  = true
+arguments = [18581]
+comment   = "Not fancy five digit"
+expected  = false
 
 [[asserts]]
-arguments = ["1881"]
-comment   = "Fancy four digit"
+arguments = [1001]
+comment   = "Palindromic and fancy"
 expected  = true
 
 [[asserts]]
-arguments = ["1001"]
-comment   = "One zero zero one"
+arguments = [6889]
+comment   = "Fancy six eight eight nine"
 expected  = true
 
 [[asserts]]
-arguments = ["9696"]
-comment   = "Nine six nine six"
-expected  = true
+arguments = [9119]
+comment   = "Nine one one nine"
+expected  = false
 
 [[asserts]]
-arguments = ["6889"]
-comment   = "Fancy six eight eight nine"
-expected  = true
+arguments = [9788]
+comment   = "Random not fancy number"
+expected  = false
 
 [[asserts]]
-arguments = ["8008"]
-comment   = "Eight zero zero eight"
-expected  = true
+arguments = [45154]
+comment   = "Not fancy"
+expected  = false
 
 [[asserts]]
-arguments = ["9119"]
-comment   = "Nine one one nine"
+arguments = [20102]
+comment   = "Five digit not fancy"
 expected  = false
 
 [[asserts]]
-arguments = ["60109"]
-comment   = "Five digit fancy"
+arguments = [96896]
+comment   = "Five digit fancy variant"
 expected  = true
 
 [[asserts]]
-arguments = ["90806"]
-comment   = "Five digit fancy variant"
-expected  = true
+arguments = [-111]
+comment   = "Negative with ones"
+expected  = false
+
+[[asserts]]
+arguments = [-888]
+comment   = "Negative with eights"
+expected  = false
 
 [[asserts]]
-arguments = ["111"]
-comment   = "Triple one"
+arguments = [9081806]
+comment   = "Fancy seven digit"
 expected  = true
 
 [[asserts]]
-arguments = ["888"]
-comment   = "Triple eight"
+arguments = [9162916]
+comment   = "Not fancy seven digit"
+expected  = false
+
+[[asserts]]
+arguments = [9088806]
+comment   = "Fancy with eights"
 expected  = true
+
+[[asserts]]
+arguments = [96966969]
+comment   = "Palindromic but not fancy"
+expected  = false
+
+[[asserts]]
+arguments = [-600080009]
+comment   = "Long negative number"
+expected  = false

From 9258b8394bdc7594f8cea849a5db31c9def6e4f0 Mon Sep 17 00:00:00 2001
From: Dmitrii <36790425+dimaush@users.noreply.github.com>
Date: Sat, 6 Jun 2026 15:20:51 +0300
Subject: [PATCH 14/17] Update fancy_number.toml

Fix misspell int -> integer
---
 tasks/easy/strings/fancy_number.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tasks/easy/strings/fancy_number.toml b/tasks/easy/strings/fancy_number.toml
index b4802da..0d61a81 100644
--- a/tasks/easy/strings/fancy_number.toml
+++ b/tasks/easy/strings/fancy_number.toml
@@ -50,7 +50,7 @@ solution(9081806) == True
 [[input_signature]]
 argument_name = "number"
 [input_signature.type]
-name = "int"
+name = "integer"
 
 [output_signature.type]
 name = "boolean"

From a81ea778c5ded0c67bf63eeca19177c7c0115112 Mon Sep 17 00:00:00 2001
From: Dmitrii Ushakov <uda2011@mail.ru>
Date: Sun, 7 Jun 2026 20:58:36 +0300
Subject: [PATCH 15/17] Added tests with negative numbers and fixed solution

---
 .../math/sum_of_two_equals_third.toml         | 130 +++++++++++++-----
 1 file changed, 92 insertions(+), 38 deletions(-)

diff --git a/tasks/elementary/math/sum_of_two_equals_third.toml b/tasks/elementary/math/sum_of_two_equals_third.toml
index f5df5c0..e73389b 100644
--- a/tasks/elementary/math/sum_of_two_equals_third.toml
+++ b/tasks/elementary/math/sum_of_two_equals_third.toml
@@ -4,140 +4,194 @@ tags              = ["math", "collections"]
 time_to_solve_sec = 300
 
 description_en = """
-Given three integers `nums = [a, b, c]`, determine whether the sum of **two** of them equals the **third**.
+Given three integers, determine whether the sum of two of them equals the third one.
 
 Return `True` if such a pair exists, otherwise return `False`.
 """
 
 description_ru = """
-Даны три целых числа `nums = [a, b, c]`. Определите, существует ли пара чисел, сумма которых равна третьему.
+Даны три целых числа. Определите, существует ли пара чисел, сумма которых равна третьему.
 
 Верните `True`, если такая пара существует, иначе `False`.
 """
 
 limits = """
-- $-10^6 \\leq a,b,c \\leq 10^6$
+- $-10^9 \\leq x, y, z \\leq 10^9$
 """
 
 solution = """
-def solution(nums: list) -> bool:
-    nums.sort()
-    return nums[0] + nums[1] == nums[2]
+def solution(x: int, y: int, z: int) -> bool:
+    return x + y == z or x + z == y or y + z == x
 """
 
 examples = """
-solution([1, 2, 3]) == True
-solution([3, 1, 3]) == False
-solution([3, 1, 2]) == True
+solution(3, 1, 2) == True
+solution(2, 3, 4) == False
+solution(-7, -2, 5) == True
 """
 
 [[input_signature]]
-argument_name = "nums"
+argument_name = "x"
+[input_signature.type]
+name = "integer"
+
+[[input_signature]]
+argument_name = "y"
+[input_signature.type]
+name = "integer"
+
+[[input_signature]]
+argument_name = "z"
 [input_signature.type]
-name = "array"
-[input_signature.type.nested]
 name = "integer"
 
 [output_signature.type]
 name = "boolean"
 
 [[asserts]]
-arguments = [[1, 2, 3]]
+arguments = [3, 1, 2]
 expected  = true
 
 [[asserts]]
-arguments = [[5, 5, 10]]
+arguments = [5, 5, 10]
 expected  = true
 
 [[asserts]]
-arguments = [[3, 7, 10]]
+arguments = [3, 7, 10]
 expected  = true
 
 [[asserts]]
-arguments = [[10, 15, 25]]
+arguments = [10, 25, 15]
 expected  = true
 
 [[asserts]]
-arguments = [[100, 200, 300]]
+arguments = [-1, -2, -3]
 expected  = true
 
 [[asserts]]
-arguments = [[1000, 2000, 3000]]
+arguments = [-5, 0, 5]
 expected  = true
 
 [[asserts]]
-arguments = [[50, 50, 100]]
+arguments = [-7, -2, -5]
 expected  = true
 
 [[asserts]]
-arguments = [[123, 456, 579]]
+arguments = [-7, -2, 5]
 expected  = true
 
 [[asserts]]
-arguments = [[1, 999, 1000]]
+arguments = [-9, -7, -2]
 expected  = true
 
 [[asserts]]
-arguments = [[50000, 50000, 100000]]
+arguments = [-7, -10, 3]
 expected  = true
 
+[[asserts]]
+arguments = [8, -3, 5]
+expected  = true
 
 [[asserts]]
-arguments = [[50571, 33109, 83680]]
+arguments = [-4, -6, -10]
 expected  = true
 
 [[asserts]]
-arguments = [[1, 1, 3]]
-expected  = false
+arguments = [0, 0, 0]
+expected  = true
 
 [[asserts]]
-arguments = [[2, 2, 5]]
+arguments = [11, 0, 11]
+expected  = true
+
+[[asserts]]
+arguments = [-23, -23, 0]
+expected  = true
+
+[[asserts]]
+arguments = [0, 0, 100]
 expected  = false
 
 [[asserts]]
-arguments = [[10, 20, 40]]
+arguments = [-3, 8, -5]
 expected  = false
 
 [[asserts]]
-arguments = [[100, 200, 400]]
+arguments = [-10, 15, 5]
+expected  = true
+
+[[asserts]]
+arguments = [-2, 7, 9]
+expected  = true
+
+[[asserts]]
+arguments = [10, -15, -5]
+expected  = true
+
+[[asserts]]
+arguments = [20, -30, -10]
+expected  = true
+
+[[asserts]]
+arguments = [-5, 3, -2]
+expected  = true
+
+[[asserts]]
+arguments = [7, -12, -5]
+expected  = true
+
+[[asserts]]
+arguments = [1, 1, 3]
 expected  = false
 
 [[asserts]]
-arguments = [[1000, 2000, 4000]]
+arguments = [2, 2, 5]
 expected  = false
 
 [[asserts]]
-arguments = [[5000, 5000, 11000]]
+arguments = [10, 20, 40]
 expected  = false
 
 [[asserts]]
-arguments = [[999, 999, 1999]]
+arguments = [5372, 4396, 7179]
 expected  = false
 
 [[asserts]]
-arguments = [[5372, 4396, 7179]]
+arguments = [58611, 74697, 89900]
 expected  = false
 
 [[asserts]]
-arguments = [[58611, 74697, 89900]]
+arguments = [1, 2, 4]
 expected  = false
 
 [[asserts]]
-arguments = [[1, 2, 4]]
+arguments = [7, 8, 16]
 expected  = false
 
 [[asserts]]
-arguments = [[7, 8, 16]]
+arguments = [99, 100, 200]
 expected  = false
 
 [[asserts]]
-arguments = [[99, 100, 200]]
+arguments = [1, 1, 1]
 expected  = false
 
 [[asserts]]
-arguments = [[1, 1, 1]]
+arguments = [10000, 19999, 10000]
 expected  = false
 
 [[asserts]]
-arguments = [[10000, 10000, 19999]]
+arguments = [1000000000, 1000000000, 2000000000]
+expected  = true
+
+[[asserts]]
+arguments = [-1000000000, -2000000000, -1000000000]
+expected  = true
+
+[[asserts]]
+arguments = [0, -1000000000, 1000000000]
+expected  = true
+
+[[asserts]]
+arguments = [1000000000, 1, -1000000000]
 expected  = false

From 4caf7727b915ba57455087a4c9ef62f6da0448bd Mon Sep 17 00:00:00 2001
From: Dmitrii <36790425+dimaush@users.noreply.github.com>
Date: Mon, 8 Jun 2026 01:52:48 +0300
Subject: [PATCH 16/17] Reduced time_to_solve

---
 tasks/elementary/math/sum_of_two_equals_third.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tasks/elementary/math/sum_of_two_equals_third.toml b/tasks/elementary/math/sum_of_two_equals_third.toml
index e73389b..6f1f259 100644
--- a/tasks/elementary/math/sum_of_two_equals_third.toml
+++ b/tasks/elementary/math/sum_of_two_equals_third.toml
@@ -1,7 +1,7 @@
 level             = "easy"
 name              = "sum_of_two_equals_third"
 tags              = ["math", "collections"]
-time_to_solve_sec = 300
+time_to_solve_sec = 60
 
 description_en = """
 Given three integers, determine whether the sum of two of them equals the third one.

From 06ed35eb69a0396488c25a50de550b313a3cf4d5 Mon Sep 17 00:00:00 2001
From: Vitaly <vtmilyakov@gmail.com>
Date: Fri, 16 Oct 2026 22:34:50 +0400
Subject: [PATCH 17/17] Fix contributed task contracts and boundary cases

---
 .../arrays/largest_perimeter_triangle.toml    |    3 +-
 tasks/easy/arrays/max_stock_profit.toml       |    3 +-
 tasks/easy/arrays/maximum_altitude.toml       |   15 +-
 tasks/easy/arrays/permutation_period.toml     |   46 +-
 tasks/easy/arrays/summary_ranges.toml         |    5 +-
 tasks/easy/arrays/toeplitz_matrix.toml        |    3 +-
 tasks/easy/arrays/town_judge.toml             |  107 +-
 .../peak_performance_sum.toml                 |    5 +-
 tasks/easy/math/custom_fibonacci.toml         |   11 +-
 tasks/easy/math/expanded_notation_array.toml  |   56 +-
 .../math/primes_with_prime_digit_sum.toml     |    7 +-
 tasks/easy/math/self_dividing_numbers.toml    |   11 +-
 tasks/easy/strings/center_strings.toml        |    7 +-
 tasks/easy/strings/digit_snake_formatter.toml |    5 +-
 tasks/easy/strings/fancy_number.toml          |   16 +-
 .../strings/longest_balanced_segment.toml     |   11 +-
 tasks/easy/strings/longest_common_prefix.toml |    3 +-
 .../strings/string_blocks_transposition.toml  |    5 +-
 .../math/sum_of_two_equals_third.toml         |    8 +-
 tasks/medium/algo/insert_interval.toml        |   15 +-
 tasks/medium/arrays/valid_sudoku.toml         | 2869 +++++++++++++++++
 tasks/medium/dp/turtle_max_path_sum.toml      |   11 +-
 tasks/medium/games/feeding_kraken.toml        |   11 +-
 tasks/medium/games/game_of_life_step.toml     |  171 +-
 tasks/medium/games/valid_sudoku.toml          |  477 ---
 tasks/medium/graphs/flood_fill.toml           | 2388 +++++++++++++-
 .../graphs/topological_sort_possible.toml     |   13 +-
 tasks/medium/regex/log_ip_sanitizer.toml      |   39 +-
 .../minimum_bracket_reversals.toml            |    3 +-
 .../medium/{regex => strings}/underscore.toml |   19 +-
 30 files changed, 5748 insertions(+), 595 deletions(-)
 rename tasks/easy/{hash_maps => hashmaps}/peak_performance_sum.toml (99%)
 create mode 100644 tasks/medium/arrays/valid_sudoku.toml
 delete mode 100644 tasks/medium/games/valid_sudoku.toml
 rename tasks/medium/{greedy => strings}/minimum_bracket_reversals.toml (99%)
 rename tasks/medium/{regex => strings}/underscore.toml (91%)

diff --git a/tasks/easy/arrays/largest_perimeter_triangle.toml b/tasks/easy/arrays/largest_perimeter_triangle.toml
index 75be510..4cad740 100644
--- a/tasks/easy/arrays/largest_perimeter_triangle.toml
+++ b/tasks/easy/arrays/largest_perimeter_triangle.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "largest_perimeter_triangle"
 tags              = ["arrays", "math", "geometry", "sorting"]
@@ -183,4 +184,4 @@ expected  = 7
 [[asserts]]
 arguments = [[1, 10, 100, 1000, 10000]]
 comment   = "Powers of 10 (no triangle possible)"
-expected  = 0
\ No newline at end of file
+expected  = 0
diff --git a/tasks/easy/arrays/max_stock_profit.toml b/tasks/easy/arrays/max_stock_profit.toml
index df69af7..74a6cb6 100644
--- a/tasks/easy/arrays/max_stock_profit.toml
+++ b/tasks/easy/arrays/max_stock_profit.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "max_stock_profit"
 tags              = ["arrays", "greedy", "math"]
@@ -194,4 +195,4 @@ expected  = 8
 [[asserts]]
 arguments = [[0, 0, 0, 0]]
 comment   = "All zeroes"
-expected  = 0
\ No newline at end of file
+expected  = 0
diff --git a/tasks/easy/arrays/maximum_altitude.toml b/tasks/easy/arrays/maximum_altitude.toml
index 752a7a4..2e1bbe2 100644
--- a/tasks/easy/arrays/maximum_altitude.toml
+++ b/tasks/easy/arrays/maximum_altitude.toml
@@ -1,23 +1,24 @@
+base_score        = 100
 level             = "easy"
 name              = "maximum_altitude"
 tags              = ["arrays", "math"]
 time_to_solve_sec = 200
 
 description_en = """
-A cyclist starts their journey at an altitude of $0$. You are given an integer array `gain` of length $n$, where `gain[i]` represents the net altitude gain between point $i$ and point $i + 1$. 
+A cyclist starts their journey at an altitude of $0$. You are given an integer array `gain` of length $n$, where `gain[i]` represents the net altitude gain between point $i$ and point $i + 1$.
 
 Return the highest altitude the cyclist reaches during their journey.
 """
 
 description_ru = """
-Велосипедист начинает свой путь на высоте $0$. Вам дан целочисленный массив `gain` длины $n$, где `gain[i]` — это изменение высоты между точкой $i$ и точкой $i + 1$. 
+Велосипедист начинает свой путь на высоте $0$. Вам дан целочисленный массив `gain` длины $n$, где `gain[i]` — это изменение высоты между точкой $i$ и точкой $i + 1$.
 
 Верните максимальную высоту, которой достигнет велосипедист за время пути.
 """
 
 limits = """
-- $1 \\leq \text{len}(\text{gain}) \\leq 100$
-- $-100 \\leq \text{gain}[i] \\leq 100$
+- $1 \\leq \\text{len}(\\text{gain}) \\leq 100$
+- $-100 \\leq \\text{gain}[i] \\leq 100$
 """
 
 solution = """
@@ -32,9 +33,9 @@ def solution(gain: list) -> int:
 examples = """
 solution([0]) == 0
 solution([1]) == 1
-solution([-4, -3, -2, -1, 4, 3, 2]) == 0
 solution([-5, 1, 5, 0, -7]) == 1
 solution([10, -5, 10, -5]) == 15
+solution([-4, -3, -2, -1, 4, 3, 2]) == 0
 """
 
 [[input_signature]]
@@ -93,7 +94,7 @@ comment   = "Constantly descending"
 expected  = 0
 
 [[asserts]]
-arguments = [[100, 100, -200, 50]]
+arguments = [[100, 100, -100, 50]]
 comment   = "Large peak then drop"
 expected  = 200
 
@@ -180,4 +181,4 @@ expected  = 20
 [[asserts]]
 arguments = [[50, 50, -100, 1, 2]]
 comment   = "Peak at the start, drop, small rise"
-expected  = 100
\ No newline at end of file
+expected  = 100
diff --git a/tasks/easy/arrays/permutation_period.toml b/tasks/easy/arrays/permutation_period.toml
index ce6a314..ed69ddb 100644
--- a/tasks/easy/arrays/permutation_period.toml
+++ b/tasks/easy/arrays/permutation_period.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "permutation_period"
 tags              = ["arrays", "math", "simulation"]
@@ -9,7 +10,7 @@ You are given an array `p` of length $n$ containing integers from $0$ to $n - 1$
 Imagine we have an initial array $\\text{arr} = [0, 1, 2, \\dots, n - 1]$.
 In one step, we permute the elements of $\\text{arr}$ such that the new array is $\\text{new\\_arr}$, where $\\text{new\\_arr}[i] = \\text{arr}[p[i]]$.
 
-Return the minimum number of steps required to return $\\text{arr}$ to its initial state $[0, 1, 2, \\dots, n - 1]$. 
+Return the minimum number of steps required to return $\\text{arr}$ to its initial state $[0, 1, 2, \\dots, n - 1]$.
 If it is impossible to ever return to the initial state, return $-1$.
 """
 
@@ -19,7 +20,7 @@ description_ru = """
 Представьте, что у нас есть исходный массив $\\text{arr} = [0, 1, 2, \\dots, n - 1]$.
 За один шаг мы переставляем элементы $\\text{arr}$ так, что получается новый массив $\\text{new\\_arr}$, где $\\text{new\\_arr}[i] = \\text{arr}[p[i]]$.
 
-Верните минимальное количество шагов, за которое массив $\\text{arr}$ вернется в свое исходное состояние $[0, 1, 2, \\dots, n - 1]$. 
+Верните минимальное количество шагов, за которое массив $\\text{arr}$ вернется в свое исходное состояние $[0, 1, 2, \\dots, n - 1]$.
 Если вернуться в исходное состояние невозможно, верните $-1$.
 """
 
@@ -175,11 +176,44 @@ comment   = "All same elements"
 expected  = -1
 
 [[asserts]]
-arguments = [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 0, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 15]]
-comment   = "Two cycles of 15"
-expected  = 15
+arguments = [
+  [
+    1,
+    2,
+    3,
+    4,
+    5,
+    6,
+    7,
+    8,
+    9,
+    10,
+    11,
+    12,
+    13,
+    14,
+    0,
+    16,
+    17,
+    18,
+    19,
+    20,
+    21,
+    22,
+    23,
+    24,
+    25,
+    26,
+    27,
+    28,
+    29,
+    15,
+  ],
+]
+comment = "Two cycles of 15"
+expected = 15
 
 [[asserts]]
 arguments = [[1, 0, 3, 4, 2, 6, 7, 8, 5, 10, 11, 12, 13, 9]]
 comment   = "Cycles of 2, 3, 4, 5 (LCM = 60)"
-expected  = 60
\ No newline at end of file
+expected  = 60
diff --git a/tasks/easy/arrays/summary_ranges.toml b/tasks/easy/arrays/summary_ranges.toml
index 1e9cc36..e9bdf71 100644
--- a/tasks/easy/arrays/summary_ranges.toml
+++ b/tasks/easy/arrays/summary_ranges.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "summary_ranges"
 tags              = ["arrays", "strings"]
@@ -26,7 +27,7 @@ description_ru = """
 limits = """
 - $0 \\leq \\text{len}(nums) \\leq 10^4$
 - $-10^9 \\leq nums[i] \\leq 10^9$
-- $nums$ is strictly increasing
+- $nums[i] < nums[i+1]$
 """
 
 solution = """
@@ -192,4 +193,4 @@ expected  = ["1", "3", "5", "7", "9"]
 [[asserts]]
 arguments = [[-10, -5, 0, 5, 10]]
 comment   = "Step of 5"
-expected  = ["-10", "-5", "0", "5", "10"]
\ No newline at end of file
+expected  = ["-10", "-5", "0", "5", "10"]
diff --git a/tasks/easy/arrays/toeplitz_matrix.toml b/tasks/easy/arrays/toeplitz_matrix.toml
index 7f51e6a..b755945 100644
--- a/tasks/easy/arrays/toeplitz_matrix.toml
+++ b/tasks/easy/arrays/toeplitz_matrix.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "toeplitz_matrix"
 tags              = ["arrays", "matrices"]
@@ -196,4 +197,4 @@ expected  = true
 [[asserts]]
 arguments = [[[3, 4, 5, 6], [2, 3, 4, 5], [1, 2, 3, 4]]]
 comment   = "Another valid 3x4 Toeplitz matrix"
-expected  = true
\ No newline at end of file
+expected  = true
diff --git a/tasks/easy/arrays/town_judge.toml b/tasks/easy/arrays/town_judge.toml
index 5cc930b..e5bf7c5 100644
--- a/tasks/easy/arrays/town_judge.toml
+++ b/tasks/easy/arrays/town_judge.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "town_judge"
 tags              = ["arrays", "graphs"]
@@ -13,6 +14,8 @@ The town judge satisfies two properties:
 You are given an array `trust` where `trust[i] = [a, b]` representing that the person labeled `a` trusts the person labeled `b`.
 
 Return the label of the town judge if they exist and can be identified, or return `-1` otherwise.
+
+Every trust pair is distinct, with both labels between $1$ and $n$ and different from each other.
 """
 
 description_ru = """
@@ -25,12 +28,16 @@ description_ru = """
 Вам дан массив пар `trust`, где `trust[i] = [a, b]` означает, что человек `a` доверяет человеку `b`.
 
 Верните номер городского судьи, если он существует, иначе верните `-1`.
+
+Все пары доверия различны; обе метки находятся от $1$ до $n$ и отличаются друг от друга.
 """
 
 limits = """
 - $1 \\leq n \\leq 1000$
 - $0 \\leq \\text{len}(\\text{trust}) \\leq 10^4$
 - $\\text{trust}[i][0] \\neq \\text{trust}[i][1]$
+
+- $1 \\leq \\text{trust}[i][0], \\text{trust}[i][1] \\leq n$
 """
 
 solution = """
@@ -48,8 +55,8 @@ def solution(n: int, trust: list) -> int:
 examples = """
 solution(2, [[1, 2]]) == 2
 solution(3, [[1, 3], [2, 3]]) == 3
-solution(3, [[1, 3], [2, 3], [3, 1]]) == -1
 solution(3, [[1, 2], [2, 3]]) == -1
+solution(3, [[1, 3], [2, 3], [3, 1]]) == -1
 """
 
 [[input_signature]]
@@ -180,9 +187,49 @@ comment   = "3 is judge, others have complex relations"
 expected  = 3
 
 [[asserts]]
-arguments = [10, [[1, 10], [2, 10], [3, 10], [4, 10], [5, 10], [6, 10], [7, 10], [8, 10], [9, 10]]]
-comment   = "Large group judge"
-expected  = 10
+arguments = [
+  10,
+  [
+    [
+      1,
+      10,
+    ],
+    [
+      2,
+      10,
+    ],
+    [
+      3,
+      10,
+    ],
+    [
+      4,
+      10,
+    ],
+    [
+      5,
+      10,
+    ],
+    [
+      6,
+      10,
+    ],
+    [
+      7,
+      10,
+    ],
+    [
+      8,
+      10,
+    ],
+    [
+      9,
+      10,
+    ],
+  ],
+]
+comment = "Large group judge"
+expected = 10
 
 [[asserts]]
 arguments = [4, [[1, 4], [2, 4]]]
@@ -195,9 +242,53 @@ comment   = "No one trusted by 2 people"
 expected  = -1
 
 [[asserts]]
-arguments = [5, [[1, 2], [1, 3], [1, 4], [1, 5], [2, 3], [2, 4], [2, 5], [3, 4], [3, 5], [4, 5]]]
-comment   = "5 is the judge"
-expected  = 5
+arguments = [
+  5,
+  [
+    [
+      1,
+      2,
+    ],
+    [
+      1,
+      3,
+    ],
+    [
+      1,
+      4,
+    ],
+    [
+      1,
+      5,
+    ],
+    [
+      2,
+      3,
+    ],
+    [
+      2,
+      4,
+    ],
+    [
+      2,
+      5,
+    ],
+    [
+      3,
+      4,
+    ],
+    [
+      3,
+      5,
+    ],
+    [
+      4,
+      5,
+    ],
+  ],
+]
+comment = "5 is the judge"
+expected = 5
 
 [[asserts]]
 arguments = [3, [[1, 3], [2, 3], [2, 1]]]
@@ -212,4 +303,4 @@ expected  = 1
 [[asserts]]
 arguments = [3, [[1, 3], [2, 3], [1, 2]]]
 comment   = "1 trusts 2 and 3, 2 trusts 3"
-expected  = 3
\ No newline at end of file
+expected  = 3
diff --git a/tasks/easy/hash_maps/peak_performance_sum.toml b/tasks/easy/hashmaps/peak_performance_sum.toml
similarity index 99%
rename from tasks/easy/hash_maps/peak_performance_sum.toml
rename to tasks/easy/hashmaps/peak_performance_sum.toml
index 39fde24..87f8b7e 100644
--- a/tasks/easy/hash_maps/peak_performance_sum.toml
+++ b/tasks/easy/hashmaps/peak_performance_sum.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "peak_performance_sum"
 tags              = ["hashmaps", "arrays"]
@@ -36,8 +37,8 @@ def solution(teams: list, scores: list) -> int:
 
 examples = """
 solution([], []) == 0
-solution(["A", "A"], [-10, -5]) == -5
 solution(["A", "B"], [10, 20]) == 30
+solution(["A", "A"], [-10, -5]) == -5
 solution(["A", "B", "A"], [10, 20, 30]) == 50
 """
 
@@ -181,4 +182,4 @@ expected  = 150
 [[asserts]]
 arguments = [["A", "B", "C", "A", "B", "C"], [1, 2, 3, 4, 5, 6]]
 comment   = "Double pass of the same teams"
-expected  = 15
\ No newline at end of file
+expected  = 15
diff --git a/tasks/easy/math/custom_fibonacci.toml b/tasks/easy/math/custom_fibonacci.toml
index 1279dc7..8497ba3 100644
--- a/tasks/easy/math/custom_fibonacci.toml
+++ b/tasks/easy/math/custom_fibonacci.toml
@@ -1,20 +1,21 @@
+base_score        = 100
 level             = "easy"
 name              = "custom_fibonacci"
 tags              = ["math", "algorithms"]
 time_to_solve_sec = 200
 
 description_en = """
-Given three integers `f0`, `f1`, and `n`. 
+Given three integers `f0`, `f1`, and `n`.
 
-Consider a sequence where the first two elements are `f0` and `f1`, and every subsequent element is the sum of the two preceding elements. 
+Consider a sequence where the first two elements are `f0` and `f1`, and every subsequent element is the sum of the two preceding elements.
 
 Return `True` if `n` belongs to this sequence, and `False` otherwise.
 """
 
 description_ru = """
-Даны три целых числа `f0`, `f1` и `n`. 
+Даны три целых числа `f0`, `f1` и `n`.
 
-Рассмотрим последовательность, первые два элемента которой равны `f0` и `f1`, а каждый последующий элемент равен сумме двух предыдущих. 
+Рассмотрим последовательность, первые два элемента которой равны `f0` и `f1`, а каждый последующий элемент равен сумме двух предыдущих.
 
 Верните `True`, если `n` принадлежит этой последовательности, и `False` в противном случае.
 """
@@ -195,4 +196,4 @@ expected  = true
 [[asserts]]
 arguments = [13, 21, 5]
 comment   = "n is smaller than f0, f1 with Fibonacci sequence"
-expected  = false
\ No newline at end of file
+expected  = false
diff --git a/tasks/easy/math/expanded_notation_array.toml b/tasks/easy/math/expanded_notation_array.toml
index 961bb2d..cd902f9 100644
--- a/tasks/easy/math/expanded_notation_array.toml
+++ b/tasks/easy/math/expanded_notation_array.toml
@@ -1,14 +1,17 @@
+base_score        = 100
 level             = "easy"
 name              = "expanded_notation_array"
 tags              = ["math", "strings", "parsing", "arrays"]
 time_to_solve_sec = 250
 
 description_en = """
-Expanded Notation means an integer is written as the sum of its digits multiplied with its place value (in strictly descending powers of $10$). 
+Expanded Notation means an integer is written as the sum of its digits multiplied with its place value (in strictly descending powers of $10$).
 
-For example, $85063 = 8 \\times 10000 + 5 \\times 1000 + 6 \\times 10 + 3$. 
+For example, $85063 = 8 \\times 10000 + 5 \\times 1000 + 6 \\times 10 + 3$.
 
-You are given an array of strings `arr`, where each string represents a natural number in expanded notation. The strings use `"x"` for multiplication and `"+"` for addition, with no spaces. Your task is to compute the sum for each string and return an array of these numbers in their normal integer form.
+You are given an array of strings `arr`, where each string represents a non-negative integer in expanded notation. The strings use `"x"` for multiplication and `"+"` for addition, with no spaces. Your task is to compute the sum for each string and return an array of these numbers in their normal integer form.
+
+Each term is a single digit multiplied by a power of ten; a units term may omit `x1`. Place values strictly decrease within each string. Each resulting integer is at most $2 \\cdot 10^9$.
 """
 
 description_ru = """
@@ -16,19 +19,23 @@ description_ru = """
 
 Например, $85063 = 8 \\times 10000 + 5 \\times 1000 + 6 \\times 10 + 3$.
 
-Вам дан массив строк `arr`, где каждая строка представляет натуральное число в развернутой записи. В строках используется `"x"` для умножения и `"+"` для сложения, без пробелов. Ваша задача — вычислить сумму для каждой строки и вернуть массив этих чисел в обычном целом виде.
+Вам дан массив строк `arr`, где каждая строка представляет неотрицательное целое число в развернутой записи. В строках используется `"x"` для умножения и `"+"` для сложения, без пробелов. Ваша задача — вычислить сумму для каждой строки и вернуть массив этих чисел в обычном целом виде.
+
+Каждое слагаемое — одна цифра, умноженная на степень десяти; у единиц можно опустить `x1`. Разрядные значения в каждой строке строго убывают. Каждое полученное целое число не превышает $2 \\cdot 10^9$.
 """
 
 limits = """
 - $1 \\leq \\text{len}(arr) \\leq 100$
-- $3 \\leq \\text{len}(arr[i]) \\leq 100$
-- $arr[i]$ contains only digits, `"x"`, and `"+"`
-- Place values are powers of $10$
+- $1 \\leq \\text{len}(arr[i]) \\leq 100$
+- $0 \\leq \\text{value}(arr[i]) \\leq 2 \\cdot 10^9$
 """
 
 solution = """
-def solution(arr: list) -> list:
-    return [sum(int(part.split('x')[0]) * int(part.split('x')[1]) for part in s.split('+')) for s in arr]
+def solution(arr: list[str]) -> list[int]:
+    def value(term):
+        factors = term.split('x')
+        return int(factors[0]) * (int(factors[1]) if len(factors) == 2 else 1)
+    return [sum(value(term) for term in s.split('+')) for s in arr]
 """
 
 examples = """
@@ -90,9 +97,13 @@ comment   = "All nines"
 expected  = [9999]
 
 [[asserts]]
-arguments = [["1x100000000+2x10000000+3x1000000+4x100000+5x10000+6x1000+7x100+8x10+9x1"]]
-comment   = "Consecutive digits"
-expected  = [123456789]
+arguments = [
+  [
+    "1x100000000+2x10000000+3x1000000+4x100000+5x10000+6x1000+7x100+8x10+9x1",
+  ],
+]
+comment = "Consecutive digits"
+expected = [123456789]
 
 [[asserts]]
 arguments = [["2x1000000+1x1", "3x10"]]
@@ -140,9 +151,13 @@ comment   = "Descending digits"
 expected  = [54321, 1]
 
 [[asserts]]
-arguments = [["9x100000000+8x10000000+7x1000000+6x100000+5x10000+4x1000+3x100+2x10+1x1"]]
-comment   = "Long descending digits"
-expected  = [987654321]
+arguments = [
+  [
+    "9x100000000+8x10000000+7x1000000+6x100000+5x10000+4x1000+3x100+2x10+1x1",
+  ],
+]
+comment = "Long descending digits"
+expected = [987654321]
 
 [[asserts]]
 arguments = [["9x100+9x10+9x1", "8x100+8x10+8x1"]]
@@ -172,4 +187,13 @@ expected  = [1230000, 4567]
 [[asserts]]
 arguments = [["8x100000+5x100+3x1", "2x10000+4x100+1x1"]]
 comment   = "Various missing place values"
-expected  = [800503, 20401]
\ No newline at end of file
+expected  = [800503, 20401]
+[[asserts]]
+arguments = [["7x100+2", "8x10000+5x1000+6x10+3"]]
+comment   = "Units may omit multiplication by one"
+expected  = [702, 85063]
+
+[[asserts]]
+arguments = [["0", "9"]]
+comment   = "Bare units and zero"
+expected  = [0, 9]
diff --git a/tasks/easy/math/primes_with_prime_digit_sum.toml b/tasks/easy/math/primes_with_prime_digit_sum.toml
index 0595507..bbcaac5 100644
--- a/tasks/easy/math/primes_with_prime_digit_sum.toml
+++ b/tasks/easy/math/primes_with_prime_digit_sum.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "primes_with_prime_digit_sum"
 tags              = ["math", "numbers"]
@@ -5,10 +6,14 @@ time_to_solve_sec = 250
 
 description_en = """
 Find all prime numbers in the inclusive range $[a, b]$ such that the sum of their digits is also a prime number. Return the result as an array.
+
+Return the numbers in increasing order.
 """
 
 description_ru = """
 Найдите все простые числа на отрезке $[a, b]$ (включительно), сумма цифр которых также является простым числом. Верните результат в виде массива.
+
+Верните числа в порядке возрастания.
 """
 
 limits = """
@@ -175,4 +180,4 @@ expected  = [11]
 [[asserts]]
 arguments = [1000, 1010]
 comment   = "Past one thousand without matches"
-expected  = []
\ No newline at end of file
+expected  = []
diff --git a/tasks/easy/math/self_dividing_numbers.toml b/tasks/easy/math/self_dividing_numbers.toml
index e3f913a..184327f 100644
--- a/tasks/easy/math/self_dividing_numbers.toml
+++ b/tasks/easy/math/self_dividing_numbers.toml
@@ -1,24 +1,29 @@
+base_score        = 100
 level             = "easy"
 name              = "self_dividing_numbers"
 tags              = ["math", "loops"]
 time_to_solve_sec = 240
 
 description_en = """
-A self-dividing number is a number that is divisible by every digit it contains. 
+A self-dividing number is a number that is divisible by every digit it contains.
 For example, `128` is a self-dividing number because $128 \\pmod 1 = 0$, $128 \\pmod 2 = 0$, and $128 \\pmod 8 = 0$.
 
 A self-dividing number is not allowed to contain the digit `0`.
 
 Given two integers `left` and `right`, return an array of all the self-dividing numbers in the range `[left, right]` (inclusive).
+
+Return the numbers in increasing order.
 """
 
 description_ru = """
-Самоделящееся число — это число, которое без остатка делится на каждую из своих цифр. 
+Самоделящееся число — это число, которое без остатка делится на каждую из своих цифр.
 Например, `128` является самоделящимся числом, так как $128 \\pmod 1 = 0$, $128 \\pmod 2 = 0$ и $128 \\pmod 8 = 0$.
 
 Самоделящееся число не должно содержать цифру `0`.
 
 Даны два целых числа `left` и `right`. Верните массив всех самоделящихся чисел в диапазоне `[left, right]` (включительно).
+
+Верните числа в порядке возрастания.
 """
 
 limits = """
@@ -179,4 +184,4 @@ expected  = []
 [[asserts]]
 arguments = [300, 315]
 comment   = "Wider range in hundreds"
-expected  = [312, 315]
\ No newline at end of file
+expected  = [312, 315]
diff --git a/tasks/easy/strings/center_strings.toml b/tasks/easy/strings/center_strings.toml
index 7ec3828..4ab44da 100644
--- a/tasks/easy/strings/center_strings.toml
+++ b/tasks/easy/strings/center_strings.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "center_strings"
 tags              = ["strings", "formatting"]
@@ -6,7 +7,7 @@ time_to_solve_sec = 200
 description_en = """
 Given an array of strings, return a new array where each string is centered to the length of the longest string in the original array, padded with spaces (`" "`).
 
-If the padding is uneven (i.e., the difference between the maximum length and the current string's length is odd), apply the standard Python `str.center()` behavior:
+If the padding is uneven (i.e., the difference between the maximum length and the current string's length is odd), place the extra space as follows:
 - If the target width is odd and the margin is odd, the extra space goes to the **left**.
 - Otherwise, the extra space goes to the **right**.
 
@@ -16,7 +17,7 @@ If the input array is empty, return an empty array.
 description_ru = """
 Дан массив строк. Верните новый массив, в котором каждая строка отцентрирована по длине самой длинной строки в исходном массиве и дополнена пробелами (`" "`).
 
-Если количество добавляемых пробелов нечетное, используйте стандартное поведение метода `str.center()` в Python:
+Если количество добавляемых пробелов нечетное, расположите дополнительный пробел по следующим правилам:
 - Если целевая ширина нечетная и общая разница нечетная, дополнительный пробел добавляется **слева**.
 - Во всех остальных случаях дополнительный пробел добавляется **справа**.
 
@@ -202,4 +203,4 @@ expected  = ["align ", "  me  ", "please", "  to  ", "center"]
 [[asserts]]
 arguments = [["12345", "1234", "123", "12", "1", ""]]
 comment   = "Decreasing lengths, max 5"
-expected  = ["12345", " 1234", " 123 ", "  12 ", "  1  ", "     "]
\ No newline at end of file
+expected  = ["12345", " 1234", " 123 ", "  12 ", "  1  ", "     "]
diff --git a/tasks/easy/strings/digit_snake_formatter.toml b/tasks/easy/strings/digit_snake_formatter.toml
index 613a116..a85285b 100644
--- a/tasks/easy/strings/digit_snake_formatter.toml
+++ b/tasks/easy/strings/digit_snake_formatter.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "digit_snake_formatter"
 tags              = ["strings", "formatting"]
@@ -26,7 +27,7 @@ description_ru = """
 limits = """
 - $0 \\leq \\text{len}(n) \\leq 1000$
 - $0 \\leq c \\leq 1000$
-- $n$ contains only digits $0-9$
+- $n \\in \\{0,1,2,3,4,5,6,7,8,9\\}^*$
 """
 
 solution = """
@@ -204,4 +205,4 @@ expected  = "9XXXXXXX"
 [[asserts]]
 arguments = ["12345678901234567890", 17]
 comment   = "Last chunk is single char, index 2 (even)"
-expected  = "12345678\n65432109\n7XXXXXXX"
\ No newline at end of file
+expected  = "12345678\n65432109\n7XXXXXXX"
diff --git a/tasks/easy/strings/fancy_number.toml b/tasks/easy/strings/fancy_number.toml
index 28f50e3..89314d9 100644
--- a/tasks/easy/strings/fancy_number.toml
+++ b/tasks/easy/strings/fancy_number.toml
@@ -12,6 +12,8 @@ A number is called **fancy** if it does not change when rotated $180$ degrees. W
 - $9$ becomes $6$;
 - $0$, $1$, $8$ remain themselves;
 - other digits break.
+
+Use the usual decimal representation without leading zeros. Negative numbers are never fancy; zero is fancy.
 """
 
 description_ru = """
@@ -22,10 +24,12 @@ description_ru = """
 - $9$ становится $6$;
 - $0$, $1$ и $8$ остаются сами собой;
 - остальные цифры перестают быть цифрами.
+
+Используйте обычную десятичную запись без ведущих нулей. Отрицательные числа не бывают причудливыми; ноль является причудливым.
 """
 
 limits = """
-- $-10^9 \\leq \\text{number} \\leq 10^9
+- $-10^9 \\leq \\text{number} \\leq 10^9$
 """
 
 solution = """
@@ -205,3 +209,13 @@ expected  = false
 arguments = [-600080009]
 comment   = "Long negative number"
 expected  = false
+
+[[asserts]]
+arguments = [-1000000000]
+comment   = "Input bound"
+expected  = false
+
+[[asserts]]
+arguments = [1000000000]
+comment   = "Input bound"
+expected  = false
diff --git a/tasks/easy/strings/longest_balanced_segment.toml b/tasks/easy/strings/longest_balanced_segment.toml
index 3da20f0..76b9534 100644
--- a/tasks/easy/strings/longest_balanced_segment.toml
+++ b/tasks/easy/strings/longest_balanced_segment.toml
@@ -1,18 +1,19 @@
+base_score        = 100
 level             = "easy"
 name              = "longest_balanced_segment"
 tags              = ["strings", "hash-map", "algorithms"]
 time_to_solve_sec = 250
 
 description_en = """
-A binary segment is called balanced if it contains the same number of `$0$`s and `$1$`s.
+A binary segment is called balanced if it contains the same number of $0$s and $1$s.
 
-Given a binary string `$s$`, determine the length of the longest balanced contiguous segment. If no such segment exists, return `$0$`.
+Given a binary string $s$, determine the length of the longest balanced contiguous segment. If no such segment exists, return $0$.
 """
 
 description_ru = """
-Бинарный сегмент называется сбалансированным, если он содержит одинаковое количество `$0$` и `$1$`.
+Бинарный сегмент называется сбалансированным, если он содержит одинаковое количество $0$ и $1$.
 
-Дана бинарная строка `$s$`. Определите длину самого длинного сбалансированного непрерывного сегмента. Если такого сегмента не существует, верните `$0$`.
+Дана бинарная строка $s$. Определите длину самого длинного сбалансированного непрерывного сегмента. Если такого сегмента не существует, верните $0$.
 """
 
 limits = """
@@ -195,4 +196,4 @@ expected  = 6
 [[asserts]]
 arguments = ["01101100"]
 comment   = "Full string is balanced with internal patterns"
-expected  = 8
\ No newline at end of file
+expected  = 8
diff --git a/tasks/easy/strings/longest_common_prefix.toml b/tasks/easy/strings/longest_common_prefix.toml
index 3072986..75b3119 100644
--- a/tasks/easy/strings/longest_common_prefix.toml
+++ b/tasks/easy/strings/longest_common_prefix.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "longest_common_prefix"
 tags              = ["strings", "arrays"]
@@ -183,4 +184,4 @@ expected  = "hell"
 [[asserts]]
 arguments = [["python", "pyramid", "pyrite", "pyre"]]
 comment   = "Another normal case"
-expected  = "py"
\ No newline at end of file
+expected  = "py"
diff --git a/tasks/easy/strings/string_blocks_transposition.toml b/tasks/easy/strings/string_blocks_transposition.toml
index 14c1782..1cb79c4 100644
--- a/tasks/easy/strings/string_blocks_transposition.toml
+++ b/tasks/easy/strings/string_blocks_transposition.toml
@@ -1,3 +1,4 @@
+base_score        = 100
 level             = "easy"
 name              = "string_blocks_transposition"
 tags              = ["strings", "formatting"]
@@ -30,9 +31,9 @@ def solution(s: str, k: int) -> str:
 """
 
 examples = """
+solution("abc", 2) == ""
 solution("abcdef", 2) == "acebdf"
 solution("abcdef", 3) == "adbecf"
-solution("abc", 2) == ""
 """
 
 [[input_signature]]
@@ -201,4 +202,4 @@ expected  = "aaabbbccc"
 [[asserts]]
 arguments = ["12345678", 2]
 comment   = "Sequence of 8 numbers, k=2"
-expected  = "13572468"
\ No newline at end of file
+expected  = "13572468"
diff --git a/tasks/elementary/math/sum_of_two_equals_third.toml b/tasks/elementary/math/sum_of_two_equals_third.toml
index 274ddd9..f146fac 100644
--- a/tasks/elementary/math/sum_of_two_equals_third.toml
+++ b/tasks/elementary/math/sum_of_two_equals_third.toml
@@ -1,5 +1,5 @@
-base_score        = 100
-level             = "easy"
+base_score        = 30
+level             = "elementary"
 name              = "sum_of_two_equals_third"
 tags              = ["math", "collections"]
 time_to_solve_sec = 60
@@ -182,11 +182,11 @@ arguments = [10000, 19999, 10000]
 expected  = false
 
 [[asserts]]
-arguments = [1000000000, 1000000000, 2000000000]
+arguments = [500000000, 500000000, 1000000000]
 expected  = true
 
 [[asserts]]
-arguments = [-1000000000, -2000000000, -1000000000]
+arguments = [-500000000, -1000000000, -500000000]
 expected  = true
 
 [[asserts]]
diff --git a/tasks/medium/algo/insert_interval.toml b/tasks/medium/algo/insert_interval.toml
index 4d6605b..0ab4398 100644
--- a/tasks/medium/algo/insert_interval.toml
+++ b/tasks/medium/algo/insert_interval.toml
@@ -1,3 +1,4 @@
+base_score        = 150
 level             = "medium"
 name              = "insert_interval"
 tags              = ["algo", "intervals", "sorting"]
@@ -11,6 +12,8 @@ You are also given an array $\\text{new\\_interval} = [start, end]$ that represe
 Insert $\\text{new\\_interval}$ into `intervals` such that `intervals` is still sorted in ascending order by $start_i$ and `intervals` still does not have any overlapping intervals (merge overlapping intervals if necessary).
 
 Return `intervals` after the insertion.
+
+Intervals include both endpoints, so intervals sharing an endpoint overlap.
 """
 
 description_ru = """
@@ -21,6 +24,8 @@ description_ru = """
 Вставьте $\\text{new\\_interval}$ в `intervals` так, чтобы `intervals` оставался отсортированным по возрастанию $start_i$ и не содержал пересекающихся интервалов (при необходимости объедините пересекающиеся интервалы).
 
 Верните `intervals` после вставки.
+
+Интервалы включают оба конца, поэтому интервалы с общей конечной точкой пересекаются.
 """
 
 limits = """
@@ -36,22 +41,22 @@ def solution(intervals: list[list[int]], new_interval: list[int]) -> list[list[i
     res = []
     i = 0
     n = len(intervals)
-    
+
     while i < n and intervals[i][1] < new_interval[0]:
         res.append(intervals[i])
         i += 1
-        
+
     start, end = new_interval[0], new_interval[1]
     while i < n and intervals[i][0] <= end:
         start = min(start, intervals[i][0])
         end = max(end, intervals[i][1])
         i += 1
     res.append([start, end])
-    
+
     while i < n:
         res.append(intervals[i])
         i += 1
-        
+
     return res
 """
 
@@ -233,4 +238,4 @@ expected  = [[1, 5], [10, 25]]
 [[asserts]]
 arguments = [[[0, 1000]], [0, 1000]]
 comment   = "Same exact large bounds"
-expected  = [[0, 1000]]
\ No newline at end of file
+expected  = [[0, 1000]]
diff --git a/tasks/medium/arrays/valid_sudoku.toml b/tasks/medium/arrays/valid_sudoku.toml
new file mode 100644
index 0000000..099d1f8
--- /dev/null
+++ b/tasks/medium/arrays/valid_sudoku.toml
@@ -0,0 +1,2869 @@
+base_score        = 150
+level             = "medium"
+name              = "valid_sudoku"
+tags              = ["arrays", "matrix", "hash"]
+time_to_solve_sec = 450
+
+description_en = """
+Determine if a $9 \\times 9$ Sudoku board is valid. Only the filled cells need to be validated according to the following rules:
+
+1. Each row must contain the digits `"1"`-`"9"` without repetition.
+2. Each column must contain the digits `"1"`-`"9"` without repetition.
+3. Each of the nine $3 \\times 3$ sub-boxes of the grid must contain the digits `"1"`-`"9"` without repetition.
+
+The Sudoku board could be partially filled, where empty cells are filled with the character `"."`.
+"""
+
+description_ru = """
+Определите, является ли поле для судоку $9 \\times 9$ валидным. Только заполненные ячейки необходимо проверять в соответствии со следующими правилами:
+
+1. Каждая строка должна содержать цифры от `"1"` до `"9"` без повторений.
+2. Каждый столбец должен содержать цифры от `"1"` до `"9"` без повторений.
+3. Каждый из девяти подквадратов $3 \\times 3$ должен содержать цифры от `"1"` до `"9"` без повторений.
+
+Поле судоку может быть частично заполнено, пустые ячейки обозначаются символом `"."`.
+"""
+
+limits = """
+- $\\text{len}(\\text{board}) = 9$
+- $\\text{len}(\\text{board}[i]) = 9$
+- $\\text{board}[i][j] \\in \\{"1", \\dots, "9", "."\\}$
+"""
+
+solution = """
+def solution(board: list) -> bool:
+    r = [set() for _ in range(9)]
+    c = [set() for _ in range(9)]
+    b = [set() for _ in range(9)]
+
+    for i in range(9):
+        for j in range(9):
+            v = board[i][j]
+            if v != ".":
+                k = (i // 3) * 3 + j // 3
+                if v in r[i] or v in c[j] or v in b[k]:
+                    return False
+                r[i].add(v)
+                c[j].add(v)
+                b[k].add(v)
+    return True
+"""
+
+examples = """
+solution([
+  ["5","3",".",".","7",".",".",".","."],
+  ["6",".",".","1","9","5",".",".","."],
+  [".","9","8",".",".",".",".","6","."],
+  ["8",".",".",".","6",".",".",".","3"],
+  ["4",".",".","8",".","3",".",".","1"],
+  ["7",".",".",".","2",".",".",".","6"],
+  [".","6",".",".",".",".","2","8","."],
+  [".",".",".","4","1","9",".",".","5"],
+  [".",".",".",".","8",".",".","7","9"]
+]) == True
+solution([
+  ["8","3",".",".","7",".",".",".","."],
+  ["6",".",".","1","9","5",".",".","."],
+  [".","9","8",".",".",".",".","6","."],
+  ["8",".",".",".","6",".",".",".","3"],
+  ["4",".",".","8",".","3",".",".","1"],
+  ["7",".",".",".","2",".",".",".","6"],
+  [".","6",".",".",".",".","2","8","."],
+  [".",".",".","4","1","9",".",".","5"],
+  [".",".",".",".","8",".",".","7","9"]
+]) == False
+"""
+
+[[input_signature]]
+argument_name = "board"
+[input_signature.type]
+name = "array"
+[input_signature.type.nested]
+name = "array"
+[input_signature.type.nested.nested]
+name = "string"
+
+[output_signature.type]
+name = "boolean"
+
+[[asserts]]
+arguments = [
+  [
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Completely empty board"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "5",
+      "3",
+      ".",
+      ".",
+      "7",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "6",
+      ".",
+      ".",
+      "1",
+      "9",
+      "5",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      "9",
+      "8",
+      ".",
+      ".",
+      ".",
+      ".",
+      "6",
+      ".",
+    ],
+    [
+      "8",
+      ".",
+      ".",
+      ".",
+      "6",
+      ".",
+      ".",
+      ".",
+      "3",
+    ],
+    [
+      "4",
+      ".",
+      ".",
+      "8",
+      ".",
+      "3",
+      ".",
+      ".",
+      "1",
+    ],
+    [
+      "7",
+      ".",
+      ".",
+      ".",
+      "2",
+      ".",
+      ".",
+      ".",
+      "6",
+    ],
+    [
+      ".",
+      "6",
+      ".",
+      ".",
+      ".",
+      ".",
+      "2",
+      "8",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "4",
+      "1",
+      "9",
+      ".",
+      ".",
+      "5",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      "8",
+      ".",
+      ".",
+      "7",
+      "9",
+    ],
+  ],
+]
+comment = "Valid partial board"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "8",
+      "3",
+      ".",
+      ".",
+      "7",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "6",
+      ".",
+      ".",
+      "1",
+      "9",
+      "5",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      "9",
+      "8",
+      ".",
+      ".",
+      ".",
+      ".",
+      "6",
+      ".",
+    ],
+    [
+      "8",
+      ".",
+      ".",
+      ".",
+      "6",
+      ".",
+      ".",
+      ".",
+      "3",
+    ],
+    [
+      "4",
+      ".",
+      ".",
+      "8",
+      ".",
+      "3",
+      ".",
+      ".",
+      "1",
+    ],
+    [
+      "7",
+      ".",
+      ".",
+      ".",
+      "2",
+      ".",
+      ".",
+      ".",
+      "6",
+    ],
+    [
+      ".",
+      "6",
+      ".",
+      ".",
+      ".",
+      ".",
+      "2",
+      "8",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "4",
+      "1",
+      "9",
+      ".",
+      ".",
+      "5",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      "8",
+      ".",
+      ".",
+      "7",
+      "9",
+    ],
+  ],
+]
+comment = "Invalid partial board (two '8's in first column)"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "1",
+      "2",
+      "3",
+      "4",
+      "5",
+      "6",
+      "7",
+      "8",
+      "9",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Valid single row"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "1",
+      "2",
+      "3",
+      "4",
+      "5",
+      "6",
+      "7",
+      "8",
+      "1",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Invalid single row (duplicate '1')"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "2",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "4",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "5",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "6",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "7",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "8",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "9",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Valid single column"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "2",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "4",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "5",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "6",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "7",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "8",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Invalid single column (duplicate '1')"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "1",
+      "2",
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "4",
+      "5",
+      "6",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "7",
+      "8",
+      "9",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Valid single box"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "1",
+      "2",
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "4",
+      "5",
+      "6",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "7",
+      "8",
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Invalid single box (duplicate '1')"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "5",
+      "3",
+      "4",
+      "6",
+      "7",
+      "8",
+      "9",
+      "1",
+      "2",
+    ],
+    [
+      "6",
+      "7",
+      "2",
+      "1",
+      "9",
+      "5",
+      "3",
+      "4",
+      "8",
+    ],
+    [
+      "1",
+      "9",
+      "8",
+      "3",
+      "4",
+      "2",
+      "5",
+      "6",
+      "7",
+    ],
+    [
+      "8",
+      "5",
+      "9",
+      "7",
+      "6",
+      "1",
+      "4",
+      "2",
+      "3",
+    ],
+    [
+      "4",
+      "2",
+      "6",
+      "8",
+      "5",
+      "3",
+      "7",
+      "9",
+      "1",
+    ],
+    [
+      "7",
+      "1",
+      "3",
+      "9",
+      "2",
+      "4",
+      "8",
+      "5",
+      "6",
+    ],
+    [
+      "9",
+      "6",
+      "1",
+      "5",
+      "3",
+      "7",
+      "2",
+      "8",
+      "4",
+    ],
+    [
+      "2",
+      "8",
+      "7",
+      "4",
+      "1",
+      "9",
+      "6",
+      "3",
+      "5",
+    ],
+    [
+      "3",
+      "4",
+      "5",
+      "2",
+      "8",
+      "6",
+      "1",
+      "7",
+      "9",
+    ],
+  ],
+]
+comment = "Fully solved valid board"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "5",
+      "3",
+      "4",
+      "6",
+      "7",
+      "8",
+      "9",
+      "1",
+      "2",
+    ],
+    [
+      "6",
+      "7",
+      "2",
+      "1",
+      "9",
+      "5",
+      "3",
+      "4",
+      "8",
+    ],
+    [
+      "1",
+      "9",
+      "8",
+      "3",
+      "4",
+      "2",
+      "5",
+      "6",
+      "7",
+    ],
+    [
+      "8",
+      "5",
+      "9",
+      "7",
+      "6",
+      "1",
+      "4",
+      "2",
+      "3",
+    ],
+    [
+      "4",
+      "2",
+      "6",
+      "8",
+      "5",
+      "3",
+      "7",
+      "9",
+      "1",
+    ],
+    [
+      "7",
+      "1",
+      "3",
+      "9",
+      "2",
+      "4",
+      "8",
+      "5",
+      "6",
+    ],
+    [
+      "9",
+      "6",
+      "1",
+      "5",
+      "3",
+      "7",
+      "2",
+      "8",
+      "4",
+    ],
+    [
+      "2",
+      "8",
+      "7",
+      "4",
+      "1",
+      "9",
+      "6",
+      "3",
+      "5",
+    ],
+    [
+      "3",
+      "4",
+      "5",
+      "2",
+      "8",
+      "6",
+      "1",
+      "7",
+      "3",
+    ],
+  ],
+]
+comment = "Invalid fully filled board (duplicate '3' in bottom right)"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "2",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      "4",
+      ".",
+      ".",
+      ".",
+      "5",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      "6",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      "7",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "8",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Valid sparse board"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "2",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      "4",
+      ".",
+      ".",
+      ".",
+      "5",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      "6",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "8",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Invalid sparse board (duplicate '1' in column 1)"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "9",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "9",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "9",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "9",
+    ],
+  ],
+]
+comment = "9 in all corners (invalid due to row/col sharing)"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "9",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "9",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Two 9s in different corners (valid)"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      "2",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "4",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      "5",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "6",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "7",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "8",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "9",
+    ],
+  ],
+]
+comment = "Valid main diagonal"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      "2",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "4",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      "5",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "6",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "7",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "8",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "9",
+    ],
+  ],
+]
+comment = "Invalid diagonal (top-left box has duplicate '1')"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "1",
+      "2",
+      "3",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "4",
+      "5",
+      "6",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "7",
+      "8",
+      "9",
+    ],
+    [
+      "1",
+      "2",
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "4",
+      "5",
+      "6",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "7",
+      "8",
+      "9",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "1",
+      "2",
+      "3",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "4",
+      "5",
+      "6",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "7",
+      "8",
+      "9",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Valid blocks staggered across grid"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "1",
+      "2",
+      "3",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "4",
+      "5",
+      "6",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "7",
+      "8",
+      "9",
+    ],
+    [
+      "1",
+      "2",
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "4",
+      "5",
+      "6",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "7",
+      "8",
+      "9",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "1",
+      "2",
+      "3",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "4",
+      "5",
+      "6",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "7",
+      "8",
+      "1",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Invalid staggered blocks (duplicate '1' in bottom-middle box)"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      ".",
+      ".",
+      "4",
+      ".",
+      ".",
+      ".",
+      "6",
+      "3",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "5",
+      ".",
+      ".",
+      ".",
+      ".",
+      "9",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "5",
+      "6",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "4",
+      ".",
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "1",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "7",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "5",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Invalid due to two 5s in the middle column (col 3)"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      ".",
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Two identical numbers in the same box, but different row/col"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      ".",
+      ".",
+      ".",
+      "1",
+      ".",
+      ".",
+      "1",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Two identical numbers in the same row, but different box/col"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      ".",
+      ".",
+      ".",
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      "1",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Two identical numbers in the same col, but different box/row"
+expected = false
+
+[[asserts]]
+arguments = [
+  [
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      "5",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Single element is always valid"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "3",
+      ".",
+      "6",
+      "5",
+      ".",
+      "8",
+      "4",
+      ".",
+      ".",
+    ],
+    [
+      "5",
+      "2",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      "8",
+      "7",
+      ".",
+      ".",
+      ".",
+      ".",
+      "3",
+      "1",
+    ],
+    [
+      ".",
+      ".",
+      "3",
+      ".",
+      "1",
+      ".",
+      ".",
+      "8",
+      ".",
+    ],
+    [
+      "9",
+      ".",
+      ".",
+      "8",
+      "6",
+      "3",
+      ".",
+      ".",
+      "5",
+    ],
+    [
+      ".",
+      "5",
+      ".",
+      ".",
+      "9",
+      ".",
+      "6",
+      ".",
+      ".",
+    ],
+    [
+      "1",
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+      "2",
+      "5",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "7",
+      "4",
+    ],
+    [
+      ".",
+      ".",
+      "5",
+      "2",
+      ".",
+      "6",
+      "3",
+      ".",
+      ".",
+    ],
+  ],
+]
+comment = "Complex real valid puzzle"
+expected = true
+
+[[asserts]]
+arguments = [
+  [
+    [
+      "3",
+      ".",
+      "6",
+      "5",
+      ".",
+      "8",
+      "4",
+      ".",
+      ".",
+    ],
+    [
+      "5",
+      "2",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+    ],
+    [
+      ".",
+      "8",
+      "7",
+      ".",
+      ".",
+      ".",
+      ".",
+      "3",
+      "1",
+    ],
+    [
+      ".",
+      ".",
+      "3",
+      ".",
+      "1",
+      ".",
+      ".",
+      "8",
+      ".",
+    ],
+    [
+      "9",
+      ".",
+      ".",
+      "8",
+      "6",
+      "3",
+      ".",
+      ".",
+      "5",
+    ],
+    [
+      ".",
+      "5",
+      ".",
+      ".",
+      "9",
+      ".",
+      "6",
+      ".",
+      ".",
+    ],
+    [
+      "1",
+      "3",
+      ".",
+      ".",
+      ".",
+      ".",
+      "2",
+      "5",
+      ".",
+    ],
+    [
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      ".",
+      "7",
+      "4",
+    ],
+    [
+      ".",
+      ".",
+      "5",
+      "2",
+      ".",
+      "6",
+      "3",
+      ".",
+      "8",
+    ],
+  ],
+]
+comment = "Complex real valid puzzle"
+expected = true
diff --git a/tasks/medium/dp/turtle_max_path_sum.toml b/tasks/medium/dp/turtle_max_path_sum.toml
index 7c178d0..fd6f358 100644
--- a/tasks/medium/dp/turtle_max_path_sum.toml
+++ b/tasks/medium/dp/turtle_max_path_sum.toml
@@ -1,20 +1,21 @@
+base_score        = 150
 level             = "medium"
 name              = "turtle_max_path_sum"
 tags              = ["dp", "matrix", "arrays"]
 time_to_solve_sec = 400
 
 description_en = """
-You are given an $m \\times n$ matrix of integers. A turtle starts its journey in the top-left corner $(0, 0)$ and wants to reach the bottom-right corner $(m-1, n-1)$. 
+You are given an $m \\times n$ matrix of integers. A turtle starts its journey in the top-left corner $(0, 0)$ and wants to reach the bottom-right corner $(m-1, n-1)$.
 
-The turtle can only move **right** or **down**. 
+The turtle can only move **right** or **down**.
 
 Return the maximum sum of the elements along its path.
 """
 
 description_ru = """
-Дана матрица целых чисел размером $m \\times n$. Черепашка начинает свой путь в левом верхнем углу $(0, 0)$ и хочет добраться до правого нижнего угла $(m-1, n-1)$. 
+Дана матрица целых чисел размером $m \\times n$. Черепашка начинает свой путь в левом верхнем углу $(0, 0)$ и хочет добраться до правого нижнего угла $(m-1, n-1)$.
 
-Черепашка может двигаться только **вправо** или **вниз**. 
+Черепашка может двигаться только **вправо** или **вниз**.
 
 Верните максимальную сумму элементов на ее пути.
 """
@@ -176,4 +177,4 @@ expected  = 15
 [[asserts]]
 arguments = [[[0, -1, -2], [-3, -4, -5], [-6, -7, -8]]]
 comment   = "Negative sequence starting with zero"
-expected  = -16
\ No newline at end of file
+expected  = -16
diff --git a/tasks/medium/games/feeding_kraken.toml b/tasks/medium/games/feeding_kraken.toml
index 3d2e28d..490f972 100644
--- a/tasks/medium/games/feeding_kraken.toml
+++ b/tasks/medium/games/feeding_kraken.toml
@@ -6,15 +6,18 @@ time_to_solve_sec = 300
 
 description_en = """
 You and the Kraken take turns taking gold coins from three piles containing `a`, `b`, and `c` coins. On each turn, a player may take any positive number of coins from exactly one pile. The player who takes the last coin survives. Determine whether you can win if both players play optimally and you move first.
+
+If all piles are empty, return `False`.
 """
 
 description_ru = """
 Вы и Кракен по очереди берете золотые монеты из трех кучек, в которых лежат `a`, `b` и `c` монет. За один ход можно взять любое положительное количество монет ровно из одной кучки. Тот, кто заберет последнюю монету, выживает. Определите, сможете ли вы победить, если оба игрока играют оптимально и вы ходите первым.
+
+Если все кучки пусты, верните `False`.
 """
 
 limits = """
 - $0 \\leq a, b, c \\leq 1000$
-- $a + b + c \\geq 1$
 """
 
 solution = """
@@ -24,6 +27,7 @@ def solution(a: int, b: int, c: int) -> bool:
 
 examples = """
 solution(1, 0, 0) == True
+solution(0, 0, 0) == False
 solution(1, 1, 0) == False
 solution(1, 2, 3) == False
 """
@@ -195,3 +199,8 @@ expected  = true
 arguments = [50, 7, 7]
 comment   = "Test 30"
 expected  = true
+
+[[asserts]]
+arguments = [0, 0, 0]
+comment   = "Empty position is losing"
+expected  = false
diff --git a/tasks/medium/games/game_of_life_step.toml b/tasks/medium/games/game_of_life_step.toml
index deba89b..a5e5782 100644
--- a/tasks/medium/games/game_of_life_step.toml
+++ b/tasks/medium/games/game_of_life_step.toml
@@ -1,7 +1,8 @@
+base_score        = 150
 level             = "medium"
 name              = "game_of_life_step"
 tags              = ["games", "simulation", "algorithms"]
-time_to_solve_sec = 600
+time_to_solve_sec = 450
 
 description_en = """
 You are given a 2D integer array `grid` representing the current state of a grid in Conway's Game of Life. `1` represents a live cell and `0` represents a dead cell.
@@ -15,6 +16,8 @@ The rules are:
 4. A dead cell with exactly `3` live neighbors becomes a live cell (reproduction).
 
 Neighbors are the 8 cells horizontally, vertically, or diagonally adjacent.
+
+Update all cells simultaneously. Cells outside the grid are dead; the grid does not wrap around.
 """
 
 description_ru = """
@@ -29,6 +32,8 @@ description_ru = """
 4. Мертвая клетка, у которой ровно `3` живых соседа, становится живой (размножение).
 
 Соседями считаются 8 клеток по горизонтали, вертикали и диагонали.
+
+Все клетки обновляются одновременно. Клетки за границей поля мертвы; противоположные края поля не соединены.
 """
 
 limits = """
@@ -43,7 +48,7 @@ def solution(grid: list) -> list:
     res = [[0] * n for _ in range(m)]
     for i in range(m):
         for j in range(n):
-            lives = sum(grid[r][c] for r in range(max(0, i-1), min(m, i+2)) 
+            lives = sum(grid[r][c] for r in range(max(0, i-1), min(m, i+2))
                                    for c in range(max(0, j-1), min(n, j+2))) - grid[i][j]
             if grid[i][j] == 1 and lives in (2, 3):
                 res[i][j] = 1
@@ -54,8 +59,8 @@ def solution(grid: list) -> list:
 
 examples = """
 solution([[1]]) == [[0]]
-solution([[0, 1, 0], [0, 1, 0], [0, 1, 0]]) == [[0, 0, 0], [1, 1, 1], [0, 0, 0]]
 solution([[1, 1], [1, 1]]) == [[1, 1], [1, 1]]
+solution([[0, 1, 0], [0, 1, 0], [0, 1, 0]]) == [[0, 0, 0], [1, 1, 1], [0, 0, 0]]
 """
 
 [[input_signature]]
@@ -200,11 +205,159 @@ comment   = "3x4 horizontal line"
 expected  = [[0, 1, 1, 0], [0, 1, 1, 0], [0, 1, 1, 0]]
 
 [[asserts]]
-arguments = [[[0, 0, 0, 0, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 1, 1, 1, 0], [0, 0, 0, 0, 0]]]
-comment   = "5x5 3x3 square in center"
-expected  = [[0, 0, 1, 0, 0], [0, 1, 0, 1, 0], [1, 0, 0, 0, 1], [0, 1, 0, 1, 0], [0, 0, 1, 0, 0]]
+arguments = [
+  [
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      1,
+      1,
+      1,
+      0,
+    ],
+    [
+      0,
+      1,
+      1,
+      1,
+      0,
+    ],
+    [
+      0,
+      1,
+      1,
+      1,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+  ],
+]
+comment = "5x5 3x3 square in center"
+expected = [
+  [
+    0,
+    0,
+    1,
+    0,
+    0,
+  ],
+  [
+    0,
+    1,
+    0,
+    1,
+    0,
+  ],
+  [
+    1,
+    0,
+    0,
+    0,
+    1,
+  ],
+  [
+    0,
+    1,
+    0,
+    1,
+    0,
+  ],
+  [
+    0,
+    0,
+    1,
+    0,
+    0,
+  ],
+]
 
 [[asserts]]
-arguments = [[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]]
-comment   = "5x5 completely empty"
-expected  = [[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]
\ No newline at end of file
+arguments = [
+  [
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+  ],
+]
+comment = "5x5 completely empty"
+expected = [
+  [
+    0,
+    0,
+    0,
+    0,
+    0,
+  ],
+  [
+    0,
+    0,
+    0,
+    0,
+    0,
+  ],
+  [
+    0,
+    0,
+    0,
+    0,
+    0,
+  ],
+  [
+    0,
+    0,
+    0,
+    0,
+    0,
+  ],
+  [
+    0,
+    0,
+    0,
+    0,
+    0,
+  ],
+]
diff --git a/tasks/medium/games/valid_sudoku.toml b/tasks/medium/games/valid_sudoku.toml
deleted file mode 100644
index ff6dd66..0000000
--- a/tasks/medium/games/valid_sudoku.toml
+++ /dev/null
@@ -1,477 +0,0 @@
-level             = "medium"
-name              = "valid_sudoku"
-tags              = ["arrays", "matrix", "hash"]
-time_to_solve_sec = 600
-
-description_en = """
-Determine if a $9 \\times 9$ Sudoku board is valid. Only the filled cells need to be validated according to the following rules:
-
-1. Each row must contain the digits `"1"`-`"9"` without repetition.
-2. Each column must contain the digits `"1"`-`"9"` without repetition.
-3. Each of the nine $3 \\times 3$ sub-boxes of the grid must contain the digits `"1"`-`"9"` without repetition.
-
-The Sudoku board could be partially filled, where empty cells are filled with the character `"."`.
-"""
-
-description_ru = """
-Определите, является ли поле для судоку $9 \\times 9$ валидным. Только заполненные ячейки необходимо проверять в соответствии со следующими правилами:
-
-1. Каждая строка должна содержать цифры от `"1"` до `"9"` без повторений.
-2. Каждый столбец должен содержать цифры от `"1"` до `"9"` без повторений.
-3. Каждый из девяти подквадратов $3 \\times 3$ должен содержать цифры от `"1"` до `"9"` без повторений.
-
-Поле судоку может быть частично заполнено, пустые ячейки обозначаются символом `"."`.
-"""
-
-limits = """
-- $\\text{len}(\\text{board}) = 9$
-- $\\text{len}(\\text{board}[i]) = 9$
-- $\\text{board}[i][j] \\in \\{"1", \\dots, "9", "."\\}$
-"""
-
-solution = """
-def solution(board: list) -> bool:
-    r = [set() for _ in range(9)]
-    c = [set() for _ in range(9)]
-    b = [set() for _ in range(9)]
-    
-    for i in range(9):
-        for j in range(9):
-            v = board[i][j]
-            if v != ".":
-                k = (i // 3) * 3 + j // 3
-                if v in r[i] or v in c[j] or v in b[k]:
-                    return False
-                r[i].add(v)
-                c[j].add(v)
-                b[k].add(v)
-    return True
-"""
-
-examples = """
-solution([
-  ["5","3",".",".","7",".",".",".","."],
-  ["6",".",".","1","9","5",".",".","."],
-  [".","9","8",".",".",".",".","6","."],
-  ["8",".",".",".","6",".",".",".","3"],
-  ["4",".",".","8",".","3",".",".","1"],
-  ["7",".",".",".","2",".",".",".","6"],
-  [".","6",".",".",".",".","2","8","."],
-  [".",".",".","4","1","9",".",".","5"],
-  [".",".",".",".","8",".",".","7","9"]
-]) == True
-
-solution([
-  ["8","3",".",".","7",".",".",".","."],
-  ["6",".",".","1","9","5",".",".","."],
-  [".","9","8",".",".",".",".","6","."],
-  ["8",".",".",".","6",".",".",".","3"],
-  ["4",".",".","8",".","3",".",".","1"],
-  ["7",".",".",".","2",".",".",".","6"],
-  [".","6",".",".",".",".","2","8","."],
-  [".",".",".","4","1","9",".",".","5"],
-  [".",".",".",".","8",".",".","7","9"]
-]) == False
-"""
-
-[[input_signature]]
-argument_name = "board"
-[input_signature.type]
-name = "array"
-[input_signature.type.nested]
-name = "array"
-[input_signature.type.nested.nested]
-name = "string"
-
-[output_signature.type]
-name = "boolean"
-
-[[asserts]]
-arguments = [[
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Completely empty board"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  ["5","3",".",".","7",".",".",".","."],
-  ["6",".",".","1","9","5",".",".","."],
-  [".","9","8",".",".",".",".","6","."],
-  ["8",".",".",".","6",".",".",".","3"],
-  ["4",".",".","8",".","3",".",".","1"],
-  ["7",".",".",".","2",".",".",".","6"],
-  [".","6",".",".",".",".","2","8","."],
-  [".",".",".","4","1","9",".",".","5"],
-  [".",".",".",".","8",".",".","7","9"]
-]]
-comment   = "Valid partial board"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  ["8","3",".",".","7",".",".",".","."],
-  ["6",".",".","1","9","5",".",".","."],
-  [".","9","8",".",".",".",".","6","."],
-  ["8",".",".",".","6",".",".",".","3"],
-  ["4",".",".","8",".","3",".",".","1"],
-  ["7",".",".",".","2",".",".",".","6"],
-  [".","6",".",".",".",".","2","8","."],
-  [".",".",".","4","1","9",".",".","5"],
-  [".",".",".",".","8",".",".","7","9"]
-]]
-comment   = "Invalid partial board (two '8's in first column)"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  ["1","2","3","4","5","6","7","8","9"],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Valid single row"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  ["1","2","3","4","5","6","7","8","1"],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Invalid single row (duplicate '1')"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  ["1",".",".",".",".",".",".",".","."],
-  ["2",".",".",".",".",".",".",".","."],
-  ["3",".",".",".",".",".",".",".","."],
-  ["4",".",".",".",".",".",".",".","."],
-  ["5",".",".",".",".",".",".",".","."],
-  ["6",".",".",".",".",".",".",".","."],
-  ["7",".",".",".",".",".",".",".","."],
-  ["8",".",".",".",".",".",".",".","."],
-  ["9",".",".",".",".",".",".",".","."]
-]]
-comment   = "Valid single column"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  ["1",".",".",".",".",".",".",".","."],
-  ["2",".",".",".",".",".",".",".","."],
-  ["3",".",".",".",".",".",".",".","."],
-  ["4",".",".",".",".",".",".",".","."],
-  ["5",".",".",".",".",".",".",".","."],
-  ["6",".",".",".",".",".",".",".","."],
-  ["7",".",".",".",".",".",".",".","."],
-  ["8",".",".",".",".",".",".",".","."],
-  ["1",".",".",".",".",".",".",".","."]
-]]
-comment   = "Invalid single column (duplicate '1')"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  ["1","2","3",".",".",".",".",".","."],
-  ["4","5","6",".",".",".",".",".","."],
-  ["7","8","9",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Valid single box"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  ["1","2","3",".",".",".",".",".","."],
-  ["4","5","6",".",".",".",".",".","."],
-  ["7","8","1",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Invalid single box (duplicate '1')"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  ["5","3","4","6","7","8","9","1","2"],
-  ["6","7","2","1","9","5","3","4","8"],
-  ["1","9","8","3","4","2","5","6","7"],
-  ["8","5","9","7","6","1","4","2","3"],
-  ["4","2","6","8","5","3","7","9","1"],
-  ["7","1","3","9","2","4","8","5","6"],
-  ["9","6","1","5","3","7","2","8","4"],
-  ["2","8","7","4","1","9","6","3","5"],
-  ["3","4","5","2","8","6","1","7","9"]
-]]
-comment   = "Fully solved valid board"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  ["5","3","4","6","7","8","9","1","2"],
-  ["6","7","2","1","9","5","3","4","8"],
-  ["1","9","8","3","4","2","5","6","7"],
-  ["8","5","9","7","6","1","4","2","3"],
-  ["4","2","6","8","5","3","7","9","1"],
-  ["7","1","3","9","2","4","8","5","6"],
-  ["9","6","1","5","3","7","2","8","4"],
-  ["2","8","7","4","1","9","6","3","5"],
-  ["3","4","5","2","8","6","1","7","3"]
-]]
-comment   = "Invalid fully filled board (duplicate '3' in bottom right)"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  [".",".",".",".",".",".",".",".","."],
-  [".","1",".",".",".",".",".","2","."],
-  [".",".",".",".","3",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".","4",".",".",".","5",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".","6",".",".",".","."],
-  [".","7",".",".",".",".",".","8","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Valid sparse board"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  [".",".",".",".",".",".",".",".","."],
-  [".","1",".",".",".",".",".","2","."],
-  [".",".",".",".","3",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".","4",".",".",".","5",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".","6",".",".",".","."],
-  [".","1",".",".",".",".",".","8","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Invalid sparse board (duplicate '1' in column 1)"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  ["9",".",".",".",".",".",".",".","9"],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  ["9",".",".",".",".",".",".",".","9"]
-]]
-comment   = "9 in all corners (invalid due to row/col sharing)"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  [".",".",".",".",".",".",".",".","9"],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  ["9",".",".",".",".",".",".",".","."]
-]]
-comment   = "Two 9s in different corners (valid)"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  ["1",".",".",".",".",".",".",".","."],
-  [".","2",".",".",".",".",".",".","."],
-  [".",".","3",".",".",".",".",".","."],
-  [".",".",".","4",".",".",".",".","."],
-  [".",".",".",".","5",".",".",".","."],
-  [".",".",".",".",".","6",".",".","."],
-  [".",".",".",".",".",".","7",".","."],
-  [".",".",".",".",".",".",".","8","."],
-  [".",".",".",".",".",".",".",".","9"]
-]]
-comment   = "Valid main diagonal"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  ["1",".",".",".",".",".",".",".","."],
-  [".","2",".",".",".",".",".",".","."],
-  [".",".","1",".",".",".",".",".","."],
-  [".",".",".","4",".",".",".",".","."],
-  [".",".",".",".","5",".",".",".","."],
-  [".",".",".",".",".","6",".",".","."],
-  [".",".",".",".",".",".","7",".","."],
-  [".",".",".",".",".",".",".","8","."],
-  [".",".",".",".",".",".",".",".","9"]
-]]
-comment   = "Invalid diagonal (top-left box has duplicate '1')"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  [".",".",".",".",".",".","1","2","3"],
-  [".",".",".",".",".",".","4","5","6"],
-  [".",".",".",".",".",".","7","8","9"],
-  ["1","2","3",".",".",".",".",".","."],
-  ["4","5","6",".",".",".",".",".","."],
-  ["7","8","9",".",".",".",".",".","."],
-  [".",".",".","1","2","3",".",".","."],
-  [".",".",".","4","5","6",".",".","."],
-  [".",".",".","7","8","9",".",".","."]
-]]
-comment   = "Valid blocks staggered across grid"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  [".",".",".",".",".",".","1","2","3"],
-  [".",".",".",".",".",".","4","5","6"],
-  [".",".",".",".",".",".","7","8","9"],
-  ["1","2","3",".",".",".",".",".","."],
-  ["4","5","6",".",".",".",".",".","."],
-  ["7","8","9",".",".",".",".",".","."],
-  [".",".",".","1","2","3",".",".","."],
-  [".",".",".","4","5","6",".",".","."],
-  [".",".",".","7","8","1",".",".","."]
-]]
-comment   = "Invalid staggered blocks (duplicate '1' in bottom-middle box)"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  [".",".","4",".",".",".","6","3","."],
-  [".",".",".",".",".",".",".",".","."],
-  ["5",".",".",".",".","9",".",".","."],
-  [".",".",".","5","6",".",".",".","."],
-  ["4",".","3",".",".",".",".",".","1"],
-  [".",".",".","7",".",".",".",".","."],
-  [".",".",".","5",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Invalid due to two 5s in the middle column (col 3)"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  [".","1",".",".",".",".",".",".","."],
-  ["1",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Two identical numbers in the same box, but different row/col"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  [".",".",".","1",".",".","1",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Two identical numbers in the same row, but different box/col"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  [".",".",".","1",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".","1",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Two identical numbers in the same col, but different box/row"
-expected  = false
-
-[[asserts]]
-arguments = [[
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".","5",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."],
-  [".",".",".",".",".",".",".",".","."]
-]]
-comment   = "Single element is always valid"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  ["3",".","6","5",".","8","4",".","."],
-  ["5","2",".",".",".",".",".",".","."],
-  [".","8","7",".",".",".",".","3","1"],
-  [".",".","3",".","1",".",".","8","."],
-  ["9",".",".","8","6","3",".",".","5"],
-  [".","5",".",".","9",".","6",".","."],
-  ["1","3",".",".",".",".","2","5","."],
-  [".",".",".",".",".",".",".","7","4"],
-  [".",".","5","2",".","6","3",".","."]
-]]
-comment   = "Complex real valid puzzle"
-expected  = true
-
-[[asserts]]
-arguments = [[
-  ["3",".","6","5",".","8","4",".","."],
-  ["5","2",".",".",".",".",".",".","."],
-  [".","8","7",".",".",".",".","3","1"],
-  [".",".","3",".","1",".",".","8","."],
-  ["9",".",".","8","6","3",".",".","5"],
-  [".","5",".",".","9",".","6",".","."],
-  ["1","3",".",".",".",".","2","5","."],
-  [".",".",".",".",".",".",".","7","4"],
-  [".",".","5","2",".","6","3",".","8"]
-]]
-comment   = "Complex real valid puzzle"
-expected  = true
\ No newline at end of file
diff --git a/tasks/medium/graphs/flood_fill.toml b/tasks/medium/graphs/flood_fill.toml
index 298c197..e0853c3 100644
--- a/tasks/medium/graphs/flood_fill.toml
+++ b/tasks/medium/graphs/flood_fill.toml
@@ -1,3 +1,4 @@
+base_score        = 150
 level             = "medium"
 name              = "flood_fill"
 tags              = ["graphs"]
@@ -34,12 +35,12 @@ limits = """
 solution = """
 def solution(image: list[list[int]], sr: int, sc: int, color: int) -> list[list[int]]:
     old = image[sr][sc]
-    if old == color: return image
-    def dfs(r, c):
-        if 0 <= r < len(image) and 0 <= c < len(image[0]) and image[r][c] == old:
+    stack = [(sr, sc)]
+    while stack:
+        r, c = stack.pop()
+        if old != color and 0 <= r < len(image) and 0 <= c < len(image[0]) and image[r][c] == old:
             image[r][c] = color
-            dfs(r + 1, c); dfs(r - 1, c); dfs(r, c + 1); dfs(r, c - 1)
-    dfs(sr, sc)
+            stack.extend(((r - 1, c), (r + 1, c), (r, c - 1), (r, c + 1)))
     return image
 """
 
@@ -216,11 +217,2376 @@ comment   = "3x2 full block"
 expected  = [[2, 2], [2, 2], [2, 2]]
 
 [[asserts]]
-arguments = [[[1, 1, 1, 1, 1], [1, 0, 0, 0, 1], [1, 0, 1, 0, 1], [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]], 2, 2, 2]
-comment   = "Nested rings, center isolated pixel"
-expected  = [[1, 1, 1, 1, 1], [1, 0, 0, 0, 1], [1, 0, 2, 0, 1], [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]]
+arguments = [
+  [
+    [
+      1,
+      1,
+      1,
+      1,
+      1,
+    ],
+    [
+      1,
+      0,
+      0,
+      0,
+      1,
+    ],
+    [
+      1,
+      0,
+      1,
+      0,
+      1,
+    ],
+    [
+      1,
+      0,
+      0,
+      0,
+      1,
+    ],
+    [
+      1,
+      1,
+      1,
+      1,
+      1,
+    ],
+  ],
+  2,
+  2,
+  2,
+]
+comment = "Nested rings, center isolated pixel"
+expected = [
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    0,
+    0,
+    0,
+    1,
+  ],
+  [
+    1,
+    0,
+    2,
+    0,
+    1,
+  ],
+  [
+    1,
+    0,
+    0,
+    0,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+]
 
 [[asserts]]
-arguments = [[[1, 1, 1, 1, 1], [1, 0, 0, 0, 1], [1, 0, 1, 0, 1], [1, 0, 0, 0, 1], [1, 1, 1, 1, 1]], 0, 0, 2]
-comment   = "Nested rings, outer boundary"
-expected  = [[2, 2, 2, 2, 2], [2, 0, 0, 0, 2], [2, 0, 1, 0, 2], [2, 0, 0, 0, 2], [2, 2, 2, 2, 2]]
\ No newline at end of file
+arguments = [
+  [
+    [
+      1,
+      1,
+      1,
+      1,
+      1,
+    ],
+    [
+      1,
+      0,
+      0,
+      0,
+      1,
+    ],
+    [
+      1,
+      0,
+      1,
+      0,
+      1,
+    ],
+    [
+      1,
+      0,
+      0,
+      0,
+      1,
+    ],
+    [
+      1,
+      1,
+      1,
+      1,
+      1,
+    ],
+  ],
+  0,
+  0,
+  2,
+]
+comment = "Nested rings, outer boundary"
+expected = [
+  [
+    2,
+    2,
+    2,
+    2,
+    2,
+  ],
+  [
+    2,
+    0,
+    0,
+    0,
+    2,
+  ],
+  [
+    2,
+    0,
+    1,
+    0,
+    2,
+  ],
+  [
+    2,
+    0,
+    0,
+    0,
+    2,
+  ],
+  [
+    2,
+    2,
+    2,
+    2,
+    2,
+  ],
+]
+[[asserts]]
+arguments = [
+  [
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+    [
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+      0,
+    ],
+  ],
+  0,
+  0,
+  1,
+]
+comment = "Large connected region without recursive depth limits"
+expected = [
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+  [
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+    1,
+  ],
+]
diff --git a/tasks/medium/graphs/topological_sort_possible.toml b/tasks/medium/graphs/topological_sort_possible.toml
index 46bce1d..c0ccc7a 100644
--- a/tasks/medium/graphs/topological_sort_possible.toml
+++ b/tasks/medium/graphs/topological_sort_possible.toml
@@ -1,3 +1,4 @@
+base_score        = 150
 level             = "medium"
 name              = "topological_sort_possible"
 tags              = ["graphs", "algorithms", "topological_sort"]
@@ -6,15 +7,15 @@ time_to_solve_sec = 400
 description_en = """
 You are given `n` nodes labeled from $0$ to $n - 1$ and a list of directed `edges`.
 
-Each edge $[u, v]$ indicates that node $u$ must appear before node $v$ in a topological ordering. 
+Each edge $[u, v]$ indicates that node $u$ must appear before node $v$ in a topological ordering.
 
 Return `True` if it is possible to topologically sort the graph (i.e., it contains no directed cycles), and `False` otherwise.
 """
 
 description_ru = """
-Вам дано `n` вершин, пронумерованных от $0$ до $n - 1$, и список ориентированных ребер `edges`. 
+Вам дано `n` вершин, пронумерованных от $0$ до $n - 1$, и список ориентированных ребер `edges`.
 
-Каждое ребро $[u, v]$ означает, что вершина $u$ должна идти перед вершиной $v$ в топологической сортировке. 
+Каждое ребро $[u, v]$ означает, что вершина $u$ должна идти перед вершиной $v$ в топологической сортировке.
 
 Верните `True`, если граф можно отсортировать топологически (то есть в нем нет ориентированных циклов), и `False` в противном случае.
 """
@@ -29,11 +30,11 @@ limits = """
 solution = """
 def solution(n: int, edges: list) -> bool:
     from graphlib import TopologicalSorter, CycleError
-    
+
     graph = {i: set() for i in range(n)}
     for u, v in edges:
         graph[v].add(u)
-        
+
     try:
         TopologicalSorter(graph).prepare()
         return True
@@ -203,4 +204,4 @@ expected  = true
 [[asserts]]
 arguments = [8, [[0, 1], [1, 2], [3, 4], [4, 5], [6, 7], [7, 6]]]
 comment   = "Large forest with one cycle hidden"
-expected  = false
\ No newline at end of file
+expected  = false
diff --git a/tasks/medium/regex/log_ip_sanitizer.toml b/tasks/medium/regex/log_ip_sanitizer.toml
index 5fb5f92..2ad1f7f 100644
--- a/tasks/medium/regex/log_ip_sanitizer.toml
+++ b/tasks/medium/regex/log_ip_sanitizer.toml
@@ -5,13 +5,14 @@ tags              = ["regex", "strings"]
 time_to_solve_sec = 300
 
 description_en = """
-You're given a log line  as a string `s`.
+You're given a log line as a string `s`.
 Replace every **valid** IPv4 address with the exact text `[REDACTED]`.
 
 A valid IPv4 is four decimal octets separated by dots: `a.b.c.d`, where each `a..d` is in `0..255`.
 Leading zeros are allowed (e.g. `001.002.003.004`).
 An IPv4 must not be part of a longer digit sequence (it's bounded by non-digits or string ends).
 
+Process valid addresses from left to right without overlapping replacements.
 Return the transformed string.
 Keep all other characters unchanged.
 If there are no valid IPv4 addresses, return the original string.
@@ -25,6 +26,7 @@ description_ru = """
 Ведущие нули разрешены (например, `001.002.003.004`).
 IPv4 не должен быть частью более длинной цифровой последовательности (он ограничен нецифровыми символами или концами строки).
 
+Обрабатывайте корректные адреса слева направо без пересекающихся замен.
 Верните преобразованную строку.
 Все остальные символы должны остаться без изменений.
 Если корректных IPv4 нет — верните исходную строку.
@@ -35,22 +37,20 @@ limits = """
 """
 
 examples = """
+solution("256.0.0.1") == "256.0.0.1"
 solution("no ip here") == "no ip here"
 solution("255.255.255.255") == "[REDACTED]"
 solution("ip=1.2.3.4, ok") == "ip=[REDACTED], ok"
-solution("256.0.0.1") == "256.0.0.1"
 solution("1.1.1.1 2.2.2.2") == "[REDACTED] [REDACTED]"
 """
 
 solution = """
 import re
 
-def replace(p):
-    ip = p.group()
-    return "[REDACTED]" if all(0 <= int(x) <= 255 for x in ip.split(".")) else ip
-
 def solution(s: str) -> str:
-    return re.sub("(\\d+\\.){3}\\d+", replace, s)
+    octet = r'0*(?:25[0-5]|2[0-4][0-9]|1[0-9]{2}|[0-9]{1,2})'
+    ipv4 = rf'(?<!\\d){octet}(?:\\.{octet}){{3}}(?!\\d)'
+    return re.sub(ipv4, '[REDACTED]', s)
 """
 
 [[input_signature]]
@@ -180,3 +180,28 @@ expected  = "1.2.3.499"
 [[asserts]]
 arguments = ["1.2.3.4,5.6.7.8"]
 expected  = "[REDACTED],[REDACTED]"
+
+[[asserts]]
+arguments = ["999.1.2.3.4"]
+comment   = "IPv4 scanning and octet boundary regression"
+expected  = "999.[REDACTED]"
+
+[[asserts]]
+arguments = ["256.001.002.003.004"]
+comment   = "IPv4 scanning and octet boundary regression"
+expected  = "256.[REDACTED]"
+
+[[asserts]]
+arguments = ["0000.0001.0002.0003"]
+comment   = "IPv4 scanning and octet boundary regression"
+expected  = "[REDACTED]"
+
+[[asserts]]
+arguments = ["a1.2.3.400"]
+comment   = "IPv4 scanning and octet boundary regression"
+expected  = "a1.2.3.400"
+
+[[asserts]]
+arguments = ["1.2.3.4.5"]
+comment   = "IPv4 scanning and octet boundary regression"
+expected  = "[REDACTED].5"
diff --git a/tasks/medium/greedy/minimum_bracket_reversals.toml b/tasks/medium/strings/minimum_bracket_reversals.toml
similarity index 99%
rename from tasks/medium/greedy/minimum_bracket_reversals.toml
rename to tasks/medium/strings/minimum_bracket_reversals.toml
index 8839ce8..e57b0b4 100644
--- a/tasks/medium/greedy/minimum_bracket_reversals.toml
+++ b/tasks/medium/strings/minimum_bracket_reversals.toml
@@ -1,3 +1,4 @@
+base_score        = 150
 level             = "medium"
 name              = "minimum_bracket_reversals"
 tags              = ["strings", "greedy", "stack"]
@@ -204,4 +205,4 @@ expected  = 1
 [[asserts]]
 arguments = ["))()()()()()()()()()()()()"]
 comment   = "Balanced with two closes at start"
-expected  = 1
\ No newline at end of file
+expected  = 1
diff --git a/tasks/medium/regex/underscore.toml b/tasks/medium/strings/underscore.toml
similarity index 91%
rename from tasks/medium/regex/underscore.toml
rename to tasks/medium/strings/underscore.toml
index da883b7..3022796 100644
--- a/tasks/medium/regex/underscore.toml
+++ b/tasks/medium/strings/underscore.toml
@@ -20,14 +20,14 @@ solution = """
 import re
 
 def solution(text: str) -> str:
-    for pattern in ['([a-z])([A-Z])', '([A-Z]+)([A-Z][a-z])']:
+    for pattern in [r'([a-z\\d])([A-Z])', '([A-Z]+)([A-Z][a-z])']:
         text = re.sub(pattern, r'\\1_\\2', text)
     return text.replace('-', '_').replace('::', '/').lower()
 """
 
 examples = """
-solution("ActiveModel::Errors") == "active_model/errors"
 solution("HelloHowAreYou") == "hello_how_are_you"
+solution("ActiveModel::Errors") == "active_model/errors"
 solution("MyNAMEIsBOND-JamesBond") == "my_name_is_bond_james_bond"
 solution("MAINCompany::BEST-MAINUser") == "main_company/best_main_user"
 """
@@ -164,3 +164,18 @@ expected  = "css_style"
 arguments = ["SQLQuery"]
 comment   = "SQL acronym"
 expected  = "sql_query"
+
+[[asserts]]
+arguments = ["version2Thing"]
+comment   = "Uppercase word after a digit"
+expected  = "version2_thing"
+
+[[asserts]]
+arguments = ["HTML5Parser"]
+comment   = "Uppercase word after a digit"
+expected  = "html5_parser"
+
+[[asserts]]
+arguments = ["user1ID"]
+comment   = "Uppercase word after a digit"
+expected  = "user1_id"