xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-11-03 19:52:01 +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/javascript/chapter_backtracking/n_queens.js
+14 -14
View File
@@ -4,51 +4,51 @@
* Author: Justin ([email protected])
*/
/* バックトラッキング：N クイーン */
/* バックトラッキング：n クイーン */
function backtrack(row, n, state, res, cols, diags1, diags2) {
// すべての行への配置が完了したら、解を記録する
// すべての行への配置が終わったら、解を記録する
if (row === n) {
res.push(state.map((row) => row.slice()));
return;
}
// すべての列を走査
// すべての列を走査する
for (let col = 0; col < n; col++) {
// このマスに対応する主対角線と副対角線を計算
// このマスに対応する主対角線と副対角線を求める
const diag1 = row - col + n - 1;
const diag2 = row + col;
// 枝刈り：そのマスの列、主対角線、副対角線にクイーンがあってはならない
// 枝刈り：このマスと同じ列、主対角線、副対角線にクイーンがあってはならない
if (!cols[col] && !diags1[diag1] && !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;
}
}
}
/* N クイーンを解く */
/* n クイーン問題を解く */
function nQueens(n) {
// n*n の盤面を初期化する。'Q' はクイーン、'#' は空きマスを表す
const state = Array.from({ length: n }, () => Array(n).fill('#'));
const cols = Array(n).fill(false); // 列にクイーンがあるか記録
const diags1 = Array(2 * n - 1).fill(false); // 主対角線にクイーンがあるかを記録
const diags2 = Array(2 * n - 1).fill(false); // 副対角線にクイーンがあるかを記録
const cols = Array(n).fill(false); // 列にクイーンがあるかどうかを記録する
const diags1 = Array(2 * n - 1).fill(false); // 主対角線にクイーンがあるかどうかを記録する
const diags2 = Array(2 * n - 1).fill(false); // 副対角線にクイーンがあるかどうかを記録する
const res = [];
backtrack(0, n, state, res, cols, diags1, diags2);
return res;
}
// Driver Code
// 実行用コード
const n = 4;
const res = nQueens(n);
console.log(`入力する盤面の縦横は ${n}`);
console.log(`クイーン配置の解法は全部で ${res.length} 通り`);
console.log(`入力した盤面の縦横の長さは ${n}`);
console.log(`クイーンの配置方法は全部で ${res.length} 通り`);
res.forEach((state) => {
console.log('--------------------');
state.forEach((row) => console.log(row));
ja/codes/javascript/chapter_backtracking/permutations_i.js
+9 -9
View File
@@ -4,37 +4,37 @@
* Author: Justin ([email protected])
*/
/* バックトラッキング：順列 I */
/* バックトラッキング：すべての順列 I */
function backtrack(state, choices, selected, res) {
// 状態の長さが要素数に等しければ、解を記録
// 状態の長さが要素数と等しくなったら、解を記録する
if (state.length === choices.length) {
res.push([...state]);
return;
}
// すべての選択肢を走査
// すべての選択肢を走査する
choices.forEach((choice, i) => {
// 枝刈り：要素の重複選択を許可しない
// 枝刈り：同じ要素を繰り返し選んではならない
if (!selected[i]) {
// 試行: 選択を行い、状態を更新
// 試行：選択を行い、状態を更新する
selected[i] = true;
state.push(choice);
// 次の選択へ進む
// 次の選択に進む
backtrack(state, choices, selected, res);
// バックトラック：選択を取り消し、前の状態に戻す
// 復元：選択を取り消し、以前の状態に戻す
selected[i] = false;
state.pop();
}
});
}
/* 全順列 I */
/* すべての順列 I */
function permutationsI(nums) {
const res = [];
backtrack([], nums, Array(nums.length).fill(false), res);
return res;
}
// Driver Code
// 実行用コード
const nums = [1, 2, 3];
const res = permutationsI(nums);
ja/codes/javascript/chapter_backtracking/permutations_ii.js
+10 -10
View File
@@ -4,39 +4,39 @@
* Author: Justin ([email protected])
*/
/* バックトラッキング：順列 II */
/* バックトラッキング：すべての順列 II */
function backtrack(state, choices, selected, res) {
// 状態の長さが要素数に等しければ、解を記録
// 状態の長さが要素数と等しくなったら、解を記録する
if (state.length === choices.length) {
res.push([...state]);
return;
}
// すべての選択肢を走査
// すべての選択肢を走査する
const duplicated = new Set();
choices.forEach((choice, i) => {
// 枝刈り：要素の重複選択を許可せず、同値要素の重複選択も許可しない
// 枝刈り：同じ要素の再選択も、等しい値を持つ要素の重複選択も許可しない
if (!selected[i] && !duplicated.has(choice)) {
// 試行: 選択を行い、状態を更新
duplicated.add(choice); // 選択済みの要素値を記録
// 試行：選択を行い、状態を更新する
duplicated.add(choice); // 選択済みの要素の値を記録する
selected[i] = true;
state.push(choice);
// 次の選択へ進む
// 次の選択に進む
backtrack(state, choices, selected, res);
// バックトラック：選択を取り消し、前の状態に戻す
// 復元：選択を取り消し、以前の状態に戻す
selected[i] = false;
state.pop();
}
});
}
/* 全順列 II */
/* すべての順列 II */
function permutationsII(nums) {
const res = [];
backtrack([], nums, Array(nums.length).fill(false), res);
return res;
}
// Driver Code
// 実行用コード
const nums = [1, 2, 2];
const res = permutationsII(nums);
ja/codes/javascript/chapter_backtracking/preorder_traversal_i_compact.js
+6 -6
View File
@@ -7,27 +7,27 @@
const { arrToTree } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 前順走査：例題 1 */
/* 行きがけ順走査：例題 1 */
function preOrder(root, res) {
if (root === null) {
return;
}
if (root.val === 7) {
// 解を記録
// 解を記録する
res.push(root);
}
preOrder(root.left, res);
preOrder(root.right, res);
}
// Driver Code
// 実行用コード
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
console.log('\n二分木を初期化');
console.log('\n二分木を初期化する');
printTree(root);
// 先行順走査
// 行きがけ順走査
const res = [];
preOrder(root, res);
console.log('\n値が 7 のすべてのノードを出力');
console.log('\n値が 7 であるすべてのノードを出力する');
console.log(res.map((node) => node.val));
ja/codes/javascript/chapter_backtracking/preorder_traversal_ii_compact.js
+8 -8
View File
@@ -7,34 +7,34 @@
const { arrToTree } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 前順走査：例題 2 */
/* 行きがけ順走査：例題 2 */
function preOrder(root, path, res) {
if (root === null) {
return;
}
// 試す
// 試行
path.push(root);
if (root.val === 7) {
// 解を記録
// 解を記録する
res.push([...path]);
}
preOrder(root.left, path, res);
preOrder(root.right, path, res);
// バックトラック
// 復元
path.pop();
}
// Driver Code
// 実行用コード
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
console.log('\n二分木を初期化');
console.log('\n二分木を初期化する');
printTree(root);
// 先行順走査
// 行きがけ順走査
const path = [];
const res = [];
preOrder(root, path, res);
console.log('\n根ノードからノード 7 までのすべての経路を出力');
console.log('\n根ノードからノード 7 までのすべての経路を出力する');
res.forEach((path) => {
console.log(path.map((node) => node.val));
});
ja/codes/javascript/chapter_backtracking/preorder_traversal_iii_compact.js
+8 -8
View File
@@ -7,35 +7,35 @@
const { arrToTree } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 前順走査：例題 3 */
/* 行きがけ順走査：例題 3 */
function preOrder(root, path, res) {
// 枝刈り
if (root === null || root.val === 3) {
return;
}
// 試す
// 試行
path.push(root);
if (root.val === 7) {
// 解を記録
// 解を記録する
res.push([...path]);
}
preOrder(root.left, path, res);
preOrder(root.right, path, res);
// バックトラック
// 復元
path.pop();
}
// Driver Code
// 実行用コード
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
console.log('\n二分木を初期化');
console.log('\n二分木を初期化する');
printTree(root);
// 先行順走査
// 行きがけ順走査
const path = [];
const res = [];
preOrder(root, path, res);
console.log('\n根ノードからノード 7 までのすべての経路を出力し，経路には値が 3 のノードを含まない');
console.log('\n値が 3 のノードを含まない、根ノードからノード 7 までのすべての経路を出力する');
res.forEach((path) => {
console.log(path.map((node) => node.val));
});
ja/codes/javascript/chapter_backtracking/preorder_traversal_iii_template.js
+16 -16
View File
@@ -7,62 +7,62 @@
const { arrToTree } = require('../modules/TreeNode');
const { printTree } = require('../modules/PrintUtil');
/* 現在の状態が解かどうかを判定 */
/* 現在の状態が解かを判定 */
function isSolution(state) {
return state && state[state.length - 1]?.val === 7;
}
/* 解を記録 */
/* 解を記録する */
function recordSolution(state, res) {
res.push([...state]);
}
/* 現在の状態で、この選択が有効かどうかを判定 */
/* 現在の状態でこの選択が有効か判定 */
function isValid(state, choice) {
return choice !== null && choice.val !== 3;
}
/* 状態を更新 */
/* 状態を更新する */
function makeChoice(state, choice) {
state.push(choice);
}
/* 状態を元に戻す */
/* 状態を復元する */
function undoChoice(state) {
state.pop();
}
/* バックトラッキング：例題 3 */
function backtrack(state, choices, res) {
// 解かどうかを確認
// 解かを確認
if (isSolution(state)) {
// 解を記録
// 解を記録する
recordSolution(state, res);
}
// すべての選択肢を走査
// すべての選択肢を走査する
for (const choice of choices) {
// 枝刈り：選択が妥当かを確認する
// 枝刈り：選択が有効か確認
if (isValid(state, choice)) {
// 試行: 選択を行い、状態を更新
// 試行：選択を行い、状態を更新する
makeChoice(state, choice);
// 次の選択へ進む
// 次の選択に進む
backtrack(state, [choice.left, choice.right], res);
// バックトラック：選択を取り消し、前の状態に戻す
// 復元：選択を取り消し、以前の状態に戻す
undoChoice(state);
}
}
}
// Driver Code
// 実行用コード
const root = arrToTree([1, 7, 3, 4, 5, 6, 7]);
console.log('\n二分木を初期化');
console.log('\n二分木を初期化する');
printTree(root);
// バックトラッキング法
// バックトラッキング
const res = [];
backtrack([], [root], res);
console.log('\n根ノードからノード 7 までのすべての経路を出力し，経路には値が 3 のノードを含まないことを条件とする');
console.log('\n値が 3 のノードを含まない、根ノードからノード 7 までのすべての経路を出力する');
res.forEach((path) => {
console.log(path.map((node) => node.val));
});
ja/codes/javascript/chapter_backtracking/subset_sum_i.js
+14 -14
View File
@@ -4,43 +4,43 @@
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* バックトラッキング：部分和 I */
/* バックトラッキング：部分集合和 I */
function backtrack(state, target, choices, start, res) {
// 部分集合の和が target に等しければ、解を記録
// 部分集合の和が target と等しくなったら、解を記録する
if (target === 0) {
res.push([...state]);
return;
}
// すべての選択肢を走査
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
// すべての選択肢を走査する
// 枝刈り 2：start から走査を始め、重複した部分集合の生成を避ける
for (let i = start; i < choices.length; i++) {
// 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
// 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
// 枝刈り 1：部分集合の和が target を超えたら、直ちにループを終了する
// 配列はソート済みで後ろの要素ほど大きいため、部分集合の和が必ず target を超えるからである
if (target - choices[i] < 0) {
break;
}
// 試す：選択を行い、target と start を更新
// 試行：選択を行い、target, start を更新する
state.push(choices[i]);
// 次の選択へ進む
// 次の選択に進む
backtrack(state, target - choices[i], choices, i, res);
// バックトラック：選択を取り消し、前の状態に戻す
// 復元：選択を取り消し、以前の状態に戻す
state.pop();
}
}
/* 部分和 I を解く */
/* 部分集合和 I を解く */
function subsetSumI(nums, target) {
const state = []; // 状態（部分集合）
nums.sort((a, b) => a - b); // nums をソート
const start = 0; // 開始点を走査
nums.sort((a, b) => a - b); // nums をソートする
const start = 0; // 走査の開始位置
const res = []; // 結果リスト（部分集合のリスト）
backtrack(state, target, nums, start, res);
return res;
}
/* Driver Code */
/* 実行用コード */
const nums = [3, 4, 5];
const target = 9;
const res = subsetSumI(nums, target);
console.log(`入力配列 nums = ${JSON.stringify(nums)}, target = ${target}`);
console.log(`和が ${target} に等しいすべての部分集合 res = ${JSON.stringify(res)}`);
console.log(`和が ${target} になるすべての部分集合 res = ${JSON.stringify(res)}`);
ja/codes/javascript/chapter_backtracking/subset_sum_i_naive.js
+12 -12
View File
@@ -4,41 +4,41 @@
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* バックトラッキング：部分和 I */
/* バックトラッキング：部分集合和 I */
function backtrack(state, target, total, choices, res) {
// 部分集合の和が target に等しければ、解を記録
// 部分集合の和が target と等しくなったら、解を記録する
if (total === target) {
res.push([...state]);
return;
}
// すべての選択肢を走査
// すべての選択肢を走査する
for (let i = 0; i < choices.length; i++) {
// 枝刈り：部分和が target を超える場合はその選択をスキップする
// 枝刈り：部分集合の和が target を超える場合、この選択をスキップする
if (total + choices[i] > target) {
continue;
}
// 試行：選択を行い、要素と total を更新する
// 試行：選択を行い、要素の和 total を更新する
state.push(choices[i]);
// 次の選択へ進む
// 次の選択に進む
backtrack(state, target, total + choices[i], choices, res);
// バックトラック：選択を取り消し、前の状態に戻す
// 復元：選択を取り消し、以前の状態に戻す
state.pop();
}
}
/* 部分和 I を解く（重複部分集合を含む） */
/* 部分集合和 I を解く（重複した部分集合を含む） */
function subsetSumINaive(nums, target) {
const state = []; // 状態（部分集合）
const total = 0; // 部分和
const total = 0; // 部分集合和
const res = []; // 結果リスト（部分集合のリスト）
backtrack(state, target, total, nums, res);
return res;
}
/* Driver Code */
/* 実行用コード */
const nums = [3, 4, 5];
const target = 9;
const res = subsetSumINaive(nums, target);
console.log(`入力配列 nums = ${JSON.stringify(nums)}, target = ${target}`);
console.log(`和が ${target} に等しいすべての部分集合 res = ${JSON.stringify(res)}`);
console.log('注意してください。この方法の出力結果には重複した集合が含まれます');
console.log(`和が ${target} になるすべての部分集合 res = ${JSON.stringify(res)}`);
console.log('この方法の出力結果には重複した集合が含まれることに注意');
ja/codes/javascript/chapter_backtracking/subset_sum_ii.js
+16 -16
View File
@@ -4,48 +4,48 @@
* Author: yuan0221 (yl1452491917@gmail.com)
*/
/* バックトラッキング：部分和 II */
/* バックトラッキング：部分集合和 II */
function backtrack(state, target, choices, start, res) {
// 部分集合の和が target に等しければ、解を記録
// 部分集合の和が target と等しくなったら、解を記録する
if (target === 0) {
res.push([...state]);
return;
}
// すべての選択肢を走査
// 枝刈り 2: start から走査し、重複する部分集合の生成を避ける
// 枝刈り 3: start から走査し、同じ要素の重複選択を避ける
// すべての選択肢を走査する
// 枝刈り 2：start から走査を始め、重複した部分集合の生成を避ける
// 枝刈り 3：start から走査を始め、同じ要素の再選択を避ける
for (let i = start; i < choices.length; i++) {
// 枝刈り1：部分集合の和が target を超えたら、直ちにループを終了する
// 配列はソート済みで後続要素のほうが大きく、部分集合の和は必ず target を超えるため
// 枝刈り 1：部分集合の和が target を超えたら、直ちにループを終了する
// 配列はソート済みで後ろの要素ほど大きいため、部分集合の和が必ず target を超えるからである
if (target - choices[i] < 0) {
break;
}
// 枝刈り4：この要素が左隣の要素と等しければ、その探索分岐は重複しているためスキップする
// 枝刈り 4：この要素が左隣の要素と等しい場合、探索の分岐が重複するため、直ちにスキップする
if (i > start && choices[i] === choices[i - 1]) {
continue;
}
// 試す：選択を行い、target と start を更新
// 試行：選択を行い、target, start を更新する
state.push(choices[i]);
// 次の選択へ進む
// 次の選択に進む
backtrack(state, target - choices[i], choices, i + 1, res);
// バックトラック：選択を取り消し、前の状態に戻す
// 復元：選択を取り消し、以前の状態に戻す
state.pop();
}
}
/* 部分和 II を解く */
/* 部分集合和 II を解く */
function subsetSumII(nums, target) {
const state = []; // 状態（部分集合）
nums.sort((a, b) => a - b); // nums をソート
const start = 0; // 開始点を走査
nums.sort((a, b) => a - b); // nums をソートする
const start = 0; // 走査の開始位置
const res = []; // 結果リスト（部分集合のリスト）
backtrack(state, target, nums, start, res);
return res;
}
/* Driver Code */
/* 実行用コード */
const nums = [4, 4, 5];
const target = 9;
const res = subsetSumII(nums, target);
console.log(`入力配列 nums = ${JSON.stringify(nums)}, target = ${target}`);
console.log(`和が ${target} に等しいすべての部分集合 res = ${JSON.stringify(res)}`);
console.log(`和が ${target} になるすべての部分集合 res = ${JSON.stringify(res)}`);