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

* 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

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) // 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 は配列の先頭要素と末尾要素の次をそれぞれ指す
i, j = 0, len(nums)
# ループし、探索区間が空になったら終了する(i = j で空)
# 探索区間が空になるまで繰り返す(i = j のとき空になる)
while i < j:
m = (i + j) // 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)

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 の挿入位置を探すのと等価
"""二分探索で最も左にある target を探す"""
# target の挿入位置を探すことに等しい
i = binary_search_insertion(nums, target)
# target が見つからなければ、-1 を返す
# target が見つからなかったので、-1 を返す
if i == len(nums) or nums[i] != target:
return -1
# target が見つかったら、インデックス i を返す
# target が見つかったので、インデックス i を返す
return i
def binary_search_right_edge(nums: list[int], target: int) -> int:
"""最も右の target を二分探索"""
# 最左の target + 1 を探す問題に変換する
"""二分探索で最も右にある target を探す"""
# 最も左にある target + 1 を探す問題に変換する
i = binary_search_insertion(nums, target + 1)
# j は最も右の target を指し、i は target より大きい最初の要素を指す
# j は最も右にある target を指し、i は target より大きい最初の要素を指す
j = i - 1
# target が見つからなければ、-1 を返す
# target が見つからなかったので、-1 を返す
if j == -1 or nums[j] != target:
return -1
# target が見つかったら、インデックス 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}")

View File

@@ -6,41 +6,41 @@ 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) // 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 - 1 # target は区間 [i, m-1] にある
j = m - 1 # target は区間 [i, m-1] に存在する
else:
return m # target が見つかったら、挿入位置 m を返す
# target が見つからなければ、挿入位置 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) // 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 - 1 # target は区間 [i, m-1] にある
j = m - 1 # target は区間 [i, m-1] に存在する
else:
j = m - 1 # target より小さい最も右の要素は区間 [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}")
@@ -48,7 +48,7 @@ if __name__ == "__main__":
# 重複要素を含む配列
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}")

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:
"""ハッシュ探索(配列)"""
# ハッシュテーブルの key: 目標要素、value: インデックス
# ハッシュテーブルにこの key がなければ -1 を返す
# ハッシュテーブルの key:目的の要素、value:インデックス
# ハッシュテーブルにこの key が存在しない場合、-1 を返す
return hmap.get(target, -1)
@@ -22,30 +22,30 @@ def hashing_search_linkedlist(
hmap: dict[int, ListNode], target: int
) -> ListNode | None:
"""ハッシュ探索(連結リスト)"""
# ハッシュテーブルの key: 対象要素、value: ノードオブジェクト
# ハッシュテーブルにこの key がなければ None を返す
# ハッシュテーブルの key:目的の要素、value:ノードオブジェクト
# ハッシュテーブルにこの key が存在しない場合、None を返す
return hmap.get(target, None)
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
target = 3
# ハッシュ探索(配列)
nums = [1, 5, 3, 2, 4, 7, 5, 9, 10, 8]
# ハッシュテーブルを初期化
# ハッシュテーブルを初期化する
map0 = dict[int, int]()
for i in range(len(nums)):
map0[nums[i]] = i # key: 要素、value: インデックス
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 # key: ノード値、value: ノード
map1[head.val] = head # key:ノードの値、value:ノード
head = head.next
node: ListNode = hashing_search_linkedlist(map1, target)
print("対象ノード値 3 に対応するノードオブジェクトは", node)
print("目的のノードの値 3 に対応するノードオブジェクトは", node)

View File

@@ -13,33 +13,33 @@ from modules import ListNode, list_to_linked_list
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)

View File

@@ -7,7 +7,7 @@ Author: krahets (krahets@163.com)
def two_sum_brute_force(nums: list[int], target: int) -> list[int]:
"""方法 1:総当たり列挙"""
# 2重ループのため、時間計算量は O(n^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:
@@ -17,9 +17,9 @@ def two_sum_brute_force(nums: list[int], target: int) -> list[int]:
def two_sum_hash_table(nums: list[int], target: int) -> list[int]:
"""方法 2:補助ハッシュテーブル"""
# 補助ハッシュテーブルを使用し、空間計算量は O(n)
# 補助ハッシュテーブルの空間計算量は 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("方法1 res =", res)
print("方法 1 res =", res)
# 方法 2
res: list[int] = two_sum_hash_table(nums, target)
print("方法2 res =", res)
print("方法 2 res =", res)