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

ja/codes/javascript/chapter_hashing/array_hash_map.js

@@ -4,7 +4,7 @@
  * Author: Justin ([email protected])
  */
 
-/* キーと値の組 Number -> String */
+/* キーと値のペア Number -> String */
 class Pair {
     constructor(key, val) {
         this.key = key;
@@ -12,11 +12,11 @@ class Pair {
     }
 }
 
-/* 配列ベースのハッシュテーブル */
+/* 配列で実装したハッシュテーブル */
 class ArrayHashMap {
     #buckets;
     constructor() {
-        // 100 個のバケットを含む配列を初期化
+        // 100 個のバケットを含む配列を初期化する
         this.#buckets = new Array(100).fill(null);
     }
 
@@ -25,7 +25,7 @@ class ArrayHashMap {
         return key % 100;
     }
 
-    /* 検索操作 */
+    /* 取得操作 */
     get(key) {
         let index = this.#hashFunc(key);
         let pair = this.#buckets[index];
@@ -42,11 +42,11 @@ class ArrayHashMap {
     /* 削除操作 */
     delete(key) {
         let index = this.#hashFunc(key);
-        // null に設定し、削除を表す
+        // null に設定して、削除を表す
         this.#buckets[index] = null;
     }
 
-    /* すべてのキーと値のペアを取得 */
+    /* キーと値のペアをすべて取得する */
     entries() {
         let arr = [];
         for (let i = 0; i < this.#buckets.length; i++) {
@@ -57,7 +57,7 @@ class ArrayHashMap {
         return arr;
     }
 
-    /* すべてのキーを取得 */
+    /* すべてのキーを取得する */
     keys() {
         let arr = [];
         for (let i = 0; i < this.#buckets.length; i++) {
@@ -68,7 +68,7 @@ class ArrayHashMap {
         return arr;
     }
 
-    /* すべての値を取得 */
+    /* すべての値を取得する */
     values() {
         let arr = [];
         for (let i = 0; i < this.#buckets.length; i++) {
@@ -79,7 +79,7 @@ class ArrayHashMap {
         return arr;
     }
 
-    /* ハッシュテーブルを出力 */
+    /* ハッシュテーブルを表示する */
     print() {
         let pairSet = this.entries();
         for (const pair of pairSet) {
@@ -88,41 +88,41 @@ class ArrayHashMap {
     }
 }
 
-/* Driver Code */
-/* ハッシュテーブルを初期化 */
+/* 実行用コード */
+/* ハッシュテーブルを初期化する */
 const map = new ArrayHashMap();
 /* 追加操作 */
-// ハッシュテーブルにキーと値のペア (key, value) を追加
-map.set(12836, 'シャオハー');
-map.set(15937, 'シャオルオ');
-map.set(16750, 'シャオスワン');
-map.set(13276, 'シャオファー');
-map.set(10583, 'シャオヤー');
-console.info('\n追加完了後、ハッシュ表は\nKey -> Value');
+// ハッシュテーブルにキーと値のペア (key, value) を追加する
+map.set(12836, '小哈');
+map.set(15937, '小啰');
+map.set(16750, '小算');
+map.set(13276, '小法');
+map.set(10583, '小鸭');
+console.info('\n追加後のハッシュテーブル\nKey -> Value');
 map.print();
 
-/* 検索操作 */
-// キー key をハッシュテーブルに渡し、値 value を取得
+/* 取得操作 */
+// ハッシュテーブルにキー key を渡し、値 value を取得する
 let name = map.get(15937);
-console.info('\n学籍番号 15937 を入力すると、氏名 ' + name);
+console.info('\n学生番号 15937 に対応する氏名は ' + name);
 
 /* 削除操作 */
-// ハッシュテーブルからキーと値のペア (key, value) を削除
+// ハッシュテーブルからキーと値のペア (key, value) を削除する
 map.delete(10583);
-console.info('\n10583 を削除した後、ハッシュ表は\nKey -> Value');
+console.info('\n10583 を削除した後のハッシュテーブル\nKey -> Value');
 map.print();
 
-/* ハッシュテーブルを走査 */
-console.info('\nキーと値のペア Key->Value を走査');
+/* ハッシュテーブルを走査する */
+console.info('\nキーと値のペア Key->Value を走査する');
 for (const pair of map.entries()) {
     if (!pair) continue;
     console.info(pair.key + ' -> ' + pair.val);
 }
-console.info('\nキー Key を個別に走査');
+console.info('\nキー Key だけを走査する');
 for (const key of map.keys()) {
     console.info(key);
 }
-console.info('\n値 Value を個別に走査');
+console.info('\n値 Value だけを走査する');
 for (const val of map.values()) {
     console.info(val);
 }

ja/codes/javascript/chapter_hashing/hash_map.js

@@ -4,41 +4,41 @@
  * Author: Justin ([email protected])
  */
 
-/* Driver Code */
-/* ハッシュテーブルを初期化 */
+/* 実行用コード */
+/* ハッシュテーブルを初期化する */
 const map = new Map();
 
 /* 追加操作 */
-// ハッシュテーブルにキーと値のペア (key, value) を追加
-map.set(12836, 'シャオハー');
-map.set(15937, 'シャオルオ');
-map.set(16750, 'シャオスワン');
-map.set(13276, 'シャオファー');
-map.set(10583, 'シャオヤー');
-console.info('\n追加完了後、ハッシュ表は\nKey -> Value');
+// ハッシュテーブルにキーと値のペア (key, value) を追加する
+map.set(12836, '小哈');
+map.set(15937, '小啰');
+map.set(16750, '小算');
+map.set(13276, '小法');
+map.set(10583, '小鸭');
+console.info('\n追加後のハッシュテーブル\nKey -> Value');
 console.info(map);
 
-/* 検索操作 */
-// キー key をハッシュテーブルに渡し、値 value を取得
+/* 取得操作 */
+// ハッシュテーブルにキー key を渡し、値 value を取得する
 let name = map.get(15937);
-console.info('\n学籍番号 15937 を入力すると、氏名 ' + name);
+console.info('\n学生番号 15937 に対応する氏名は ' + name);
 
 /* 削除操作 */
-// ハッシュテーブルからキーと値のペア (key, value) を削除
+// ハッシュテーブルからキーと値のペア (key, value) を削除する
 map.delete(10583);
-console.info('\n10583 を削除した後、ハッシュ表は\nKey -> Value');
+console.info('\n10583 を削除した後のハッシュテーブル\nKey -> Value');
 console.info(map);
 
-/* ハッシュテーブルを走査 */
-console.info('\nキーと値のペア Key->Value を走査');
+/* ハッシュテーブルを走査する */
+console.info('\nキーと値のペア Key->Value を走査する');
 for (const [k, v] of map.entries()) {
     console.info(k + ' -> ' + v);
 }
-console.info('\nキー Key を個別に走査');
+console.info('\nキー Key だけを走査する');
 for (const k of map.keys()) {
     console.info(k);
 }
-console.info('\n値 Value を個別に走査');
+console.info('\n値 Value だけを走査する');
 for (const v of map.values()) {
     console.info(v);
 }

ja/codes/javascript/chapter_hashing/hash_map_chaining.js

@@ -4,7 +4,7 @@
  * Author: yuan0221 ([email protected])
  */
 
-/* キーと値の組 Number -> String */
+/* キーと値のペア Number -> String */
 class Pair {
     constructor(key, val) {
         this.key = key;
@@ -12,12 +12,12 @@ class Pair {
     }
 }
 
-/* チェイン法ハッシュテーブル */
+/* チェイン法のハッシュテーブル */
 class HashMapChaining {
-    #size; // キーと値のペア数
-    #capacity; // ハッシュテーブル容量
-    #loadThres; // リサイズを発動する負荷率のしきい値
-    #extendRatio; // 拡張倍率
+    #size; // キーと値のペアの数
+    #capacity; // ハッシュテーブルの容量
+    #loadThres; // 容量の拡張を開始する負荷率のしきい値
+    #extendRatio; // 容量の拡張倍率
     #buckets; // バケット配列
 
     /* コンストラクタ */
@@ -39,36 +39,36 @@ class HashMapChaining {
         return this.#size / this.#capacity;
     }
 
-    /* 検索操作 */
+    /* 取得操作 */
     get(key) {
         const index = this.#hashFunc(key);
         const bucket = this.#buckets[index];
-        // バケットを走査し、key が見つかれば対応する val を返す
+        // バケットを走査し、key が見つかったら対応する val を返す
         for (const pair of bucket) {
             if (pair.key === key) {
                 return pair.val;
             }
         }
-        // key が見つからない場合は null を返す
+        // key が見つからなかった場合、null を返す
         return null;
     }
 
     /* 追加操作 */
     put(key, val) {
-        // 負荷率がしきい値を超えたら、リサイズを実行
+        // 負荷率がしきい値を超えた場合、容量を拡張する
         if (this.#loadFactor() > this.#loadThres) {
             this.#extend();
         }
         const index = this.#hashFunc(key);
         const bucket = this.#buckets[index];
-        // バケットを走査し、指定した key が見つかれば対応する val を更新して返す
+        // バケットを走査し、指定された key が見つかったら、対応する val を更新して戻る
         for (const pair of bucket) {
             if (pair.key === key) {
                 pair.val = val;
                 return;
             }
         }
-        // その key が存在しなければ、キーと値のペアを末尾に追加
+        // key が存在しない場合、キーと値のペアを末尾に追加する
         const pair = new Pair(key, val);
         bucket.push(pair);
         this.#size++;
@@ -78,7 +78,7 @@ class HashMapChaining {
     remove(key) {
         const index = this.#hashFunc(key);
         let bucket = this.#buckets[index];
-        // バケットを走査してキーと値のペアを削除
+        // バケットを走査し、キーと値のペアを削除する
         for (let i = 0; i < bucket.length; i++) {
             if (bucket[i].key === key) {
                 bucket.splice(i, 1);
@@ -88,15 +88,15 @@ class HashMapChaining {
         }
     }
 
-    /* ハッシュテーブルを拡張 */
+    /* ハッシュテーブルの容量を拡張する */
     #extend() {
-        // 元のハッシュテーブルを一時保存
+        // 元のハッシュテーブルを一時保存する
         const bucketsTmp = this.#buckets;
-        // リサイズ後の新しいハッシュテーブルを初期化
+        // 拡張後の新しいハッシュテーブルを初期化する
         this.#capacity *= this.#extendRatio;
         this.#buckets = new Array(this.#capacity).fill(null).map((x) => []);
         this.#size = 0;
-        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す
+        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルに移す
         for (const bucket of bucketsTmp) {
             for (const pair of bucket) {
                 this.put(pair.key, pair.val);
@@ -104,7 +104,7 @@ class HashMapChaining {
         }
     }
 
-    /* ハッシュテーブルを出力 */
+    /* ハッシュテーブルを表示する */
     print() {
         for (const bucket of this.#buckets) {
             let res = [];
@@ -116,27 +116,27 @@ class HashMapChaining {
     }
 }
 
-/* Driver Code */
-/* ハッシュテーブルを初期化 */
+/* 実行用コード */
+/* ハッシュテーブルを初期化する */
 const map = new HashMapChaining();
 
 /* 追加操作 */
-// ハッシュテーブルにキーと値のペア (key, value) を追加
-map.put(12836, 'シャオハー');
-map.put(15937, 'シャオルオ');
-map.put(16750, 'シャオスワン');
-map.put(13276, 'シャオファー');
-map.put(10583, 'シャオヤー');
-console.log('\n追加完了後、ハッシュ表は\nKey -> Value');
+// ハッシュテーブルにキーと値のペア (key, value) を追加する
+map.put(12836, '小哈');
+map.put(15937, '小啰');
+map.put(16750, '小算');
+map.put(13276, '小法');
+map.put(10583, '小鸭');
+console.log('\n追加後のハッシュテーブル\nKey -> Value');
 map.print();
 
-/* 検索操作 */
-// キー key をハッシュテーブルに渡し、値 value を取得
+/* 取得操作 */
+// ハッシュテーブルにキー key を渡し、値 value を取得する
 const name = map.get(13276);
-console.log('\n学籍番号 13276 を入力すると、名前 ' + name);
+console.log('\n学生番号 13276 に対応する氏名は ' + name);
 
 /* 削除操作 */
-// ハッシュテーブルからキーと値のペア (key, value) を削除
+// ハッシュテーブルからキーと値のペア (key, value) を削除する
 map.remove(12836);
-console.log('\n12836 を削除した後、ハッシュテーブルは\nKey -> Value');
+console.log('\n12836 を削除した後のハッシュテーブル\nKey -> Value');
 map.print();

ja/codes/javascript/chapter_hashing/hash_map_open_addressing.js

@@ -4,7 +4,7 @@
  * Author: yuan0221 ([email protected]), krahets ([email protected])
  */
 
-/* キーと値の組 Number -> String */
+/* キーと値のペア Number -> String */
 class Pair {
     constructor(key, val) {
         this.key = key;
@@ -12,23 +12,23 @@ class Pair {
     }
 }
 
-/* オープンアドレス法ハッシュテーブル */
+/* オープンアドレス法のハッシュテーブル */
 class HashMapOpenAddressing {
-    #size; // キーと値のペア数
-    #capacity; // ハッシュテーブル容量
-    #loadThres; // リサイズを発動する負荷率のしきい値
-    #extendRatio; // 拡張倍率
+    #size; // キーと値のペアの数
+    #capacity; // ハッシュテーブルの容量
+    #loadThres; // 容量の拡張を開始する負荷率のしきい値
+    #extendRatio; // 容量の拡張倍率
     #buckets; // バケット配列
-    #TOMBSTONE; // 削除済みマーク
+    #TOMBSTONE; // 削除マーカー
 
     /* コンストラクタ */
     constructor() {
-        this.#size = 0; // キーと値のペア数
-        this.#capacity = 4; // ハッシュテーブル容量
-        this.#loadThres = 2.0 / 3.0; // リサイズを発動する負荷率のしきい値
-        this.#extendRatio = 2; // 拡張倍率
+        this.#size = 0; // キーと値のペアの数
+        this.#capacity = 4; // ハッシュテーブルの容量
+        this.#loadThres = 2.0 / 3.0; // 容量の拡張を開始する負荷率のしきい値
+        this.#extendRatio = 2; // 容量の拡張倍率
         this.#buckets = Array(this.#capacity).fill(null); // バケット配列
-        this.#TOMBSTONE = new Pair(-1, '-1'); // 削除済みマーク
+        this.#TOMBSTONE = new Pair(-1, '-1'); // 削除マーカー
     }
 
     /* ハッシュ関数 */
@@ -41,23 +41,23 @@ class HashMapOpenAddressing {
         return this.#size / this.#capacity;
     }
 
-    /* key に対応するバケットインデックスを探す */
+    /* key に対応するバケットのインデックスを探索する */
     #findBucket(key) {
         let index = this.#hashFunc(key);
         let firstTombstone = -1;
-        // 線形プロービングを行い、空バケットに達したら終了
+        // 線形探索法で探索し、空のバケットに到達したら終了する
         while (this.#buckets[index] !== null) {
-            // key が見つかったら、対応するバケットのインデックスを返す
+            // key が見つかった場合、対応するバケットのインデックスを返す
             if (this.#buckets[index].key === key) {
-                // 以前に削除マークが見つかっていれば、そのインデックスへキーと値のペアを移動
+                // それ以前に削除マーカーが見つかっていれば、そのインデックスにキーと値のペアを移す
                 if (firstTombstone !== -1) {
                     this.#buckets[firstTombstone] = this.#buckets[index];
                     this.#buckets[index] = this.#TOMBSTONE;
-                    return firstTombstone; // 移動後のバケットインデックスを返す
+                    return firstTombstone; // 移動後のバケットのインデックスを返す
                 }
                 return index; // バケットのインデックスを返す
             }
-            // 最初に見つかった削除マークを記録
+            // 最初に見つかった削除マーカーを記録する
             if (
                 firstTombstone === -1 &&
                 this.#buckets[index] === this.#TOMBSTONE
@@ -67,34 +67,34 @@ class HashMapOpenAddressing {
             // バケットのインデックスを計算し、末尾を越えたら先頭に戻る
             index = (index + 1) % this.#capacity;
         }
-        // key が存在しない場合は追加位置のインデックスを返す
+        // key が存在しない場合、追加位置のインデックスを返す
         return firstTombstone === -1 ? index : firstTombstone;
     }
 
-    /* 検索操作 */
+    /* 取得操作 */
     get(key) {
-        // key に対応するバケットインデックスを探す
+        // key に対応するバケットのインデックスを探索する
         const index = this.#findBucket(key);
-        // キーと値の組が見つかったら、対応する val を返す
+        // キーと値のペアが見つかった場合、対応する val を返す
         if (
             this.#buckets[index] !== null &&
             this.#buckets[index] !== this.#TOMBSTONE
         ) {
             return this.#buckets[index].val;
         }
-        // キーと値の組が存在しなければ null を返す
+        // キーと値のペアが存在しない場合、null を返す
         return null;
     }
 
     /* 追加操作 */
     put(key, val) {
-        // 負荷率がしきい値を超えたら、リサイズを実行
+        // 負荷率がしきい値を超えた場合、容量を拡張する
         if (this.#loadFactor() > this.#loadThres) {
             this.#extend();
         }
-        // key に対応するバケットインデックスを探す
+        // key に対応するバケットのインデックスを探索する
         const index = this.#findBucket(key);
-        // キーと値の組が見つかったら、val を上書きして返す
+        // キーと値のペアが見つかった場合、val を上書きして戻る
         if (
             this.#buckets[index] !== null &&
             this.#buckets[index] !== this.#TOMBSTONE
@@ -102,16 +102,16 @@ class HashMapOpenAddressing {
             this.#buckets[index].val = val;
             return;
         }
-        // キーと値の組が存在しない場合は、その組を追加する
+        // キーと値のペアが存在しない場合、そのペアを追加する
         this.#buckets[index] = new Pair(key, val);
         this.#size++;
     }
 
     /* 削除操作 */
     remove(key) {
-        // key に対応するバケットインデックスを探す
+        // key に対応するバケットのインデックスを探索する
         const index = this.#findBucket(key);
-        // キーと値の組が見つかったら、削除マーカーで上書きする
+        // キーと値のペアが見つかった場合、削除マーカーで上書きする
         if (
             this.#buckets[index] !== null &&
             this.#buckets[index] !== this.#TOMBSTONE
@@ -121,15 +121,15 @@ class HashMapOpenAddressing {
         }
     }
 
-    /* ハッシュテーブルを拡張 */
+    /* ハッシュテーブルの容量を拡張する */
     #extend() {
-        // 元のハッシュテーブルを一時保存
+        // 元のハッシュテーブルを一時保存する
         const bucketsTmp = this.#buckets;
-        // リサイズ後の新しいハッシュテーブルを初期化
+        // 拡張後の新しいハッシュテーブルを初期化する
         this.#capacity *= this.#extendRatio;
         this.#buckets = Array(this.#capacity).fill(null);
         this.#size = 0;
-        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルへ移す
+        // キーと値のペアを元のハッシュテーブルから新しいハッシュテーブルに移す
         for (const pair of bucketsTmp) {
             if (pair !== null && pair !== this.#TOMBSTONE) {
                 this.put(pair.key, pair.val);
@@ -137,7 +137,7 @@ class HashMapOpenAddressing {
         }
     }
 
-    /* ハッシュテーブルを出力 */
+    /* ハッシュテーブルを表示する */
     print() {
         for (const pair of this.#buckets) {
             if (pair === null) {
@@ -151,27 +151,27 @@ class HashMapOpenAddressing {
     }
 }
 
-/* Driver Code */
-// ハッシュテーブルを初期化
+/* 実行用コード */
+// ハッシュテーブルを初期化する
 const hashmap = new HashMapOpenAddressing();
 
 // 追加操作
-// ハッシュテーブルにキーと値の組 (key, val) を追加する
-hashmap.put(12836, 'シャオハー');
-hashmap.put(15937, 'シャオルオ');
-hashmap.put(16750, 'シャオスワン');
-hashmap.put(13276, 'シャオファー');
-hashmap.put(10583, 'シャオヤー');
-console.log('\n追加完了後、ハッシュ表は\nKey -> Value');
+// ハッシュテーブルにキーと値のペア (key, val) を追加する
+hashmap.put(12836, '小哈');
+hashmap.put(15937, '小啰');
+hashmap.put(16750, '小算');
+hashmap.put(13276, '小法');
+hashmap.put(10583, '小鸭');
+console.log('\n追加後のハッシュテーブル\nKey -> Value');
 hashmap.print();
 
-// 検索操作
-// ハッシュテーブルにキー key を入力し、値 val を得る
+// 取得操作
+// ハッシュテーブルにキー key を渡し、値 val を取得する
 const name = hashmap.get(13276);
-console.log('\n学籍番号 13276 を入力すると、名前 ' + name);
+console.log('\n学生番号 13276 に対応する氏名は ' + name);
 
 // 削除操作
-// ハッシュテーブルからキーと値の組 (key, val) を削除する
+// ハッシュテーブルからキーと値のペア (key, val) を削除する
 hashmap.remove(16750);
-console.log('\n16750 を削除した後、ハッシュテーブルは\nKey -> Value');
+console.log('\n16750 を削除した後のハッシュテーブル\nKey -> Value');
 hashmap.print();

ja/codes/javascript/chapter_hashing/simple_hash.js

@@ -24,7 +24,7 @@ function mulHash(key) {
     return hash;
 }
 
-/* XOR ハッシュ */
+/* 排他的論理和ハッシュ */
 function xorHash(key) {
     let hash = 0;
     const MODULUS = 1000000007;
@@ -44,17 +44,17 @@ function rotHash(key) {
     return hash;
 }
 
-/* Driver Code */
-const key = 'Hello アルゴリズム';
+/* 実行用コード */
+const key = 'Hello 算法';
 
 let hash = addHash(key);
-console.log('加算ハッシュ値は ' + hash);
+console.log('加算ハッシュの値は ' + hash);
 
 hash = mulHash(key);
-console.log('乗算ハッシュ値は ' + hash);
+console.log('乗算ハッシュの値は ' + hash);
 
 hash = xorHash(key);
-console.log('XORハッシュ値は ' + hash);
+console.log('排他的論理和ハッシュの値は ' + hash);
 
 hash = rotHash(key);
-console.log('回転ハッシュ値は ' + hash);
+console.log('回転ハッシュの値は ' + hash);