Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/javascript/chapter_computational_complexity/iteration.js

@@ -0,0 +1,70 @@
+/**
+ * File: iteration.js
+ * Created Time: 2023-08-28
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* for ループ */
+function forLoop(n) {
+    let res = 0;
+    // 1, 2, ..., n-1, n を順に加算する
+    for (let i = 1; i <= n; i++) {
+        res += i;
+    }
+    return res;
+}
+
+/* while ループ */
+function whileLoop(n) {
+    let res = 0;
+    let i = 1; // 条件変数を初期化する
+    // 1, 2, ..., n-1, n を順に加算する
+    while (i <= n) {
+        res += i;
+        i++; // 条件変数を更新する
+    }
+    return res;
+}
+
+/* while ループ（2回更新） */
+function whileLoopII(n) {
+    let res = 0;
+    let i = 1; // 条件変数を初期化する
+    // 1, 4, 10, ... を順に加算する
+    while (i <= n) {
+        res += i;
+        // 条件変数を更新する
+        i++;
+        i *= 2;
+    }
+    return res;
+}
+
+/* 二重 for ループ */
+function nestedForLoop(n) {
+    let res = '';
+    // i = 1, 2, ..., n-1, n とループする
+    for (let i = 1; i <= n; i++) {
+        // j = 1, 2, ..., n-1, n とループする
+        for (let j = 1; j <= n; j++) {
+            res += `(${i}, ${j}), `;
+        }
+    }
+    return res;
+}
+
+/* Driver Code */
+const n = 5;
+let res;
+
+res = forLoop(n);
+console.log(`for ループの合計結果 res = ${res}`);
+
+res = whileLoop(n);
+console.log(`while ループの合計結果 res = ${res}`);
+
+res = whileLoopII(n);
+console.log(`while ループ（2 回更新）の合計結果 res = ${res}`);
+
+const resStr = nestedForLoop(n);
+console.log(`二重 for ループの走査結果 ${resStr}`);

ja/codes/javascript/chapter_computational_complexity/recursion.js

@@ -0,0 +1,69 @@
+/**
+ * File: recursion.js
+ * Created Time: 2023-08-28
+ * Author: Gaofer Chou (gaofer-chou@qq.com)
+ */
+
+/* 再帰 */
+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
+    return res;
+}
+
+/* 末尾再帰 */
+function tailRecur(n, res) {
+    // 終了条件
+    if (n === 0) return res;
+    // 末尾再帰呼び出し
+    return tailRecur(n - 1, res + n);
+}
+
+/* フィボナッチ数列：再帰 */
+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) を再帰的に呼び出す
+    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}`);
+
+res = forLoopRecur(n);
+console.log(`反復で再帰を模擬した合計結果 res = ${res}`);
+
+res = tailRecur(n, 0);
+console.log(`末尾再帰関数の合計結果 res = ${res}`);
+
+res = fib(n);
+console.log(`フィボナッチ数列の第 ${n} 項は ${res}`);
+

ja/codes/javascript/chapter_computational_complexity/space_complexity.js

@@ -0,0 +1,103 @@
+/**
+ * File: space_complexity.js
+ * Created Time: 2023-02-05
+ * Author: Justin (xiefahit@gmail.com)
+ */
+
+const { ListNode } = require('../modules/ListNode');
+const { TreeNode } = require('../modules/TreeNode');
+const { printTree } = require('../modules/PrintUtil');
+
+/* 関数 */
+function constFunc() {
+    // 何らかの処理を行う
+    return 0;
+}
+
+/* 定数階 */
+function constant(n) {
+    // 定数、変数、オブジェクトは O(1) の空間を占める
+    const a = 0;
+    const b = 0;
+    const nums = new Array(10000);
+    const node = new ListNode(0);
+    // ループ内の変数は O(1) の空間を占める
+    for (let i = 0; i < n; i++) {
+        const c = 0;
+    }
+    // ループ内の関数は O(1) の空間を占める
+    for (let i = 0; i < n; i++) {
+        constFunc();
+    }
+}
+
+/* 線形階 */
+function linear(n) {
+    // 長さ n の配列は O(n) の空間を使用
+    const nums = new Array(n);
+    // 長さ n のリストは O(n) の空間を使用
+    const nodes = [];
+    for (let i = 0; i < n; i++) {
+        nodes.push(new ListNode(i));
+    }
+    // 長さ 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) の空間を使用する
+    const numMatrix = Array(n)
+        .fill(null)
+        .map(() => Array(n).fill(null));
+    // 二次元リストは O(n^2) の空間を使用
+    const numList = [];
+    for (let i = 0; i < n; i++) {
+        const tmp = [];
+        for (let j = 0; j < n; j++) {
+            tmp.push(0);
+        }
+        numList.push(tmp);
+    }
+}
+
+/* 二次時間（再帰実装） */
+function quadraticRecur(n) {
+    if (n <= 0) return 0;
+    const nums = new Array(n);
+    console.log(`再帰 n = ${n} における nums の長さ = ${nums.length}`);
+    return quadraticRecur(n - 1);
+}
+
+/* 指数時間（完全二分木の構築） */
+function buildTree(n) {
+    if (n === 0) return null;
+    const root = new TreeNode(0);
+    root.left = buildTree(n - 1);
+    root.right = buildTree(n - 1);
+    return root;
+}
+
+/* Driver Code */
+const n = 5;
+// 定数階
+constant(n);
+// 線形階
+linear(n);
+linearRecur(n);
+// 二乗階
+quadratic(n);
+quadraticRecur(n);
+// 指数オーダー
+const root = buildTree(n);
+printTree(root);

ja/codes/javascript/chapter_computational_complexity/time_complexity.js

@@ -0,0 +1,155 @@
+/**
+ * File: time_complexity.js
+ * Created Time: 2023-01-02
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+/* 定数階 */
+function constant(n) {
+    let count = 0;
+    const size = 100000;
+    for (let i = 0; i < size; i++) count++;
+    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 の二乗に比例する
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+            count++;
+        }
+    }
+    return count;
+}
+
+/* 二次時間（バブルソート） */
+function bubbleSort(nums) {
+    let count = 0; // カウンタ
+    // 外側のループ：未ソート区間は [0, i]
+    for (let i = nums.length - 1; i > 0; i--) {
+        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
+        for (let j = 0; j < i; j++) {
+            if (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 回の単位操作が含まれる
+            }
+        }
+    }
+    return count;
+}
+
+/* 指数時間（ループ実装） */
+function exponential(n) {
+    let count = 0,
+        base = 1;
+    // 細胞は各ラウンドで 2 つに分裂し、数列 1, 2, 4, 8, ..., 2^(n-1) を形成する
+    for (let i = 0; i < n; i++) {
+        for (let j = 0; j < base; j++) {
+            count++;
+        }
+        base *= 2;
+    }
+    // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1
+    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) {
+        n = n / 2;
+        count++;
+    }
+    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);
+    for (let i = 0; i < n; i++) {
+        count++;
+    }
+    return count;
+}
+
+/* 階乗時間（再帰実装） */
+function factorialRecur(n) {
+    if (n === 0) return 1;
+    let count = 0;
+    // 1個から n 個に分裂
+    for (let i = 0; i < n; i++) {
+        count += factorialRecur(n - 1);
+    }
+    return count;
+}
+
+/* Driver Code */
+// n を変えて実行し、各計算量で操作回数がどう変化するかを確認できる
+const n = 8;
+console.log('入力データサイズ n = ' + n);
+
+let count = constant(n);
+console.log('定数時間の操作回数 = ' + count);
+
+count = linear(n);
+console.log('線形時間の操作回数 = ' + count);
+count = arrayTraversal(new Array(n));
+console.log('線形時間（配列の走査）の操作回数 = ' + count);
+
+count = quadratic(n);
+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);
+
+count = exponential(n);
+console.log('指数時間（ループ実装）の操作回数 = ' + count);
+count = expRecur(n);
+console.log('指数時間（再帰実装）の操作回数 = ' + count);
+
+count = logarithmic(n);
+console.log('対数時間（ループ実装）の操作回数 = ' + count);
+count = logRecur(n);
+console.log('対数時間（再帰実装）の操作回数 = ' + count);
+
+count = linearLogRecur(n);
+console.log('線形対数時間（再帰実装）の操作回数 = ' + count);
+
+count = factorialRecur(n);
+console.log('階乗時間（再帰実装）の操作回数 = ' + count);

ja/codes/javascript/chapter_computational_complexity/worst_best_time_complexity.js

@@ -0,0 +1,43 @@
+/**
+ * File: worst_best_time_complexity.js
+ * Created Time: 2023-01-05
+ * Author: RiverTwilight (contact@rene.wang)
+ */
+
+/* 要素が { 1, 2, ..., n } で、順序がシャッフルされた配列を生成 */
+function randomNumbers(n) {
+    const nums = Array(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];
+        nums[i] = nums[r];
+        nums[r] = temp;
+    }
+    return nums;
+}
+
+/* 配列 nums 内で数値 1 のインデックスを探す */
+function findOne(nums) {
+    for (let i = 0; i < nums.length; i++) {
+        // 要素 1 が配列の先頭にあるとき、最良時間計算量 O(1) となる
+        // 要素 1 が配列の末尾にあるとき、最悪時間計算量 O(n) となる
+        if (nums[i] === 1) {
+            return i;
+        }
+    }
+    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);
+}