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/codes/c/chapter_computational_complexity/CMakeLists.txt

@@ -3,3 +3,4 @@ add_executable(recursion recursion.c)
 add_executable(time_complexity time_complexity.c)
 add_executable(worst_best_time_complexity worst_best_time_complexity.c)
 add_executable(space_complexity space_complexity.c)
+add_executable(complexity_exercises complexity_exercises.c)

ja/codes/c/chapter_computational_complexity/complexity_exercises.c

@@ -0,0 +1,61 @@
+/**
+ * File: complexity_exercises.c
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+#include <assert.h>
+
+/* 反復による総和 */
+int sumIter(int n) {
+    int res = 0;
+    for (int i = 1; i <= n; i++) {
+        res += i;
+    }
+    return res;
+}
+
+/* 再帰による総和 */
+int sumRecur(int n) {
+    if (n == 1) {
+        return 1;
+    }
+    return n + sumRecur(n - 1);
+}
+
+/* 線形時間のループ */
+int linearLoop(int n) {
+    int res = 0;
+    for (int i = 0; i < n; i++) {
+        res += i;
+    }
+    return res;
+}
+
+/* 二次時間のループ */
+int quadraticLoop(int n) {
+    int res = 0;
+    for (int i = 0; i < n; i++) {
+        for (int j = i; j < n; j++) {
+            res += j;
+        }
+    }
+    return res;
+}
+
+/* 対数時間のループ */
+int logarithmicLoop(int n) {
+    while (n > 1) {
+        n /= 2;
+    }
+    return n;
+}
+
+int main(void) {
+    assert(sumIter(1) == 1 && sumRecur(1) == 1);
+    assert(sumIter(4) == 10 && sumRecur(4) == 10);
+    assert(linearLoop(4) == 6);
+    assert(quadraticLoop(4) == 20);
+    assert(logarithmicLoop(4) == 1 && logarithmicLoop(5) == 1);
+    return 0;
+}

ja/codes/c/chapter_divide_and_conquer/CMakeLists.txt

@@ -1,3 +1,4 @@
 add_executable(binary_search_recur binary_search_recur.c)
 add_executable(build_tree build_tree.c)
 add_executable(hanota hanota.c)
+add_executable(fast_power fast_power.c)

ja/codes/c/chapter_divide_and_conquer/fast_power.c

@@ -0,0 +1,26 @@
+/**
+ * File: fast_power.c
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+#include <assert.h>
+
+/* 高速べき乗 */
+int fastPow(int x, int n) {
+    if (n == 0) {
+        return 1;
+    }
+    int half = fastPow(x, n / 2);
+    if (n % 2 == 0) {
+        return half * half;
+    }
+    return half * half * x;
+}
+
+int main(void) {
+    assert(fastPow(7, 0) == 1);
+    assert(fastPow(3, 5) == 243);
+    assert(fastPow(2, 6) == 64);
+    return 0;
+}

ja/codes/cpp/chapter_computational_complexity/CMakeLists.txt

@@ -2,4 +2,5 @@ add_executable(iteration iteration.cpp)
 add_executable(recursion recursion.cpp)
 add_executable(space_complexity space_complexity.cpp)
 add_executable(time_complexity time_complexity.cpp)
-add_executable(worst_best_time_complexity worst_best_time_complexity.cpp)
+add_executable(worst_best_time_complexity worst_best_time_complexity.cpp)
+add_executable(complexity_exercises complexity_exercises.cpp)

ja/codes/cpp/chapter_computational_complexity/complexity_exercises.cpp

@@ -0,0 +1,61 @@
+/**
+ * File: complexity_exercises.cpp
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+#include <cassert>
+
+/* 反復による総和 */
+int sumIter(int n) {
+    int res = 0;
+    for (int i = 1; i <= n; ++i) {
+        res += i;
+    }
+    return res;
+}
+
+/* 再帰による総和 */
+int sumRecur(int n) {
+    if (n == 1) {
+        return 1;
+    }
+    return n + sumRecur(n - 1);
+}
+
+/* 線形時間のループ */
+int linearLoop(int n) {
+    int res = 0;
+    for (int i = 0; i < n; ++i) {
+        res += i;
+    }
+    return res;
+}
+
+/* 二次時間のループ */
+int quadraticLoop(int n) {
+    int res = 0;
+    for (int i = 0; i < n; ++i) {
+        for (int j = i; j < n; ++j) {
+            res += j;
+        }
+    }
+    return res;
+}
+
+/* 対数時間のループ */
+int logarithmicLoop(int n) {
+    while (n > 1) {
+        n /= 2;
+    }
+    return n;
+}
+
+int main() {
+    assert(sumIter(1) == 1 && sumRecur(1) == 1);
+    assert(sumIter(4) == 10 && sumRecur(4) == 10);
+    assert(linearLoop(4) == 6);
+    assert(quadraticLoop(4) == 20);
+    assert(logarithmicLoop(4) == 1 && logarithmicLoop(5) == 1);
+    return 0;
+}

ja/codes/cpp/chapter_divide_and_conquer/CMakeLists.txt

@@ -1,3 +1,4 @@
 add_executable(binary_search_recur binary_search_recur.cpp)
 add_executable(build_tree build_tree.cpp)
-add_executable(hanota hanota.cpp)
+add_executable(hanota hanota.cpp)
+add_executable(fast_power fast_power.cpp)

ja/codes/cpp/chapter_divide_and_conquer/fast_power.cpp

@@ -0,0 +1,26 @@
+/**
+ * File: fast_power.cpp
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+#include <cassert>
+
+/* 高速べき乗 */
+int fastPow(int x, int n) {
+    if (n == 0) {
+        return 1;
+    }
+    int half = fastPow(x, n / 2);
+    if (n % 2 == 0) {
+        return half * half;
+    }
+    return half * half * x;
+}
+
+int main() {
+    assert(fastPow(7, 0) == 1);
+    assert(fastPow(3, 5) == 243);
+    assert(fastPow(2, 6) == 64);
+    return 0;
+}

ja/codes/csharp/chapter_computational_complexity/complexity_exercises.cs

@@ -0,0 +1,66 @@
+/**
+ * File: complexity_exercises.cs
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+namespace hello_algo.chapter_computational_complexity;
+
+public class complexity_exercises {
+    /* 反復による総和 */
+    int SumIter(int n) {
+        int res = 0;
+        for (int i = 1; i <= n; i++) {
+            res += i;
+        }
+        return res;
+    }
+
+    /* 再帰による総和 */
+    int SumRecur(int n) {
+        if (n == 1) {
+            return 1;
+        }
+        return n + SumRecur(n - 1);
+    }
+
+    /* 線形時間のループ */
+    int LinearLoop(int n) {
+        int res = 0;
+        for (int i = 0; i < n; i++) {
+            res += i;
+        }
+        return res;
+    }
+
+    /* 二次時間のループ */
+    int QuadraticLoop(int n) {
+        int res = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = i; j < n; j++) {
+                res += j;
+            }
+        }
+        return res;
+    }
+
+    /* 対数時間のループ */
+    int LogarithmicLoop(int n) {
+        while (n > 1) {
+            n /= 2;
+        }
+        return n;
+    }
+
+    [Test]
+    public void Test() {
+        Assert.That(SumIter(1), Is.EqualTo(1));
+        Assert.That(SumRecur(1), Is.EqualTo(1));
+        Assert.That(SumIter(4), Is.EqualTo(10));
+        Assert.That(SumRecur(4), Is.EqualTo(10));
+        Assert.That(LinearLoop(4), Is.EqualTo(6));
+        Assert.That(QuadraticLoop(4), Is.EqualTo(20));
+        Assert.That(LogarithmicLoop(4), Is.EqualTo(1));
+        Assert.That(LogarithmicLoop(5), Is.EqualTo(1));
+    }
+}

ja/codes/csharp/chapter_divide_and_conquer/fast_power.cs

@@ -0,0 +1,28 @@
+/**
+ * File: fast_power.cs
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+namespace hello_algo.chapter_divide_and_conquer;
+
+public class fast_power {
+    /* 高速べき乗 */
+    int FastPow(int x, int n) {
+        if (n == 0) {
+            return 1;
+        }
+        int half = FastPow(x, n / 2);
+        if (n % 2 == 0) {
+            return half * half;
+        }
+        return half * half * x;
+    }
+
+    [Test]
+    public void Test() {
+        Assert.That(FastPow(7, 0), Is.EqualTo(1));
+        Assert.That(FastPow(3, 5), Is.EqualTo(243));
+        Assert.That(FastPow(2, 6), Is.EqualTo(64));
+    }
+}

ja/codes/dart/chapter_computational_complexity/complexity_exercises.dart

@@ -0,0 +1,63 @@
+/**
+ * File: complexity_exercises.dart
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+/* 反復による総和 */
+int sumIter(int n) {
+  int res = 0;
+  for (int i = 1; i <= n; i++) {
+    res += i;
+  }
+  return res;
+}
+
+/* 再帰による総和 */
+int sumRecur(int n) {
+  if (n == 1) {
+    return 1;
+  }
+  return n + sumRecur(n - 1);
+}
+
+/* 線形時間のループ */
+int linearLoop(int n) {
+  int res = 0;
+  for (int i = 0; i < n; i++) {
+    res += i;
+  }
+  return res;
+}
+
+/* 二次時間のループ */
+int quadraticLoop(int n) {
+  int res = 0;
+  for (int i = 0; i < n; i++) {
+    for (int j = i; j < n; j++) {
+      res += j;
+    }
+  }
+  return res;
+}
+
+/* 対数時間のループ */
+int logarithmicLoop(int n) {
+  while (n > 1) {
+    n ~/= 2;
+  }
+  return n;
+}
+
+void main() {
+  if (sumIter(1) != 1 ||
+      sumRecur(1) != 1 ||
+      sumIter(4) != 10 ||
+      sumRecur(4) != 10 ||
+      linearLoop(4) != 6 ||
+      quadraticLoop(4) != 20 ||
+      logarithmicLoop(4) != 1 ||
+      logarithmicLoop(5) != 1) {
+    throw StateError('complexity exercise check failed');
+  }
+}

ja/codes/dart/chapter_divide_and_conquer/fast_power.dart

@@ -0,0 +1,23 @@
+/**
+ * File: fast_power.dart
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+/* 高速べき乗 */
+int fastPow(int x, int n) {
+  if (n == 0) {
+    return 1;
+  }
+  int half = fastPow(x, n ~/ 2);
+  if (n % 2 == 0) {
+    return half * half;
+  }
+  return half * half * x;
+}
+
+void main() {
+  if (fastPow(7, 0) != 1 || fastPow(3, 5) != 243 || fastPow(2, 6) != 64) {
+    throw StateError('fast power check failed');
+  }
+}

ja/codes/go/chapter_computational_complexity/complexity_exercises.go

@@ -0,0 +1,50 @@
+// File: complexity_exercises.go
+// Created Time: 2026-08-18
+// Author: Hello Algo Team
+
+package chapter_computational_complexity
+
+/* 反復による総和 */
+func sumIter(n int) int {
+	res := 0
+	for i := 1; i <= n; i++ {
+		res += i
+	}
+	return res
+}
+
+/* 再帰による総和 */
+func sumRecur(n int) int {
+	if n == 1 {
+		return 1
+	}
+	return n + sumRecur(n-1)
+}
+
+/* 線形時間のループ */
+func linearLoop(n int) int {
+	res := 0
+	for i := 0; i < n; i++ {
+		res += i
+	}
+	return res
+}
+
+/* 二次時間のループ */
+func quadraticLoop(n int) int {
+	res := 0
+	for i := 0; i < n; i++ {
+		for j := i; j < n; j++ {
+			res += j
+		}
+	}
+	return res
+}
+
+/* 対数時間のループ */
+func logarithmicLoop(n int) int {
+	for n > 1 {
+		n /= 2
+	}
+	return n
+}

ja/codes/go/chapter_computational_complexity/complexity_exercises_test.go

@@ -0,0 +1,22 @@
+// File: complexity_exercises_test.go
+// Created Time: 2026-08-18
+// Author: Hello Algo Team
+
+package chapter_computational_complexity
+
+import "testing"
+
+func TestComplexityExercises(t *testing.T) {
+	if sumIter(1) != 1 || sumRecur(1) != 1 {
+		t.Fatal("sum functions failed for n = 1")
+	}
+	if sumIter(4) != 10 || sumRecur(4) != 10 {
+		t.Fatal("sum functions failed for n = 4")
+	}
+	if linearLoop(4) != 6 || quadraticLoop(4) != 20 {
+		t.Fatal("complexity loops returned an unexpected value")
+	}
+	if logarithmicLoop(4) != 1 || logarithmicLoop(5) != 1 {
+		t.Fatal("logarithmic loop returned an unexpected value")
+	}
+}

ja/codes/go/chapter_divide_and_conquer/fast_power.go

@@ -0,0 +1,17 @@
+// File: fast_power.go
+// Created Time: 2026-08-18
+// Author: Hello Algo Team
+
+package chapter_divide_and_conquer
+
+/* 高速べき乗 */
+func fastPow(x, n int) int {
+	if n == 0 {
+		return 1
+	}
+	half := fastPow(x, n/2)
+	if n%2 == 0 {
+		return half * half
+	}
+	return half * half * x
+}

ja/codes/go/chapter_divide_and_conquer/fast_power_test.go

@@ -0,0 +1,13 @@
+// File: fast_power_test.go
+// Created Time: 2026-08-18
+// Author: Hello Algo Team
+
+package chapter_divide_and_conquer
+
+import "testing"
+
+func TestFastPower(t *testing.T) {
+	if fastPow(7, 0) != 1 || fastPow(3, 5) != 243 || fastPow(2, 6) != 64 {
+		t.Fatal("fast power returned an unexpected value")
+	}
+}

ja/codes/java/chapter_computational_complexity/complexity_exercises.java

@@ -0,0 +1,62 @@
+/**
+ * File: complexity_exercises.java
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+package chapter_computational_complexity;
+
+public class complexity_exercises {
+    /* 反復による総和 */
+    static int sumIter(int n) {
+        int res = 0;
+        for (int i = 1; i <= n; i++) {
+            res += i;
+        }
+        return res;
+    }
+
+    /* 再帰による総和 */
+    static int sumRecur(int n) {
+        if (n == 1) {
+            return 1;
+        }
+        return n + sumRecur(n - 1);
+    }
+
+    /* 線形時間のループ */
+    static int linearLoop(int n) {
+        int res = 0;
+        for (int i = 0; i < n; i++) {
+            res += i;
+        }
+        return res;
+    }
+
+    /* 二次時間のループ */
+    static int quadraticLoop(int n) {
+        int res = 0;
+        for (int i = 0; i < n; i++) {
+            for (int j = i; j < n; j++) {
+                res += j;
+            }
+        }
+        return res;
+    }
+
+    /* 対数時間のループ */
+    static int logarithmicLoop(int n) {
+        while (n > 1) {
+            n /= 2;
+        }
+        return n;
+    }
+
+    public static void main(String[] args) {
+        assert sumIter(1) == 1 && sumRecur(1) == 1;
+        assert sumIter(4) == 10 && sumRecur(4) == 10;
+        assert linearLoop(4) == 6;
+        assert quadraticLoop(4) == 20;
+        assert logarithmicLoop(4) == 1 && logarithmicLoop(5) == 1;
+    }
+}

ja/codes/java/chapter_divide_and_conquer/fast_power.java

@@ -0,0 +1,27 @@
+/**
+ * File: fast_power.java
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+package chapter_divide_and_conquer;
+
+public class fast_power {
+    /* 高速べき乗 */
+    static int fastPow(int x, int n) {
+        if (n == 0) {
+            return 1;
+        }
+        int half = fastPow(x, n / 2);
+        if (n % 2 == 0) {
+            return half * half;
+        }
+        return half * half * x;
+    }
+
+    public static void main(String[] args) {
+        assert fastPow(7, 0) == 1;
+        assert fastPow(3, 5) == 243;
+        assert fastPow(2, 6) == 64;
+    }
+}

ja/codes/javascript/chapter_computational_complexity/complexity_exercises.js

@@ -0,0 +1,63 @@
+/**
+ * File: complexity_exercises.js
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+/* 反復による総和 */
+function sumIter(n) {
+    let res = 0;
+    for (let i = 1; i <= n; i++) {
+        res += i;
+    }
+    return res;
+}
+
+/* 再帰による総和 */
+function sumRecur(n) {
+    if (n === 1) {
+        return 1;
+    }
+    return n + sumRecur(n - 1);
+}
+
+/* 線形時間のループ */
+function linearLoop(n) {
+    let res = 0;
+    for (let i = 0; i < n; i++) {
+        res += i;
+    }
+    return res;
+}
+
+/* 二次時間のループ */
+function quadraticLoop(n) {
+    let res = 0;
+    for (let i = 0; i < n; i++) {
+        for (let j = i; j < n; j++) {
+            res += j;
+        }
+    }
+    return res;
+}
+
+/* 対数時間のループ */
+function logarithmicLoop(n) {
+    while (n > 1) {
+        n = Math.floor(n / 2);
+    }
+    return n;
+}
+
+if (
+    sumIter(1) !== 1 ||
+    sumRecur(1) !== 1 ||
+    sumIter(4) !== 10 ||
+    sumRecur(4) !== 10 ||
+    linearLoop(4) !== 6 ||
+    quadraticLoop(4) !== 20 ||
+    logarithmicLoop(4) !== 1 ||
+    logarithmicLoop(5) !== 1
+) {
+    throw new Error('complexity exercise check failed');
+}

ja/codes/javascript/chapter_divide_and_conquer/fast_power.js

@@ -0,0 +1,21 @@
+/**
+ * File: fast_power.js
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+/* 高速べき乗 */
+function fastPow(x, n) {
+    if (n === 0) {
+        return 1;
+    }
+    const half = fastPow(x, Math.floor(n / 2));
+    if (n % 2 === 0) {
+        return half * half;
+    }
+    return half * half * x;
+}
+
+if (fastPow(7, 0) !== 1 || fastPow(3, 5) !== 243 || fastPow(2, 6) !== 64) {
+    throw new Error('fast power check failed');
+}

ja/codes/kotlin/chapter_computational_complexity/complexity_exercises.kt

@@ -0,0 +1,61 @@
+/**
+ * File: complexity_exercises.kt
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+package chapter_computational_complexity.complexity_exercises
+
+/* 反復による総和 */
+fun sumIter(n: Int): Int {
+    var res = 0
+    for (i in 1..n) {
+        res += i
+    }
+    return res
+}
+
+/* 再帰による総和 */
+fun sumRecur(n: Int): Int {
+    if (n == 1) {
+        return 1
+    }
+    return n + sumRecur(n - 1)
+}
+
+/* 線形時間のループ */
+fun linearLoop(n: Int): Int {
+    var res = 0
+    for (i in 0 until n) {
+        res += i
+    }
+    return res
+}
+
+/* 二次時間のループ */
+fun quadraticLoop(n: Int): Int {
+    var res = 0
+    for (i in 0 until n) {
+        for (j in i until n) {
+            res += j
+        }
+    }
+    return res
+}
+
+/* 対数時間のループ */
+fun logarithmicLoop(n: Int): Int {
+    var value = n
+    while (value > 1) {
+        value /= 2
+    }
+    return value
+}
+
+fun main() {
+    check(sumIter(1) == 1 && sumRecur(1) == 1)
+    check(sumIter(4) == 10 && sumRecur(4) == 10)
+    check(linearLoop(4) == 6)
+    check(quadraticLoop(4) == 20)
+    check(logarithmicLoop(4) == 1 && logarithmicLoop(5) == 1)
+}

ja/codes/kotlin/chapter_divide_and_conquer/fast_power.kt

@@ -0,0 +1,25 @@
+/**
+ * File: fast_power.kt
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+package chapter_divide_and_conquer.fast_power
+
+/* 高速べき乗 */
+fun fastPow(x: Int, n: Int): Int {
+    if (n == 0) {
+        return 1
+    }
+    val half = fastPow(x, n / 2)
+    if (n % 2 == 0) {
+        return half * half
+    }
+    return half * half * x
+}
+
+fun main() {
+    check(fastPow(7, 0) == 1)
+    check(fastPow(3, 5) == 243)
+    check(fastPow(2, 6) == 64)
+}

ja/codes/python/chapter_computational_complexity/complexity_exercises.py

@@ -0,0 +1,52 @@
+"""
+File: complexity_exercises.py
+Created Time: 2026-08-18
+Author: Hello Algo Team
+"""
+
+
+def sum_iter(n: int) -> int:
+    """反復による総和"""
+    res = 0
+    for i in range(1, n + 1):
+        res += i
+    return res
+
+
+def sum_recur(n: int) -> int:
+    """再帰による総和"""
+    if n == 1:
+        return 1
+    return n + sum_recur(n - 1)
+
+
+def linear_loop(n: int) -> int:
+    """線形時間のループ"""
+    res = 0
+    for i in range(n):
+        res += i
+    return res
+
+
+def quadratic_loop(n: int) -> int:
+    """二次時間のループ"""
+    res = 0
+    for i in range(n):
+        for j in range(i, n):
+            res += j
+    return res
+
+
+def logarithmic_loop(n: int) -> int:
+    """対数時間のループ"""
+    while n > 1:
+        n //= 2
+    return n
+
+
+if __name__ == "__main__":
+    assert sum_iter(1) == sum_recur(1) == 1
+    assert sum_iter(4) == sum_recur(4) == 10
+    assert linear_loop(4) == 6
+    assert quadratic_loop(4) == 20
+    assert logarithmic_loop(4) == logarithmic_loop(5) == 1

ja/codes/python/chapter_divide_and_conquer/fast_power.py

@@ -0,0 +1,21 @@
+"""
+File: fast_power.py
+Created Time: 2026-08-18
+Author: Hello Algo Team
+"""
+
+
+def fast_pow(x: int, n: int) -> int:
+    """高速べき乗"""
+    if n == 0:
+        return 1
+    half = fast_pow(x, n // 2)
+    if n % 2 == 0:
+        return half * half
+    return half * half * x
+
+
+if __name__ == "__main__":
+    assert fast_pow(7, 0) == 1
+    assert fast_pow(3, 5) == 243
+    assert fast_pow(2, 6) == 64

ja/codes/ruby/chapter_computational_complexity/complexity_exercises.rb

@@ -0,0 +1,55 @@
+=begin
+File: complexity_exercises.rb
+Created Time: 2026-08-18
+Author: Hello Algo Team
+=end
+
+### 反復による総和 ###
+def sum_iter(n)
+  res = 0
+  for i in 1..n
+    res += i
+  end
+  res
+end
+
+### 再帰による総和 ###
+def sum_recur(n)
+  return 1 if n == 1
+
+  n + sum_recur(n - 1)
+end
+
+### 線形時間のループ ###
+def linear_loop(n)
+  res = 0
+  for i in 0...n
+    res += i
+  end
+  res
+end
+
+### 二次時間のループ ###
+def quadratic_loop(n)
+  res = 0
+  for i in 0...n
+    for j in i...n
+      res += j
+    end
+  end
+  res
+end
+
+### 対数時間のループ ###
+def logarithmic_loop(n)
+  n /= 2 while n > 1
+  n
+end
+
+if __FILE__ == $0
+  raise 'sum check failed' unless sum_iter(1) == 1 && sum_recur(1) == 1
+  raise 'sum check failed' unless sum_iter(4) == 10 && sum_recur(4) == 10
+  raise 'linear check failed' unless linear_loop(4) == 6
+  raise 'quadratic check failed' unless quadratic_loop(4) == 20
+  raise 'logarithmic check failed' unless logarithmic_loop(4) == 1 && logarithmic_loop(5) == 1
+end

ja/codes/ruby/chapter_divide_and_conquer/fast_power.rb

@@ -0,0 +1,21 @@
+=begin
+File: fast_power.rb
+Created Time: 2026-08-18
+Author: Hello Algo Team
+=end
+
+### 高速べき乗 ###
+def fast_pow(x, n)
+  return 1 if n == 0
+
+  half = fast_pow(x, n / 2)
+  return half * half if n.even?
+
+  half * half * x
+end
+
+if __FILE__ == $0
+  raise 'fast power check failed' unless fast_pow(7, 0) == 1
+  raise 'fast power check failed' unless fast_pow(3, 5) == 243
+  raise 'fast power check failed' unless fast_pow(2, 6) == 64
+end

ja/codes/rust/Cargo.toml

@@ -4,6 +4,16 @@ version = "0.1.0"
 edition = "2021"
 publish = false
 
+# Run Command: cargo run --bin complexity_exercises
+[[bin]]
+name = "complexity_exercises"
+path = "chapter_computational_complexity/complexity_exercises.rs"
+
+# Run Command: cargo run --bin fast_power
+[[bin]]
+name = "fast_power"
+path = "chapter_divide_and_conquer/fast_power.rs"
+
 # Run Command: cargo run --bin time_complexity
 [[bin]]
 name = "time_complexity"

ja/codes/rust/chapter_computational_complexity/complexity_exercises.rs

@@ -0,0 +1,61 @@
+/*
+ * File: complexity_exercises.rs
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+/* 反復による総和 */
+fn sum_iter(n: i32) -> i32 {
+    let mut res = 0;
+    for i in 1..=n {
+        res += i;
+    }
+    res
+}
+
+/* 再帰による総和 */
+fn sum_recur(n: i32) -> i32 {
+    if n == 1 {
+        return 1;
+    }
+    n + sum_recur(n - 1)
+}
+
+/* 線形時間のループ */
+fn linear_loop(n: i32) -> i32 {
+    let mut res = 0;
+    for i in 0..n {
+        res += i;
+    }
+    res
+}
+
+/* 二次時間のループ */
+fn quadratic_loop(n: i32) -> i32 {
+    let mut res = 0;
+    for i in 0..n {
+        for j in i..n {
+            res += j;
+        }
+    }
+    res
+}
+
+/* 対数時間のループ */
+fn logarithmic_loop(mut n: i32) -> i32 {
+    while n > 1 {
+        n /= 2;
+    }
+    n
+}
+
+fn main() {
+    assert_eq!(sum_iter(1), 1);
+    assert_eq!(sum_recur(1), 1);
+    assert_eq!(sum_iter(4), 10);
+    assert_eq!(sum_recur(4), 10);
+    assert_eq!(linear_loop(4), 6);
+    assert_eq!(quadratic_loop(4), 20);
+    assert_eq!(logarithmic_loop(4), 1);
+    assert_eq!(logarithmic_loop(5), 1);
+}

ja/codes/rust/chapter_divide_and_conquer/fast_power.rs

@@ -0,0 +1,23 @@
+/*
+ * File: fast_power.rs
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+/* 高速べき乗 */
+fn fast_pow(x: i32, n: i32) -> i32 {
+    if n == 0 {
+        return 1;
+    }
+    let half = fast_pow(x, n / 2);
+    if n % 2 == 0 {
+        return half * half;
+    }
+    half * half * x
+}
+
+fn main() {
+    assert_eq!(fast_pow(7, 0), 1);
+    assert_eq!(fast_pow(3, 5), 243);
+    assert_eq!(fast_pow(2, 6), 64);
+}

ja/codes/swift/Package.swift

@@ -11,6 +11,7 @@ let package = Package(
         .executable(name: "time_complexity", targets: ["time_complexity"]),
         .executable(name: "worst_best_time_complexity", targets: ["worst_best_time_complexity"]),
         .executable(name: "space_complexity", targets: ["space_complexity"]),
+        .executable(name: "complexity_exercises", targets: ["complexity_exercises"]),
         // chapter_array_and_linkedlist
         .executable(name: "array", targets: ["array"]),
         .executable(name: "linked_list", targets: ["linked_list"]),
@@ -70,6 +71,7 @@ let package = Package(
         .executable(name: "binary_search_recur", targets: ["binary_search_recur"]),
         .executable(name: "build_tree", targets: ["build_tree"]),
         .executable(name: "hanota", targets: ["hanota"]),
+        .executable(name: "fast_power", targets: ["fast_power"]),
         // chapter_backtracking
         .executable(name: "preorder_traversal_i_compact", targets: ["preorder_traversal_i_compact"]),
         .executable(name: "preorder_traversal_ii_compact", targets: ["preorder_traversal_ii_compact"]),
@@ -114,6 +116,7 @@ let package = Package(
         .executableTarget(name: "time_complexity", path: "chapter_computational_complexity", sources: ["time_complexity.swift"]),
         .executableTarget(name: "worst_best_time_complexity", path: "chapter_computational_complexity", sources: ["worst_best_time_complexity.swift"]),
         .executableTarget(name: "space_complexity", dependencies: ["utils"], path: "chapter_computational_complexity", sources: ["space_complexity.swift"]),
+        .executableTarget(name: "complexity_exercises", path: "chapter_computational_complexity", sources: ["complexity_exercises.swift"]),
         // chapter_array_and_linkedlist
         .executableTarget(name: "array", path: "chapter_array_and_linkedlist", sources: ["array.swift"]),
         .executableTarget(name: "linked_list", dependencies: ["utils"], path: "chapter_array_and_linkedlist", sources: ["linked_list.swift"]),
@@ -173,6 +176,7 @@ let package = Package(
         .executableTarget(name: "binary_search_recur", path: "chapter_divide_and_conquer", sources: ["binary_search_recur.swift"]),
         .executableTarget(name: "build_tree", dependencies: ["utils"], path: "chapter_divide_and_conquer", sources: ["build_tree.swift"]),
         .executableTarget(name: "hanota", path: "chapter_divide_and_conquer", sources: ["hanota.swift"]),
+        .executableTarget(name: "fast_power", path: "chapter_divide_and_conquer", sources: ["fast_power.swift"]),
         // chapter_backtracking
         .executableTarget(name: "preorder_traversal_i_compact", dependencies: ["utils"], path: "chapter_backtracking", sources: ["preorder_traversal_i_compact.swift"]),
         .executableTarget(name: "preorder_traversal_ii_compact", dependencies: ["utils"], path: "chapter_backtracking", sources: ["preorder_traversal_ii_compact.swift"]),

ja/codes/swift/chapter_computational_complexity/complexity_exercises.swift

@@ -0,0 +1,62 @@
+/**
+ File: complexity_exercises.swift
+ Created Time: 2026-08-18
+ Author: Hello Algo Team
+ */
+
+/* 反復による総和 */
+func sumIter(n: Int) -> Int {
+    var res = 0
+    for i in 1 ... n {
+        res += i
+    }
+    return res
+}
+
+/* 再帰による総和 */
+func sumRecur(n: Int) -> Int {
+    if n == 1 {
+        return 1
+    }
+    return n + sumRecur(n: n - 1)
+}
+
+/* 線形時間のループ */
+func linearLoop(n: Int) -> Int {
+    var res = 0
+    for i in 0 ..< n {
+        res += i
+    }
+    return res
+}
+
+/* 二次時間のループ */
+func quadraticLoop(n: Int) -> Int {
+    var res = 0
+    for i in 0 ..< n {
+        for j in i ..< n {
+            res += j
+        }
+    }
+    return res
+}
+
+/* 対数時間のループ */
+func logarithmicLoop(n: Int) -> Int {
+    var n = n
+    while n > 1 {
+        n /= 2
+    }
+    return n
+}
+
+@main
+enum ComplexityExercises {
+    static func main() {
+        assert(sumIter(n: 1) == 1 && sumRecur(n: 1) == 1)
+        assert(sumIter(n: 4) == 10 && sumRecur(n: 4) == 10)
+        assert(linearLoop(n: 4) == 6)
+        assert(quadraticLoop(n: 4) == 20)
+        assert(logarithmicLoop(n: 4) == 1 && logarithmicLoop(n: 5) == 1)
+    }
+}

ja/codes/swift/chapter_divide_and_conquer/fast_power.swift

@@ -0,0 +1,26 @@
+/**
+ File: fast_power.swift
+ Created Time: 2026-08-18
+ Author: Hello Algo Team
+ */
+
+/* 高速べき乗 */
+func fastPow(x: Int, n: Int) -> Int {
+    if n == 0 {
+        return 1
+    }
+    let half = fastPow(x: x, n: n / 2)
+    if n % 2 == 0 {
+        return half * half
+    }
+    return half * half * x
+}
+
+@main
+enum FastPower {
+    static func main() {
+        assert(fastPow(x: 7, n: 0) == 1)
+        assert(fastPow(x: 3, n: 5) == 243)
+        assert(fastPow(x: 2, n: 6) == 64)
+    }
+}

ja/codes/typescript/chapter_computational_complexity/complexity_exercises.ts

@@ -0,0 +1,65 @@
+/**
+ * File: complexity_exercises.ts
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+/* 反復による総和 */
+function sumIter(n: number): number {
+    let res = 0;
+    for (let i = 1; i <= n; i++) {
+        res += i;
+    }
+    return res;
+}
+
+/* 再帰による総和 */
+function sumRecur(n: number): number {
+    if (n === 1) {
+        return 1;
+    }
+    return n + sumRecur(n - 1);
+}
+
+/* 線形時間のループ */
+function linearLoop(n: number): number {
+    let res = 0;
+    for (let i = 0; i < n; i++) {
+        res += i;
+    }
+    return res;
+}
+
+/* 二次時間のループ */
+function quadraticLoop(n: number): number {
+    let res = 0;
+    for (let i = 0; i < n; i++) {
+        for (let j = i; j < n; j++) {
+            res += j;
+        }
+    }
+    return res;
+}
+
+/* 対数時間のループ */
+function logarithmicLoop(n: number): number {
+    while (n > 1) {
+        n = Math.floor(n / 2);
+    }
+    return n;
+}
+
+if (
+    sumIter(1) !== 1 ||
+    sumRecur(1) !== 1 ||
+    sumIter(4) !== 10 ||
+    sumRecur(4) !== 10 ||
+    linearLoop(4) !== 6 ||
+    quadraticLoop(4) !== 20 ||
+    logarithmicLoop(4) !== 1 ||
+    logarithmicLoop(5) !== 1
+) {
+    throw new Error('complexity exercise check failed');
+}
+
+export {};

ja/codes/typescript/chapter_divide_and_conquer/fast_power.ts

@@ -0,0 +1,23 @@
+/**
+ * File: fast_power.ts
+ * Created Time: 2026-08-18
+ * Author: Hello Algo Team
+ */
+
+/* 高速べき乗 */
+function fastPow(x: number, n: number): number {
+    if (n === 0) {
+        return 1;
+    }
+    const half = fastPow(x, Math.floor(n / 2));
+    if (n % 2 === 0) {
+        return half * half;
+    }
+    return half * half * x;
+}
+
+if (fastPow(7, 0) !== 1 || fastPow(3, 5) !== 243 || fastPow(2, 6) !== 64) {
+    throw new Error('fast power check failed');
+}
+
+export {};