xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-11-04 20:22:14 +08:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* 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
This commit is contained in:
Yudong Jin
2026-10-30 02:12:26 +08:00
committed by GitHub
parent 455e8c1281
commit 7257641e0e
1987 changed files with 23531 additions and 23261 deletions
Download Patch File Download Diff File Expand all files Collapse all files
ja/codes/python/chapter_sorting/bubble_sort.py
+8 -8
View File
@@ -10,30 +10,30 @@ def bubble_sort(nums: list[int]):
n = len(nums)
# 外側のループ：未ソート区間は [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] を交換
# nums[j] と nums[j + 1] を交換する
nums[j], nums[j + 1] = nums[j + 1], nums[j]
def bubble_sort_with_flag(nums: list[int]):
"""バブルソート（フラグ最適化）"""
"""バブルソート（フラグによる最適化）"""
n = len(nums)
# 外側のループ：未ソート区間は [0, i]
for i in range(n - 1, 0, -1):
flag = False # フラグを初期化する
# 内側のループ：未ソート区間 [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] を交換する
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)
ja/codes/python/chapter_sorting/bucket_sort.py
+6 -6
View File
@@ -7,20 +7,20 @@ Author: krahets ([email protected])
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 に追加
# num をバケット i に追加する
buckets[i].append(num)
# 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)
ja/codes/python/chapter_sorting/counting_sort.py
+14 -14
View File
@@ -6,8 +6,8 @@ Author: krahets ([email protected])
def counting_sort_naive(nums: list[int]):
"""計数ソート"""
# 簡易版。オブジェクトのソートには使えない
"""カウントソート"""
# 簡易実装。オブジェクトのソートには使えない
# 1. 配列の最大要素 m を求める
m = max(nums)
# 2. 各数値の出現回数を数える
@@ -15,7 +15,7 @@ def counting_sort_naive(nums: list[int]):
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]):
@@ -24,8 +24,8 @@ def counting_sort_naive(nums: list[int]):
def counting_sort(nums: list[int]):
"""計数ソート"""
# 完全版。オブジェクトをソートでき、かつ安定ソートである
"""カウントソート"""
# 完全な実装。オブジェクトをソートでき、安定ソートである
# 1. 配列の最大要素 m を求める
m = max(nums)
# 2. 各数値の出現回数を数える
@@ -33,30 +33,30 @@ def counting_sort(nums: list[int]):
counter = [0] * (m + 1)
for num in nums:
counter[num] += 1
# 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する
# つまり counter[num]-1 は、num が res に最後に現れるインデックス
# 3. counter の累積和を求め、「出現回数」を「末尾のインデックス」に変換する
# つまり、counter[num]-1 は res 内で num が最後に現れるインデックスである
for i in range(m):
counter[i + 1] += counter[i]
# 4. nums を逆順に走査し、各要素を結果配列 res に格納する
# 結果を記録するための配列 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[counter[num] - 1] = num # 対応するインデックスに num を配置する
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
+10 -10
View File
@@ -6,9 +6,9 @@ Author: krahets ([email protected])
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,29 +16,29 @@ 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)
ja/codes/python/chapter_sorting/insertion_sort.py
+5 -5
View File
@@ -7,18 +7,18 @@ Author: timi ([email protected])
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] の正しい位置に挿入する
# 内側のループ：ソート済み区間 [0, i-1] の正しい位置に base を挿入する
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)
ja/codes/python/chapter_sorting/merge_sort.py
+13 -13
View File
@@ -6,13 +6,13 @@ Author: timi ([email protected]), krahets ([email protected])
def merge(nums: list[int], left: int, mid: int, right: int):
"""左部分配列と右部分配列をマージ"""
"""左部分配列と右部分配列をマージする"""
# 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]
# マージ結果を格納する一時配列 tmp を作成
# マージ後の結果を格納する一時配列 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,16 +39,16 @@ def merge_sort(nums: list[int], left: int, right: int):
"""マージソート"""
# 終了条件
if left >= right:
return # 部分配列の長さが 1 になったら再帰を終了
# 分割フェーズ
mid = (left + right) // 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)
ja/codes/python/chapter_sorting/quick_sort.py
+43 -43
View File
@@ -9,121 +9,121 @@ 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)
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 の間
return mid # m が l と r の間にある
if (m <= l <= r) or (r <= l <= m):
return left # l は m と r の間
return left # l が m と r の間にある
return right
def partition(self, nums: list[int], left: int, right: int) -> int:
"""番兵による分割処理（3 点中央値）"""
# 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 つの部分配列のうち短いほうにクイックソートを適用する
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)
# クイックソート（中央値の基準値で最適化）
# クイックソート（中央値ピボットによる最適化）
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
+14 -14
View File
@@ -6,29 +6,29 @@ Author: krahets ([email protected])
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 桁に基づくソート）"""
# 十進数の各桁の範囲は 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 とする
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 に格納する
j = counter[d] - 1 # 配列内での d のインデックス j を取得する
res[j] = nums[i] # 現在の要素をインデックス j に入れる
counter[d] -= 1 # d の個数を 1 減らす
# 結果で元の配列 nums を上書きする
for i in range(n):
@@ -37,12 +37,12 @@ def counting_sort_digit(nums: list[int], exp: int):
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)
@@ -50,7 +50,7 @@ def radix_sort(nums: list[int]):
exp *= 10
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
# 基数ソート
nums = [
ja/codes/python/chapter_sorting/selection_sort.py
+5 -5
View File
@@ -8,18 +8,18 @@ Author: krahets ([email protected])
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 # 最小要素のインデックスを記録
# その最小要素を未整列区間の先頭要素と交換する
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)