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/cpp/chapter_array_and_linkedlist/array.cpp

@@ -6,20 +6,20 @@
 
 #include "../utils/common.hpp"
 
-/* 要素へランダムアクセス */
+/* 要素にランダムアクセスする */
 int randomAccess(int *nums, int size) {
-    // 区間 [0, size) からランダムに 1 つの数を選ぶ
+    // 区間 [0, size) から数値をランダムに 1 つ選ぶ
     int randomIndex = rand() % size;
-    // ランダムな要素を取得して返す
+    // ランダムに選んだ要素を取得して返す
     int randomNum = nums[randomIndex];
     return randomNum;
 }
 
-/* 配列長を拡張する */
+/* 配列の長さを拡張する */
 int *extend(int *nums, int size, int enlarge) {
-    // 拡張後の長さを持つ配列を初期化する
+    // 拡張後の長さの配列を初期化する
     int *res = new int[size + enlarge];
-    // 元の配列の全要素を新しい配列にコピー
+    // 元の配列の全要素を新しい配列にコピーする
     for (int i = 0; i < size; i++) {
         res[i] = nums[i];
     }
@@ -29,34 +29,34 @@ int *extend(int *nums, int size, int enlarge) {
     return res;
 }
 
-/* 配列の index 番目に要素 num を挿入 */
+/* 配列のインデックス index に要素 num を挿入する */
 void insert(int *nums, int size, int num, int index) {
-    // インデックス index 以降の全要素を 1 つ後ろへ移動する
+    // インデックス index 以降の全要素を 1 つ後ろにずらす
     for (int i = size - 1; i > index; i--) {
         nums[i] = nums[i - 1];
     }
-    // index の要素に num を代入する
+    // インデックス index の要素に num を代入する
     nums[index] = num;
 }
 
-/* index の要素を削除する */
+/* インデックス index の要素を削除する */
 void remove(int *nums, int size, int index) {
-    // インデックス index より後ろの全要素を 1 つ前へ移動する
+    // インデックス index より後の全要素を 1 つ前にずらす
     for (int i = index; i < size - 1; i++) {
         nums[i] = nums[i + 1];
     }
 }
 
-/* 配列を走査 */
+/* 配列を走査する */
 void traverse(int *nums, int size) {
     int count = 0;
-    // インデックスで配列を走査
+    // インデックスを使って配列を走査する
     for (int i = 0; i < size; i++) {
         count += nums[i];
     }
 }
 
-/* 配列内で指定要素を探す */
+/* 配列から指定した要素を探索する */
 int find(int *nums, int size, int target) {
     for (int i = 0; i < size; i++) {
         if (nums[i] == target)
@@ -65,9 +65,9 @@ int find(int *nums, int size, int target) {
     return -1;
 }
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* 配列を初期化 */
+    /* 配列を初期化する */
     int size = 5;
     int *arr = new int[size];
     cout << "配列 arr = ";
@@ -79,31 +79,31 @@ int main() {
 
     /* ランダムアクセス */
     int randomNum = randomAccess(nums, size);
-    cout << "nums から取得したランダム要素 " << randomNum << endl;
+    cout << "nums からランダムに取得した要素 " << randomNum << endl;
 
-    /* 長さを拡張 */
+    /* 長さの拡張 */
     int enlarge = 3;
     nums = extend(nums, size, enlarge);
     size += enlarge;
-    cout << "配列長を 8 に拡張し、nums = ";
+    cout << "配列の長さを 8 に拡張した結果 nums = ";
     printArray(nums, size);
 
     /* 要素を挿入する */
     insert(nums, size, 6, 3);
-    cout << "インデックス 3 に数値 6 を挿入し、nums = ";
+    cout << "インデックス 3 に数値 6 を挿入した結果 nums = ";
     printArray(nums, size);
 
-    /* 要素を削除 */
+    /* 要素を削除する */
     remove(nums, size, 2);
-    cout << "インデックス 2 の要素を削除し、nums = ";
+    cout << "インデックス 2 の要素を削除した結果 nums = ";
     printArray(nums, size);
 
-    /* 配列を走査 */
+    /* 配列を走査する */
     traverse(nums, size);
 
     /* 要素を探索する */
     int index = find(nums, size, 3);
-    cout << "nums 内で要素 3 を検索し、インデックス = " << index << endl;
+    cout << "nums から要素 3 を探索した結果のインデックス = " << index << endl;
 
     // メモリを解放する
     delete[] arr;

ja/codes/cpp/chapter_array_and_linkedlist/linked_list.cpp

@@ -6,14 +6,14 @@
 
 #include "../utils/common.hpp"
 
-/* 連結リストでノード n0 の後ろにノード P を挿入する */
+/* 連結リストのノード n0 の直後にノード P を挿入する */
 void insert(ListNode *n0, ListNode *P) {
     ListNode *n1 = n0->next;
     P->next = n1;
     n0->next = P;
 }
 
-/* 連結リストでノード n0 の直後のノードを削除する */
+/* 連結リストのノード n0 の直後のノードを削除する */
 void remove(ListNode *n0) {
     if (n0->next == nullptr)
         return;
@@ -25,7 +25,7 @@ void remove(ListNode *n0) {
     delete P;
 }
 
-/* 連結リスト内で index 番目のノードにアクセス */
+/* 連結リストのインデックス index にあるノードにアクセスする */
 ListNode *access(ListNode *head, int index) {
     for (int i = 0; i < index; i++) {
         if (head == nullptr)
@@ -35,7 +35,7 @@ ListNode *access(ListNode *head, int index) {
     return head;
 }
 
-/* 連結リストで値が target の最初のノードを探す */
+/* 連結リストから値が target である最初のノードを探索する */
 int find(ListNode *head, int target) {
     int index = 0;
     while (head != nullptr) {
@@ -47,40 +47,40 @@ int find(ListNode *head, int target) {
     return -1;
 }
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* 連結リストを初期化 */
-    // 各ノードを初期化
+    /* 連結リストを初期化する */
+    // 各ノードを初期化する
     ListNode *n0 = new ListNode(1);
     ListNode *n1 = new ListNode(3);
     ListNode *n2 = new ListNode(2);
     ListNode *n3 = new ListNode(5);
     ListNode *n4 = new ListNode(4);
-    // ノード間の参照を構築する
+    // ノード間の参照を設定する
     n0->next = n1;
     n1->next = n2;
     n2->next = n3;
     n3->next = n4;
-    cout << "初期化した連結リストは" << endl;
+    cout << "初期化した連結リスト" << endl;
     printLinkedList(n0);
 
-    /* ノードを挿入 */
+    /* ノードを挿入する */
     insert(n0, new ListNode(0));
-    cout << "ノード挿入後の連結リストは" << endl;
+    cout << "ノードを挿入した後の連結リスト" << endl;
     printLinkedList(n0);
 
-    /* ノードを削除 */
+    /* ノードを削除する */
     remove(n0);
-    cout << "ノード削除後の連結リストは" << endl;
+    cout << "ノードを削除した後の連結リスト" << endl;
     printLinkedList(n0);
 
-    /* ノードにアクセス */
+    /* ノードにアクセスする */
     ListNode *node = access(n0, 3);
-    cout << "連結リストのインデックス 3 のノードの値 = " << node->val << endl;
+    cout << "連結リストのインデックス 3 にあるノードの値 = " << node->val << endl;
 
-    /* ノードを探索 */
+    /* ノードを探索する */
     int index = find(n0, 2);
-    cout << "連結リスト内で値が 2 のノードのインデックス = " << index << endl;
+    cout << "連結リスト内で値が 2 であるノードのインデックス = " << index << endl;
 
     // メモリを解放する
     freeMemoryLinkedList(n0);

ja/codes/cpp/chapter_array_and_linkedlist/list.cpp

@@ -6,52 +6,52 @@
 
 #include "../utils/common.hpp"
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* リストを初期化 */
+    /* リストを初期化する */
     vector<int> nums = {1, 3, 2, 5, 4};
     cout << "リスト nums = ";
     printVector(nums);
 
-    /* 要素にアクセス */
+    /* 要素にアクセスする */
     int num = nums[1];
-    cout << "インデックス 1 の要素にアクセスすると、num = " << num << endl;
+    cout << "インデックス 1 の要素にアクセスした結果 num = " << num << endl;
 
-    /* 要素を更新 */
+    /* 要素を更新する */
     nums[1] = 0;
-    cout << "インデックス 1 の要素を 0 に更新すると、nums = ";
+    cout << "インデックス 1 の要素を 0 に更新した結果 nums = ";
     printVector(nums);
 
     /* リストを空にする */
     nums.clear();
-    cout << "リストを空にした後の nums = ";
+    cout << "リストを空にした後 nums = ";
     printVector(nums);
 
-    /* 末尾に要素を追加 */
+    /* 末尾に要素を追加する */
     nums.push_back(1);
     nums.push_back(3);
     nums.push_back(2);
     nums.push_back(5);
     nums.push_back(4);
-    cout << "要素追加後の nums = ";
+    cout << "要素を追加した後 nums = ";
     printVector(nums);
 
-    /* 中間に要素を挿入 */
+    /* 途中に要素を挿入する */
     nums.insert(nums.begin() + 3, 6);
-    cout << "インデックス 3 に数値 6 を挿入し、nums = ";
+    cout << "インデックス 3 に数値 6 を挿入した結果 nums = ";
     printVector(nums);
 
-    /* 要素を削除 */
+    /* 要素を削除する */
     nums.erase(nums.begin() + 3);
-    cout << "インデックス 3 の要素を削除すると、nums = ";
+    cout << "インデックス 3 の要素を削除した結果 nums = ";
     printVector(nums);
 
-    /* インデックスでリストを走査 */
+    /* インデックスを使ってリストを走査する */
     int count = 0;
     for (int i = 0; i < nums.size(); i++) {
         count += nums[i];
     }
-    /* リスト要素を直接走査 */
+    /* リストの要素を直接走査する */
     count = 0;
     for (int x : nums) {
         count += x;
@@ -60,12 +60,12 @@ int main() {
     /* 2 つのリストを連結する */
     vector<int> nums1 = {6, 8, 7, 10, 9};
     nums.insert(nums.end(), nums1.begin(), nums1.end());
-    cout << "リスト nums1 を nums の後ろに連結すると、nums = ";
+    cout << "リスト nums の後ろに nums1 を連結した結果 nums = ";
     printVector(nums);
 
-    /* リストをソート */
+    /* リストをソートする */
     sort(nums.begin(), nums.end());
-    cout << "リストをソートした後の nums = ";
+    cout << "リストをソートした後 nums = ";
     printVector(nums);
 
     return 0;

ja/codes/cpp/chapter_array_and_linkedlist/my_list.cpp

@@ -9,10 +9,10 @@
 /* リストクラス */
 class MyList {
   private:
-    int *arr;             // 配列（リスト要素を格納）
-    int arrCapacity = 10; // リスト容量
+    int *arr;             // 配列（リストの要素を格納する）
+    int arrCapacity = 10; // リストの容量
     int arrSize = 0;      // リストの長さ（現在の要素数）
-    int extendRatio = 2;   // リスト拡張時の増加倍率
+    int extendRatio = 2;   // リストの容量を拡張する際の倍率
 
   public:
     /* コンストラクタ */
@@ -20,84 +20,84 @@ class MyList {
         arr = new int[arrCapacity];
     }
 
-    /* デストラクタメソッド */
+    /* デストラクタ */
     ~MyList() {
         delete[] arr;
     }
 
-    /* リストの長さを取得（現在の要素数） */
+    /* リストの長さ（現在の要素数）を取得する*/
     int size() {
         return arrSize;
     }
 
-    /* リスト容量を取得する */
+    /* リストの容量を取得する */
     int capacity() {
         return arrCapacity;
     }
 
-    /* 要素にアクセス */
+    /* 要素にアクセスする */
     int get(int index) {
-        // インデックスが範囲外なら例外を送出する。以下同様
+        // インデックスが範囲外の場合、例外を送出する。以下も同様
         if (index < 0 || index >= size())
-            throw out_of_range("インデックスが範囲外");
+            throw out_of_range("インデックスが範囲外です");
         return arr[index];
     }
 
-    /* 要素を更新 */
+    /* 要素を更新する */
     void set(int index, int num) {
         if (index < 0 || index >= size())
-            throw out_of_range("インデックスが範囲外");
+            throw out_of_range("インデックスが範囲外です");
         arr[index] = num;
     }
 
-    /* 末尾に要素を追加 */
+    /* 末尾に要素を追加する */
     void add(int num) {
-        // 要素数が容量を超えると、拡張機構が発動する
+        // 要素数が容量を超える場合、容量を拡張する
         if (size() == capacity())
             extendCapacity();
         arr[size()] = num;
-        // 要素数を更新
+        // 要素数を更新する
         arrSize++;
     }
 
-    /* 中間に要素を挿入 */
+    /* 途中に要素を挿入する */
     void insert(int index, int num) {
         if (index < 0 || index >= size())
-            throw out_of_range("インデックスが範囲外");
-        // 要素数が容量を超えると、拡張機構が発動する
+            throw out_of_range("インデックスが範囲外です");
+        // 要素数が容量を超える場合、容量を拡張する
         if (size() == capacity())
             extendCapacity();
-        // index 以降の要素をすべて 1 つ後ろへずらす
+        // インデックス index 以降の全要素を後ろに 1 つずらす
         for (int j = size() - 1; j >= index; j--) {
             arr[j + 1] = arr[j];
         }
         arr[index] = num;
-        // 要素数を更新
+        // 要素数を更新する
         arrSize++;
     }
 
-    /* 要素を削除 */
+    /* 要素を削除する */
     int remove(int index) {
         if (index < 0 || index >= size())
-            throw out_of_range("インデックスが範囲外");
+            throw out_of_range("インデックスが範囲外です");
         int num = arr[index];
-        // インデックス index より後の要素をすべて 1 つ前に移動する
+        // インデックス index より後の全要素を前に 1 つずらす
         for (int j = index; j < size() - 1; j++) {
             arr[j] = arr[j + 1];
         }
-        // 要素数を更新
+        // 要素数を更新する
         arrSize--;
-        // 削除された要素を返す
+        // 削除した要素を返す
         return num;
     }
 
-    /* リストの拡張 */
+    /* リストの容量を拡張する */
     void extendCapacity() {
-        // 元の配列の `extendRatio` 倍の長さを持つ新しい配列を作成する
+        // 元の配列の extendRatio 倍の長さの新しい配列を作成する
         int newCapacity = capacity() * extendRatio;
         int *tmp = arr;
         arr = new int[newCapacity];
-        // 元の配列の全要素を新しい配列にコピー
+        // 元の配列の全要素を新しい配列にコピーする
         for (int i = 0; i < size(); i++) {
             arr[i] = tmp[i];
         }
@@ -106,9 +106,9 @@ class MyList {
         arrCapacity = newCapacity;
     }
 
-    /* 出力用にリストを Vector に変換 */
+    /* 表示用にリストを Vector に変換する */
     vector<int> toVector() {
-        // 有効長の範囲内のリスト要素のみを変換
+        // 有効な長さの範囲内にあるリストの要素だけを変換する
         vector<int> vec(size());
         for (int i = 0; i < size(); i++) {
             vec[i] = arr[i];
@@ -117,11 +117,11 @@ class MyList {
     }
 };
 
-/* Driver Code */
+/* 実行用コード */
 int main() {
-    /* リストを初期化 */
+    /* リストを初期化する */
     MyList *nums = new MyList();
-    /* 末尾に要素を追加 */
+    /* 末尾に要素を追加する */
     nums->add(1);
     nums->add(3);
     nums->add(2);
@@ -130,39 +130,39 @@ int main() {
     cout << "リスト nums = ";
     vector<int> vec = nums->toVector();
     printVector(vec);
-    cout << "容量 = " << nums->capacity() << " ，長さ = " << nums->size() << endl;
+    cout << "容量 = " << nums->capacity() << " 、長さ = " << nums->size() << endl;
 
-    /* 中間に要素を挿入 */
+    /* 途中に要素を挿入する */
     nums->insert(3, 6);
-    cout << "インデックス 3 に数値 6 を挿入し、nums = ";
+    cout << "インデックス 3 に数値 6 を挿入した結果 nums = ";
     vec = nums->toVector();
     printVector(vec);
 
-    /* 要素を削除 */
+    /* 要素を削除する */
     nums->remove(3);
-    cout << "インデックス 3 の要素を削除すると、nums = ";
+    cout << "インデックス 3 の要素を削除した結果 nums = ";
     vec = nums->toVector();
     printVector(vec);
 
-    /* 要素にアクセス */
+    /* 要素にアクセスする */
     int num = nums->get(1);
-    cout << "インデックス 1 の要素にアクセスすると、num = " << num << endl;
+    cout << "インデックス 1 の要素にアクセスした結果 num = " << num << endl;
 
-    /* 要素を更新 */
+    /* 要素を更新する */
     nums->set(1, 0);
-    cout << "インデックス 1 の要素を 0 に更新すると、nums = ";
+    cout << "インデックス 1 の要素を 0 に更新した結果 nums = ";
     vec = nums->toVector();
     printVector(vec);
 
-    /* 拡張機構をテストする */
+    /* 容量の拡張をテストする */
     for (int i = 0; i < 10; i++) {
-        // i = 5 のとき、リスト長が容量を超えるため、この時点で拡張機構が発動する
+        // i = 5 のときにリストの長さが容量を超えるため、容量が拡張される
         nums->add(i);
     }
-    cout << "拡張後のリスト nums = ";
+    cout << "容量を拡張した後のリスト nums = ";
     vec = nums->toVector();
     printVector(vec);
-    cout << "容量 = " << nums->capacity() << " ，長さ = " << nums->size() << endl;
+    cout << "容量 = " << nums->capacity() << " 、長さ = " << nums->size() << endl;
 
     // メモリを解放する
     delete nums;