Add multilingual exercise code (#1959)

Replace the exercise pages' Python-only snippets with source-backed implementations for the 13 visible programming languages, and localize reader-facing comments by site language. Zig remains out of scope.

Approval bypass: repository protection requires one approval but does not enforce it for administrators. All 68 completed checks succeeded; four non-required Java jobs remained queued on the existing ubuntu-20.04 workflow, with no failed checks.

ru/docs/chapter_computational_complexity/exercises.md

@@ -7,33 +7,23 @@
 Обе функции ниже вычисляют $1 + 2 + \dots + n$ (считайте, что $n \ge 1$). Присвойте `n` значение 4,
 ответьте на вопросы в порядке фактического выполнения программы, а затем сравните эффективность двух вариантов.
 
-```python
-def sum_iter(n):
-    s = 0
-    for i in range(1, n + 1):
-        s += i
-    return s
-
-def sum_recur(n):
-    if n == 1:
-        return 1
-    return n + sum_recur(n - 1)
+```src
+[file]{complexity_exercises}-[class]{}-[func]{sum_iter}
 ```
 
 <!-- numbered-subquestions -->
 
-1. Какие значения принимает переменная `s` после каждой итерации при выполнении `sum_iter(4)`?
-2. Какие функции поочередно вызываются при выполнении `sum_recur(4)`? Как формируется результат при возврате, начиная с самого глубокого вызова?
+1. Какие значения принимает переменная-аккумулятор `res` после каждой итерации при выполнении итеративной функции с `n = 4`?
+2. Какие значения поочередно принимает параметр `n` при выполнении рекурсивной функции с `n = 4`? Как формируется результат при возврате, начиная с самого глубокого вызова?
 3. Каковы временная и пространственная сложности каждого варианта? Обоснуйте ответ, опираясь на процессы выполнения из вопросов 1 и 2.
 
 ??? success "Ответ"
 
-    1. Переменная цикла `i` поочередно принимает значения `1, 2, 3, 4`, а `s` после каждой итерации становится равной
-        `1, 3, 6, 10`. Поэтому `sum_iter(4)` возвращает 10.
+    1. Переменная цикла `i` поочередно принимает значения `1, 2, 3, 4`, а `res` после каждой итерации становится равной
+        `1, 3, 6, 10`. Поэтому итеративная функция возвращает 10.
 
-    2. Функции вызываются в следующем порядке:
-        `sum_recur(4) → sum_recur(3) → sum_recur(2) → sum_recur(1)`.
-        `sum_recur(1)` возвращает 1, после чего следующие уровни поочередно получают `2 + 1 = 3`, `3 + 3 = 6` и `4 + 6 = 10`.
+    2. Параметр `n` принимает значения `4 → 3 → 2 → 1`.
+        Самый глубокий вызов возвращает 1, после чего следующие уровни поочередно получают `2 + 1 = 3`, `3 + 3 = 6` и `4 + 6 = 10`.
         В самой глубокой точке все 4 вызова функции еще не завершены.
 
     3. В обеих функциях число итераций или вызовов пропорционально $n$, поэтому их временная сложность равна $O(n)$.
@@ -47,21 +37,8 @@ def sum_recur(n):
 
 Во всех трех фрагментах кода входные данные — положительное целое число $n$. Расположите фрагменты в порядке возрастания временной сложности и укажите сложность каждого из них.
 
-```python
-# Фрагмент 1
-s = 0
-for i in range(n):
-    s += i
-
-# Фрагмент 2
-s = 0
-for i in range(n):
-    for j in range(i, n):
-        s += j
-
-# Фрагмент 3
-while n > 1:
-    n = n // 2
+```src
+[file]{complexity_exercises}-[class]{}-[func]{linear_loop}
 ```
 
 ??? success "Ответ"

ru/docs/chapter_divide_and_conquer/exercises.md

@@ -25,23 +25,17 @@
 
 Рекурсивная функция ниже вычисляет $x^n$ методом «разделяй и властвуй»:
 
-```python
-def fast_pow(x, n):
-    if n == 0:
-        return 1
-    half = fast_pow(x, n // 2)
-    if n % 2 == 0:
-        return half * half
-    return half * half * x
+```src
+[file]{fast_power}-[class]{}-[func]{fast_pow}
 ```
 
-Функция вызывается как `fast_pow(3, 5)`.
+Задайте `x = 3` и `n = 5`, затем вычислите результат с помощью этой функции.
 
 <!-- numbered-subquestions -->
 
 1. Какие значения последовательно принимает параметр `n` при рекурсивных вызовах?
 2. Какие значения поочередно возвращаются на каждом уровне, начиная с самого глубокого?
-3. Почему результат нужно сначала сохранить в `half`, а не дважды записывать `fast_pow(x, n // 2)`?
+3. Почему результат рекурсии нужно сначала сохранить в `half`, а не вызывать одну и ту же подзадачу по одному разу с каждой стороны умножения?
 
 ??? success "Ответ"
 
@@ -50,7 +44,7 @@ def fast_pow(x, n):
     2. При `n = 0` возвращается 1; при `n = 1` возвращается $1×1×3=3$;
         при `n = 2` — $3×3=9$; при `n = 5` — $9×9×3=243$.
 
-    3. Если записать `fast_pow(x, n // 2)` по обе стороны умножения, два рекурсивных вызова будут решать одну и ту же подзадачу.
+    3. Если вызвать одну и ту же подзадачу по одному разу с каждой стороны умножения, два рекурсивных вызова выполнят одинаковые вычисления.
         Когда результат сохраняется в `half`, на каждом уровне выполняется только один рекурсивный вызов, а глубина рекурсии составляет примерно $\log n$;
         два вызова привели бы к множеству повторных вычислений.