xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-11-05 04:32:19 +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_computational_complexity/complexity_exercises.js
+4 -4
View File
@@ -21,7 +21,7 @@ function sumRecur(n) {
return n + sumRecur(n - 1);
}
/* 線形時間のループ */
/* 線形オーダーのループ */
function linearLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
@@ -30,7 +30,7 @@ function linearLoop(n) {
return res;
}
/* 二次時間のループ */
/* 二次オーダーのループ */
function quadraticLoop(n) {
let res = 0;
for (let i = 0; i < n; i++) {
@@ -41,7 +41,7 @@ function quadraticLoop(n) {
return res;
}
/* 対数時間のループ */
/* 対数オーダーのループ */
function logarithmicLoop(n) {
while (n > 1) {
n = Math.floor(n / 2);
@@ -59,5 +59,5 @@ if (
logarithmicLoop(4) !== 1 ||
logarithmicLoop(5) !== 1
) {
throw new Error('complexity exercise check failed');
throw new Error('計算量の練習問題の検証に失敗しました');
}
ja/codes/javascript/chapter_computational_complexity/iteration.js
+10 -10
View File
@@ -7,7 +7,7 @@
/* for ループ */
function forLoop(n) {
let res = 0;
// 1, 2, ..., n-1, n を順に加算する
// ループで 1, 2, ..., n-1, n の和を求める
for (let i = 1; i <= n; i++) {
res += i;
}
@@ -18,7 +18,7 @@ function forLoop(n) {
function whileLoop(n) {
let res = 0;
let i = 1; // 条件変数を初期化する
// 1, 2, ..., n-1, n を順に加算する
// ループで 1, 2, ..., n-1, n の和を求める
while (i <= n) {
res += i;
i++; // 条件変数を更新する
@@ -26,11 +26,11 @@ function whileLoop(n) {
return res;
}
/* while ループ（2回更新） */
/* while ループ（2 回の更新） */
function whileLoopII(n) {
let res = 0;
let i = 1; // 条件変数を初期化する
// 1, 4, 10, ... を順に加算する
// ループで 1, 4, 10, ... の和を求める
while (i <= n) {
res += i;
// 条件変数を更新する
@@ -43,9 +43,9 @@ function whileLoopII(n) {
/* 二重 for ループ */
function nestedForLoop(n) {
let res = '';
// i = 1, 2, ..., n-1, n とループする
// i = 1, 2, ..., n-1, n のループ
for (let i = 1; i <= n; i++) {
// j = 1, 2, ..., n-1, n とループする
// j = 1, 2, ..., n-1, n のループ
for (let j = 1; j <= n; j++) {
res += `(${i}, ${j}), `;
}
@@ -53,18 +53,18 @@ function nestedForLoop(n) {
return res;
}
/* Driver Code */
/* 実行用コード */
const n = 5;
let res;
res = forLoop(n);
console.log(`for ループの合計結果 res = ${res}`);
console.log(`for ループで求めた和 res = ${res}`);
res = whileLoop(n);
console.log(`while ループの合計結果 res = ${res}`);
console.log(`while ループで求めた和 res = ${res}`);
res = whileLoopII(n);
console.log(`while ループ（2 回更新）の合計結果 res = ${res}`);
console.log(`while ループ（2 回の更新）で求めた和 res = ${res}`);
const resStr = nestedForLoop(n);
console.log(`二重 for ループの走査結果 ${resStr}`);
ja/codes/javascript/chapter_computational_complexity/recursion.js
+13 -13
View File
@@ -8,25 +8,25 @@
function recur(n) {
// 終了条件
if (n === 1) return 1;
// 再帰：再帰呼び出し
// 往路：再帰呼び出し
const res = recur(n - 1);
// 帰りがけ：結果を返す
// 復路：結果を返す
return n + res;
}
/* 反復で再帰を模擬する */
/* 反復を使って再帰を再現する */
function forLoopRecur(n) {
// 明示的なスタックを使ってシステムコールスタックを模擬する
// 明示的なスタックを使って、システムの呼び出しスタックを再現する
const stack = [];
let res = 0;
// 再帰：再帰呼び出し
// 往路：再帰呼び出し
for (let i = n; i > 0; i--) {
// 「スタックへのプッシュ」で「再帰」を模擬する
// 「プッシュ操作」で再帰の「往路」を再現する
stack.push(i);
}
// 帰りがけ：結果を返す
// 復路：結果を返す
while (stack.length) {
// 「スタックから取り出す操作」で「帰り」をシミュレート
// 「ポップ操作」で再帰の「復路」を再現する
res += stack.pop();
}
// res = 1+2+3+...+n
@@ -45,24 +45,24 @@ function tailRecur(n, res) {
function fib(n) {
// 終了条件 f(1) = 0, f(2) = 1
if (n === 1 || n === 2) return n - 1;
// f(n) = f(n-1) + f(n-2) を再帰的に呼び出す
// 再帰呼び出し f(n) = f(n-1) + f(n-2)
const res = fib(n - 1) + fib(n - 2);
// 結果 f(n) を返す
return res;
}
/* Driver Code */
/* 実行用コード */
const n = 5;
let res;
res = recur(n);
console.log(`再帰関数の合計結果 res = ${res}`);
console.log(`再帰関数で求めた和 res = ${res}`);
res = forLoopRecur(n);
console.log(`反復で再帰を模擬した合計結果 res = ${res}`);
console.log(`反復で再帰を再現して求めた和 res = ${res}`);
res = tailRecur(n, 0);
console.log(`末尾再帰関数の合計結果 res = ${res}`);
console.log(`末尾再帰関数で求めた和 res = ${res}`);
res = fib(n);
console.log(`フィボナッチ数列の第 ${n} 項は ${res}`);
ja/codes/javascript/chapter_computational_complexity/space_complexity.js
+19 -19
View File
@@ -10,57 +10,57 @@ const { printTree } = require('../modules/PrintUtil');
/* 関数 */
function constFunc() {
// 何らかの処理を行う
// 何らかの処理を実行する
return 0;
}
/* 定数階 */
/* 定数オーダー */
function constant(n) {
// 定数、変数、オブジェクトは O(1) の空間を占める
// 定数、変数、オブジェクトは O(1) の領域を使用する
const a = 0;
const b = 0;
const nums = new Array(10000);
const node = new ListNode(0);
// ループ内の変数は O(1) の空間を占める
// ループ内の変数は O(1) の領域を使用する
for (let i = 0; i < n; i++) {
const c = 0;
}
// ループ内の関数は O(1) の空間を占める
// ループ内の関数は O(1) の領域を使用する
for (let i = 0; i < n; i++) {
constFunc();
}
}
/* 線形階 */
/* 線形オーダー */
function linear(n) {
// 長さ n の配列は O(n) の空間を使用
// 長さ n の配列は O(n) の領域を使用する
const nums = new Array(n);
// 長さ n のリストは O(n) の空間を使用
// 長さ n のリストは O(n) の領域を使用する
const nodes = [];
for (let i = 0; i < n; i++) {
nodes.push(new ListNode(i));
}
// 長さ n のハッシュテーブルは O(n) の空間を使用
// 長さ n のハッシュテーブルは O(n) の領域を使用する
const map = new Map();
for (let i = 0; i < n; i++) {
map.set(i, i.toString());
}
}
/* 線形時間（再帰実装） */
/* 線形オーダー（再帰による実装） */
function linearRecur(n) {
console.log(`再帰 n = ${n}`);
if (n === 1) return;
linearRecur(n - 1);
}
/* 二乗階 */
/* 二次オーダー */
function quadratic(n) {
// 行列は O(n^2) の空間を使用する
// 行列は O(n^2) の領域を使用する
const numMatrix = Array(n)
.fill(null)
.map(() => Array(n).fill(null));
// 二次元リストは O(n^2) の空間を使用
// 二次元リストは O(n^2) の領域を使用する
const numList = [];
for (let i = 0; i < n; i++) {
const tmp = [];
@@ -71,7 +71,7 @@ function quadratic(n) {
}
}
/* 二次時間（再帰実装） */
/* 二次オーダー（再帰による実装） */
function quadraticRecur(n) {
if (n <= 0) return 0;
const nums = new Array(n);
@@ -79,7 +79,7 @@ function quadraticRecur(n) {
return quadraticRecur(n - 1);
}
/* 指数時間（完全二分木の構築） */
/* 指数オーダー（パーフェクト二分木の構築） */
function buildTree(n) {
if (n === 0) return null;
const root = new TreeNode(0);
@@ -88,14 +88,14 @@ function buildTree(n) {
return root;
}
/* Driver Code */
/* 実行用コード */
const n = 5;
// 定数階
// 定数オーダー
constant(n);
// 線形階
// 線形オーダー
linear(n);
linearRecur(n);
// 二乗階
// 二次オーダー
quadratic(n);
quadraticRecur(n);
// 指数オーダー
ja/codes/javascript/chapter_computational_complexity/time_complexity.js
+32 -32
View File
@@ -4,7 +4,7 @@
* Author: RiverTwilight ([email protected])
*/
/* 定数階 */
/* 定数オーダー */
function constant(n) {
let count = 0;
const size = 100000;
@@ -12,27 +12,27 @@ function constant(n) {
return count;
}
/* 線形階 */
/* 線形オーダー */
function linear(n) {
let count = 0;
for (let i = 0; i < n; i++) count++;
return count;
}
/* 線形時間（配列を走査） */
/* 線形オーダー（配列の走査） */
function arrayTraversal(nums) {
let count = 0;
// ループ回数は配列長に比例する
// ループの回数は配列の長さに比例する
for (let i = 0; i < nums.length; i++) {
count++;
}
return count;
}
/* 二乗階 */
/* 二次オーダー */
function quadratic(n) {
let count = 0;
// ループ回数はデータサイズ n の二乗に比例する
// ループの回数はデータの大きさ n の二乗に比例する
for (let i = 0; i < n; i++) {
for (let j = 0; j < n; j++) {
count++;
@@ -41,30 +41,30 @@ function quadratic(n) {
return count;
}
/* 二次時間（バブルソート） */
/* 二次オーダー（バブルソート） */
function bubbleSort(nums) {
let count = 0; // カウンタ
// 外側のループ：未ソート区間は [0, i]
for (let i = nums.length - 1; i > 0; i--) {
// 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
// 内側のループ：未ソート区間 [0, i] の最大要素を区間の右端に移す
for (let j = 0; j < i; j++) {
if (nums[j] > nums[j + 1]) {
// nums[j] と nums[j + 1] を交換
// nums[j] と nums[j + 1] を交換する
let tmp = nums[j];
nums[j] = nums[j + 1];
nums[j + 1] = tmp;
count += 3; // 要素交換には 3 回の単位操作が含まれる
count += 3; // 要素の交換は 3 回の単位操作からなる
}
}
}
return count;
}
/* 指数時間（ループ実装） */
/* 指数オーダー（ループによる実装） */
function exponential(n) {
let count = 0,
base = 1;
// 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する
// 各回で細胞が 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する
for (let i = 0; i < n; i++) {
for (let j = 0; j < base; j++) {
count++;
@@ -75,13 +75,13 @@ function exponential(n) {
return count;
}
/* 指数時間（再帰実装） */
/* 指数オーダー（再帰による実装） */
function expRecur(n) {
if (n === 1) return 1;
return expRecur(n - 1) + expRecur(n - 1) + 1;
}
/* 対数時間（ループ実装） */
/* 対数オーダー（ループによる実装） */
function logarithmic(n) {
let count = 0;
while (n > 1) {
@@ -91,13 +91,13 @@ function logarithmic(n) {
return count;
}
/* 対数時間（再帰実装） */
/* 対数オーダー（再帰による実装） */
function logRecur(n) {
if (n <= 1) return 0;
return logRecur(n / 2) + 1;
}
/* 線形対数時間 */
/* 線形対数オーダー */
function linearLogRecur(n) {
if (n <= 1) return 1;
let count = linearLogRecur(n / 2) + linearLogRecur(n / 2);
@@ -107,49 +107,49 @@ function linearLogRecur(n) {
return count;
}
/* 階乗時間（再帰実装） */
/* 階乗オーダー（再帰による実装） */
function factorialRecur(n) {
if (n === 0) return 1;
let count = 0;
// 1個から n 個に分裂
// 1 個から n 個に分裂する
for (let i = 0; i < n; i++) {
count += factorialRecur(n - 1);
}
return count;
}
/* Driver Code */
// n を変えて実行し、各計算量で操作回数がどう変化するかを確認できる
/* 実行用コード */
// n を変更して実行し、各計算量で操作回数がどのように変化するか確かめられる
const n = 8;
console.log('入力データサイズ n = ' + n);
console.log('入力データの大きさ n = ' + n);
let count = constant(n);
console.log('定数時間の操作回数 = ' + count);
console.log('定数オーダーの操作回数 = ' + count);
count = linear(n);
console.log('線形時間の操作回数 = ' + count);
console.log('線形オーダーの操作回数 = ' + count);
count = arrayTraversal(new Array(n));
console.log('線形時間（配列の走査）の操作回数 = ' + count);
console.log('線形オーダー（配列の走査）の操作回数 = ' + count);
count = quadratic(n);
console.log('二乗時間の操作回数 = ' + count);
console.log('二次オーダーの操作回数 = ' + count);
let nums = new Array(n);
for (let i = 0; i < n; i++) nums[i] = n - i; // [n,n-1,...,2,1]
count = bubbleSort(nums);
console.log('二乗時間（バブルソート）の操作回数 = ' + count);
console.log('二次オーダー（バブルソート）の操作回数 = ' + count);
count = exponential(n);
console.log('指数時間（ループ実装）の操作回数 = ' + count);
console.log('指数オーダー（ループによる実装）の操作回数 = ' + count);
count = expRecur(n);
console.log('指数時間（再帰実装）の操作回数 = ' + count);
console.log('指数オーダー（再帰による実装）の操作回数 = ' + count);
count = logarithmic(n);
console.log('対数時間（ループ実装）の操作回数 = ' + count);
console.log('対数オーダー（ループによる実装）の操作回数 = ' + count);
count = logRecur(n);
console.log('対数時間（再帰実装）の操作回数 = ' + count);
console.log('対数オーダー（再帰による実装）の操作回数 = ' + count);
count = linearLogRecur(n);
console.log('線形対数時間（再帰実装）の操作回数 = ' + count);
console.log('線形対数オーダー（再帰による実装）の操作回数 = ' + count);
count = factorialRecur(n);
console.log('階乗時間（再帰実装）の操作回数 = ' + count);
console.log('階乗オーダー（再帰による実装）の操作回数 = ' + count);
ja/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js
+9 -9
View File
@@ -4,14 +4,14 @@
* Author: RiverTwilight ([email protected])
*/
/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */
/* 要素が { 1, 2, ..., n } で、順序をシャッフルした配列を生成する */
function randomNumbers(n) {
const nums = Array(n);
// 配列 nums = { 1, 2, 3, ..., n } を生成
// 配列 nums = { 1, 2, 3, ..., n } を生成する
for (let i = 0; i < n; i++) {
nums[i] = i + 1;
}
// 配列要素をランダムにシャッフル
// 配列の要素をランダムに並べ替える
for (let i = 0; i < n; i++) {
const r = Math.floor(Math.random() * (i + 1));
const temp = nums[i];
@@ -21,11 +21,11 @@ function randomNumbers(n) {
return nums;
}
/* 配列 nums 内で数値 1 のインデックスを探す */
/* 配列 nums 内で数値 1 のインデックスを探索する */
function findOne(nums) {
for (let i = 0; i < nums.length; i++) {
// 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる
// 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる
// 要素 1 が配列の先頭にある場合、最良時間計算量 O(1) となる
// 要素 1 が配列の末尾にある場合、最悪時間計算量 O(n) となる
if (nums[i] === 1) {
return i;
}
@@ -33,11 +33,11 @@ function findOne(nums) {
return -1;
}
/* Driver Code */
/* 実行用コード */
for (let i = 0; i < 10; i++) {
const n = 100;
const nums = randomNumbers(n);
const index = findOne(nums);
console.log('\n配列 [ 1, 2, ..., n ] をシャッフルした後 = [' + nums.join(', ') + ']');
console.log('数字 1 のインデックスは ' + index);
console.log('\n配列 [ 1, 2, ..., n ] をシャッフルした結果 = [' + nums.join(', ') + ']');
console.log('数値 1 のインデックスは ' + index);
}