Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/python/chapter_sorting/bubble_sort.py

@@ -8,9 +8,9 @@ Author: timi (xisunyy@163.com)
 def bubble_sort(nums: list[int]):
     """バブルソート"""
     n = len(nums)
-    # 外側のループ：未ソート範囲は [0, i]
+    # 外側のループ：未ソート区間は [0, i]
     for i in range(n - 1, 0, -1):
-        # 内側のループ：未ソート範囲 [0, i] の最大要素を範囲の右端に移動
+        # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
         for j in range(i):
             if nums[j] > nums[j + 1]:
                 # nums[j] と nums[j + 1] を交換
@@ -18,27 +18,27 @@ def bubble_sort(nums: list[int]):
 
 
 def bubble_sort_with_flag(nums: list[int]):
-    """バブルソート（フラグによる最適化）"""
+    """バブルソート（フラグ最適化）"""
     n = len(nums)
-    # 外側のループ：未ソート範囲は [0, i]
+    # 外側のループ：未ソート区間は [0, i]
     for i in range(n - 1, 0, -1):
-        flag = False  # フラグを初期化
-        # 内側のループ：未ソート範囲 [0, i] の最大要素を範囲の右端に移動
+        flag = False  # フラグを初期化する
+        # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
         for j in range(i):
             if nums[j] > nums[j + 1]:
                 # nums[j] と nums[j + 1] を交換
                 nums[j], nums[j + 1] = nums[j + 1], nums[j]
-                flag = True  # 要素を交換したことを記録
+                flag = True  # 交換する要素を記録
         if not flag:
-            break  # この回の「バブリング」で要素が交換されなかった場合、終了
+            break  # このバブル処理で要素交換が一度もなければそのまま終了
 
 
-"""ドライバーコード"""
+"""Driver Code"""
 if __name__ == "__main__":
     nums = [4, 1, 3, 1, 5, 2]
     bubble_sort(nums)
-    print("バブルソート完了 nums =", nums)
+    print("バブルソート完了後 nums =", nums)
 
     nums1 = [4, 1, 3, 1, 5, 2]
     bubble_sort_with_flag(nums1)
-    print("バブルソート完了 nums =", nums1)
+    print("バブルソート完了後 nums =", nums1)

ja/codes/python/chapter_sorting/bucket_sort.py

@@ -7,20 +7,20 @@ Author: krahets (krahets@163.com)
 
 def bucket_sort(nums: list[float]):
     """バケットソート"""
-    # k = n/2 個のバケットを初期化、各バケットに平均2個の要素を配置することを期待
+    # k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする
     k = len(nums) // 2
     buckets = [[] for _ in range(k)]
-    # 1. 配列要素を各バケットに分散
+    # 1. 配列要素を各バケットに振り分ける
     for num in nums:
-        # 入力データ範囲は [0, 1)、num * k を使用してインデックス範囲 [0, k-1] にマッピング
+        # 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する
         i = int(num * k)
         # num をバケット i に追加
         buckets[i].append(num)
-    # 2. 各バケットをソート
+    # 2. 各バケットをソートする
     for bucket in buckets:
-        # 組み込みソート関数を使用、他のソートアルゴリズムに置き換えることも可能
+        # 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい
         bucket.sort()
-    # 3. バケットを走査して結果をマージ
+    # 3. バケットを走査して結果を結合
     i = 0
     for bucket in buckets:
         for num in bucket:
@@ -29,7 +29,7 @@ def bucket_sort(nums: list[float]):
 
 
 if __name__ == "__main__":
-    # 入力データが浮動小数点数、範囲 [0, 1) であると仮定
+    # 入力データは範囲 [0, 1) の浮動小数点数とする
     nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37]
     bucket_sort(nums)
-    print("バケットソート完了 nums =", nums)
+    print("バケットソート完了後 nums =", nums)

ja/codes/python/chapter_sorting/counting_sort.py

@@ -7,17 +7,15 @@ Author: krahets (krahets@163.com)
 
 def counting_sort_naive(nums: list[int]):
     """計数ソート"""
-    # シンプルな実装、オブジェクトのソートには使用できない
-    # 1. 配列内の最大要素 m を統計
-    m = 0
-    for num in nums:
-        m = max(m, num)
-    # 2. 各数字の出現回数を統計
+    # 簡易版。オブジェクトのソートには使えない
+    # 1. 配列の最大要素 m を求める
+    m = max(nums)
+    # 2. 各数値の出現回数を数える
     # counter[num] は num の出現回数を表す
     counter = [0] * (m + 1)
     for num in nums:
         counter[num] += 1
-    # 3. counter を走査し、各要素を元の配列 nums に埋め戻し
+    # 3. counter を走査し、各要素を元の配列 nums に書き戻す
     i = 0
     for num in range(m + 1):
         for _ in range(counter[num]):
@@ -27,38 +25,38 @@ def counting_sort_naive(nums: list[int]):
 
 def counting_sort(nums: list[int]):
     """計数ソート"""
-    # 完全な実装、オブジェクトのソートが可能で、安定ソート
-    # 1. 配列内の最大要素 m を統計
+    # 完全版。オブジェクトをソートでき、かつ安定ソートである
+    # 1. 配列の最大要素 m を求める
     m = max(nums)
-    # 2. 各数字の出現回数を統計
+    # 2. 各数値の出現回数を数える
     # counter[num] は num の出現回数を表す
     counter = [0] * (m + 1)
     for num in nums:
         counter[num] += 1
-    # 3. counter の前置和を計算し、「出現回数」を「末尾インデックス」に変換
-    # counter[num]-1 は res において num が最後に出現するインデックス
+    # 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する
+    # つまり counter[num]-1 は、num が res に最後に現れるインデックス
     for i in range(m):
         counter[i + 1] += counter[i]
-    # 4. nums を逆順に走査し、各要素を結果配列 res に配置
+    # 4. nums を逆順に走査し、各要素を結果配列 res に格納する
     # 結果を記録するための配列 res を初期化
     n = len(nums)
     res = [0] * n
     for i in range(n - 1, -1, -1):
         num = nums[i]
         res[counter[num] - 1] = num  # num を対応するインデックスに配置
-        counter[num] -= 1  # 前置和を1減らし、num を配置する次のインデックスを取得
-    # 結果配列 res を使用して元の配列 nums を上書き
+        counter[num] -= 1  # 累積和を 1 減らして、次に num を配置するインデックスを得る
+    # 結果配列 res で元の配列 nums を上書きする
     for i in range(n):
         nums[i] = res[i]
 
 
-"""ドライバーコード"""
+"""Driver Code"""
 if __name__ == "__main__":
     nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
 
     counting_sort_naive(nums)
-    print(f"計数ソート（オブジェクトソート不可）完了 nums = {nums}")
+    print(f"計数ソート（オブジェクトはソート不可）完了後 nums = {nums}")
 
     nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
     counting_sort(nums1)
-    print(f"計数ソート完了 nums1 = {nums1}")
+    print(f"計数ソート完了後 nums1 = {nums1}")

ja/codes/python/chapter_sorting/heap_sort.py

@@ -6,9 +6,9 @@ Author: krahets (krahets@163.com)
 
 
 def sift_down(nums: list[int], n: int, i: int):
-    """ヒープの長さが n、ノード i から上から下へヒープ化を開始"""
+    """ヒープの長さは n。ノード i から下方向にヒープ化"""
     while True:
-        # i、l、r の中で最大のノードを判定し、ma とする
+        # ノード i, l, r のうち値が最大のノードを ma とする
         l = 2 * i + 1
         r = 2 * i + 2
         ma = i
@@ -16,30 +16,30 @@ def sift_down(nums: list[int], n: int, i: int):
             ma = l
         if r < n and nums[r] > nums[ma]:
             ma = r
-        # ノード i が最大または l、r のインデックスが範囲外の場合、さらなるヒープ化は不要、ループを抜ける
+        # ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
         if ma == i:
             break
-        # 2つのノードを交換
+        # 2 つのノードを交換
         nums[i], nums[ma] = nums[ma], nums[i]
-        # 下向きにヒープ化をループ
+        # ループで上から下へヒープ化
         i = ma
 
 
 def heap_sort(nums: list[int]):
     """ヒープソート"""
-    # ヒープ構築操作：葉ノード以外のすべてのノードをヒープ化
+    # ヒープ構築：葉ノード以外のすべてのノードをヒープ化する
     for i in range(len(nums) // 2 - 1, -1, -1):
         sift_down(nums, len(nums), i)
-    # ヒープから最大要素を抽出し、n-1 回繰り返す
+    # ヒープから最大要素を取り出し、n-1 回繰り返す
     for i in range(len(nums) - 1, 0, -1):
-        # ルートノードと最も右の葉ノードを交換（最初の要素と最後の要素を交換）
+        # 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
         nums[0], nums[i] = nums[i], nums[0]
-        # ルートノードから上から下へヒープ化を開始
+        # 根ノードを起点に、上から下へヒープ化
         sift_down(nums, i, 0)
 
 
-"""ドライバーコード"""
+"""Driver Code"""
 if __name__ == "__main__":
     nums = [4, 1, 3, 1, 5, 2]
     heap_sort(nums)
-    print("ヒープソート完了 nums =", nums)
+    print("ヒープソート完了後 nums =", nums)

ja/codes/python/chapter_sorting/insertion_sort.py

@@ -7,19 +7,19 @@ Author: timi (xisunyy@163.com)
 
 def insertion_sort(nums: list[int]):
     """挿入ソート"""
-    # 外側のループ：ソート済み範囲は [0, i-1]
+    # 外側ループ：整列済み区間は [0, i-1]
     for i in range(1, len(nums)):
         base = nums[i]
         j = i - 1
-        # 内側のループ：base をソート済み範囲 [0, i-1] の正しい位置に挿入
+        # 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する
         while j >= 0 and nums[j] > base:
-            nums[j + 1] = nums[j]  # nums[j] を右に1つ移動
+            nums[j + 1] = nums[j]  # nums[j] を 1 つ右へ移動する
             j -= 1
-        nums[j + 1] = base  # base を正しい位置に代入
+        nums[j + 1] = base  # base を正しい位置に配置する
 
 
-"""ドライバーコード"""
+"""Driver Code"""
 if __name__ == "__main__":
     nums = [4, 1, 3, 1, 5, 2]
     insertion_sort(nums)
-    print("挿入ソート完了 nums =", nums)
+    print("挿入ソート完了後 nums =", nums)

ja/codes/python/chapter_sorting/merge_sort.py

@@ -6,13 +6,13 @@ Author: timi (xisunyy@163.com), krahets (krahets@163.com)
 
 
 def merge(nums: list[int], left: int, mid: int, right: int):
-    """左サブ配列と右サブ配列をマージ"""
-    # 左サブ配列区間は [left, mid]、右サブ配列区間は [mid+1, right]
-    # 一時配列 tmp を作成してマージ結果を格納
+    """左部分配列と右部分配列をマージ"""
+    # 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]
+    # マージ結果を格納する一時配列 tmp を作成
     tmp = [0] * (right - left + 1)
-    # 左右サブ配列の開始インデックスを初期化
+    # 左右の部分配列の開始インデックスを初期化する
     i, j, k = left, mid + 1, 0
-    # 両方のサブ配列に要素が残っている間、より小さい要素を一時配列にコピー
+    # 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする
     while i <= mid and j <= right:
         if nums[i] <= nums[j]:
             tmp[k] = nums[i]
@@ -21,7 +21,7 @@ def merge(nums: list[int], left: int, mid: int, right: int):
             tmp[k] = nums[j]
             j += 1
         k += 1
-    # 残った左右サブ配列の要素を一時配列にコピー
+    # 左右の部分配列の残り要素を一時配列にコピーする
     while i <= mid:
         tmp[k] = nums[i]
         i += 1
@@ -30,7 +30,7 @@ def merge(nums: list[int], left: int, mid: int, right: int):
         tmp[k] = nums[j]
         j += 1
         k += 1
-    # 一時配列 tmp の要素を元の配列 nums の対応する区間にコピーバック
+    # 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする
     for k in range(0, len(tmp)):
         nums[left + k] = tmp[k]
 
@@ -39,17 +39,17 @@ def merge_sort(nums: list[int], left: int, right: int):
     """マージソート"""
     # 終了条件
     if left >= right:
-        return  # サブ配列の長さが1のときに再帰を終了
-    # 分割段階
-    mid = left + (right - left) // 2  # 中点を計算
-    merge_sort(nums, left, mid)  # 左サブ配列を再帰的に処理
-    merge_sort(nums, mid + 1, right)  # 右サブ配列を再帰的に処理
-    # マージ段階
+        return  # 部分配列の長さが 1 になったら再帰を終了
+    # 分割フェーズ
+    mid = (left + right) // 2 # 中点を計算
+    merge_sort(nums, left, mid)  # 左部分配列を再帰処理
+    merge_sort(nums, mid + 1, right)  # 右部分配列を再帰処理
+    # マージフェーズ
     merge(nums, left, mid, right)
 
 
-"""ドライバーコード"""
+"""Driver Code"""
 if __name__ == "__main__":
     nums = [7, 3, 2, 6, 0, 1, 5, 4]
     merge_sort(nums, 0, len(nums) - 1)
-    print("マージソート完了 nums =", nums)
+    print("マージソート完了後 nums =", nums)

ja/codes/python/chapter_sorting/quick_sort.py

@@ -9,28 +9,28 @@ class QuickSort:
     """クイックソートクラス"""
 
     def partition(self, nums: list[int], left: int, right: int) -> int:
-        """分割"""
-        # nums[left] をピボットとして使用
+        """番兵分割"""
+        # nums[left] を基準値とする
         i, j = left, right
         while i < j:
             while i < j and nums[j] >= nums[left]:
-                j -= 1  # 右から左へピボットより小さい最初の要素を探す
+                j -= 1  # 右から左へ基準値未満の最初の要素を探す
             while i < j and nums[i] <= nums[left]:
-                i += 1  # 左から右へピボットより大きい最初の要素を探す
-            # 要素を交換
+                i += 1  # 左から右へ基準値より大きい最初の要素を探す
+            # 要素の交換
             nums[i], nums[j] = nums[j], nums[i]
-        # ピボットを2つのサブ配列の境界に交換
+        # 基準値を 2 つの部分配列の境界へ交換する
         nums[i], nums[left] = nums[left], nums[i]
-        return i  # ピボットのインデックスを返す
+        return i  # 基準値のインデックスを返す
 
     def quick_sort(self, nums: list[int], left: int, right: int):
         """クイックソート"""
-        # サブ配列の長さが1のときに再帰を終了
+        # 部分配列の長さが 1 なら再帰を終了する
         if left >= right:
             return
-        # 分割
+        # 番兵分割
         pivot = self.partition(nums, left, right)
-        # 左サブ配列と右サブ配列を再帰的に処理
+        # 左右の部分配列を再帰処理
         self.quick_sort(nums, left, pivot - 1)
         self.quick_sort(nums, pivot + 1, right)
 
@@ -39,7 +39,7 @@ class QuickSortMedian:
     """クイックソートクラス（中央値ピボット最適化）"""
 
     def median_three(self, nums: list[int], left: int, mid: int, right: int) -> int:
-        """3つの候補要素の中央値を選択"""
+        """3つの候補要素の中央値を選ぶ"""
         l, m, r = nums[left], nums[mid], nums[right]
         if (l <= m <= r) or (r <= m <= l):
             return mid  # m は l と r の間
@@ -48,82 +48,82 @@ class QuickSortMedian:
         return right
 
     def partition(self, nums: list[int], left: int, right: int) -> int:
-        """分割（三点中央値）"""
-        # nums[left] をピボットとして使用
+        """番兵による分割処理（3 点中央値）"""
+        # nums[left] を基準値とする
         med = self.median_three(nums, left, (left + right) // 2, right)
-        # 中央値を配列の最左端に交換
+        # 中央値を配列の最左端に交換する
         nums[left], nums[med] = nums[med], nums[left]
-        # nums[left] をピボットとして使用
+        # nums[left] を基準値とする
         i, j = left, right
         while i < j:
             while i < j and nums[j] >= nums[left]:
-                j -= 1  # 右から左へピボットより小さい最初の要素を探す
+                j -= 1  # 右から左へ基準値未満の最初の要素を探す
             while i < j and nums[i] <= nums[left]:
-                i += 1  # 左から右へピボットより大きい最初の要素を探す
-            # 要素を交換
+                i += 1  # 左から右へ基準値より大きい最初の要素を探す
+            # 要素の交換
             nums[i], nums[j] = nums[j], nums[i]
-        # ピボットを2つのサブ配列の境界に交換
+        # 基準値を 2 つの部分配列の境界へ交換する
         nums[i], nums[left] = nums[left], nums[i]
-        return i  # ピボットのインデックスを返す
+        return i  # 基準値のインデックスを返す
 
     def quick_sort(self, nums: list[int], left: int, right: int):
         """クイックソート"""
-        # サブ配列の長さが1のときに再帰を終了
+        # 部分配列の長さが 1 なら再帰を終了する
         if left >= right:
             return
-        # 分割
+        # 番兵分割
         pivot = self.partition(nums, left, right)
-        # 左サブ配列と右サブ配列を再帰的に処理
+        # 左右の部分配列を再帰処理
         self.quick_sort(nums, left, pivot - 1)
         self.quick_sort(nums, pivot + 1, right)
 
 
 class QuickSortTailCall:
-    """クイックソートクラス（末尾再帰最適化）"""
+    """クイックソートクラス（再帰深度最適化）"""
 
     def partition(self, nums: list[int], left: int, right: int) -> int:
-        """分割"""
-        # nums[left] をピボットとして使用
+        """番兵分割"""
+        # nums[left] を基準値とする
         i, j = left, right
         while i < j:
             while i < j and nums[j] >= nums[left]:
-                j -= 1  # 右から左へピボットより小さい最初の要素を探す
+                j -= 1  # 右から左へ基準値未満の最初の要素を探す
             while i < j and nums[i] <= nums[left]:
-                i += 1  # 左から右へピボットより大きい最初の要素を探す
-            # 要素を交換
+                i += 1  # 左から右へ基準値より大きい最初の要素を探す
+            # 要素の交換
             nums[i], nums[j] = nums[j], nums[i]
-        # ピボットを2つのサブ配列の境界に交換
+        # 基準値を 2 つの部分配列の境界へ交換する
         nums[i], nums[left] = nums[left], nums[i]
-        return i  # ピボットのインデックスを返す
+        return i  # 基準値のインデックスを返す
 
     def quick_sort(self, nums: list[int], left: int, right: int):
-        """クイックソート（末尾再帰最適化）"""
-        # サブ配列の長さが1のときに終了
+        """クイックソート（再帰深度最適化）"""
+        # 部分配列の長さが 1 なら終了
         while left < right:
-            # 分割操作
+            # 番兵による分割処理
             pivot = self.partition(nums, left, right)
-            # 2つのサブ配列のうち短い方に対してクイックソートを実行
+            # 2 つの部分配列のうち短いほうにクイックソートを適用する
             if pivot - left < right - pivot:
-                self.quick_sort(nums, left, pivot - 1)  # 左サブ配列を再帰的にソート
-                left = pivot + 1  # 残りの未ソート区間は [pivot + 1, right]
+                self.quick_sort(nums, left, pivot - 1)  # 左部分配列を再帰的にソート
+                left = pivot + 1  # 未ソート区間の残りは [pivot + 1, right]
             else:
-                self.quick_sort(nums, pivot + 1, right)  # 右サブ配列を再帰的にソート
-                right = pivot - 1  # 残りの未ソート区間は [left, pivot - 1]
+                self.quick_sort(nums, pivot + 1, right)  # 右部分配列を再帰的にソート
+                right = pivot - 1  # 未ソート区間の残りは [left, pivot - 1]
 
 
-"""ドライバーコード"""
+"""Driver Code"""
 if __name__ == "__main__":
     # クイックソート
     nums = [2, 4, 1, 0, 3, 5]
     QuickSort().quick_sort(nums, 0, len(nums) - 1)
-    print("クイックソート完了 nums =", nums)
+    print("クイックソート完了後 nums =", nums)
 
-    # クイックソート（中央値ピボット最適化）
+    # クイックソート（中央値の基準値で最適化）
     nums1 = [2, 4, 1, 0, 3, 5]
     QuickSortMedian().quick_sort(nums1, 0, len(nums1) - 1)
-    print("クイックソート（中央値ピボット最適化）完了 nums =", nums1)
+    print("クイックソート（中央値ピボット最適化）完了後 nums =", nums1)
 
-    # クイックソート（末尾再帰最適化）
+    # クイックソート（再帰深度最適化）
     nums2 = [2, 4, 1, 0, 3, 5]
     QuickSortTailCall().quick_sort(nums2, 0, len(nums2) - 1)
-    print("クイックソート（末尾再帰最適化）完了 nums =", nums2)
+    print("クイックソート（再帰深度最適化）完了後 nums =", nums2)

ja/codes/python/chapter_sorting/radix_sort.py

@@ -6,51 +6,51 @@ Author: krahets (krahets@163.com)
 
 
 def digit(num: int, exp: int) -> int:
-    """要素 num の k 番目の桁を取得、exp = 10^(k-1)"""
-    # k の代わりに exp を渡すことで、ここでコストの高い累乗計算を避けることができる
+    """要素 num の下から k 桁目を取得（exp = 10^(k-1)）"""
+    # ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す
     return (num // exp) % 10
 
 
 def counting_sort_digit(nums: list[int], exp: int):
-    """計数ソート（nums の k 番目の桁に基づく）"""
-    # 10進数の桁の範囲は 0~9、したがって長さ10のバケット配列が必要
+    """計数ソート（nums の k 桁目でソート）"""
+    # 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要
     counter = [0] * 10
     n = len(nums)
-    # 数字 0~9 の出現回数を統計
+    # 0~9 の各数字の出現回数を集計する
     for i in range(n):
-        d = digit(nums[i], exp)  # nums[i] の k 番目の桁を取得、d とする
-        counter[d] += 1  # 数字 d の出現回数を統計
-    # 前置和を計算し、「出現回数」を「配列インデックス」に変換
+        d = digit(nums[i], exp)  # nums[i] の第 k 位を取得し、d とする
+        counter[d] += 1  # 数字 d の出現回数を数える
+    # 累積和を求め、「出現回数」を「配列インデックス」に変換する
     for i in range(1, 10):
         counter[i] += counter[i - 1]
-    # 逆順に走査し、バケット統計に基づいて各要素を res に配置
+    # 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する
     res = [0] * n
     for i in range(n - 1, -1, -1):
         d = digit(nums[i], exp)
-        j = counter[d] - 1  # 配列内の d のインデックス j を取得
-        res[j] = nums[i]  # 現在の要素をインデックス j に配置
-        counter[d] -= 1  # d の数を1減らす
-    # 結果を使用して元の配列 nums を上書き
+        j = counter[d] - 1  # d の配列内インデックス j を取得する
+        res[j] = nums[i]  # 現在の要素をインデックス j に格納する
+        counter[d] -= 1  # d の個数を 1 減らす
+    # 結果で元の配列 nums を上書きする
     for i in range(n):
         nums[i] = res[i]
 
 
 def radix_sort(nums: list[int]):
     """基数ソート"""
-    # 配列の最大要素を取得し、最大桁数を判定するために使用
+    # 最大桁数の判定用に配列の最大要素を取得
     m = max(nums)
-    # 最下位桁から最上位桁まで走査
+    # 下位桁から上位桁の順に走査する
     exp = 1
     while exp <= m:
-        # 配列要素の k 番目の桁に対して計数ソートを実行
+        # 配列要素の k 桁目に対して計数ソートを行う
         # k = 1 -> exp = 1
         # k = 2 -> exp = 10
-        # つまり、exp = 10^(k-1)
+        # つまり exp = 10^(k-1)
         counting_sort_digit(nums, exp)
         exp *= 10
 
 
-"""ドライバーコード"""
+"""Driver Code"""
 if __name__ == "__main__":
     # 基数ソート
     nums = [
@@ -66,4 +66,4 @@ if __name__ == "__main__":
         63832996,
     ]
     radix_sort(nums)
-    print("基数ソート完了 nums =", nums)
+    print("基数ソート完了後 nums =", nums)

ja/codes/python/chapter_sorting/selection_sort.py

@@ -8,19 +8,19 @@ Author: krahets (krahets@163.com)
 def selection_sort(nums: list[int]):
     """選択ソート"""
     n = len(nums)
-    # 外側のループ：未ソート範囲は [i, n-1]
+    # 外側ループ：未整列区間は [i, n-1]
     for i in range(n - 1):
-        # 内側のループ：未ソート範囲内で最小要素を見つける
+        # 内側のループ：未ソート区間の最小要素を見つける
         k = i
         for j in range(i + 1, n):
             if nums[j] < nums[k]:
                 k = j  # 最小要素のインデックスを記録
-        # 最小要素を未ソート範囲の先頭要素と交換
+        # その最小要素を未整列区間の先頭要素と交換する
         nums[i], nums[k] = nums[k], nums[i]
 
 
-"""ドライバーコード"""
+"""Driver Code"""
 if __name__ == "__main__":
     nums = [4, 1, 3, 1, 5, 2]
     selection_sort(nums)
-    print("選択ソート完了 nums =", nums)
+    print("選択ソート完了後 nums =", nums)