Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/zig/chapter_array_and_linkedlist/array.zig

@@ -0,0 +1,131 @@
+// File: array.zig
+// Created Time: 2023-01-07
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
+
+const std = @import("std");
+const utils = @import("utils");
+
+// 要素へランダムアクセス
+pub fn randomAccess(nums: []const i32) i32 {
+    // 区間 [0, nums.len) からランダムに整数を 1 つ選ぶ
+    const random_index = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
+    // ランダムな要素を取得して返す
+    const randomNum = nums[random_index];
+    return randomNum;
+}
+
+// 配列長を拡張する
+pub fn extend(allocator: std.mem.Allocator, nums: []const i32, enlarge: usize) ![]i32 {
+    // 拡張後の長さを持つ配列を初期化する
+    const res = try allocator.alloc(i32, nums.len + enlarge);
+    @memset(res, 0);
+
+    // 元の配列の全要素を新しい配列にコピー
+    std.mem.copyForwards(i32, res, nums);
+
+    // 拡張後の新しい配列を返す
+    return res;
+}
+
+// 配列の index 番目に要素 num を挿入
+pub fn insert(nums: []i32, num: i32, index: usize) void {
+    // インデックス index 以降の全要素を 1 つ後ろへ移動する
+    var i = nums.len - 1;
+    while (i > index) : (i -= 1) {
+        nums[i] = nums[i - 1];
+    }
+    // index の要素に num を代入する
+    nums[index] = num;
+}
+
+// index の要素を削除する
+pub fn remove(nums: []i32, index: usize) void {
+    // インデックス index より後ろの全要素を 1 つ前へ移動する
+    var i = index;
+    while (i < nums.len - 1) : (i += 1) {
+        nums[i] = nums[i + 1];
+    }
+}
+
+// 配列を走査
+pub fn traverse(nums: []const i32) void {
+    var count: i32 = 0;
+
+    // インデックスで配列を走査
+    var i: usize = 0;
+    while (i < nums.len) : (i += 1) {
+        count += nums[i];
+    }
+
+    // 配列要素を直接走査
+    count = 0;
+    for (nums) |num| {
+        count += num;
+    }
+
+    // データのインデックスと要素を同時に走査する
+    for (nums, 0..) |num, index| {
+        count += nums[index];
+        count += num;
+    }
+}
+
+// 配列内で指定要素を探す
+pub fn find(nums: []i32, target: i32) i32 {
+    for (nums, 0..) |num, i| {
+        if (num == target) return @intCast(i);
+    }
+    return -1;
+}
+
+// Driver Code
+pub fn run() !void {
+    // 配列を初期化
+    const arr = [_]i32{0} ** 5;
+    std.debug.print("配列 arr = {}\n", .{utils.fmt.slice(&arr)});
+
+    // 配列スライス
+    var array = [_]i32{ 1, 3, 2, 5, 4 };
+    var known_at_runtime_zero: usize = 0;
+    _ = &known_at_runtime_zero;
+    var nums = array[known_at_runtime_zero..array.len]; // 実行時変数 known_at_runtime_zero を用いてポインタをスライスに変換する
+    std.debug.print("配列 nums = {}\n", .{utils.fmt.slice(nums)});
+
+    // ランダムアクセス
+    const randomNum = randomAccess(nums);
+    std.debug.print("nums からランダムな要素 {} を取得\n", .{randomNum});
+
+    // メモリアロケータを初期化する
+    var arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
+    defer arena.deinit();
+    const allocator = arena.allocator();
+
+    // 長さを拡張
+    nums = try extend(allocator, nums, 3);
+    std.debug.print("配列の長さを 8 に拡張し、nums = {} を得る\n", .{utils.fmt.slice(nums)});
+
+    // 要素を挿入する
+    insert(nums, 6, 3);
+    std.debug.print("インデックス 3 に数値 6 を挿入し、nums = {} を得る\n", .{utils.fmt.slice(nums)});
+
+    // 要素を削除
+    remove(nums, 2);
+    std.debug.print("インデックス 2 の要素を削除し、nums = {} を得る\n", .{utils.fmt.slice(nums)});
+
+    // 配列を走査
+    traverse(nums);
+
+    // 要素を探索する
+    const index = find(nums, 3);
+    std.debug.print("nums で要素 3 を検索し、インデックス = {} を得る\n", .{index});
+
+    std.debug.print("\n", .{});
+}
+
+pub fn main() !void {
+    try run();
+}
+
+test "array" {
+    try run();
+}

ja/codes/zig/chapter_array_and_linkedlist/linked_list.zig

@@ -0,0 +1,106 @@
+// File: linked_list.zig
+// Created Time: 2023-01-07
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
+
+const std = @import("std");
+const utils = @import("utils");
+const ListNode = utils.ListNode;
+
+// 連結リストでノード n0 の後ろにノード P を挿入する
+pub fn insert(comptime T: type, n0: *ListNode(T), P: *ListNode(T)) void {
+    const n1 = n0.next;
+    P.next = n1;
+    n0.next = P;
+}
+
+// 連結リストでノード n0 の直後のノードを削除する
+pub fn remove(comptime T: type, n0: *ListNode(T)) void {
+    // n0 -> P -> n1 => n0 -> n1
+    const P = n0.next;
+    const n1 = P.?.next;
+    n0.next = n1;
+}
+
+// 連結リスト内で index 番目のノードにアクセス
+pub fn access(comptime T: type, node: *ListNode(T), index: i32) ?*ListNode(T) {
+    var head: ?*ListNode(T) = node;
+    var i: i32 = 0;
+    while (i < index) : (i += 1) {
+        if (head) |cur| {
+            head = cur.next;
+        } else {
+            return null;
+        }
+    }
+    return head;
+}
+
+// 連結リストで値が target の最初のノードを探す
+pub fn find(comptime T: type, node: *ListNode(T), target: T) i32 {
+    var head: ?*ListNode(T) = node;
+    var index: i32 = 0;
+    while (head) |cur| {
+        if (cur.val == target) return index;
+        head = cur.next;
+        index += 1;
+    }
+    return -1;
+}
+
+// Driver Code
+pub fn run() void {
+    // 各ノードを初期化
+    var n0 = ListNode(i32){ .val = 1 };
+    var n1 = ListNode(i32){ .val = 3 };
+    var n2 = ListNode(i32){ .val = 2 };
+    var n3 = ListNode(i32){ .val = 5 };
+    var n4 = ListNode(i32){ .val = 4 };
+    // ノード間の参照を構築する
+    n0.next = &n1;
+    n1.next = &n2;
+    n2.next = &n3;
+    n3.next = &n4;
+    std.debug.print(
+        "初期化後の連結リストは {}\n",
+            .{utils.fmt.linkedList(i32, &n0)},
+        );
+
+    // ノードを挿入
+    var tmp = ListNode(i32){ .val = 0 };
+    insert(i32, &n0, &tmp);
+    std.debug.print(
+        "ノード挿入後の連結リストは {}\n",
+            .{utils.fmt.linkedList(i32, &n0)},
+        );
+
+    // ノードを削除
+    remove(i32, &n0);
+    std.debug.print(
+        "ノード削除後の連結リストは{}\n",
+            .{utils.fmt.linkedList(i32, &n0)},
+        );
+
+    // ノードにアクセス
+    const node = access(i32, &n0, 3);
+    std.debug.print(
+        "連結リストのインデックス 3 にあるノードの値 = {}\n",
+            .{node.?.val},
+        );
+
+    // ノードを探索
+    const index = find(i32, &n0, 2);
+    std.debug.print(
+        "連結リスト内の値 2 のノードのインデックス = {}\n",
+            .{index},
+        );
+
+    std.debug.print("\n", .{});
+}
+
+pub fn main() void {
+    run();
+}
+
+test "linked_list" {
+    run();
+}

ja/codes/zig/chapter_array_and_linkedlist/list.zig

@@ -0,0 +1,78 @@
+// File: list.zig
+// Created Time: 2023-01-07
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
+
+const std = @import("std");
+const utils = @import("utils");
+
+// Driver Code
+pub fn run() !void {
+    // リストを初期化
+    var nums = std.ArrayList(i32).init(std.heap.page_allocator);
+    defer nums.deinit(); // メモリの遅延解放
+
+    try nums.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });
+    std.debug.print("リスト nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // 要素にアクセス
+    const num = nums.items[1];
+    std.debug.print("インデックス 1 の要素にアクセスすると、num = {}\n", .{num});
+
+    // 要素を更新
+    nums.items[1] = 0;
+    std.debug.print("インデックス 1 の要素を 0 に更新すると、nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // リストを空にする
+    nums.clearRetainingCapacity();
+    std.debug.print("リストを空にした後 nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // 末尾に要素を追加
+    try nums.append(1);
+    try nums.append(3);
+    try nums.append(2);
+    try nums.append(5);
+    try nums.append(4);
+    std.debug.print("要素を追加すると nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // 中間に要素を挿入
+    try nums.insert(3, 6);
+    std.debug.print("インデックス 3 に数値 6 を挿入すると、nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // 要素を削除
+    _ = nums.orderedRemove(3);
+    std.debug.print("インデックス 3 の要素を削除すると、nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // インデックスでリストを走査
+    var count: i32 = 0;
+    var i: usize = 0;
+    while (i < nums.items.len) : (i += 1) {
+        count += nums.items[i];
+    }
+
+    // リスト要素を直接走査
+    count = 0;
+    for (nums.items) |x| {
+        count += x;
+    }
+
+    // 2 つのリストを連結する
+    var nums1 = std.ArrayList(i32).init(std.heap.page_allocator);
+    defer nums1.deinit();
+    try nums1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });
+    try nums.insertSlice(nums.items.len, nums1.items);
+    std.debug.print("リスト nums1 を nums の後ろに連結すると、nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    // リストをソート
+    std.mem.sort(i32, nums.items, {}, comptime std.sort.asc(i32));
+    std.debug.print("リストをソートすると nums = {}\n", .{utils.fmt.slice(nums.items)});
+
+    std.debug.print("\n", .{});
+}
+
+pub fn main() !void {
+    try run();
+}
+
+test "list" {
+    try run();
+}

ja/codes/zig/chapter_array_and_linkedlist/my_list.zig

@@ -0,0 +1,233 @@
+// File: my_list.zig
+// Created Time: 2023-01-08
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
+
+const std = @import("std");
+const utils = @import("utils");
+
+// リストクラス
+const MyList = struct {
+    const Self = @This();
+
+    items: []i32, // 配列（リスト要素を格納）
+    capacity: usize, // リスト容量
+    allocator: std.mem.Allocator, // メモリアロケータ
+
+    extend_ratio: usize = 2, // リスト拡張時の増加倍率
+
+    // コンストラクタ（メモリを確保してリストを初期化）
+    pub fn init(allocator: std.mem.Allocator) Self {
+        return Self{
+            .items = &[_]i32{},
+            .capacity = 0,
+            .allocator = allocator,
+        };
+    }
+
+    // デストラクタ（メモリを解放する）
+    pub fn deinit(self: Self) void {
+        self.allocator.free(self.allocatedSlice());
+    }
+
+    // 末尾に要素を追加
+    pub fn add(self: *Self, item: i32) !void {
+        // 要素数が容量を超えると、拡張機構が発動する
+        const newlen = self.items.len + 1;
+        try self.ensureTotalCapacity(newlen);
+
+        // 要素を更新
+        self.items.len += 1;
+        const new_item_ptr = &self.items[self.items.len - 1];
+        new_item_ptr.* = item;
+    }
+
+    // リストの長さを取得（現在の要素数）
+    pub fn getSize(self: *Self) usize {
+        return self.items.len;
+    }
+
+    // リスト容量を取得する
+    pub fn getCapacity(self: *Self) usize {
+        return self.capacity;
+    }
+
+    // 要素にアクセス
+    pub fn get(self: *Self, index: usize) i32 {
+        // インデックスが範囲外なら例外を送出する。以下同様
+        if (index < 0 or index >= self.items.len) {
+            @panic("インデックスが範囲外です");
+        }
+        return self.items[index];
+    }
+
+    // 要素を更新
+    pub fn set(self: *Self, index: usize, num: i32) void {
+        // インデックスが範囲外なら例外を送出する。以下同様
+        if (index < 0 or index >= self.items.len) {
+            @panic("インデックスが範囲外です");
+        }
+        self.items[index] = num;
+    }
+
+    // 中間に要素を挿入
+    pub fn insert(self: *Self, index: usize, item: i32) !void {
+        if (index < 0 or index >= self.items.len) {
+            @panic("インデックスが範囲外です");
+        }
+
+        // 要素数が容量を超えると、拡張機構が発動する
+        const newlen = self.items.len + 1;
+        try self.ensureTotalCapacity(newlen);
+
+        // index 以降の要素をすべて 1 つ後ろへずらす
+        self.items.len += 1;
+        var i = self.items.len - 1;
+        while (i >= index) : (i -= 1) {
+            self.items[i] = self.items[i - 1];
+        }
+        self.items[index] = item;
+    }
+
+    // 要素を削除
+    pub fn remove(self: *Self, index: usize) i32 {
+        if (index < 0 or index >= self.getSize()) {
+            @panic("インデックスが範囲外です");
+        }
+        // インデックス index より後の要素をすべて 1 つ前に移動する
+        const item = self.items[index];
+        var i = index;
+        while (i < self.items.len - 1) : (i += 1) {
+            self.items[i] = self.items[i + 1];
+        }
+        self.items.len -= 1;
+        // 削除された要素を返す
+        return item;
+    }
+
+    // リストを配列に変換する
+    pub fn toArraySlice(self: *Self) ![]i32 {
+        return self.toOwnedSlice(false);
+    }
+
+    // 新しいスライスを返し、リストコンテナをリセットまたはクリアするかどうかを設定する
+    pub fn toOwnedSlice(self: *Self, clear: bool) ![]i32 {
+        const allocator = self.allocator;
+        const old_memory = self.allocatedSlice();
+        if (allocator.remap(old_memory, self.items.len)) |new_items| {
+            if (clear) {
+                self.* = init(allocator);
+            }
+            return new_items;
+        }
+
+        const new_memory = try allocator.alloc(i32, self.items.len);
+        @memcpy(new_memory, self.items);
+        if (clear) {
+            self.clearAndFree();
+        }
+        return new_memory;
+    }
+
+    // リストの拡張
+    fn ensureTotalCapacity(self: *Self, new_capacity: usize) !void {
+        if (self.capacity >= new_capacity) return;
+        const capcacity = if (self.capacity == 0) 10 else self.capacity;
+        const better_capacity = capcacity * self.extend_ratio;
+
+        const old_memory = self.allocatedSlice();
+        if (self.allocator.remap(old_memory, better_capacity)) |new_memory| {
+            self.items.ptr = new_memory.ptr;
+            self.capacity = new_memory.len;
+        } else {
+            const new_memory = try self.allocator.alloc(i32, better_capacity);
+            @memcpy(new_memory[0..self.items.len], self.items);
+            self.allocator.free(old_memory);
+            self.items.ptr = new_memory.ptr;
+            self.capacity = new_memory.len;
+        }
+    }
+
+    fn clearAndFree(self: *Self, allocator: std.mem.Allocator) void {
+        allocator.free(self.allocatedSlice());
+        self.items.len = 0;
+        self.capacity = 0;
+    }
+
+    fn allocatedSlice(self: Self) []i32 {
+        return self.items.ptr[0..self.capacity];
+    }
+};
+
+// Driver Code
+pub fn run() !void {
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
+    // リストを初期化
+    var nums = MyList.init(allocator);
+    // メモリの遅延解放
+    defer nums.deinit();
+
+    // 末尾に要素を追加
+    try nums.add(1);
+    try nums.add(3);
+    try nums.add(2);
+    try nums.add(5);
+    try nums.add(4);
+    std.debug.print("リスト nums = {} ，容量 = {} ，長さ = {}\n", .{
+        utils.fmt.slice(nums.items),
+        nums.getCapacity(),
+        nums.getSize(),
+    });
+
+    // 中間に要素を挿入
+    try nums.insert(3, 6);
+    std.debug.print(
+        "インデックス 3 に数値 6 を挿入すると、nums = {}\n",
+            .{utils.fmt.slice(nums.items)},
+        );
+
+    // 要素を削除
+    _ = nums.remove(3);
+    std.debug.print(
+        "インデックス 3 の要素を削除すると、nums = {}\n",
+            .{utils.fmt.slice(nums.items)},
+        );
+
+    // 要素にアクセス
+    const num = nums.get(1);
+    std.debug.print("インデックス 1 の要素にアクセスすると、num = {}\n", .{num});
+
+    // 要素を更新
+    nums.set(1, 0);
+    std.debug.print(
+        "インデックス 1 の要素を 0 に更新すると、nums = {}\n",
+            .{utils.fmt.slice(nums.items)},
+        );
+
+    // 拡張機構をテストする
+    var i: i32 = 0;
+    while (i < 10) : (i += 1) {
+        // i = 5 のとき、リスト長が容量を超えるため、この時点で拡張機構が発動する
+        try nums.add(i);
+    }
+    std.debug.print(
+        "拡張後のリスト nums = {} ，容量 = {} ，長さ = {}\n",
+            .{
+                utils.fmt.slice(nums.items),
+                nums.getCapacity(),
+                nums.getSize(),
+            },
+        );
+
+    std.debug.print("\n", .{});
+}
+
+pub fn main() !void {
+    try run();
+}
+
+test "my_list" {
+    try run();
+}