Retranslate the complete Japanese online edition from Chinese (#2008)

* Retranslate the complete Japanese online edition from Chinese

* Fit Japanese homepage labels and localize heading permalinks

* Point Japanese contribution instructions to the Japanese preview

* Replace locale conditionals with multilingual UI tables

ja/codes/python/chapter_computational_complexity/complexity_exercises.py

@@ -21,7 +21,7 @@ def sum_recur(n: int) -> int:
 
 
 def linear_loop(n: int) -> int:
-    """線形時間のループ"""
+    """線形オーダーのループ"""
     res = 0
     for i in range(n):
         res += i
@@ -29,7 +29,7 @@ def linear_loop(n: int) -> int:
 
 
 def quadratic_loop(n: int) -> int:
-    """二次時間のループ"""
+    """二次オーダーのループ"""
     res = 0
     for i in range(n):
         for j in range(i, n):
@@ -38,7 +38,7 @@ def quadratic_loop(n: int) -> int:
 
 
 def logarithmic_loop(n: int) -> int:
-    """対数時間のループ"""
+    """対数オーダーのループ"""
     while n > 1:
         n //= 2
     return n

ja/codes/python/chapter_computational_complexity/iteration.py

@@ -8,7 +8,7 @@ Author: krahets (krahets@163.com)
 def for_loop(n: int) -> int:
     """for ループ"""
     res = 0
-    # 1, 2, ..., n-1, n を順に加算する
+    # ループで 1, 2, ..., n-1, n の和を求める
     for i in range(1, n + 1):
         res += i
     return res
@@ -18,7 +18,7 @@ def while_loop(n: int) -> int:
     """while ループ"""
     res = 0
     i = 1  # 条件変数を初期化する
-    # 1, 2, ..., n-1, n を順に加算する
+    # ループで 1, 2, ..., n-1, n の和を求める
     while i <= n:
         res += i
         i += 1  # 条件変数を更新する
@@ -26,10 +26,10 @@ def while_loop(n: int) -> int:
 
 
 def while_loop_ii(n: int) -> int:
-    """while ループ（2回更新）"""
+    """while ループ（2 回の更新）"""
     res = 0
     i = 1  # 条件変数を初期化する
-    # 1, 4, 10, ... を順に加算する
+    # ループで 1, 4, 10, ... の和を求める
     while i <= n:
         res += i
         # 条件変数を更新する
@@ -41,25 +41,25 @@ def while_loop_ii(n: int) -> int:
 def nested_for_loop(n: int) -> str:
     """二重 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
 
 
-"""Driver Code"""
+"""実行用コード"""
 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}")

ja/codes/python/chapter_computational_complexity/recursion.py

@@ -10,24 +10,24 @@ def recur(n: int) -> int:
     # 終了条件
     if n == 1:
         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,23 +47,23 @@ 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
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
     n = 5
     res = recur(n)
-    print(f"\n再帰関数の合計結果 res = {res}")
+    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}")
+    print(f"\n末尾再帰関数で求めた和 res = {res}")
 
     res = fib(n)
     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,13 +50,13 @@ 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
@@ -65,7 +65,7 @@ def quadratic_recur(n: int) -> int:
 
 
 def build_tree(n: int) -> TreeNode | None:
-    """指数時間（完全二分木の構築）"""
+    """指数オーダー（パーフェクト二分木の構築）"""
     if n == 0:
         return None
     root = TreeNode(0)
@@ -74,15 +74,15 @@ def build_tree(n: int) -> TreeNode | None:
     return root
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
     n = 5
-    # 定数階
+    # 定数オーダー
     constant(n)
-    # 線形階
+    # 線形オーダー
     linear(n)
     linear_recur(n)
-    # 二乗階
+    # 二次オーダー
     quadratic(n)
     quadratic_recur(n)
     # 指数オーダー

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]
     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,67 +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
-    # 二つに分割すると、部分問題の規模は半分になる
+    # 2 つに分割し、部分問題の大きさを半分にする
     count = linear_log_recur(n // 2) + linear_log_recur(n // 2)
-    # 現在の部分問題には n 個の操作が含まれる
+    # 現在の部分問題には 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)
+    print("入力データの大きさ n =", n)
 
     count = constant(n)
-    print("定数時間の操作回数 =", count)
+    print("定数オーダーの操作回数 =", count)
 
     count = linear(n)
-    print("線形時間の操作回数 =", count)
+    print("線形オーダーの操作回数 =", count)
     count = array_traversal([0] * n)
-    print("線形時間（配列走査）の操作回数 =", count)
+    print("線形オーダー（配列の走査）の操作回数 =", count)
 
     count = quadratic(n)
-    print("二乗時間の操作回数 =", count)
+    print("二次オーダーの操作回数 =", count)
     nums = [i for i in range(n, 0, -1)]  # [n, n-1, ..., 2, 1]
     count = bubble_sort(nums)
-    print("二乗時間（バブルソート）の操作回数 =", count)
+    print("二次オーダー（バブルソート）の操作回数 =", count)
 
     count = exponential(n)
-    print("指数時間（ループ実装）の操作回数 =", count)
+    print("指数オーダー（ループによる実装）の操作回数 =", count)
     count = exp_recur(n)
-    print("指数時間（再帰実装）の操作回数 =", count)
+    print("指数オーダー（再帰による実装）の操作回数 =", count)
 
     count = logarithmic(n)
-    print("対数時間（ループ実装）の操作回数 =", count)
+    print("対数オーダー（ループによる実装）の操作回数 =", count)
     count = log_recur(n)
-    print("対数時間（再帰実装）の操作回数 =", count)
+    print("対数オーダー（再帰による実装）の操作回数 =", count)
 
     count = linear_log_recur(n)
-    print("線形対数時間（再帰実装）の操作回数 =", count)
+    print("線形対数オーダー（再帰による実装）の操作回数 =", count)
 
     count = factorial_recur(n)
-    print("階乗時間（再帰実装）の操作回数 =", count)
+    print("階乗オーダー（再帰による実装）の操作回数 =", count)

ja/codes/python/chapter_computational_complexity/worst_best_time_complexity.py

@@ -8,29 +8,29 @@ import random
 
 
 def random_numbers(n: int) -> list[int]:
-    """要素が 1, 2, ..., n で順序がシャッフルされた配列を生成する"""
+    """要素が 1, 2, ..., n で、順序をシャッフルした配列を生成する"""
     # 配列 nums =: 1, 2, 3, ..., n を生成する
     nums = [i for i in range(1, n + 1)]
-    # 配列要素をランダムにシャッフル
+    # 配列の要素をランダムに並べ替える
     random.shuffle(nums)
     return nums
 
 
 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
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
     for i in range(10):
         n = 100
         nums: list[int] = random_numbers(n)
         index: int = find_one(nums)
-        print("\n配列 [ 1, 2, ..., n ] をシャッフルすると =", nums)
+        print("\n配列 [ 1, 2, ..., n ] をシャッフルした結果 =", nums)
         print("数値 1 のインデックスは", index)