Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/python/chapter_computational_complexity/iteration.py

@@ -6,44 +6,44 @@ Author: krahets (krahets@163.com)
 
 
 def for_loop(n: int) -> int:
-    """forループ"""
+    """for ループ"""
     res = 0
-    # 1, 2, ..., n-1, n の合計をループ
+    # 1, 2, ..., n-1, n を順に加算する
     for i in range(1, n + 1):
         res += i
     return res
 
 
 def while_loop(n: int) -> int:
-    """whileループ"""
+    """while ループ"""
     res = 0
-    i = 1  # 条件変数を初期化
-    # 1, 2, ..., n-1, n の合計をループ
+    i = 1  # 条件変数を初期化する
+    # 1, 2, ..., n-1, n を順に加算する
     while i <= n:
         res += i
-        i += 1  # 条件変数を更新
+        i += 1  # 条件変数を更新する
     return res
 
 
 def while_loop_ii(n: int) -> int:
-    """whileループ（2つの更新）"""
+    """while ループ（2回更新）"""
     res = 0
-    i = 1  # 条件変数を初期化
-    # 1, 4, 10, ... の合計をループ
+    i = 1  # 条件変数を初期化する
+    # 1, 4, 10, ... を順に加算する
     while i <= n:
         res += i
-        # 条件変数を更新
+        # 条件変数を更新する
         i += 1
         i *= 2
     return res
 
 
 def nested_for_loop(n: int) -> str:
-    """二重forループ"""
+    """二重 for ループ"""
     res = ""
-    # i = 1, 2, ..., n-1, n をループ
+    # i = 1, 2, ..., n-1, n とループする
     for i in range(1, n + 1):
-        # j = 1, 2, ..., n-1, n をループ
+        # j = 1, 2, ..., n-1, n とループする
         for j in range(1, n + 1):
             res += f"({i}, {j}), "
     return res
@@ -53,13 +53,13 @@ def nested_for_loop(n: int) -> str:
 if __name__ == "__main__":
     n = 5
     res = for_loop(n)
-    print(f"\nforループの合計結果 res = {res}")
+    print(f"\nfor ループの合計結果 res = {res}")
 
     res = while_loop(n)
-    print(f"\nwhileループの合計結果 res = {res}")
+    print(f"\nwhile ループの合計結果 res = {res}")
 
     res = while_loop_ii(n)
-    print(f"\nwhileループ（2つの更新）の合計結果 res = {res}")
+    print(f"\nwhile ループ（2 回更新）の合計結果 res = {res}")
 
     res = nested_for_loop(n)
-    print(f"\n二重forループの走査結果 {res}")
+    print(f"\n二重 for ループの走査結果 {res}")

ja/codes/python/chapter_computational_complexity/recursion.py

@@ -12,22 +12,22 @@ def recur(n: int) -> int:
         return 1
     # 再帰：再帰呼び出し
     res = recur(n - 1)
-    # 復帰：結果を返す
+    # 帰りがけ：結果を返す
     return n + res
 
 
 def for_loop_recur(n: int) -> int:
-    """反復で再帰をシミュレート"""
-    # 明示的なスタックを使用してシステムコールスタックをシミュレート
+    """反復で再帰を模擬する"""
+    # 明示的なスタックを使ってシステムコールスタックを模擬する
     stack = []
     res = 0
     # 再帰：再帰呼び出し
     for i in range(n, 0, -1):
-        # 「スタックへのプッシュ」で「再帰」をシミュレート
+        # 「スタックへのプッシュ」で「再帰」を模擬する
         stack.append(i)
-    # 復帰：結果を返す
+    # 帰りがけ：結果を返す
     while stack:
-        # 「スタックからのポップ」で「復帰」をシミュレート
+        # 「スタックから取り出す操作」で「帰り」をシミュレート
         res += stack.pop()
     # res = 1+2+3+...+n
     return res
@@ -47,7 +47,7 @@ def fib(n: int) -> int:
     # 終了条件 f(1) = 0, f(2) = 1
     if n == 1 or n == 2:
         return n - 1
-    # 再帰呼び出し f(n) = f(n-1) + f(n-2)
+    # f(n) = f(n-1) + f(n-2) を再帰的に呼び出す
     res = fib(n - 1) + fib(n - 2)
     # 結果 f(n) を返す
     return res
@@ -60,10 +60,10 @@ if __name__ == "__main__":
     print(f"\n再帰関数の合計結果 res = {res}")
 
     res = for_loop_recur(n)
-    print(f"\n反復で再帰をシミュレートする合計結果 res = {res}")
+    print(f"\n反復で再帰をシミュレートした合計結果 res = {res}")
 
     res = tail_recur(n, 0)
     print(f"\n末尾再帰関数の合計結果 res = {res}")
 
     res = fib(n)
-    print(f"\nフィボナッチ数列の第 {n} 項は {res} です")
+    print(f"\nフィボナッチ数列の第 {n} 項は {res}")

ja/codes/python/chapter_computational_complexity/space_complexity.py

@@ -13,36 +13,36 @@ from modules import ListNode, TreeNode, print_tree
 
 def function() -> int:
     """関数"""
-    # 何らかの操作を実行
+    # 何らかの処理を行う
     return 0
 
 
 def constant(n: int):
-    """定数複雑度"""
-    # 定数、変数、オブジェクトは O(1) のスペースを占有
+    """定数階"""
+    # 定数、変数、オブジェクトは O(1) の空間を占める
     a = 0
     nums = [0] * 10000
     node = ListNode(0)
-    # ループ内の変数は O(1) のスペースを占有
+    # ループ内の変数は O(1) の空間を占める
     for _ in range(n):
         c = 0
-    # ループ内の関数は O(1) のスペースを占有
+    # ループ内の関数は O(1) の空間を占める
     for _ in range(n):
         function()
 
 
 def linear(n: int):
-    """線形複雑度"""
-    # 長さ n のリストは O(n) のスペースを占有
+    """線形階"""
+    # 長さ n のリストは O(n) の空間を使用
     nums = [0] * n
-    # 長さ n のハッシュマップは O(n) のスペースを占有
+    # 長さ n のハッシュテーブルは O(n) の空間を使用
     hmap = dict[int, str]()
     for i in range(n):
         hmap[i] = str(i)
 
 
 def linear_recur(n: int):
-    """線形複雑度（再帰実装）"""
+    """線形時間（再帰実装）"""
     print("再帰 n =", n)
     if n == 1:
         return
@@ -50,22 +50,22 @@ def linear_recur(n: int):
 
 
 def quadratic(n: int):
-    """平方複雑度"""
-    # 二次元リストは O(n^2) のスペースを占有
+    """二乗階"""
+    # 二次元リストは O(n^2) の空間を使用
     num_matrix = [[0] * n for _ in range(n)]
 
 
 def quadratic_recur(n: int) -> int:
-    """平方複雑度（再帰実装）"""
+    """二次時間（再帰実装）"""
     if n <= 0:
         return 0
+    # 配列 nums の長さは n, n-1, ..., 2, 1
     nums = [0] * n
-    print(f"再帰 n = {n} の中で配列の長さ = {len(nums)}")
     return quadratic_recur(n - 1)
 
 
 def build_tree(n: int) -> TreeNode | None:
-    """指数複雑度（完全二分木の構築）"""
+    """指数時間（完全二分木の構築）"""
     if n == 0:
         return None
     root = TreeNode(0)
@@ -77,14 +77,14 @@ def build_tree(n: int) -> TreeNode | None:
 """Driver Code"""
 if __name__ == "__main__":
     n = 5
-    # 定数複雑度
+    # 定数階
     constant(n)
-    # 線形複雑度
+    # 線形階
     linear(n)
     linear_recur(n)
-    # 平方複雑度
+    # 二乗階
     quadratic(n)
     quadratic_recur(n)
-    # 指数複雑度
+    # 指数オーダー
     root = build_tree(n)
     print_tree(root)

ja/codes/python/chapter_computational_complexity/time_complexity.py

@@ -6,7 +6,7 @@ Author: krahets (krahets@163.com)
 
 
 def constant(n: int) -> int:
-    """定数複雑度"""
+    """定数階"""
     count = 0
     size = 100000
     for _ in range(size):
@@ -15,7 +15,7 @@ def constant(n: int) -> int:
 
 
 def linear(n: int) -> int:
-    """線形複雑度"""
+    """線形階"""
     count = 0
     for _ in range(n):
         count += 1
@@ -23,18 +23,18 @@ def linear(n: int) -> int:
 
 
 def array_traversal(nums: list[int]) -> int:
-    """線形複雑度（配列の走査）"""
+    """線形時間（配列を走査）"""
     count = 0
-    # ループ回数は配列の長さに比例する
+    # ループ回数は配列長に比例する
     for num in nums:
         count += 1
     return count
 
 
 def quadratic(n: int) -> int:
-    """二次複雑度"""
+    """二乗階"""
     count = 0
-    # ループ回数はデータサイズnの二乗に比例する
+    # ループ回数はデータサイズ n の二乗に比例する
     for i in range(n):
         for j in range(n):
             count += 1
@@ -42,26 +42,26 @@ def quadratic(n: int) -> int:
 
 
 def bubble_sort(nums: list[int]) -> int:
-    """二次複雑度（バブルソート）"""
+    """二次時間（バブルソート）"""
     count = 0  # カウンタ
-    # 外側のループ: 未ソート範囲は [0, i]
+    # 外側のループ：未ソート区間は [0, i]
     for i in range(len(nums) - 1, 0, -1):
-        # 内側のループ: 未ソート範囲 [0, i] の最大要素を右端にスワップ
+        # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
         for j in range(i):
             if nums[j] > nums[j + 1]:
-                # nums[j] と nums[j + 1] をスワップ
+                # nums[j] と nums[j + 1] を交換
                 tmp: int = nums[j]
                 nums[j] = nums[j + 1]
                 nums[j + 1] = tmp
-                count += 3  # 要素のスワップは3つの個別操作を含む
+                count += 3  # 要素交換には 3 回の単位操作が含まれる
     return count
 
 
 def exponential(n: int) -> int:
-    """指数複雑度（ループ実装）"""
+    """指数時間（ループ実装）"""
     count = 0
     base = 1
-    # セルは毎回2つに分裂し、1, 2, 4, 8, ..., 2^(n-1) の数列を形成する
+    # 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する
     for _ in range(n):
         for _ in range(base):
             count += 1
@@ -71,14 +71,14 @@ def exponential(n: int) -> int:
 
 
 def exp_recur(n: int) -> int:
-    """指数複雑度（再帰実装）"""
+    """指数時間（再帰実装）"""
     if n == 1:
         return 1
     return exp_recur(n - 1) + exp_recur(n - 1) + 1
 
 
 def logarithmic(n: int) -> int:
-    """対数複雑度（ループ実装）"""
+    """対数時間（ループ実装）"""
     count = 0
     while n > 1:
         n = n / 2
@@ -87,65 +87,67 @@ def logarithmic(n: int) -> int:
 
 
 def log_recur(n: int) -> int:
-    """対数複雑度（再帰実装）"""
+    """対数時間（再帰実装）"""
     if n <= 1:
         return 0
     return log_recur(n / 2) + 1
 
 
 def linear_log_recur(n: int) -> int:
-    """線形対数複雑度"""
+    """線形対数時間"""
     if n <= 1:
         return 1
-    count: int = linear_log_recur(n // 2) + linear_log_recur(n // 2)
+    # 二つに分割すると、部分問題の規模は半分になる
+    count = linear_log_recur(n // 2) + linear_log_recur(n // 2)
+    # 現在の部分問題には n 個の操作が含まれる
     for _ in range(n):
         count += 1
     return count
 
 
 def factorial_recur(n: int) -> int:
-    """階乗複雑度（再帰実装）"""
+    """階乗時間（再帰実装）"""
     if n == 0:
         return 1
     count = 0
-    # 1つからnに分岐
+    # 1個から n 個に分裂
     for _ in range(n):
         count += factorial_recur(n - 1)
     return count
 
 
-"""ドライバコード"""
+"""Driver Code"""
 if __name__ == "__main__":
-    # nを変更して、様々な複雑度での操作回数の変化傾向を体験できる
+    # n を変えて実行し、各計算量で操作回数がどう変化するかを確認できる
     n = 8
     print("入力データサイズ n =", n)
 
-    count: int = constant(n)
-    print("定数複雑度の操作回数 =", count)
+    count = constant(n)
+    print("定数時間の操作回数 =", count)
 
-    count: int = linear(n)
-    print("線形複雑度の操作回数 =", count)
-    count: int = array_traversal([0] * n)
-    print("線形複雑度（配列の走査）の操作回数 =", count)
+    count = linear(n)
+    print("線形時間の操作回数 =", count)
+    count = array_traversal([0] * n)
+    print("線形時間（配列走査）の操作回数 =", count)
 
-    count: int = quadratic(n)
-    print("二次複雑度の操作回数 =", count)
+    count = quadratic(n)
+    print("二乗時間の操作回数 =", count)
     nums = [i for i in range(n, 0, -1)]  # [n, n-1, ..., 2, 1]
-    count: int = bubble_sort(nums)
-    print("二次複雑度（バブルソート）の操作回数 =", count)
+    count = bubble_sort(nums)
+    print("二乗時間（バブルソート）の操作回数 =", count)
 
-    count: int = exponential(n)
-    print("指数複雑度（ループ実装）の操作回数 =", count)
-    count: int = exp_recur(n)
-    print("指数複雑度（再帰実装）の操作回数 =", count)
+    count = exponential(n)
+    print("指数時間（ループ実装）の操作回数 =", count)
+    count = exp_recur(n)
+    print("指数時間（再帰実装）の操作回数 =", count)
 
-    count: int = logarithmic(n)
-    print("対数複雑度（ループ実装）の操作回数 =", count)
-    count: int = log_recur(n)
-    print("対数複雑度（再帰実装）の操作回数 =", count)
+    count = logarithmic(n)
+    print("対数時間（ループ実装）の操作回数 =", count)
+    count = log_recur(n)
+    print("対数時間（再帰実装）の操作回数 =", count)
 
-    count: int = linear_log_recur(n)
-    print("線形対数複雑度（再帰実装）の操作回数 =", count)
+    count = linear_log_recur(n)
+    print("線形対数時間（再帰実装）の操作回数 =", count)
 
-    count: int = factorial_recur(n)
-    print("階乗複雑度（再帰実装）の操作回数 =", count)
+    count = factorial_recur(n)
+    print("階乗時間（再帰実装）の操作回数 =", count)

ja/codes/python/chapter_computational_complexity/worst_best_time_complexity.py

@@ -8,8 +8,8 @@ import random
 
 
 def random_numbers(n: int) -> list[int]:
-    """要素 1, 2, ..., n を含む配列を生成、順序はシャッフル"""
-    # 配列 nums = 1, 2, 3, ..., n を生成
+    """要素が 1, 2, ..., n で順序がシャッフルされた配列を生成する"""
+    # 配列 nums =: 1, 2, 3, ..., n を生成する
     nums = [i for i in range(1, n + 1)]
     # 配列要素をランダムにシャッフル
     random.shuffle(nums)
@@ -17,10 +17,10 @@ def random_numbers(n: int) -> list[int]:
 
 
 def find_one(nums: list[int]) -> int:
-    """配列 nums で数値 1 のインデックスを検索"""
+    """配列 nums 内で数値 1 のインデックスを探す"""
     for i in range(len(nums)):
-        # 要素 1 が配列の最初にある場合、最良時間計算量 O(1) を達成
-        # 要素 1 が配列の最後にある場合、最悪時間計算量 O(n) を達成
+        # 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる
+        # 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる
         if nums[i] == 1:
             return i
     return -1
@@ -32,5 +32,5 @@ if __name__ == "__main__":
         n = 100
         nums: list[int] = random_numbers(n)
         index: int = find_one(nums)
-        print("\nシャッフル後の配列 [ 1, 2, ..., n ] =", nums)
-        print("数値 1 のインデックス =", index)
+        print("\n配列 [ 1, 2, ..., n ] をシャッフルすると =", nums)
+        print("数値 1 のインデックスは", index)