[pull] main from krahets:main

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)

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;
+}

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)

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;
+}

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)

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;
+}

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)

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;
+}

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));
+    }
+}

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));
+    }
+}

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');
+  }
+}

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');
+  }
+}