docs: add Japanese translate documents (#1812)

* docs: add Japanese documents (`ja/docs`)

* docs: add Japanese documents (`ja/codes`)

* docs: add Japanese documents

* Remove pythontutor blocks in ja/

* Add an empty at the end of each markdown file.

* Add the missing figures (use the English version temporarily).

* Add index.md for Japanese version.

* Add index.html for Japanese version.

* Add missing index.assets

* Fix backtracking_algorithm.md for Japanese version.

* Add avatar_eltociear.jpg. Fix image links on the Japanese landing page.

* Add the Japanese banner.

---------

Co-authored-by: krahets <krahets@163.com>

ja/codes/cpp/chapter_sorting/bubble_sort.cpp

@@ -0,0 +1,56 @@
+/**
+ * File: bubble_sort.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* バブルソート */
+void bubbleSort(vector<int> &nums) {
+    // 外側ループ：未ソート範囲は[0, i]
+    for (int i = nums.size() - 1; i > 0; i--) {
+        // 内側ループ：未ソート範囲[0, i]内の最大要素を範囲の右端に交換
+        for (int j = 0; j < i; j++) {
+            if (nums[j] > nums[j + 1]) {
+                // nums[j]とnums[j + 1]を交換
+                // ここではstdのswapを使用
+                swap(nums[j], nums[j + 1]);
+            }
+        }
+    }
+}
+
+/* バブルソート（フラグ最適化版）*/
+void bubbleSortWithFlag(vector<int> &nums) {
+    // 外側ループ：未ソート範囲は[0, i]
+    for (int i = nums.size() - 1; i > 0; i--) {
+        bool flag = false; // フラグを初期化
+        // 内側ループ：未ソート範囲[0, i]内の最大要素を範囲の右端に交換
+        for (int j = 0; j < i; j++) {
+            if (nums[j] > nums[j + 1]) {
+                // nums[j]とnums[j + 1]を交換
+                // ここではstdのswapを使用
+                swap(nums[j], nums[j + 1]);
+                flag = true; // 交換された要素を記録
+            }
+        }
+        if (!flag)
+            break; // この回の「バブリング」で要素が交換されなかった場合、終了
+    }
+}
+
+/* ドライバコード */
+int main() {
+    vector<int> nums = {4, 1, 3, 1, 5, 2};
+    bubbleSort(nums);
+    cout << "バブルソート後、nums = ";
+    printVector(nums);
+
+    vector<int> nums1 = {4, 1, 3, 1, 5, 2};
+    bubbleSortWithFlag(nums1);
+    cout << "バブルソート後、nums1 = ";
+    printVector(nums1);
+
+    return 0;
+}

ja/codes/cpp/chapter_sorting/bucket_sort.cpp

@@ -0,0 +1,44 @@
+/**
+ * File: bucket_sort.cpp
+ * Created Time: 2023-03-30
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* バケットソート */
+void bucketSort(vector<float> &nums) {
+    // k = n/2個のバケットを初期化、各バケットに2つの要素を割り当てることを期待
+    int k = nums.size() / 2;
+    vector<vector<float>> buckets(k);
+    // 1. 配列要素を各バケットに分配
+    for (float num : nums) {
+        // 入力データ範囲は[0, 1)、num * kを使用してインデックス範囲[0, k-1]にマップ
+        int i = num * k;
+        // bucket_idxバケットに数値を追加
+        buckets[i].push_back(num);
+    }
+    // 2. 各バケットをソート
+    for (vector<float> &bucket : buckets) {
+        // 組み込みソート関数を使用、他のソートアルゴリズムに置き換えることも可能
+        sort(bucket.begin(), bucket.end());
+    }
+    // 3. バケットを走査して結果をマージ
+    int i = 0;
+    for (vector<float> &bucket : buckets) {
+        for (float num : bucket) {
+            nums[i++] = num;
+        }
+    }
+}
+
+/* ドライバコード */
+int main() {
+    // 入力データが浮動小数点数、範囲[0, 1)と仮定
+    vector<float> nums = {0.49f, 0.96f, 0.82f, 0.09f, 0.57f, 0.43f, 0.91f, 0.75f, 0.15f, 0.37f};
+    bucketSort(nums);
+    cout << "バケットソート後、nums = ";
+    printVector(nums);
+
+    return 0;
+}

ja/codes/cpp/chapter_sorting/counting_sort.cpp

@@ -0,0 +1,77 @@
+/**
+ * File: counting_sort.cpp
+ * Created Time: 2023-03-17
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* カウントソート */
+// 簡単な実装、オブジェクトのソートには使用できない
+void countingSortNaive(vector<int> &nums) {
+    // 1. 配列の最大要素mを統計
+    int m = 0;
+    for (int num : nums) {
+        m = max(m, num);
+    }
+    // 2. 各数字の出現回数を統計
+    // counter[num]はnumの出現回数を表す
+    vector<int> counter(m + 1, 0);
+    for (int num : nums) {
+        counter[num]++;
+    }
+    // 3. counterを走査し、各要素を元の配列numsに戻す
+    int i = 0;
+    for (int num = 0; num < m + 1; num++) {
+        for (int j = 0; j < counter[num]; j++, i++) {
+            nums[i] = num;
+        }
+    }
+}
+
+/* カウントソート */
+// 完全な実装、オブジェクトのソートが可能で安定ソート
+void countingSort(vector<int> &nums) {
+    // 1. 配列の最大要素mを統計
+    int m = 0;
+    for (int num : nums) {
+        m = max(m, num);
+    }
+    // 2. 各数字の出現回数を統計
+    // counter[num]はnumの出現回数を表す
+    vector<int> counter(m + 1, 0);
+    for (int num : nums) {
+        counter[num]++;
+    }
+    // 3. counterの前缀和を計算し、「出現回数」を「末尾インデックス」に変換
+    // counter[num]-1はnumがresで現れる最後のインデックス
+    for (int i = 0; i < m; i++) {
+        counter[i + 1] += counter[i];
+    }
+    // 4. numsを逆順で走査し、各要素を結果配列resに配置
+    // 結果を記録する配列resを初期化
+    int n = nums.size();
+    vector<int> res(n);
+    for (int i = n - 1; i >= 0; i--) {
+        int num = nums[i];
+        res[counter[num] - 1] = num; // numを対応するインデックスに配置
+        counter[num]--;              // 前缀和を1減らし、numを配置する次のインデックスを取得
+    }
+    // 結果配列resで元の配列numsを上書き
+    nums = res;
+}
+
+/* ドライバコード */
+int main() {
+    vector<int> nums = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
+    countingSortNaive(nums);
+    cout << "カウントソート（オブジェクトソート不可）後、nums = ";
+    printVector(nums);
+
+    vector<int> nums1 = {1, 0, 1, 2, 0, 4, 0, 2, 2, 4};
+    countingSort(nums1);
+    cout << "カウントソート後、nums1 = ";
+    printVector(nums1);
+
+    return 0;
+}

ja/codes/cpp/chapter_sorting/heap_sort.cpp

@@ -0,0 +1,54 @@
+/**
+ * File: heap_sort.cpp
+ * Created Time: 2023-05-26
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* ヒープの長さはn、ノードiから上から下へヒープ化を開始 */
+void siftDown(vector<int> &nums, int n, int i) {
+    while (true) {
+        // i、l、r の中で最大のノードを決定し、maとして記録
+        int l = 2 * i + 1;
+        int r = 2 * i + 2;
+        int ma = i;
+        if (l < n && nums[l] > nums[ma])
+            ma = l;
+        if (r < n && nums[r] > nums[ma])
+            ma = r;
+        // ノードiが最大か、インデックスl、rが境界外の場合、それ以上のヒープ化は不要で終了
+        if (ma == i) {
+            break;
+        }
+        // 二つのノードを交換
+        swap(nums[i], nums[ma]);
+        // 下向きにヒープ化をループ
+        i = ma;
+    }
+}
+
+/* ヒープソート */
+void heapSort(vector<int> &nums) {
+    // ヒープ構築操作：葉以外のすべてのノードをヒープ化
+    for (int i = nums.size() / 2 - 1; i >= 0; --i) {
+        siftDown(nums, nums.size(), i);
+    }
+    // ヒープから最大要素を抽出し、n-1回繰り返す
+    for (int i = nums.size() - 1; i > 0; --i) {
+        // ルートノードを最右葉ノードと交換（最初の要素を最後の要素と交換）
+        swap(nums[0], nums[i]);
+        // ルートノードから上から下へヒープ化を開始
+        siftDown(nums, i, 0);
+    }
+}
+
+/* ドライバコード */
+int main() {
+    vector<int> nums = {4, 1, 3, 1, 5, 2};
+    heapSort(nums);
+    cout << "ヒープソート後、nums = ";
+    printVector(nums);
+
+    return 0;
+}

ja/codes/cpp/chapter_sorting/insertion_sort.cpp

@@ -0,0 +1,31 @@
+/**
+ * File: insertion_sort.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* 挿入ソート */
+void insertionSort(vector<int> &nums) {
+    // 外側ループ：ソート済み範囲は[0, i-1]
+    for (int i = 1; i < nums.size(); i++) {
+        int base = nums[i], j = i - 1;
+        // 内側ループ：baseをソート済み範囲[0, i-1]内の正しい位置に挿入
+        while (j >= 0 && nums[j] > base) {
+            nums[j + 1] = nums[j]; // nums[j]を一つ右に移動
+            j--;
+        }
+        nums[j + 1] = base; // baseを正しい位置に代入
+    }
+}
+
+/* ドライバコード */
+int main() {
+    vector<int> nums = {4, 1, 3, 1, 5, 2};
+    insertionSort(nums);
+    cout << "挿入ソート後、nums = ";
+    printVector(nums);
+
+    return 0;
+}

ja/codes/cpp/chapter_sorting/merge_sort.cpp

@@ -0,0 +1,58 @@
+/**
+ * File: merge_sort.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* 左サブ配列と右サブ配列をマージ */
+void merge(vector<int> &nums, int left, int mid, int right) {
+    // 左サブ配列の区間は[left, mid]、右サブ配列の区間は[mid+1, right]
+    // マージ結果を保存する一時配列tmpを作成
+    vector<int> tmp(right - left + 1);
+    // 左右サブ配列の開始インデックスを初期化
+    int i = left, j = mid + 1, k = 0;
+    // 両サブ配列に要素がある間、小さい方の要素を一時配列にコピー
+    while (i <= mid && j <= right) {
+        if (nums[i] <= nums[j])
+            tmp[k++] = nums[i++];
+        else
+            tmp[k++] = nums[j++];
+    }
+    // 左右サブ配列の残りの要素を一時配列にコピー
+    while (i <= mid) {
+        tmp[k++] = nums[i++];
+    }
+    while (j <= right) {
+        tmp[k++] = nums[j++];
+    }
+    // 一時配列tmpの要素を元の配列numsの対応する区間にコピー
+    for (k = 0; k < tmp.size(); k++) {
+        nums[left + k] = tmp[k];
+    }
+}
+
+/* マージソート */
+void mergeSort(vector<int> &nums, int left, int right) {
+    // 終了条件
+    if (left >= right)
+        return; // サブ配列の長さが1の時、再帰を終了
+    // 分割段階
+    int mid = left + (right - left) / 2;    // 中点を計算
+    mergeSort(nums, left, mid);      // 左サブ配列を再帰的に処理
+    mergeSort(nums, mid + 1, right); // 右サブ配列を再帰的に処理
+    // マージ段階
+    merge(nums, left, mid, right);
+}
+
+/* ドライバコード */
+int main() {
+    /* マージソート */
+    vector<int> nums = {7, 3, 2, 6, 0, 1, 5, 4};
+    mergeSort(nums, 0, nums.size() - 1);
+    cout << "マージソート後、nums = ";
+    printVector(nums);
+
+    return 0;
+}

ja/codes/cpp/chapter_sorting/quick_sort.cpp

@@ -0,0 +1,166 @@
+/**
+ * File: quick_sort.cpp
+ * Created Time: 2022-11-25
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* クイックソートクラス */
+class QuickSort {
+  private:
+    /* 要素を交換 */
+    static void swap(vector<int> &nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* 分割 */
+    static int partition(vector<int> &nums, int left, int right) {
+        // nums[left]をピボットとして使用
+        int i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left])
+                j--; // 右から左へピボットより小さい最初の要素を検索
+            while (i < j && nums[i] <= nums[left])
+                i++;          // 左から右へピボットより大きい最初の要素を検索
+            swap(nums, i, j); // これら二つの要素を交換
+        }
+        swap(nums, i, left); // ピボットを二つのサブ配列の境界に交換
+        return i;            // ピボットのインデックスを返す
+    }
+
+  public:
+    /* クイックソート */
+    static void quickSort(vector<int> &nums, int left, int right) {
+        // サブ配列の長さが1の時、再帰を終了
+        if (left >= right)
+            return;
+        // 分割
+        int pivot = partition(nums, left, right);
+        // 左サブ配列と右サブ配列を再帰的に処理
+        quickSort(nums, left, pivot - 1);
+        quickSort(nums, pivot + 1, right);
+    }
+};
+
+/* クイックソートクラス（中央値ピボット最適化） */
+class QuickSortMedian {
+  private:
+    /* 要素を交換 */
+    static void swap(vector<int> &nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* 三つの候補要素の中央値を選択 */
+    static int medianThree(vector<int> &nums, int left, int mid, int right) {
+        int l = nums[left], m = nums[mid], r = nums[right];
+        if ((l <= m && m <= r) || (r <= m && m <= l))
+            return mid; // mはlとrの間
+        if ((m <= l && l <= r) || (r <= l && l <= m))
+            return left; // lはmとrの間
+        return right;
+    }
+
+    /* 分割（三つの中央値） */
+    static int partition(vector<int> &nums, int left, int right) {
+        // 三つの候補要素の中央値を選択
+        int med = medianThree(nums, left, (left + right) / 2, right);
+        // 中央値を配列の最左位置に交換
+        swap(nums, left, med);
+        // nums[left]をピボットとして使用
+        int i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left])
+                j--; // 右から左へピボットより小さい最初の要素を検索
+            while (i < j && nums[i] <= nums[left])
+                i++;          // 左から右へピボットより大きい最初の要素を検索
+            swap(nums, i, j); // これら二つの要素を交換
+        }
+        swap(nums, i, left); // ピボットを二つのサブ配列の境界に交換
+        return i;            // ピボットのインデックスを返す
+    }
+
+  public:
+    /* クイックソート */
+    static void quickSort(vector<int> &nums, int left, int right) {
+        // サブ配列の長さが1の時、再帰を終了
+        if (left >= right)
+            return;
+        // 分割
+        int pivot = partition(nums, left, right);
+        // 左サブ配列と右サブ配列を再帰的に処理
+        quickSort(nums, left, pivot - 1);
+        quickSort(nums, pivot + 1, right);
+    }
+};
+
+/* クイックソートクラス（末尾再帰最適化） */
+class QuickSortTailCall {
+  private:
+    /* 要素を交換 */
+    static void swap(vector<int> &nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    /* 分割 */
+    static int partition(vector<int> &nums, int left, int right) {
+        // nums[left]をピボットとして使用
+        int i = left, j = right;
+        while (i < j) {
+            while (i < j && nums[j] >= nums[left])
+                j--; // 右から左へピボットより小さい最初の要素を検索
+            while (i < j && nums[i] <= nums[left])
+                i++;          // 左から右へピボットより大きい最初の要素を検索
+            swap(nums, i, j); // これら二つの要素を交換
+        }
+        swap(nums, i, left); // ピボットを二つのサブ配列の境界に交換
+        return i;            // ピボットのインデックスを返す
+    }
+
+  public:
+    /* クイックソート（末尾再帰最適化） */
+    static void quickSort(vector<int> &nums, int left, int right) {
+        // サブ配列の長さが1の時終了
+        while (left < right) {
+            // 分割操作
+            int pivot = partition(nums, left, right);
+            // 二つのサブ配列のうち短い方でクイックソートを実行
+            if (pivot - left < right - pivot) {
+                quickSort(nums, left, pivot - 1); // 左サブ配列を再帰的にソート
+                left = pivot + 1;                 // 残りの未ソート区間は[pivot + 1, right]
+            } else {
+                quickSort(nums, pivot + 1, right); // 右サブ配列を再帰的にソート
+                right = pivot - 1;                 // 残りの未ソート区間は[left, pivot - 1]
+            }
+        }
+    }
+};
+
+/* ドライバコード */
+int main() {
+    /* クイックソート */
+    vector<int> nums{2, 4, 1, 0, 3, 5};
+    QuickSort::quickSort(nums, 0, nums.size() - 1);
+    cout << "クイックソート後、nums = ";
+    printVector(nums);
+
+    /* クイックソート（中央値ピボット最適化） */
+    vector<int> nums1 = {2, 4, 1, 0, 3, 5};
+    QuickSortMedian::quickSort(nums1, 0, nums1.size() - 1);
+    cout << "クイックソート（中央値ピボット最適化）完了、nums = ";
+    printVector(nums1);
+
+    /* クイックソート（末尾再帰最適化） */
+    vector<int> nums2 = {2, 4, 1, 0, 3, 5};
+    QuickSortTailCall::quickSort(nums2, 0, nums2.size() - 1);
+    cout << "クイックソート（末尾再帰最適化）完了、nums = ";
+    printVector(nums2);
+
+    return 0;
+}

ja/codes/cpp/chapter_sorting/radix_sort.cpp

@@ -0,0 +1,65 @@
+/**
+ * File: radix_sort.cpp
+ * Created Time: 2023-03-26
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* 要素numのk番目の桁を取得、exp = 10^(k-1) */
+int digit(int num, int exp) {
+    // kの代わりにexpを渡すことで、ここで繰り返される高価な冪乗計算を避けることができる
+    return (num / exp) % 10;
+}
+
+/* カウントソート（numsのk番目の桁に基づく） */
+void countingSortDigit(vector<int> &nums, int exp) {
+    // 10進数の桁範囲は0~9なので、長さ10のバケット配列が必要
+    vector<int> counter(10, 0);
+    int n = nums.size();
+    // 数字0~9の出現回数を統計
+    for (int i = 0; i < n; i++) {
+        int d = digit(nums[i], exp); // nums[i]のk番目の桁を取得、dとして記録
+        counter[d]++;                // 数字dの出現回数を統計
+    }
+    // 前缀和を計算し、「出現回数」を「配列インデックス」に変換
+    for (int i = 1; i < 10; i++) {
+        counter[i] += counter[i - 1];
+    }
+    // 逆順で走査し、バケット統計に基づいて各要素をresに配置
+    vector<int> res(n, 0);
+    for (int i = n - 1; i >= 0; i--) {
+        int d = digit(nums[i], exp);
+        int j = counter[d] - 1; // dが配列内にあるインデックスjを取得
+        res[j] = nums[i];       // 現在の要素をインデックスjに配置
+        counter[d]--;           // dのカウントを1減らす
+    }
+    // 結果で元の配列numsを上書き
+    for (int i = 0; i < n; i++)
+        nums[i] = res[i];
+}
+
+/* 基数ソート */
+void radixSort(vector<int> &nums) {
+    // 配列の最大要素を取得、最大桁数を判定するために使用
+    int m = *max_element(nums.begin(), nums.end());
+    // 最下位桁から最上位桁まで走査
+    for (int exp = 1; exp <= m; exp *= 10)
+        // 配列要素のk番目の桁でカウントソートを実行
+        // k = 1 -> exp = 1
+        // k = 2 -> exp = 10
+        // つまり、exp = 10^(k-1)
+        countingSortDigit(nums, exp);
+}
+
+/* ドライバコード */
+int main() {
+    // 基数ソート
+    vector<int> nums = {10546151, 35663510, 42865989, 34862445, 81883077,
+                        88906420, 72429244, 30524779, 82060337, 63832996};
+    radixSort(nums);
+    cout << "基数ソート後、nums = ";
+    printVector(nums);
+
+    return 0;
+}

ja/codes/cpp/chapter_sorting/selection_sort.cpp

@@ -0,0 +1,34 @@
+/**
+ * File: selection_sort.cpp
+ * Created Time: 2023-05-23
+ * Author: krahets (krahets@163.com)
+ */
+
+#include "../utils/common.hpp"
+
+/* 選択ソート */
+void selectionSort(vector<int> &nums) {
+    int n = nums.size();
+    // 外側ループ：未ソート範囲は[i, n-1]
+    for (int i = 0; i < n - 1; i++) {
+        // 内側ループ：未ソート範囲内で最小要素を見つける
+        int k = i;
+        for (int j = i + 1; j < n; j++) {
+            if (nums[j] < nums[k])
+                k = j; // 最小要素のインデックスを記録
+        }
+        // 最小要素を未ソート範囲の最初の要素と交換
+        swap(nums[i], nums[k]);
+    }
+}
+
+/* ドライバコード */
+int main() {
+    vector<int> nums = {4, 1, 3, 1, 5, 2};
+    selectionSort(nums);
+
+    cout << "選択ソート後、nums = ";
+    printVector(nums);
+
+    return 0;
+}