Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/zig/chapter_sorting/bubble_sort.zig

@@ -0,0 +1,61 @@
+// File: bubble_sort.zig
+// Created Time: 2023-01-08
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// バブルソート
+fn bubbleSort(nums: []i32) void {
+    // 外側のループ：未ソート区間は [0, i]
+    var i: usize = nums.len - 1;
+    while (i > 0) : (i -= 1) {
+        var j: usize = 0;
+        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
+        while (j < i) : (j += 1) {
+            if (nums[j] > nums[j + 1]) {
+                // nums[j] と nums[j + 1] を交換
+                var tmp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = tmp;
+            }
+        }
+    }
+}
+
+// バブルソート（フラグ最適化）
+fn bubbleSortWithFlag(nums: []i32) void {
+    // 外側のループ：未ソート区間は [0, i]
+    var i: usize = nums.len - 1;
+    while (i > 0) : (i -= 1) {
+        var flag = false;   // フラグを初期化する
+        var j: usize = 0;
+        // 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
+        while (j < i) : (j += 1) {
+            if (nums[j] > nums[j + 1]) {
+                // nums[j] と nums[j + 1] を交換
+                var tmp = nums[j];
+                nums[j] = nums[j + 1];
+                nums[j + 1] = tmp;
+                flag = true;
+            }
+        }
+        if (!flag) break;   // このバブル処理で要素交換が一度もなければそのまま終了
+    }
+}
+
+// Driver Code
+pub fn main() !void {
+    var nums = [_]i32{ 4, 1, 3, 1, 5, 2 };
+    bubbleSort(&nums);
+    std.debug.print("バブルソート完了後 nums = ", .{});
+    inc.PrintUtil.printArray(i32, &nums);
+
+    var nums1 = [_]i32{ 4, 1, 3, 1, 5, 2 };
+    bubbleSortWithFlag(&nums1);
+    std.debug.print("\nバブルソート完了後 nums1 = ", .{});
+    inc.PrintUtil.printArray(i32, &nums1);
+    
+    _ = try std.io.getStdIn().reader().readByte();
+}
+

ja/codes/zig/chapter_sorting/insertion_sort.zig

@@ -0,0 +1,31 @@
+// File: insertion_sort.zig
+// Created Time: 2023-01-08
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 挿入ソート
+fn insertionSort(nums: []i32) void {
+    // 外側ループ：整列済み区間は [0, i-1]
+    var i: usize = 1;
+    while (i < nums.len) : (i += 1) {
+        var base = nums[i];
+        var j: usize = i;
+        // 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する
+        while (j >= 1 and nums[j - 1] > base) : (j -= 1) {
+            nums[j] = nums[j - 1];  // nums[j] を 1 つ右へ移動する
+        }
+        nums[j] = base;             // base を正しい位置に配置する
+    }
+}
+
+// Driver Code
+pub fn main() !void {
+    var nums = [_]i32{ 4, 1, 3, 1, 5, 2 };
+    insertionSort(&nums);
+    std.debug.print("挿入ソート完了後 nums = ", .{});
+    inc.PrintUtil.printArray(i32, &nums);
+    
+    _ = try std.io.getStdIn().reader().readByte();
+}

ja/codes/zig/chapter_sorting/merge_sort.zig

@@ -0,0 +1,67 @@
+// File: merge_sort.zig
+// Created Time: 2023-01-15
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 左部分配列と右部分配列をマージする
+// 左部分配列の区間は [left, mid]
+// 右部分配列の区間は [mid + 1, right]
+fn merge(nums: []i32, left: usize, mid: usize, right: usize) !void {
+    // 補助配列を初期化する
+    var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer mem_arena.deinit();
+    const mem_allocator = mem_arena.allocator();
+    var tmp = try mem_allocator.alloc(i32, right + 1 - left);
+    std.mem.copy(i32, tmp, nums[left..right+1]);
+    // 左部分配列の開始添字と終了添字
+    var leftStart = left - left;
+    var leftEnd = mid - left;
+    // 右部分配列の開始インデックスと終了インデックス
+    var rightStart = mid + 1 - left;
+    var rightEnd = right - left;
+    // i, j はそれぞれ左部分配列と右部分配列の先頭要素を指す
+    var i = leftStart;
+    var j = rightStart;
+    // 元の配列 nums を上書きして左部分配列と右部分配列をマージする
+    var k = left;
+    while (k <= right) : (k += 1) {
+        // 「左部分配列のマージがすべて完了している」場合は、右部分配列の要素を選び、`j++` する
+        if (i > leftEnd) {
+            nums[k] = tmp[j];
+            j += 1;
+        // そうでなければ、「右部分配列のマージがすべて完了している」または「左部分配列の要素 <= 右部分配列の要素」の場合、左部分配列の要素を選び、i++ する
+        } else if  (j > rightEnd or tmp[i] <= tmp[j]) {
+            nums[k] = tmp[i];
+            i += 1;
+        // そうでなければ、「左右の部分配列のマージがどちらも完了しておらず」かつ「左部分配列の要素 > 右部分配列の要素」の場合、右部分配列の要素を選び、j++ する
+        } else {
+            nums[k] = tmp[j];
+            j += 1;
+        }
+    }
+}
+
+// マージソート
+fn mergeSort(nums: []i32, left: usize, right: usize) !void {
+    // 終了条件
+    if (left >= right) return;              // 部分配列の長さが 1 になったら再帰を終了
+    // 分割フェーズ
+    var mid = left + (right - left) / 2;    // 中点を計算
+    try mergeSort(nums, left, mid);         // 左部分配列を再帰処理
+    try mergeSort(nums, mid + 1, right);    // 右部分配列を再帰処理
+    // マージフェーズ
+    try merge(nums, left, mid, right);
+}
+
+// Driver Code
+pub fn main() !void {
+    // マージソート
+    var nums = [_]i32{ 7, 3, 2, 6, 0, 1, 5, 4 };
+    try mergeSort(&nums, 0, nums.len - 1);
+    std.debug.print("マージソート完了後 nums = ", .{});
+    inc.PrintUtil.printArray(i32, &nums);
+
+    _ = try std.io.getStdIn().reader().readByte();
+}

ja/codes/zig/chapter_sorting/quick_sort.zig

@@ -0,0 +1,162 @@
+// File: quick_sort.zig
+// Created Time: 2023-01-15
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// クイックソートクラス
+const QuickSort = struct {
+
+    // 要素の交換
+    pub fn swap(nums: []i32, i: usize, j: usize) void {
+        var tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    // 番兵分割
+    pub fn partition(nums: []i32, left: usize, right: usize) usize {
+        // nums[left] を基準値とする
+        var i = left;
+        var j = right;
+        while (i < j) {
+            while (i < j and nums[j] >= nums[left]) j -= 1; // 右から左へ基準値未満の最初の要素を探す
+            while (i < j and nums[i] <= nums[left]) i += 1; // 左から右へ基準値より大きい最初の要素を探す
+            swap(nums, i, j);   // この 2 つの要素を交換
+        }
+        swap(nums, i, left);    // 基準値を 2 つの部分配列の境界へ交換する
+        return i;               // 基準値のインデックスを返す
+    }
+
+    // クイックソート
+    pub fn quickSort(nums: []i32, left: usize, right: usize) void {
+        // 部分配列の長さが 1 なら再帰を終了する
+        if (left >= right) return;
+        // 番兵分割
+        var pivot = partition(nums, left, right);
+        // 左右の部分配列を再帰処理
+        quickSort(nums, left, pivot - 1);
+        quickSort(nums, pivot + 1, right);
+    }
+};
+
+// クイックソートクラス（中央値ピボット最適化）
+const QuickSortMedian = struct {
+
+    // 要素の交換
+    pub fn swap(nums: []i32, i: usize, j: usize) void {
+        var tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    // 3つの候補要素の中央値を選ぶ
+    pub fn medianThree(nums: []i32, left: usize, mid: usize, right: usize) usize {
+        var l = nums[left];
+        var m = nums[mid];
+        var 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;
+    }
+
+    // 番兵による分割処理（3 点中央値）
+    pub fn partition(nums: []i32, left: usize, right: usize) usize {
+        // 3つの候補要素の中央値を選ぶ
+        var med = medianThree(nums, left, (left + right) / 2, right);
+        // 中央値を配列の最左端に交換する
+        swap(nums, left, med);
+        // nums[left] を基準値とする
+        var i = left;
+        var j = right;
+        while (i < j) {
+            while (i < j and nums[j] >= nums[left]) j -= 1; // 右から左へ基準値未満の最初の要素を探す
+            while (i < j and nums[i] <= nums[left]) i += 1; // 左から右へ基準値より大きい最初の要素を探す
+            swap(nums, i, j);   // この 2 つの要素を交換
+        }
+        swap(nums, i, left);    // 基準値を 2 つの部分配列の境界へ交換する
+        return i;               // 基準値のインデックスを返す
+    }
+
+    // クイックソート
+    pub fn quickSort(nums: []i32, left: usize, right: usize) void {
+        // 部分配列の長さが 1 なら再帰を終了する
+        if (left >= right) return;
+        // 番兵分割
+        var pivot = partition(nums, left, right);
+        if (pivot == 0) return;
+        // 左右の部分配列を再帰処理
+        quickSort(nums, left, pivot - 1);
+        quickSort(nums, pivot + 1, right);
+    }
+};
+
+// クイックソートクラス（再帰深度最適化）
+const QuickSortTailCall = struct {
+
+    // 要素の交換
+    pub fn swap(nums: []i32, i: usize, j: usize) void {
+        var tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+
+    // 番兵分割
+    pub fn partition(nums: []i32, left: usize, right: usize) usize {
+        // nums[left] を基準値とする
+        var i = left;
+        var j = right;
+        while (i < j) {
+            while (i < j and nums[j] >= nums[left]) j -= 1; // 右から左へ基準値未満の最初の要素を探す
+            while (i < j and nums[i] <= nums[left]) i += 1; // 左から右へ基準値より大きい最初の要素を探す
+            swap(nums, i, j);   // この 2 つの要素を交換
+        }
+        swap(nums, i, left);    // 基準値を 2 つの部分配列の境界へ交換する
+        return i;               // 基準値のインデックスを返す
+    }
+
+    // クイックソート（再帰深度最適化）
+    pub fn quickSort(nums: []i32, left_: usize, right_: usize) void {
+        var left = left_;
+        var right = right_;
+        // 部分配列の長さが 1 なら再帰を終了する
+        while (left < right) {
+            // 番兵による分割処理
+            var pivot = partition(nums, left, right);
+            // 2 つの部分配列のうち短いほうにクイックソートを適用する
+            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]
+            }
+        }
+    }
+};
+
+// Driver Code
+pub fn main() !void {
+    // クイックソート
+    var nums = [_]i32{ 2, 4, 1, 0, 3, 5 };
+    QuickSort.quickSort(&nums, 0, nums.len - 1);
+    std.debug.print("クイックソート完了後 nums = ", .{});
+    inc.PrintUtil.printArray(i32, &nums);
+
+    // クイックソート（中央値の基準値で最適化）
+    var nums1 = [_]i32{ 2, 4, 1, 0, 3, 5 };
+    QuickSortMedian.quickSort(&nums1, 0, nums1.len - 1);
+    std.debug.print("\nクイックソート（中央値ピボット最適化）完了後 nums = ", .{});
+    inc.PrintUtil.printArray(i32, &nums1);
+
+    // クイックソート（再帰深度最適化）
+    var nums2 = [_]i32{ 2, 4, 1, 0, 3, 5 };
+    QuickSortTailCall.quickSort(&nums2, 0, nums2.len - 1);
+    std.debug.print("\nクイックソート（再帰深度最適化）完了後 nums = ", .{});
+    inc.PrintUtil.printArray(i32, &nums2);
+    
+    _ = try std.io.getStdIn().reader().readByte();
+}

ja/codes/zig/chapter_sorting/radix_sort.zig

@@ -0,0 +1,77 @@
+// File: radix_sort.zig
+// Created Time: 2023-01-15
+// Author: codingonion (coderonion@gmail.com)
+
+const std = @import("std");
+const inc = @import("include");
+
+// 要素 num の下から k 桁目を取得（exp = 10^(k-1)）
+fn digit(num: i32, exp: i32) i32 {
+    // ここで高コストな累乗計算を繰り返さないよう、k ではなく exp を渡す
+    return @mod(@divFloor(num, exp), 10);
+}
+
+// 計数ソート（nums の k 桁目でソート）
+fn countingSortDigit(nums: []i32, exp: i32) !void {
+    // 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要
+    var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    // defer mem_arena.deinit();
+    const mem_allocator = mem_arena.allocator();
+    var counter = try mem_allocator.alloc(usize, 10);
+    @memset(counter, 0);
+    var n = nums.len;
+    // 0~9 の各数字の出現回数を集計する
+    for (nums) |num| {
+        var d: u32 = @bitCast(digit(num, exp)); // nums[i] の第 k 位を取得し、d とする
+        counter[d] += 1; // 数字 d の出現回数を数える
+    }
+    // 累積和を求め、「出現回数」を「配列インデックス」に変換する
+    var i: usize = 1;
+    while (i < 10) : (i += 1) {
+        counter[i] += counter[i - 1];
+    }
+    // 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する
+    var res = try mem_allocator.alloc(i32, n);
+    i = n - 1;
+    while (i >= 0) : (i -= 1) {
+        var d: u32 = @bitCast(digit(nums[i], exp));
+        var j = counter[d] - 1; // d の配列内インデックス j を取得する
+        res[j] = nums[i];       // 現在の要素をインデックス j に格納する
+        counter[d] -= 1;        // d の個数を 1 減らす
+        if (i == 0) break;
+    }
+    // 結果で元の配列 nums を上書きする
+    i = 0;
+    while (i < n) : (i += 1) {
+        nums[i] = res[i];
+    }
+}
+
+// 基数ソート
+fn radixSort(nums: []i32) !void {
+    // 最大桁数の判定用に配列の最大要素を取得
+    var m: i32 = std.math.minInt(i32);
+    for (nums) |num| {
+        if (num > m) m = num;
+    }
+    // 下位桁から上位桁の順に走査する
+    var exp: i32 = 1;
+    while (exp <= m) : (exp *= 10) {
+        // 配列要素の k 桁目に対して計数ソートを行う
+        // k = 1 -> exp = 1
+        // k = 2 -> exp = 10
+        // つまり exp = 10^(k-1)
+        try countingSortDigit(nums, exp);    
+    }
+} 
+
+// Driver Code
+pub fn main() !void {
+    // 基数ソート
+    var nums = [_]i32{ 23, 12, 3, 4, 788, 192 };
+    try radixSort(&nums);
+    std.debug.print("基数ソート完了後 nums = ", .{});
+    inc.PrintUtil.printArray(i32, &nums);
+    
+    _ = try std.io.getStdIn().reader().readByte();
+}