CS_learn/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-11-10 16:00:36 +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

28
ja/codes/python/chapter_backtracking/n_queens.py
View File

@@ -14,48 +14,48 @@ def backtrack(
diags1: list[bool],
diags2: list[bool],
):
"""バックトラッキング：N クイーン"""
# すべての行への配置が完了したら、解を記録する
"""バックトラッキング：n クイーン"""
# すべての行への配置が終わったら、解を記録する
if row == n:
res.append([list(row) for row in state])
return
# すべての列を走査
# すべての列を走査する
for col in range(n):
# このマスに対応する主対角線と副対角線を計算
# このマスに対応する主対角線と副対角線を求める
diag1 = row - col + n - 1
diag2 = row + col
# 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない
# 枝刈り：このマスと同じ列、主対角線、副対角線にクイーンがあってはならない
if not cols[col] and not diags1[diag1] and not diags2[diag2]:
# 試行：そのマスにクイーンを置く
# 試行：このマスにクイーンを配置する
state[row][col] = "Q"
cols[col] = diags1[diag1] = diags2[diag2] = True
# 次の行に配置する
backtrack(row + 1, n, state, res, cols, diags1, diags2)
# 戻す：そのマスを空きマスに戻す
# 復元：このマスを空きマスに戻す
state[row][col] = "#"
cols[col] = diags1[diag1] = diags2[diag2] = False
def n_queens(n: int) -> list[list[list[str]]]:
"""N クイーンを解く"""
"""n クイーン問題を解く"""
# n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す
state = [["#" for _ in range(n)] for _ in range(n)]
cols = [False] * n # 列にクイーンがあるか記録
diags1 = [False] * (2 * n - 1) # 主対角線にクイーンがあるかを記録
diags2 = [False] * (2 * n - 1) # 副対角線にクイーンがあるかを記録
cols = [False] * n # 列にクイーンがあるかどうかを記録する
diags1 = [False] * (2 * n - 1) # 主対角線にクイーンがあるかどうかを記録する
diags2 = [False] * (2 * n - 1) # 副対角線にクイーンがあるかどうかを記録する
res = []
backtrack(0, n, state, res, cols, diags1, diags2)
return res
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
n = 4
res = n_queens(n)
print(f"入力された盤面の縦横の長さは {n} です")
print(f"クイーンの配置パターンは全部で {len(res)} 通りです")
print(f"入力した盤面の縦横の長さは {n}")
print(f"クイーンの配置方法は全部で {len(res)} 通り")
for state in res:
print("--------------------")
for row in state:

18
ja/codes/python/chapter_backtracking/permutations_i.py
View File

@@ -8,33 +8,33 @@ Author: krahets (krahets@163.com)
def backtrack(
state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
):
"""バックトラッキング：順列 I"""
# 状態の長さが要素数に等しければ、解を記録
"""バックトラッキング：すべての順列 I"""
# 状態の長さが要素数と等しくなったら、解を記録する
if len(state) == len(choices):
res.append(list(state))
return
# すべての選択肢を走査
# すべての選択肢を走査する
for i, choice in enumerate(choices):
# 枝刈り：要素の重複選択を許可しない
# 枝刈り：同じ要素を繰り返し選んではならない
if not selected[i]:
# 試行: 選択を行い、状態を更新
# 試行：選択を行い、状態を更新する
selected[i] = True
state.append(choice)
# 次の選択へ進む
# 次の選択に進む
backtrack(state, choices, selected, res)
# バックトラック：選択を取り消し、前の状態に戻す
# 復元：選択を取り消し、以前の状態に戻す
selected[i] = False
state.pop()
def permutations_i(nums: list[int]) -> list[list[int]]:
"""全順列 I"""
"""すべての順列 I"""
res = []
backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
return res
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
nums = [1, 2, 3]

20
ja/codes/python/chapter_backtracking/permutations_ii.py
View File

@@ -8,35 +8,35 @@ Author: krahets (krahets@163.com)
def backtrack(
state: list[int], choices: list[int], selected: list[bool], res: list[list[int]]
):
"""バックトラッキング：順列 II"""
# 状態の長さが要素数に等しければ、解を記録
"""バックトラッキング：すべての順列 II"""
# 状態の長さが要素数と等しくなったら、解を記録する
if len(state) == len(choices):
res.append(list(state))
return
# すべての選択肢を走査
# すべての選択肢を走査する
duplicated = set[int]()
for i, choice in enumerate(choices):
# 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない
# 枝刈り：同じ要素の再選択も、等しい値を持つ要素の重複選択も許可しない
if not selected[i] and choice not in duplicated:
# 試行: 選択を行い、状態を更新
duplicated.add(choice) # 選択済みの要素値を記録
# 試行：選択を行い、状態を更新する
duplicated.add(choice) # 選択済みの要素の値を記録する
selected[i] = True
state.append(choice)
# 次の選択へ進む
# 次の選択に進む
backtrack(state, choices, selected, res)
# バックトラック：選択を取り消し、前の状態に戻す
# 復元：選択を取り消し、以前の状態に戻す
selected[i] = False
state.pop()
def permutations_ii(nums: list[int]) -> list[list[int]]:
"""全順列 II"""
"""すべての順列 II"""
res = []
backtrack(state=[], choices=nums, selected=[False] * len(nums), res=res)
return res
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
nums = [1, 2, 2]

12
ja/codes/python/chapter_backtracking/preorder_traversal_i_compact.py
View File

@@ -12,25 +12,25 @@ from modules import TreeNode, print_tree, list_to_tree
def pre_order(root: TreeNode):
"""前順走査：例題 1"""
"""行きがけ順走査：例題 1"""
if root is None:
return
if root.val == 7:
# 解を記録
# 解を記録する
res.append(root)
pre_order(root.left)
pre_order(root.right)
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
print("\n二分木を初期化")
print("\n二分木を初期化する")
print_tree(root)
# 先行順走査
# 行きがけ順走査
res = list[TreeNode]()
pre_order(root)
print("\n値が 7 のノードをすべて出力")
print("\n値が 7 であるすべてのノードを出力する")
print([node.val for node in res])

16
ja/codes/python/chapter_backtracking/preorder_traversal_ii_compact.py
View File

@@ -12,31 +12,31 @@ from modules import TreeNode, print_tree, list_to_tree
def pre_order(root: TreeNode):
"""前順走査：例題 2"""
"""行きがけ順走査：例題 2"""
if root is None:
return
# 試す
# 試行
path.append(root)
if root.val == 7:
# 解を記録
# 解を記録する
res.append(list(path))
pre_order(root.left)
pre_order(root.right)
# バックトラック
# 復元
path.pop()
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
print("\n二分木を初期化")
print("\n二分木を初期化する")
print_tree(root)
# 先行順走査
# 行きがけ順走査
path = list[TreeNode]()
res = list[list[TreeNode]]()
pre_order(root)
print("\n根ノードからノード 7 までの経路をすべて出力")
print("\n根ノードからノード 7 までのすべての経路を出力する")
for path in res:
print([node.val for node in path])

16
ja/codes/python/chapter_backtracking/preorder_traversal_iii_compact.py
View File

@@ -12,32 +12,32 @@ from modules import TreeNode, print_tree, list_to_tree
def pre_order(root: TreeNode):
"""前順走査：例題 3"""
"""行きがけ順走査：例題 3"""
# 枝刈り
if root is None or root.val == 3:
return
# 試す
# 試行
path.append(root)
if root.val == 7:
# 解を記録
# 解を記録する
res.append(list(path))
pre_order(root.left)
pre_order(root.right)
# バックトラック
# 復元
path.pop()
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
print("\n二分木を初期化")
print("\n二分木を初期化する")
print_tree(root)
# 先行順走査
# 行きがけ順走査
path = list[TreeNode]()
res = list[list[TreeNode]]()
pre_order(root)
print("\n根ノードからノード 7 までの経路をすべて出力し、経路には値が 3 のノードを含めない")
print("\n値が 3 のノードを含まない、根ノードからノード 7 までのすべての経路を出力する")
for path in res:
print([node.val for node in path])

32
ja/codes/python/chapter_backtracking/preorder_traversal_iii_template.py
View File

@@ -12,27 +12,27 @@ from modules import TreeNode, print_tree, list_to_tree
def is_solution(state: list[TreeNode]) -> bool:
"""現在の状態が解かどうかを判定"""
"""現在の状態が解かを判定"""
return state and state[-1].val == 7
def record_solution(state: list[TreeNode], res: list[list[TreeNode]]):
"""解を記録"""
"""解を記録する"""
res.append(list(state))
def is_valid(state: list[TreeNode], choice: TreeNode) -> bool:
"""現在の状態で、この選択が有効かどうかを判定"""
"""現在の状態でこの選択が有効か判定"""
return choice is not None and choice.val != 3
def make_choice(state: list[TreeNode], choice: TreeNode):
"""状態を更新"""
"""状態を更新する"""
state.append(choice)
def undo_choice(state: list[TreeNode], choice: TreeNode):
"""状態を元に戻す"""
"""状態を復元する"""
state.pop()
@@ -40,32 +40,32 @@ def backtrack(
state: list[TreeNode], choices: list[TreeNode], res: list[list[TreeNode]]
):
"""バックトラッキング：例題 3"""
# 解かどうかを確認
# 解かを確認
if is_solution(state):
# 解を記録
# 解を記録する
record_solution(state, res)
# すべての選択肢を走査
# すべての選択肢を走査する
for choice in choices:
# 枝刈り：選択が妥当かを確認する
# 枝刈り：選択が有効か確認
if is_valid(state, choice):
# 試行: 選択を行い、状態を更新
# 試行：選択を行い、状態を更新する
make_choice(state, choice)
# 次の選択へ進む
# 次の選択に進む
backtrack(state, [choice.left, choice.right], res)
# バックトラック：選択を取り消し、前の状態に戻す
# 復元：選択を取り消し、以前の状態に戻す
undo_choice(state, choice)
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
root = list_to_tree([1, 7, 3, 4, 5, 6, 7])
print("\n二分木を初期化")
print("\n二分木を初期化する")
print_tree(root)
# バックトラッキング法
# バックトラッキング
res = []
backtrack(state=[], choices=[root], res=res)
print("\n根ノードからノード 7 までの経路をすべて出力し、経路には値が 3 のノードを含まないことを条件とする")
print("\n値が 3 のノードを含まない、根ノードからノード 7 までのすべての経路を出力する")
for path in res:
print([node.val for node in path])

28
ja/codes/python/chapter_backtracking/subset_sum_i.py
View File

@@ -8,41 +8,41 @@ Author: krahets (krahets@163.com)
def backtrack(
state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]
):
"""バックトラッキング：部分和 I"""
# 部分集合の和が target に等しければ、解を記録
"""バックトラッキング：部分集合和 I"""
# 部分集合の和が target と等しくなったら、解を記録する
if target == 0:
res.append(list(state))
return
# すべての選択肢を走査
# 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
# すべての選択肢を走査する
# 枝刈り 2：start から走査を始め、重複した部分集合の生成を避ける
for i in range(start, len(choices)):
# 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
# 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
# 枝刈り 1：部分集合の和が target を超えたら、直ちにループを終了する
# 配列はソート済みで後ろの要素ほど大きいため、部分集合の和が必ず target を超えるからである
if target - choices[i] < 0:
break
# 試す：選択を行い、target と start を更新
# 試行：選択を行い、target, start を更新する
state.append(choices[i])
# 次の選択へ進む
# 次の選択に進む
backtrack(state, target - choices[i], choices, i, res)
# バックトラック：選択を取り消し、前の状態に戻す
# 復元：選択を取り消し、以前の状態に戻す
state.pop()
def subset_sum_i(nums: list[int], target: int) -> list[list[int]]:
"""部分和 I を解く"""
"""部分集合和 I を解く"""
state = [] # 状態（部分集合）
nums.sort() # nums をソート
start = 0 # 開始点を走査
nums.sort() # nums をソートする
start = 0 # 走査の開始位置
res = [] # 結果リスト（部分集合のリスト）
backtrack(state, target, nums, start, res)
return res
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
nums = [3, 4, 5]
target = 9
res = subset_sum_i(nums, target)
print(f"入力配列 nums = {nums}, target = {target}")
print(f"和が {target} に等しいすべての部分集合 res = {res}")
print(f"和が {target} になるすべての部分集合 res = {res}")

24
ja/codes/python/chapter_backtracking/subset_sum_i_naive.py
View File

@@ -12,39 +12,39 @@ def backtrack(
choices: list[int],
res: list[list[int]],
):
"""バックトラッキング：部分和 I"""
# 部分集合の和が target に等しければ、解を記録
"""バックトラッキング：部分集合和 I"""
# 部分集合の和が target と等しくなったら、解を記録する
if total == target:
res.append(list(state))
return
# すべての選択肢を走査
# すべての選択肢を走査する
for i in range(len(choices)):
# 枝刈り：部分和が target を超える場合はその選択をスキップする
# 枝刈り：部分集合の和が target を超える場合、この選択をスキップする
if total + choices[i] > target:
continue
# 試行：選択を行い、要素と total を更新する
# 試行：選択を行い、要素の和 total を更新する
state.append(choices[i])
# 次の選択へ進む
# 次の選択に進む
backtrack(state, target, total + choices[i], choices, res)
# バックトラック：選択を取り消し、前の状態に戻す
# 復元：選択を取り消し、以前の状態に戻す
state.pop()
def subset_sum_i_naive(nums: list[int], target: int) -> list[list[int]]:
"""部分和 I を解く（重複部分集合を含む）"""
"""部分集合和 I を解く（重複した部分集合を含む）"""
state = [] # 状態（部分集合）
total = 0 # 部分和
total = 0 # 部分集合和
res = [] # 結果リスト（部分集合のリスト）
backtrack(state, target, total, nums, res)
return res
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
nums = [3, 4, 5]
target = 9
res = subset_sum_i_naive(nums, target)
print(f"入力配列 nums = {nums}, target = {target}")
print(f"和が {target} に等しいすべての部分集合 res = {res}")
print(f"注意: この方法の出力結果には重複する集合が含まれます")
print(f"和が {target} になるすべての部分集合 res = {res}")
print(f"この方法の出力結果には重複した集合が含まれることに注意")

32
ja/codes/python/chapter_backtracking/subset_sum_ii.py
View File

@@ -8,45 +8,45 @@ Author: krahets (krahets@163.com)
def backtrack(
state: list[int], target: int, choices: list[int], start: int, res: list[list[int]]
):
"""バックトラッキング：部分和 II"""
# 部分集合の和が target に等しければ、解を記録
"""バックトラッキング：部分集合和 II"""
# 部分集合の和が target と等しくなったら、解を記録する
if target == 0:
res.append(list(state))
return
# すべての選択肢を走査
# 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
# 枝刈り 3: start から走査し、同じ要素の重複選択を避ける
# すべての選択肢を走査する
# 枝刈り 2：start から走査を始め、重複した部分集合の生成を避ける
# 枝刈り 3：start から走査を始め、同じ要素の再選択を避ける
for i in range(start, len(choices)):
# 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
# 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
# 枝刈り 1：部分集合の和が target を超えたら、直ちにループを終了する
# 配列はソート済みで後ろの要素ほど大きいため、部分集合の和が必ず target を超えるからである
if target - choices[i] < 0:
break
# 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする
# 枝刈り 4：この要素が左隣の要素と等しい場合、探索の分岐が重複するため、直ちにスキップする
if i > start and choices[i] == choices[i - 1]:
continue
# 試す：選択を行い、target と start を更新
# 試行：選択を行い、target, start を更新する
state.append(choices[i])
# 次の選択へ進む
# 次の選択に進む
backtrack(state, target - choices[i], choices, i + 1, res)
# バックトラック：選択を取り消し、前の状態に戻す
# 復元：選択を取り消し、以前の状態に戻す
state.pop()
def subset_sum_ii(nums: list[int], target: int) -> list[list[int]]:
"""部分和 II を解く"""
"""部分集合和 II を解く"""
state = [] # 状態（部分集合）
nums.sort() # nums をソート
start = 0 # 開始点を走査
nums.sort() # nums をソートする
start = 0 # 走査の開始位置
res = [] # 結果リスト（部分集合のリスト）
backtrack(state, target, nums, start, res)
return res
"""Driver Code"""
"""実行用コード"""
if __name__ == "__main__":
nums = [4, 4, 5]
target = 9
res = subset_sum_ii(nums, target)
print(f"入力配列 nums = {nums}, target = {target}")
print(f"和が {target} に等しいすべての部分集合 res = {res}")
print(f"和が {target} になるすべての部分集合 res = {res}")