Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

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] から数値をランダムに選択
+    """要素へランダムアクセス"""
+    # 区間 [0, len(nums)-1] からランダムに数字を 1 つ選ぶ
     random_index = random.randint(0, len(nums) - 1)
     # ランダムな要素を取得して返す
     random_num = nums[random_index]
     return random_num
 
 
-# PythonのlistはextendできるDynamic Arrayであることに注意
-# 学習を容易にするため、この関数ではlistをStatic Arrayとして扱う
+# 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,38 +30,38 @@ 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]
-    # num を index の位置の要素に代入
+    # 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
-    # データのインデックスと要素の両方を走査
+    # データのインデックスと要素を同時に走査する
     for i, num in enumerate(nums):
         count += nums[i]
         count += num
 
 
 def find(nums: list[int], target: int) -> int:
-    """配列内の指定された要素を検索"""
+    """配列内で指定要素を探す"""
     for i in range(len(nums)):
         if nums[i] == target:
             return i
@@ -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 =", 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:
@@ -50,36 +50,36 @@ def find(head: ListNode, target: int) -> int:
 
 """Driver Code"""
 if __name__ == "__main__":
-    # 連結リストを初期化
-    # 各ノードを初期化
+    # 連結リストを初期化する
+    # 各ノードを初期化する
     n0 = ListNode(1)
     n1 = ListNode(3)
     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))
 
-    # ノードを検索
+    # ノードを探索
     index: int = find(n0, 2)
-    print("連結リストで値 2 を持つノードのインデックス = {}".format(index))
+    print("連結リスト内で値が 2 のノードのインデックス = {}".format(index))

ja/codes/python/chapter_array_and_linkedlist/list.py

@@ -12,15 +12,15 @@ if __name__ == "__main__":
 
     # 要素にアクセス
     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)
+    print("\nリストを空にした後 nums =", nums)
 
     # 末尾に要素を追加
     nums.append(1)
@@ -28,29 +28,29 @@ if __name__ == "__main__":
     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つのリストを連結
+    # 2 つのリストを連結する
     nums1 = [6, 8, 7, 10, 9]
     nums += nums1
-    print("\nリスト nums1 を nums に連結、結果は nums =", nums)
+    print("\nリスト nums1 を nums の後ろに連結すると、nums =", nums)
 
     # リストをソート
     nums.sort()
-    print("\nリストをソート後、nums =", nums)
+    print("\nリストをソートすると nums =", nums)

ja/codes/python/chapter_array_and_linkedlist/my_list.py

@@ -10,35 +10,35 @@ class MyList:
 
     def __init__(self):
         """コンストラクタ"""
-        self._capacity: int = 10  # リストの容量
+        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("Index out of bounds")
+            raise IndexError("インデックスが範囲外です")
         return self._arr[index]
 
     def set(self, num: int, index: int):
         """要素を更新"""
         if index < 0 or index >= self._size:
-            raise IndexError("Index out of bounds")
+            raise IndexError("インデックスが範囲外です")
         self._arr[index] = num
 
     def add(self, num: int):
         """末尾に要素を追加"""
-        # 要素数が容量を超える場合、拡張メカニズムをトリガー
+        # 要素数が容量を超えると、拡張機構が発動する
         if self.size() == self.capacity():
             self.extend_capacity()
         self._arr[self._size] = num
@@ -47,11 +47,11 @@ class MyList:
     def insert(self, num: int, index: int):
         """中間に要素を挿入"""
         if index < 0 or index >= self._size:
-            raise IndexError("Index out of bounds")
-        # 要素数が容量を超える場合、拡張メカニズムをトリガー
+            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
@@ -61,9 +61,9 @@ class MyList:
     def remove(self, index: int) -> int:
         """要素を削除"""
         if index < 0 or index >= self._size:
-            raise IndexError("Index out of bounds")
+            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]
         # 要素数を更新
@@ -72,14 +72,14 @@ class MyList:
         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]
 
 
@@ -93,26 +93,26 @@ if __name__ == "__main__":
     nums.add(2)
     nums.add(5)
     nums.add(4)
-    print(f"リスト nums = {nums.to_array()} ，容量 = {nums.capacity()} ，長さ = {nums.size()}")
+    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()}")