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.

ja/docs/chapter_computational_complexity/exercises.md

@@ -7,33 +7,23 @@
 次の 2 つのコードは、どちらも $1 + 2 + \dots + n$ を計算します（$n \ge 1$ とします）。`n` を 4 として、
 プログラムが実際に実行される順序に沿って次の問いに答え、2 つの書き方の効率を比較してください。
 
-```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. `sum_iter(4)` を実行すると、各ループの終了時に変数 `s` はそれぞれいくつになりますか？
-2. `sum_recur(4)` を実行すると、どの関数が順に呼び出されますか？最も深い呼び出しから戻るとき、結果はどのように求められますか？
+1. `n = 4` を入力して反復関数を実行すると、各ループの終了時に累積変数 `res` はそれぞれいくつになりますか？
+2. `n = 4` を入力して再帰関数を実行すると、引数 `n` はどの値を順に取りますか？最も深い呼び出しから戻るとき、結果はどのように求められますか？
 3. 2 つの書き方の時間計算量と空間計算量は、それぞれいくつですか？問い 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):
 
 次の 3 つのコード片はいずれも、正の整数 $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 "解答"

ja/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. `fast_pow(x, n // 2)` を 2 回書くのではなく、先に `half` へ保存するのはなぜですか？
+3. 同じ部分問題を乗算の両側で 1 回ずつ呼び出すのではなく、再帰結果を先に `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)` を 1 回ずつ書くと、2 つの再帰呼び出しがまったく同じ部分問題を計算します。
+    3. 同じ部分問題を乗算の両側で 1 回ずつ呼び出すと、2 つの再帰呼び出しがまったく同じ計算を行います。
         結果を先に `half` へ保存すれば、各層で再帰するのは 1 回だけとなり、再帰の深さは約 $\log n$ です。
         2 回呼び出すと、大量の重複計算が発生します。