CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-06-16 23:27:59 +08:00
Code Issues Packages Projects Releases Wiki Activity

Re-translate the Japanese version (#1871)

Browse Source 
* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4
This commit is contained in:
Yudong Jin
2026-03-30 07:30:15 +08:00
committed by GitHub
parent fe6443235b
commit d7b2277d2b
1444 changed files with 83312 additions and 8363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
ja/codes/python/chapter_searching/binary_search.py
View File

@@ -6,47 +6,47 @@ Author: timi (xisunyy@163.com)
def binary_search(nums: list[int], target: int) -> int:
"""二分探索（両端閉区間）"""
# 両端閉区間 [0, n-1] を初期化、すなわち i, j はそれぞれ配列の最初の要素と最後の要素を指す
"""二分探索（両閉区間）"""
# 両閉区間 [0, n-1] を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素を指す
i, j = 0, len(nums) - 1
# 検索区間が空になるまでループ（i > j のとき空）
# ループし、探索区間が空になったら終了する（i > j で空）
while i <= j:
# 理論的には、Pythonの数値は無限に大きくなることができる（メモリサイズに依存）ため、大きな数のオーバーフローを考慮する必要はない
m = i + (j - i) // 2 # 中点インデックス m を計算
# 理論上、Python の数値は無限に大きくできるため（メモリ容量に依存）、大きな数のオーバーフローを考慮する必要はない
m = (i + j) // 2 # 中点インデックス m を計算
if nums[m] < target:
i = m + 1 # この場合、target は区間 [m+1, j] にあることを示す
i = m + 1 # この場合、target は区間 [m+1, j] にある
elif nums[m] > target:
j = m - 1 # この場合、target は区間 [i, m-1] にあることを示す
j = m - 1 # この場合、target は区間 [i, m-1] にある
else:
return m # ターゲット要素が見つかったため、そのインデックスを返す
return -1 # ターゲット要素が見つからなかったため、-1 を返す
return m # 目標要素が見つかったらそのインデックスを返す
return -1 # 目標要素が見つからなければ -1 を返す
def binary_search_lcro(nums: list[int], target: int) -> int:
"""二分探索（左閉右開区間）"""
# 左閉右開区間 [0, n) を初期化、すなわち i, j はそれぞれ配列の最初の要素と最後の要素+1を指す
# 左閉右開区間 [0, n) を初期化する。つまり i, j はそれぞれ配列の先頭要素と末尾要素+1を指す
i, j = 0, len(nums)
# 検索区間が空になるまでループ（i = j のとき空）
# ループし、探索区間が空になったら終了する（i = j で空）
while i < j:
m = i + (j - i) // 2 # 中点インデックス m を計算
m = (i + j) // 2 # 中点インデックス m を計算
if nums[m] < target:
i = m + 1 # この場合、target は区間 [m+1, j) にあることを示す
i = m + 1 # この場合、target は区間 [m+1, j) にある
elif nums[m] > target:
j = m # この場合、target は区間 [i, m) にあることを示す
j = m # この場合、target は区間 [i, m) にある
else:
return m # ターゲット要素が見つかったため、そのインデックスを返す
return -1 # ターゲット要素が見つからなかったため、-1 を返す
return m # 目標要素が見つかったらそのインデックスを返す
return -1 # 目標要素が見つからなければ -1 を返す
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
target = 6
nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35]
# 二分探索（両端閉区間）
# 二分探索（両閉区間）
index = binary_search(nums, target)
print("ターゲット要素 6 のインデックス =", index)
print("対象要素 6 のインデックス = ", index)
# 二分探索（左閉右開区間）
index = binary_search_lcro(nums, target)
print("ターゲット要素 6 のインデックス =", index)
print("対象要素 6 のインデックス = ", index)

28
ja/codes/python/chapter_searching/binary_search_edge.py
View File

@@ -12,38 +12,38 @@ from binary_search_insertion import binary_search_insertion
def binary_search_left_edge(nums: list[int], target: int) -> int:
"""最左端のターゲットの二分探索"""
# ターゲットの挿入位置を見つけることと同等
"""最も左の target を二分探索"""
# target の挿入位置を探すのと等価
i = binary_search_insertion(nums, target)
# ターゲットが見つからなかった場合、-1 を返す
# target が見つからなければ、-1 を返す
if i == len(nums) or nums[i] != target:
return -1
# ターゲットが見つかった場合、インデックス i を返す
# target が見つかったら、インデックス i を返す
return i
def binary_search_right_edge(nums: list[int], target: int) -> int:
"""最右端のターゲットの二分探索"""
# 最左端のターゲット + 1 を見つけることに変換
"""最も右の target を二分探索"""
# 最左の target + 1 を探す問題に変換する
i = binary_search_insertion(nums, target + 1)
# j は最右端のターゲットを指し、i はターゲットより大きい最初の要素を指す
# j は最も右の target を指し、i は target より大きい最初の要素を指す
j = i - 1
# ターゲットが見つからなかった場合、-1 を返す
# target が見つからなければ、-1 を返す
if j == -1 or nums[j] != target:
return -1
# ターゲットが見つかった場合、インデックス j を返す
# target が見つかったら、インデックス j を返す
return j
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
# 重複要素のある配列
# 重複要素を含む配列
nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15]
print(f"\n配列 nums = {nums}")
# 左端と右端の境界の二分探索
# 二分探索で左端と右端を探す
for target in [6, 7]:
index = binary_search_left_edge(nums, target)
print(f"最左端の要素 {target} のインデックスは {index}")
print(f"左端の要素 {target} のインデックスは {index}")
index = binary_search_right_edge(nums, target)
print(f"最右端の要素 {target} のインデックスは {index}")
print(f"右端の要素 {target} のインデックスは {index}")

38
ja/codes/python/chapter_searching/binary_search_insertion.py
View File

@@ -6,49 +6,49 @@ Author: krahets (krahets@163.com)
def binary_search_insertion_simple(nums: list[int], target: int) -> int:
"""挿入位置の二分探索（重複要素なし）"""
i, j = 0, len(nums) - 1 # 両端閉区間 [0, n-1] を初期化
"""二分探索で挿入位置を探す（重複要素なし）"""
i, j = 0, len(nums) - 1 # 両閉区間 [0, n-1] を初期化
while i <= j:
m = i + (j - i) // 2 # 中点インデックス m を計算
m = (i + j) // 2 # 中点インデックス m を計算
if nums[m] < target:
i = m + 1 # ターゲットは区間 [m+1, j] にある
i = m + 1 # target は区間 [m+1, j] にある
elif nums[m] > target:
j = m - 1 # ターゲットは区間 [i, m-1] にある
j = m - 1 # target は区間 [i, m-1] にある
else:
return m # ターゲットが見つかった場合、挿入位置 m を返す
# ターゲットが見つからなかった場合、挿入位置 i を返す
return m # target が見つかったら、挿入位置 m を返す
# target が見つからなければ、挿入位置 i を返す
return i
def binary_search_insertion(nums: list[int], target: int) -> int:
"""挿入位置の二分探索（重複要素あり）"""
i, j = 0, len(nums) - 1 # 両端閉区間 [0, n-1] を初期化
"""二分探索で挿入位置を探す（重複要素あり）"""
i, j = 0, len(nums) - 1 # 両閉区間 [0, n-1] を初期化
while i <= j:
m = i + (j - i) // 2 # 中点インデックス m を計算
m = (i + j) // 2 # 中点インデックス m を計算
if nums[m] < target:
i = m + 1 # ターゲットは区間 [m+1, j] にある
i = m + 1 # target は区間 [m+1, j] にある
elif nums[m] > target:
j = m - 1 # ターゲットは区間 [i, m-1] にある
j = m - 1 # target は区間 [i, m-1] にある
else:
j = m - 1 # ターゲット未満の最初の要素は区間 [i, m-1] にある
j = m - 1 # target より小さい最初の要素は区間 [i, m-1] にある
# 挿入位置 i を返す
return i
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
# 重複要素のない配列
nums = [1, 3, 6, 8, 12, 15, 23, 26, 31, 35]
print(f"\n配列 nums = {nums}")
# 挿入位置の二分探索
# 二分探索で挿入位置を探す
for target in [6, 9]:
index = binary_search_insertion_simple(nums, target)
print(f"要素 {target} の挿入位置インデックスは {index}")
print(f"要素 {target} の挿入位置のインデックスは {index}")
# 重複要素のある配列
# 重複要素を含む配列
nums = [1, 3, 6, 6, 6, 6, 6, 10, 12, 15]
print(f"\n配列 nums = {nums}")
# 挿入位置の二分探索
# 二分探索で挿入位置を探す
for target in [2, 6, 20]:
index = binary_search_insertion(nums, target)
print(f"要素 {target} の挿入位置インデックスは {index}")
print(f"要素 {target} の挿入位置のインデックスは {index}")

18
ja/codes/python/chapter_searching/hashing_search.py
View File

@@ -13,8 +13,8 @@ from modules import ListNode, list_to_linked_list
def hashing_search_array(hmap: dict[int, int], target: int) -> int:
"""ハッシュ探索（配列）"""
# ハッシュテーブルのキー：ターゲット要素、値：インデックス
# ハッシュテーブルがこのキーを含まない場合、-1 を返す
# ハッシュテーブルの key: 目標要素、value: インデックス
# ハッシュテーブルにこの key がなければ -1 を返す
return hmap.get(target, -1)
@@ -22,12 +22,12 @@ def hashing_search_linkedlist(
hmap: dict[int, ListNode], target: int
) -> ListNode | None:
"""ハッシュ探索（連結リスト）"""
# ハッシュテーブルのキー：ターゲット要素、値：ノードオブジェクト
# ハッシュテーブルがこのキーを含まない場合、None を返す
# ハッシュテーブルの key: 対象要素、value: ノードオブジェクト
# ハッシュテーブルにこの key がなければ None を返す
return hmap.get(target, None)
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
target = 3
@@ -36,16 +36,16 @@ if __name__ == "__main__":
# ハッシュテーブルを初期化
map0 = dict[int, int]()
for i in range(len(nums)):
map0[nums[i]] = i # キー：要素、値：インデックス
map0[nums[i]] = i # key: 要素、value: インデックス
index: int = hashing_search_array(map0, target)
print("ターゲット要素 3 のインデックス =", index)
print("対象要素 3 のインデックス =", index)
# ハッシュ探索（連結リスト）
head: ListNode = list_to_linked_list(nums)
# ハッシュテーブルを初期化
map1 = dict[int, ListNode]()
while head:
map1[head.val] = head # キー：ノード値、値：ノード
map1[head.val] = head # key: ノード値、value: ノード
head = head.next
node: ListNode = hashing_search_linkedlist(map1, target)
print("ターゲットノード値 3 に対応するノードオブジェクトは", node)
print("対象ノード値 3 に対応するノードオブジェクトは", node)

20
ja/codes/python/chapter_searching/linear_search.py
View File

@@ -15,31 +15,31 @@ def linear_search_array(nums: list[int], target: int) -> int:
"""線形探索（配列）"""
# 配列を走査
for i in range(len(nums)):
if nums[i] == target: # ターゲット要素が見つかったため、そのインデックスを返す
if nums[i] == target: # 目標要素が見つかったらそのインデックスを返す
return i
return -1 # ターゲット要素が見つからなかったため、-1 を返す
return -1 # 目標要素が見つからなければ -1 を返す
def linear_search_linkedlist(head: ListNode, target: int) -> ListNode | None:
"""線形探索（連結リスト）"""
# リストを走査
# 連結リストを走査
while head:
if head.val == target: # ターゲットノードが見つかったため、それを返す
if head.val == target: # 対象ノードが見つかったら、それを返す
return head
head = head.next
return None # ターゲットノードが見つからなかったため、None を返す
return None # 対象ノードが見つからない場合は None を返す
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
target = 3
# 配列での線形探索を実行
# 配列で線形探索を行う
nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
index: int = linear_search_array(nums, target)
print("ターゲット要素 3 のインデックス =", index)
print("対象要素 3 のインデックス =", index)
# 連結リストでの線形探索を実行
# 連結リストで線形探索を行う
head: ListNode = list_to_linked_list(nums)
node: ListNode | None = linear_search_linkedlist(head, target)
print("ターゲットノード値 3 に対応するノードオブジェクトは", node)
print("対象ノード値 3 に対応するノードオブジェクトは", node)

24
ja/codes/python/chapter_searching/two_sum.py
View File

@@ -6,8 +6,8 @@ Author: krahets (krahets@163.com)
def two_sum_brute_force(nums: list[int], target: int) -> list[int]:
"""方法一：ブルートフォース列挙"""
# 二重ループ、時間計算量は O(n^2)
"""方法 1：総当たり列挙"""
# 2重ループのため、時間計算量は O(n^2)
for i in range(len(nums) - 1):
for j in range(i + 1, len(nums)):
if nums[i] + nums[j] == target:
@@ -16,10 +16,10 @@ def two_sum_brute_force(nums: list[int], target: int) -> list[int]:
def two_sum_hash_table(nums: list[int], target: int) -> list[int]:
"""方法二：補助ハッシュテーブル"""
# 補助ハッシュテーブル、空間計算量は O(n)
"""方法 2：補助ハッシュテーブル"""
# 補助ハッシュテーブルを使用し、空間計算量は O(n)
dic = {}
# 単一ループ、時間計算量は O(n)
# 単一ループで、時間計算量は O(n)
for i in range(len(nums)):
if target - nums[i] in dic:
return [dic[target - nums[i]], i]
@@ -27,16 +27,16 @@ def two_sum_hash_table(nums: list[int], target: int) -> list[int]:
return []
"""ドライバーコード"""
"""Driver Code"""
if __name__ == "__main__":
# ======= テストケース =======
# ======= Test Case =======
nums = [2, 7, 11, 15]
target = 13
# ====== ドライバーコード ======
# 方法一
# ====== Driver Code ======
# 方法 1
res: list[int] = two_sum_brute_force(nums, target)
print("方法一の結果 =", res)
# 方法二
print("方法1 res =", res)
# 方法 2
res: list[int] = two_sum_hash_table(nums, target)
print("方法二の結果 =", res)
print("方法2 res =", res)