Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/python/chapter_heap/heap.py

@@ -14,41 +14,41 @@ import heapq
 
 
 def test_push(heap: list, val: int, flag: int = 1):
-    heapq.heappush(heap, flag * val)  # ヒープに要素をプッシュ
-    print(f"\n要素 {val} をヒープにプッシュ後")
+    heapq.heappush(heap, flag * val)  # 要素をヒープに追加
+    print(f"\n要素 {val} をヒープに追加した後")
     print_heap([flag * val for val in heap])
 
 
 def test_pop(heap: list, flag: int = 1):
-    val = flag * heapq.heappop(heap)  # ヒープの先頭要素をポップ
-    print(f"\nヒープの先頭要素 {val} がヒープから出た後")
+    val = flag * heapq.heappop(heap)  # ヒープ頂点の要素を取り出す
+    print(f"\nヒープ先頭要素 {val} を取り出した後")
     print_heap([flag * val for val in heap])
 
 
-"""ドライバコード"""
+"""Driver Code"""
 if __name__ == "__main__":
     # 最小ヒープを初期化
     min_heap, flag = [], 1
     # 最大ヒープを初期化
     max_heap, flag = [], -1
 
-    print("\n以下のテストケースは最大ヒープ用です")
-    # PythonのheapqモジュールはデフォルトでMinHeapを実装
-    # ヒープに入れる前に「要素を反転」することを考慮し、比較演算子を逆転させて最大ヒープを実装
-    # この例では、flag = 1は最小ヒープに対応し、flag = -1は最大ヒープに対応
+    print("\n以下のテストケースは最大ヒープ")
+    # Python の heapq モジュールはデフォルトで最小ヒープを実装している
+    # 要素を負にしてからヒープに入れると大小関係を反転でき、最大ヒープを実現できる
+    # この例では、flag = 1 が最小ヒープ、flag = -1 が最大ヒープに対応する
 
-    # ヒープに要素をプッシュ
+    # 要素をヒープに追加
     test_push(max_heap, 1, flag)
     test_push(max_heap, 3, flag)
     test_push(max_heap, 2, flag)
     test_push(max_heap, 5, flag)
     test_push(max_heap, 4, flag)
 
-    # ヒープの先頭要素にアクセス
+    # ヒープ頂点の要素を取得
     peek: int = flag * max_heap[0]
-    print(f"\nヒープの先頭要素は {peek}")
+    print(f"\nヒープ先頭要素は {peek}")
 
-    # ヒープの先頭要素をポップ
+    # ヒープ頂点の要素を取り出す
     test_pop(max_heap, flag)
     test_pop(max_heap, flag)
     test_pop(max_heap, flag)
@@ -57,15 +57,15 @@ if __name__ == "__main__":
 
     # ヒープのサイズを取得
     size: int = len(max_heap)
-    print(f"\nヒープの要素数は {size}")
+    print(f"\nヒープ要素数は {size}")
 
     # ヒープが空かどうかを判定
     is_empty: bool = not max_heap
-    print(f"\nヒープは空ですか {is_empty}")
+    print(f"\nヒープが空かどうかは {is_empty}")
 
-    # リストを入力してヒープを構築
-    # 時間複雑度はO(n)、O(nlogn)ではない
+    # リストを入力してヒープを構築する
+    # 時間計算量は O(n) であり、O(nlogn) ではない
     min_heap = [1, 3, 2, 5, 4]
     heapq.heapify(min_heap)
-    print("\nリストを入力して最小ヒープを構築")
-    print_heap(min_heap)
+    print("\nリストを入力して最小ヒープを構築した後")
+    print_heap(min_heap)

ja/codes/python/chapter_heap/my_heap.py

@@ -15,24 +15,24 @@ class MaxHeap:
     """最大ヒープ"""
 
     def __init__(self, nums: list[int]):
-        """コンストラクタ、入力リストに基づいてヒープを構築"""
-        # すべてのリスト要素をヒープに追加
+        """コンストラクタ。入力リストに基づいてヒープを構築する"""
+        # リスト要素をそのままヒープに追加
         self.max_heap = nums
-        # 葉以外のすべてのノードをヒープ化
+        # 葉ノード以外のすべてのノードをヒープ化
         for i in range(self.parent(self.size() - 1), -1, -1):
             self.sift_down(i)
 
     def left(self, i: int) -> int:
-        """左の子ノードのインデックスを取得"""
+        """左子ノードのインデックスを取得"""
         return 2 * i + 1
 
     def right(self, i: int) -> int:
-        """右の子ノードのインデックスを取得"""
+        """右子ノードのインデックスを取得"""
         return 2 * i + 2
 
     def parent(self, i: int) -> int:
         """親ノードのインデックスを取得"""
-        return (i - 1) // 2  # 整数除算で切り下げ
+        return (i - 1) // 2  # 切り捨て除算
 
     def swap(self, i: int, j: int):
         """要素を交換"""
@@ -47,91 +47,91 @@ class MaxHeap:
         return self.size() == 0
 
     def peek(self) -> int:
-        """ヒープの先頭要素にアクセス"""
+        """ヒープ先頭要素にアクセス"""
         return self.max_heap[0]
 
     def push(self, val: int):
-        """ヒープに要素をプッシュ"""
+        """要素をヒープに追加"""
         # ノードを追加
         self.max_heap.append(val)
         # 下から上へヒープ化
         self.sift_up(self.size() - 1)
 
     def sift_up(self, i: int):
-        """ノードiから開始して、下から上へヒープ化"""
+        """ノード i から始めて、下から上へヒープ化"""
         while True:
-            # ノードiの親ノードを取得
+            # ノード i の親ノードを取得
             p = self.parent(i)
-            # 「ルートノードを越える」または「ノードが修復不要」の場合、ヒープ化を終了
+            # 「根ノードを越えた」または「ノードの修復が不要」になったらヒープ化を終了
             if p < 0 or self.max_heap[i] <= self.max_heap[p]:
                 break
-            # 2つのノードを交換
+            # 2 つのノードを交換
             self.swap(i, p)
-            # 上向きのループヒープ化
+            # ループで下から上へヒープ化
             i = p
 
     def pop(self) -> int:
-        """要素をヒープから出す"""
-        # 空の処理
+        """要素をヒープから取り出す"""
+        # 空判定の処理
         if self.is_empty():
-            raise IndexError("Heap is empty")
-        # ルートノードと最右端の葉ノードを交換（最初の要素と最後の要素を交換）
+            raise IndexError("ヒープが空です")
+        # 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
         self.swap(0, self.size() - 1)
         # ノードを削除
         val = self.max_heap.pop()
         # 上から下へヒープ化
         self.sift_down(0)
-        # ヒープの先頭要素を返す
+        # ヒープ先頭要素を返す
         return val
 
     def sift_down(self, i: int):
-        """ノードiから開始して、上から下へヒープ化"""
+        """ノード i から始めて、上から下へヒープ化"""
         while True:
-            # i、l、rの中で最大のノードを決定し、maとする
+            # ノード i, l, r のうち値が最大のノードを ma とする
             l, r, ma = self.left(i), self.right(i), i
             if l < self.size() and self.max_heap[l] > self.max_heap[ma]:
                 ma = l
             if r < self.size() and self.max_heap[r] > self.max_heap[ma]:
                 ma = r
-            # ノードiが最大またはインデックスl、rが範囲外の場合、さらなるヒープ化は不要、ブレーク
+            # ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
             if ma == i:
                 break
-            # 2つのノードを交換
+            # 2 つのノードを交換
             self.swap(i, ma)
-            # 下向きのループヒープ化
+            # ループで上から下へヒープ化
             i = ma
 
     def print(self):
-        """ヒープを出力（二分木）"""
+        """ヒープ（二分木）を出力"""
         print_heap(self.max_heap)
 
 
-"""ドライバコード"""
+"""Driver Code"""
 if __name__ == "__main__":
     # 最大ヒープを初期化
     max_heap = MaxHeap([9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2])
-    print("\nリストを入力してヒープを構築")
+    print("\nリストを入力してヒープを構築した後")
     max_heap.print()
 
-    # ヒープの先頭要素にアクセス
+    # ヒープ頂点の要素を取得
     peek = max_heap.peek()
-    print(f"\nヒープの先頭要素は {peek}")
+    print(f"\nヒープ先頭要素は {peek}")
 
-    # ヒープに要素をプッシュ
+    # 要素をヒープに追加
     val = 7
     max_heap.push(val)
-    print(f"\n要素 {val} をヒープにプッシュ後")
+    print(f"\n要素 {val} をヒープに追加した後")
     max_heap.print()
 
-    # ヒープの先頭要素をポップ
+    # ヒープ頂点の要素を取り出す
     peek = max_heap.pop()
-    print(f"\nヒープの先頭要素 {peek} がヒープから出た後")
+    print(f"\nヒープ先頭要素 {peek} を取り出した後")
     max_heap.print()
 
     # ヒープのサイズを取得
     size = max_heap.size()
-    print(f"\nヒープの要素数は {size}")
+    print(f"\nヒープ要素数は {size}")
 
     # ヒープが空かどうかを判定
     is_empty = max_heap.is_empty()
-    print(f"\nヒープは空ですか {is_empty}")
+    print(f"\nヒープが空かどうかは {is_empty}")

ja/codes/python/chapter_heap/top_k.py

@@ -14,26 +14,26 @@ import heapq
 
 
 def top_k_heap(nums: list[int], k: int) -> list[int]:
-    """ヒープを使用して配列内の最大k個の要素を見つける"""
+    """ヒープに基づいて配列中の最大の k 個の要素を探す"""
     # 最小ヒープを初期化
     heap = []
-    # 配列の最初のk個の要素をヒープに入力
+    # 配列の先頭 k 個の要素をヒープに追加
     for i in range(k):
         heapq.heappush(heap, nums[i])
-    # k+1番目の要素から、ヒープの長さをkに保つ
+    # k+1 番目の要素から開始し、ヒープ長を k に保つ
     for i in range(k, len(nums)):
-        # 現在の要素がヒープの先頭要素より大きい場合、ヒープの先頭要素を削除し、現在の要素をヒープに入力
+        # 現在の要素がヒープ先頭より大きければ、ヒープ先頭を取り出して現在の要素を追加する
         if nums[i] > heap[0]:
             heapq.heappop(heap)
             heapq.heappush(heap, nums[i])
     return heap
 
 
-"""ドライバコード"""
+"""Driver Code"""
 if __name__ == "__main__":
     nums = [1, 7, 6, 3, 2]
     k = 3
 
     res = top_k_heap(nums, k)
     print(f"最大の {k} 個の要素は")
-    print_heap(res)
+    print_heap(res)