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_array_and_linkedlist/array.py

@@ -8,21 +8,21 @@ import random
 
 
 def random_access(nums: list[int]) -> int:
-    """要素へランダムアクセス"""
-    # 区間 [0, len(nums)-1] からランダムに数字を 1 つ選ぶ
+    """要素にランダムアクセスする"""
+    # 区間 [0, len(nums)-1] から数値をランダムに 1 つ選ぶ
     random_index = random.randint(0, len(nums) - 1)
-    # ランダムな要素を取得して返す
+    # ランダムに選んだ要素を取得して返す
     random_num = nums[random_index]
     return random_num
 
 
-# Python の list は動的配列であり、直接拡張できます
-# 学習しやすいよう、本関数では list を長さ不変の配列として扱います
+# Python の list は動的配列なので、そのまま拡張できることに注意
+# 学習しやすいように、この関数では list を長さが変わらない配列として扱う
 def extend(nums: list[int], enlarge: int) -> list[int]:
-    """配列長を拡張する"""
-    # 拡張後の長さを持つ配列を初期化する
+    """配列の長さを拡張する"""
+    # 拡張後の長さの配列を初期化する
     res = [0] * (len(nums) + enlarge)
-    # 元の配列の全要素を新しい配列にコピー
+    # 元の配列の全要素を新しい配列にコピーする
     for i in range(len(nums)):
         res[i] = nums[i]
     # 拡張後の新しい配列を返す
@@ -30,28 +30,28 @@ def extend(nums: list[int], enlarge: int) -> list[int]:
 
 
 def insert(nums: list[int], num: int, index: int):
-    """配列の index 番目に要素 num を挿入"""
-    # インデックス index 以降の全要素を 1 つ後ろへ移動する
+    """配列のインデックス index に要素 num を挿入する"""
+    # インデックス index 以降の全要素を 1 つ後ろにずらす
     for i in range(len(nums) - 1, index, -1):
         nums[i] = nums[i - 1]
-    # index の要素に num を代入する
+    # インデックス index の要素に num を代入する
     nums[index] = num
 
 
 def remove(nums: list[int], index: int):
-    """index の要素を削除する"""
-    # インデックス index より後ろの全要素を 1 つ前へ移動する
+    """インデックス index の要素を削除する"""
+    # インデックス index より後の全要素を 1 つ前にずらす
     for i in range(index, len(nums) - 1):
         nums[i] = nums[i + 1]
 
 
 def traverse(nums: list[int]):
-    """配列を走査"""
+    """配列を走査する"""
     count = 0
-    # インデックスで配列を走査
+    # インデックスを使って配列を走査する
     for i in range(len(nums)):
         count += nums[i]
-    # 配列要素を直接走査
+    # 配列の要素を直接走査する
     for num in nums:
         count += num
     # データのインデックスと要素を同時に走査する
@@ -61,16 +61,16 @@ def traverse(nums: list[int]):
 
 
 def find(nums: list[int], target: int) -> int:
-    """配列内で指定要素を探す"""
+    """配列から指定した要素を探索する"""
     for i in range(len(nums)):
         if nums[i] == target:
             return i
     return -1
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # 配列を初期化
+    # 配列を初期化する
     arr = [0] * 5
     print("配列 arr =", arr)
     nums = [1, 3, 2, 5, 4]
@@ -78,23 +78,23 @@ if __name__ == "__main__":
 
     # ランダムアクセス
     random_num: int = random_access(nums)
-    print("nums からランダムな要素を取得", random_num)
+    print("nums からランダムに取得した要素", random_num)
 
-    # 長さを拡張
+    # 長さの拡張
     nums: list[int] = extend(nums, 3)
-    print("配列の長さを 8 に拡張し、nums =", nums)
+    print("配列の長さを 8 に拡張した結果 nums =", nums)
 
     # 要素を挿入する
     insert(nums, 6, 3)
-    print("インデックス 3 に数値 6 を挿入し、nums =", nums)
+    print("インデックス 3 に数値 6 を挿入した結果 nums =", nums)
 
-    # 要素を削除
+    # 要素を削除する
     remove(nums, 2)
-    print("インデックス 2 の要素を削除し、nums =", nums)
+    print("インデックス 2 の要素を削除した結果 nums =", nums)
 
-    # 配列を走査
+    # 配列を走査する
     traverse(nums)
 
     # 要素を探索する
     index: int = find(nums, 3)
-    print("nums で要素 3 を検索し、インデックス =", index)
+    print("nums から要素 3 を探索した結果のインデックス =", index)

ja/codes/python/chapter_array_and_linkedlist/linked_list.py

@@ -12,14 +12,14 @@ from modules import ListNode, print_linked_list
 
 
 def insert(n0: ListNode, P: ListNode):
-    """連結リストでノード n0 の後ろにノード P を挿入する"""
+    """連結リストのノード n0 の直後にノード P を挿入する"""
     n1 = n0.next
     P.next = n1
     n0.next = P
 
 
 def remove(n0: ListNode):
-    """連結リストでノード n0 の直後のノードを削除する"""
+    """連結リストのノード n0 の直後のノードを削除する"""
     if not n0.next:
         return
     # n0 -> P -> n1
@@ -29,7 +29,7 @@ def remove(n0: ListNode):
 
 
 def access(head: ListNode, index: int) -> ListNode | None:
-    """連結リスト内で index 番目のノードにアクセス"""
+    """連結リストのインデックス index にあるノードにアクセスする"""
     for _ in range(index):
         if not head:
             return None
@@ -38,7 +38,7 @@ def access(head: ListNode, index: int) -> ListNode | None:
 
 
 def find(head: ListNode, target: int) -> int:
-    """連結リストで値が target の最初のノードを探す"""
+    """連結リストから値が target である最初のノードを探索する"""
     index = 0
     while head:
         if head.val == target:
@@ -48,7 +48,7 @@ def find(head: ListNode, target: int) -> int:
     return -1
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
     # 連結リストを初期化する
     # 各ノードを初期化する
@@ -57,29 +57,29 @@ if __name__ == "__main__":
     n2 = ListNode(2)
     n3 = ListNode(5)
     n4 = ListNode(4)
-    # ノード間の参照を構築する
+    # ノード間の参照を設定する
     n0.next = n1
     n1.next = n2
     n2.next = n3
     n3.next = n4
-    print("初期化した連結リストは")
+    print("初期化した連結リスト")
     print_linked_list(n0)
 
-    # ノードを挿入
+    # ノードを挿入する
     p = ListNode(0)
     insert(n0, p)
-    print("ノード挿入後の連結リストは")
+    print("ノードを挿入した後の連結リスト")
     print_linked_list(n0)
 
-    # ノードを削除
+    # ノードを削除する
     remove(n0)
-    print("ノード削除後の連結リストは")
+    print("ノードを削除した後の連結リスト")
     print_linked_list(n0)
 
-    # ノードにアクセス
+    # ノードにアクセスする
     node: ListNode = access(n0, 3)
-    print("連結リストのインデックス 3 のノードの値 = {}".format(node.val))
+    print("連結リストのインデックス 3 にあるノードの値 = {}".format(node.val))
 
-    # ノードを探索
+    # ノードを探索する
     index: int = find(n0, 2)
-    print("連結リスト内で値が 2 のノードのインデックス = {}".format(index))
+    print("連結リスト内で値が 2 であるノードのインデックス = {}".format(index))

ja/codes/python/chapter_array_and_linkedlist/list.py

@@ -4,53 +4,53 @@ Created Time: 2022-11-25
 Author: krahets ([email protected])
 """
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # リストを初期化
+    # リストを初期化する
     nums: list[int] = [1, 3, 2, 5, 4]
     print("\nリスト nums =", nums)
 
-    # 要素にアクセス
+    # 要素にアクセスする
     x: int = nums[1]
-    print("\nインデックス 1 の要素にアクセスし、x =", x)
+    print("\nインデックス 1 の要素にアクセスした結果 x =", x)
 
-    # 要素を更新
+    # 要素を更新する
     nums[1] = 0
-    print("\nインデックス 1 の要素を 0 に更新し、nums =", nums)
+    print("\nインデックス 1 の要素を 0 に更新した結果 nums =", nums)
 
     # リストを空にする
     nums.clear()
     print("\nリストを空にした後 nums =", nums)
 
-    # 末尾に要素を追加
+    # 末尾に要素を追加する
     nums.append(1)
     nums.append(3)
     nums.append(2)
     nums.append(5)
     nums.append(4)
-    print("\n要素追加後 nums =", nums)
+    print("\n要素を追加した後 nums =", nums)
 
-    # 中間に要素を挿入
+    # 途中に要素を挿入する
     nums.insert(3, 6)
-    print("\nインデックス 3 に数値 6 を挿入すると、nums =", nums)
+    print("\nインデックス 3 に数値 6 を挿入した結果 nums =", nums)
 
-    # 要素を削除
+    # 要素を削除する
     nums.pop(3)
-    print("\nインデックス 3 の要素を削除すると、nums =", nums)
+    print("\nインデックス 3 の要素を削除した結果 nums =", nums)
 
-    # インデックスでリストを走査
+    # インデックスを使ってリストを走査する
     count = 0
     for i in range(len(nums)):
         count += nums[i]
-    # リスト要素を直接走査
+    # リストの要素を直接走査する
     for num in nums:
         count += num
 
     # 2 つのリストを連結する
     nums1 = [6, 8, 7, 10, 9]
     nums += nums1
-    print("\nリスト nums1 を nums の後ろに連結すると、nums =", nums)
+    print("\nリスト nums の後ろに nums1 を連結した結果 nums =", nums)
 
-    # リストをソート
+    # リストをソートする
     nums.sort()
-    print("\nリストをソートすると nums =", nums)
+    print("\nリストをソートした後 nums =", nums)

ja/codes/python/chapter_array_and_linkedlist/my_list.py

@@ -10,84 +10,84 @@ class MyList:
 
     def __init__(self):
         """コンストラクタ"""
-        self._capacity: int = 10  # リスト容量
-        self._arr: list[int] = [0] * self._capacity  # 配列（リスト要素を格納）
+        self._capacity: int = 10  # リストの容量
+        self._arr: list[int] = [0] * self._capacity  # 配列（リストの要素を格納する）
         self._size: int = 0  # リストの長さ（現在の要素数）
-        self._extend_ratio: int = 2  # リスト拡張時の増加倍率
+        self._extend_ratio: int = 2  # リストの容量を拡張する際の倍率
 
     def size(self) -> int:
-        """リストの長さを取得（現在の要素数）"""
+        """リストの長さ（現在の要素数）を取得する"""
         return self._size
 
     def capacity(self) -> int:
-        """リスト容量を取得する"""
+        """リストの容量を取得する"""
         return self._capacity
 
     def get(self, index: int) -> int:
-        """要素にアクセス"""
-        # インデックスが範囲外なら例外を送出する。以下同様
+        """要素にアクセスする"""
+        # インデックスが範囲外の場合、例外を送出する。以下も同様
         if index < 0 or index >= self._size:
             raise IndexError("インデックスが範囲外です")
         return self._arr[index]
 
     def set(self, num: int, index: int):
-        """要素を更新"""
+        """要素を更新する"""
         if index < 0 or index >= self._size:
             raise IndexError("インデックスが範囲外です")
         self._arr[index] = num
 
     def add(self, num: int):
-        """末尾に要素を追加"""
-        # 要素数が容量を超えると、拡張機構が発動する
+        """末尾に要素を追加する"""
+        # 要素数が容量を超える場合、容量を拡張する
         if self.size() == self.capacity():
             self.extend_capacity()
         self._arr[self._size] = num
         self._size += 1
 
     def insert(self, num: int, index: int):
-        """中間に要素を挿入"""
+        """途中に要素を挿入する"""
         if index < 0 or index >= self._size:
             raise IndexError("インデックスが範囲外です")
-        # 要素数が容量を超えると、拡張機構が発動する
+        # 要素数が容量を超える場合、容量を拡張する
         if self._size == self.capacity():
             self.extend_capacity()
-        # index 以降の要素をすべて 1 つ後ろへずらす
+        # インデックス index 以降の全要素を後ろに 1 つずらす
         for j in range(self._size - 1, index - 1, -1):
             self._arr[j + 1] = self._arr[j]
         self._arr[index] = num
-        # 要素数を更新
+        # 要素数を更新する
         self._size += 1
 
     def remove(self, index: int) -> int:
-        """要素を削除"""
+        """要素を削除する"""
         if index < 0 or index >= self._size:
             raise IndexError("インデックスが範囲外です")
         num = self._arr[index]
-        # インデックス index より後の要素をすべて 1 つ前に移動する
+        # インデックス index より後の全要素を前に 1 つずらす
         for j in range(index, self._size - 1):
             self._arr[j] = self._arr[j + 1]
-        # 要素数を更新
+        # 要素数を更新する
         self._size -= 1
-        # 削除された要素を返す
+        # 削除した要素を返す
         return num
 
     def extend_capacity(self):
-        """リストの拡張"""
-        # 元の配列の `_extend_ratio` 倍の長さを持つ新しい配列を作成し、元の配列を新しい配列にコピーする
+        """リストの容量を拡張する"""
+        # 元の配列の _extend_ratio 倍の長さの配列を新たに作成し、元の配列をコピーする
         self._arr = self._arr + [0] * self.capacity() * (self._extend_ratio - 1)
-        # リストの容量を更新
+        # リストの容量を更新する
         self._capacity = len(self._arr)
 
     def to_array(self) -> list[int]:
-        """有効長のリストを返す"""
+        """有効な長さのリストを返す"""
         return self._arr[: self._size]
 
 
-"""Driver Code"""
+"""実行用コード"""
 if __name__ == "__main__":
-    # リストを初期化
+    # リストを初期化する
     nums = MyList()
-    # 末尾に要素を追加
+    # 末尾に要素を追加する
     nums.add(1)
     nums.add(3)
     nums.add(2)
@@ -95,24 +95,24 @@ if __name__ == "__main__":
     nums.add(4)
     print(f"リスト nums = {nums.to_array()} 、容量 = {nums.capacity()} 、長さ = {nums.size()}")
 
-    # 中間に要素を挿入
+    # 途中に要素を挿入する
     nums.insert(6, index=3)
-    print("インデックス 3 に数値 6 を挿入すると、nums =", nums.to_array())
+    print("インデックス 3 に数値 6 を挿入した結果 nums =", nums.to_array())
 
-    # 要素を削除
+    # 要素を削除する
     nums.remove(3)
-    print("インデックス 3 の要素を削除すると、nums =", nums.to_array())
+    print("インデックス 3 の要素を削除した結果 nums =", nums.to_array())
 
-    # 要素にアクセス
+    # 要素にアクセスする
     num = nums.get(1)
-    print("インデックス 1 の要素にアクセスすると、num =", num)
+    print("インデックス 1 の要素にアクセスした結果 num =", num)
 
-    # 要素を更新
+    # 要素を更新する
     nums.set(0, 1)
-    print("インデックス 1 の要素を 0 に更新すると、nums =", nums.to_array())
+    print("インデックス 1 の要素を 0 に更新した結果 nums =", nums.to_array())
 
-    # 拡張機構をテストする
+    # 容量の拡張をテストする
     for i in range(10):
-        # i = 5 のとき、リスト長が容量を超えるため、この時点で拡張機構が発動する
+        # i = 5 のときにリストの長さが容量を超えるため、容量が拡張される
         nums.add(i)
-    print(f"拡張後のリスト {nums.to_array()} 、容量 = {nums.capacity()} 、長さ = {nums.size()}")
+    print(f"容量を拡張した後のリスト {nums.to_array()} 、容量 = {nums.capacity()} 、長さ = {nums.size()}")