Bug fixes and improvements (#1813)

* Sync zh and zh-hant version.

* Add the Warp sponsor banner.

* Update README with acknowledgments and Warp recommendation

Added acknowledgments and a recommendation for the Warp terminal application.

* Update README.md

* Update links in README.md to use HTTPS

* Sync zh and zh-hant versions.

* Add special thanks for Warp spnsorship.

* Use official warp image link.

zh-hant/codes/zig/chapter_array_and_linkedlist/array.zig

@@ -1,26 +1,28 @@
 // File: array.zig
 // Created Time: 2023-01-07
-// Author: codingonion (coderonion@gmail.com)
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
 
 const std = @import("std");
-const inc = @import("include");
+const utils = @import("utils");
 
 // 隨機訪問元素
-pub fn randomAccess(nums: []i32) i32 {
+pub fn randomAccess(nums: []const i32) i32 {
     // 在區間 [0, nums.len) 中隨機抽取一個整數
-    var randomIndex = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
+    const random_index = std.crypto.random.intRangeLessThan(usize, 0, nums.len);
     // 獲取並返回隨機元素
-    var randomNum = nums[randomIndex];
+    const randomNum = nums[random_index];
     return randomNum;
 }
 
 // 擴展陣列長度
-pub fn extend(mem_allocator: std.mem.Allocator, nums: []i32, enlarge: usize) ![]i32 {
+pub fn extend(allocator: std.mem.Allocator, nums: []const i32, enlarge: usize) ![]i32 {
     // 初始化一個擴展長度後的陣列
-    var res = try mem_allocator.alloc(i32, nums.len + enlarge);
+    const res = try allocator.alloc(i32, nums.len + enlarge);
     @memset(res, 0);
+
     // 將原陣列中的所有元素複製到新陣列
-    std.mem.copy(i32, res, nums);
+    std.mem.copyForwards(i32, res, nums);
+
     // 返回擴展後的新陣列
     return res;
 }
@@ -46,18 +48,26 @@ pub fn remove(nums: []i32, index: usize) void {
 }
 
 // 走訪陣列
-pub fn traverse(nums: []i32) void {
+pub fn traverse(nums: []const i32) void {
     var count: i32 = 0;
+
     // 透過索引走訪陣列
-    var i: i32 = 0;
+    var i: usize = 0;
     while (i < nums.len) : (i += 1) {
         count += nums[i];
     }
-    count = 0;
+
     // 直接走訪陣列元素
+    count = 0;
     for (nums) |num| {
         count += num;
     }
+
+    // 同時走訪資料索引和元素
+    for (nums, 0..) |num, index| {
+        count += nums[index];
+        count += num;
+    }
 }
 
 // 在陣列中查詢指定元素
@@ -69,49 +79,53 @@ pub fn find(nums: []i32, target: i32) i32 {
 }
 
 // Driver Code
-pub fn main() !void {
-    // 初始化記憶體分配器
-    var mem_arena = std.heap.ArenaAllocator.init(std.heap.page_allocator);
-    defer mem_arena.deinit();
-    const mem_allocator = mem_arena.allocator();
-
+pub fn run() !void {
     // 初始化陣列
-    var arr = [_]i32{0} ** 5;
-    std.debug.print("陣列 arr = ", .{});
-    inc.PrintUtil.printArray(i32, &arr);
+    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;
-    var nums = array[known_at_runtime_zero..];
-    std.debug.print("\n陣列 nums = ", .{});
-    inc.PrintUtil.printArray(i32, nums);
+    _ = &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)});
 
     // 隨機訪問
-    var randomNum = randomAccess(nums);
-    std.debug.print("\n在 nums 中獲取隨機元素 {}", .{randomNum});
+    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(mem_allocator, nums, 3);
-    std.debug.print("\n將陣列長度擴展至 8 ，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, nums);
+    nums = try extend(allocator, nums, 3);
+    std.debug.print("將陣列長度擴展至 8 ，得到 nums = {}\n", .{utils.fmt.slice(nums)});
 
     // 插入元素
     insert(nums, 6, 3);
-    std.debug.print("\n在索引 3 處插入數字 6 ，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, nums);
+    std.debug.print("在索引 3 處插入數字 6 ，得到 nums = {}\n", .{utils.fmt.slice(nums)});
 
     // 刪除元素
     remove(nums, 2);
-    std.debug.print("\n刪除索引 2 處的元素，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, nums);
+    std.debug.print("刪除索引 2 處的元素，得到 nums = {}\n", .{utils.fmt.slice(nums)});
 
     // 走訪陣列
     traverse(nums);
 
     // 查詢元素
-    var index = find(nums, 3);
-    std.debug.print("\n在 nums 中查詢元素 3 ，得到索引 = {}\n", .{index});
+    const index = find(nums, 3);
+    std.debug.print("在 nums 中查詢元素 3 ，得到索引 = {}\n", .{index});
 
-    _ = try std.io.getStdIn().reader().readByte();
+    std.debug.print("\n", .{});
 }
 
+pub fn main() !void {
+    try run();
+}
+
+test "array" {
+    try run();
+}

zh-hant/codes/zig/chapter_array_and_linkedlist/linked_list.zig

@@ -1,84 +1,106 @@
 // File: linked_list.zig
 // Created Time: 2023-01-07
-// Author: codingonion (coderonion@gmail.com)
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
 
 const std = @import("std");
-const inc = @import("include");
+const utils = @import("utils");
+const ListNode = utils.ListNode;
 
 // 在鏈結串列的節點 n0 之後插入節點 P
-pub fn insert(n0: ?*inc.ListNode(i32), P: ?*inc.ListNode(i32)) void {
-    var n1 = n0.?.next;
-    P.?.next = n1;
-    n0.?.next = 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(n0: ?*inc.ListNode(i32)) void {
-    if (n0.?.next == null) return;
-    // n0 -> P -> n1
-    var P = n0.?.next;
-    var n1 = P.?.next;
-    n0.?.next = n1;
+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(node: ?*inc.ListNode(i32), index: i32) ?*inc.ListNode(i32) {
-    var head = node;
+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) {
-        head = head.?.next;
-        if (head == null) return null;
+        if (head) |cur| {
+            head = cur.next;
+        } else {
+            return null;
+        }
     }
     return head;
 }
 
 // 在鏈結串列中查詢值為 target 的首個節點
-pub fn find(node: ?*inc.ListNode(i32), target: i32) i32 {
-    var head = node;
+pub fn find(comptime T: type, node: *ListNode(T), target: T) i32 {
+    var head: ?*ListNode(T) = node;
     var index: i32 = 0;
-    while (head != null) {
-        if (head.?.val == target) return index;
-        head = head.?.next;
+    while (head) |cur| {
+        if (cur.val == target) return index;
+        head = cur.next;
         index += 1;
     }
     return -1;
 }
 
 // Driver Code
-pub fn main() !void {
-    // 初始化鏈結串列
-    // 初始化各個節點 
-    var n0 = inc.ListNode(i32){.val = 1};
-    var n1 = inc.ListNode(i32){.val = 3};
-    var n2 = inc.ListNode(i32){.val = 2};
-    var n3 = inc.ListNode(i32){.val = 5};
-    var n4 = inc.ListNode(i32){.val = 4};
+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("初始化的鏈結串列為", .{});
-    try inc.PrintUtil.printLinkedList(i32, &n0);
+    std.debug.print(
+        "初始化的鏈結串列為 {}\n",
+        .{utils.fmt.linkedList(i32, &n0)},
+    );
 
     // 插入節點
-    var tmp = inc.ListNode(i32){.val = 0};
-    insert(&n0, &tmp);
-    std.debug.print("插入節點後的鏈結串列為", .{});
-    try inc.PrintUtil.printLinkedList(i32, &n0);
+    var tmp = ListNode(i32){ .val = 0 };
+    insert(i32, &n0, &tmp);
+    std.debug.print(
+        "插入節點後的鏈結串列為 {}\n",
+        .{utils.fmt.linkedList(i32, &n0)},
+    );
 
     // 刪除節點
-    remove(&n0);
-    std.debug.print("刪除節點後的鏈結串列為", .{});
-    try inc.PrintUtil.printLinkedList(i32, &n0);
+    remove(i32, &n0);
+    std.debug.print(
+        "刪除節點後的鏈結串列為{}\n",
+        .{utils.fmt.linkedList(i32, &n0)},
+    );
 
     // 訪問節點
-    var node = access(&n0, 3);
-    std.debug.print("鏈結串列中索引 3 處的節點的值 = {}\n", .{node.?.val});
+    const node = access(i32, &n0, 3);
+    std.debug.print(
+        "鏈結串列中索引 3 處的節點的值 = {}\n",
+        .{node.?.val},
+    );
 
     // 查詢節點
-    var index = find(&n0, 2);
-    std.debug.print("鏈結串列中值為 2 的節點的索引 = {}\n", .{index});
+    const index = find(i32, &n0, 2);
+    std.debug.print(
+        "鏈結串列中值為 2 的節點的索引 = {}\n",
+        .{index},
+    );
 
-    _ = try std.io.getStdIn().reader().readByte();
-}
+    std.debug.print("\n", .{});
+}
+
+pub fn main() void {
+    run();
+}
+
+test "linked_list" {
+    run();
+}

zh-hant/codes/zig/chapter_array_and_linkedlist/list.zig

@@ -1,33 +1,30 @@
 // File: list.zig
 // Created Time: 2023-01-07
-// Author: codingonion (coderonion@gmail.com)
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
 
 const std = @import("std");
-const inc = @import("include");
+const utils = @import("utils");
 
 // Driver Code
-pub fn main() !void {
+pub fn run() !void {
     // 初始化串列
     var nums = std.ArrayList(i32).init(std.heap.page_allocator);
-    // 延遲釋放記憶體
-    defer nums.deinit();
+    defer nums.deinit(); // 延遲釋放記憶體
+
     try nums.appendSlice(&[_]i32{ 1, 3, 2, 5, 4 });
-    std.debug.print("串列 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("串列 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 訪問元素
-    var num = nums.items[1];
-    std.debug.print("\n訪問索引 1 處的元素，得到 num = {}", .{num});
+    const num = nums.items[1];
+    std.debug.print("訪問索引 1 處的元素，得到 num = {}\n", .{num});
 
     // 更新元素
     nums.items[1] = 0;
-    std.debug.print("\n將索引 1 處的元素更新為 0 ，得到 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("將索引 1 處的元素更新為 0 ，得到 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 清空串列
     nums.clearRetainingCapacity();
-    std.debug.print("\n清空串列後 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("清空串列後 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 在尾部新增元素
     try nums.append(1);
@@ -35,25 +32,23 @@ pub fn main() !void {
     try nums.append(2);
     try nums.append(5);
     try nums.append(4);
-    std.debug.print("\n新增元素後 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("新增元素後 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 在中間插入元素
     try nums.insert(3, 6);
-    std.debug.print("\n在索引 3 處插入數字 6 ，得到 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("在索引 3 處插入數字 6 ，得到 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 刪除元素
     _ = nums.orderedRemove(3);
-    std.debug.print("\n刪除索引 3 處的元素，得到 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("刪除索引 3 處的元素，得到 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
     // 透過索引走訪串列
     var count: i32 = 0;
-    var i: i32 = 0;
+    var i: usize = 0;
     while (i < nums.items.len) : (i += 1) {
-        count += nums[i];
+        count += nums.items[i];
     }
+
     // 直接走訪串列元素
     count = 0;
     for (nums.items) |x| {
@@ -65,14 +60,19 @@ pub fn main() !void {
     defer nums1.deinit();
     try nums1.appendSlice(&[_]i32{ 6, 8, 7, 10, 9 });
     try nums.insertSlice(nums.items.len, nums1.items);
-    std.debug.print("\n將串列 nums1 拼接到 nums 之後，得到 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    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("\n排序串列後 nums = ", .{});
-    inc.PrintUtil.printList(i32, nums);
+    std.debug.print("排序串列後 nums = {}\n", .{utils.fmt.slice(nums.items)});
 
-    _ = try std.io.getStdIn().reader().readByte();
+    std.debug.print("\n", .{});
 }
 
+pub fn main() !void {
+    try run();
+}
+
+test "list" {
+    try run();
+}

zh-hant/codes/zig/chapter_array_and_linkedlist/my_list.zig

@@ -1,132 +1,171 @@
 // File: my_list.zig
 // Created Time: 2023-01-08
-// Author: codingonion (coderonion@gmail.com)
+// Author: codingonion (coderonion@gmail.com), CreatorMetaSky (creator_meta_sky@163.com)
 
 const std = @import("std");
-const inc = @import("include");
+const utils = @import("utils");
 
 // 串列類別
-pub fn MyList(comptime T: type) type {
-    return struct {
-        const Self = @This();
-        
-        arr: []T = undefined,                        // 陣列（儲存串列元素）
-        arrCapacity: usize = 10,                     // 串列容量
-        numSize: usize = 0,                           // 串列長度（當前元素數量）
-        extendRatio: usize = 2,                       // 每次串列擴容的倍數
-        mem_arena: ?std.heap.ArenaAllocator = null,
-        mem_allocator: std.mem.Allocator = undefined, // 記憶體分配器
+const MyList = struct {
+    const Self = @This();
 
-        // 建構子（分配記憶體+初始化串列）
-        pub fn init(self: *Self, allocator: std.mem.Allocator) !void {
-            if (self.mem_arena == null) {
-                self.mem_arena = std.heap.ArenaAllocator.init(allocator);
-                self.mem_allocator = self.mem_arena.?.allocator();
-            }
-            self.arr = try self.mem_allocator.alloc(T, self.arrCapacity);
-            @memset(self.arr, @as(T, 0));
-        }
+    items: []i32, // 陣列（儲存串列元素）
+    capacity: usize, // 串列容量
+    allocator: std.mem.Allocator, // 記憶體分配器
 
-        // 析構函式（釋放記憶體）
-        pub fn deinit(self: *Self) void {
-            if (self.mem_arena == null) return;
-            self.mem_arena.?.deinit();
-        }
+    extend_ratio: usize = 2, // 每次串列擴容的倍數
 
-        // 獲取串列長度（當前元素數量）
-        pub fn size(self: *Self) usize {
-            return self.numSize;
-        }
+    // 建構子（分配記憶體+初始化串列）
+    pub fn init(allocator: std.mem.Allocator) Self {
+        return Self{
+            .items = &[_]i32{},
+            .capacity = 0,
+            .allocator = allocator,
+        };
+    }
 
-        // 獲取串列容量
-        pub fn capacity(self: *Self) usize {
-            return self.arrCapacity;
-        }
+    // 析構函式（釋放記憶體）
+    pub fn deinit(self: Self) void {
+        self.allocator.free(self.allocatedSlice());
+    }
 
-        // 訪問元素
-        pub fn get(self: *Self, index: usize) T {
-            // 索引如果越界，則丟擲異常，下同
-            if (index < 0 or index >= self.size()) @panic("索引越界");
-            return self.arr[index];
-        }  
+    // 在尾部新增元素
+    pub fn add(self: *Self, item: i32) !void {
+        // 元素數量超出容量時，觸發擴容機制
+        const newlen = self.items.len + 1;
+        try self.ensureTotalCapacity(newlen);
 
         // 更新元素
-        pub fn set(self: *Self, index: usize, num: T) void {
-            // 索引如果越界，則丟擲異常，下同
-            if (index < 0 or index >= self.size()) @panic("索引越界");
-            self.arr[index] = num;
-        }  
+        self.items.len += 1;
+        const new_item_ptr = &self.items[self.items.len - 1];
+        new_item_ptr.* = item;
+    }
 
-        // 在尾部新增元素
-        pub fn add(self: *Self, num: T) !void {
-            // 元素數量超出容量時，觸發擴容機制
-            if (self.size() == self.capacity()) try self.extendCapacity();
-            self.arr[self.size()] = num;
-            // 更新元素數量
-            self.numSize += 1;
-        }  
+    // 獲取串列長度（當前元素數量）
+    pub fn getSize(self: *Self) usize {
+        return self.items.len;
+    }
 
-        // 在中間插入元素
-        pub fn insert(self: *Self, index: usize, num: T) !void {
-            if (index < 0 or index >= self.size()) @panic("索引越界");
-            // 元素數量超出容量時，觸發擴容機制
-            if (self.size() == self.capacity()) try self.extendCapacity();
-            // 將索引 index 以及之後的元素都向後移動一位
-            var j = self.size() - 1;
-            while (j >= index) : (j -= 1) {
-                self.arr[j + 1] = self.arr[j];
+    // 獲取串列容量
+    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 以及之後的元素都向後移動一位
+        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 之後的元素都向前移動一位
+        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);
             }
-            self.arr[index] = num;
-            // 更新元素數量
-            self.numSize += 1;
+            return new_items;
         }
 
-        // 刪除元素
-        pub fn remove(self: *Self, index: usize) T {
-            if (index < 0 or index >= self.size()) @panic("索引越界");
-            var num = self.arr[index];
-            // 將索引 index 之後的元素都向前移動一位
-            var j = index;
-            while (j < self.size() - 1) : (j += 1) {
-                self.arr[j] = self.arr[j + 1];
-            }
-            // 更新元素數量
-            self.numSize -= 1;
-            // 返回被刪除的元素
-            return num;
+        const new_memory = try allocator.alloc(i32, self.items.len);
+        @memcpy(new_memory, self.items);
+        if (clear) {
+            self.clearAndFree();
         }
+        return new_memory;
+    }
 
-        // 串列擴容
-        pub fn extendCapacity(self: *Self) !void {
-            // 新建一個長度為 size * extendRatio 的陣列，並將原陣列複製到新陣列
-            var newCapacity = self.capacity() * self.extendRatio;
-            var extend = try self.mem_allocator.alloc(T, newCapacity);
-            @memset(extend, @as(T, 0));
-            // 將原陣列中的所有元素複製到新陣列
-            std.mem.copy(T, extend, self.arr);
-            self.arr = extend;
-            // 更新串列容量
-            self.arrCapacity = newCapacity;
-        }
+    // 串列擴容
+    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;
 
-        // 將串列轉換為陣列
-        pub fn toArray(self: *Self) ![]T {
-            // 僅轉換有效長度範圍內的串列元素
-            var arr = try self.mem_allocator.alloc(T, self.size());
-           @memset(arr, @as(T, 0));
-            for (arr, 0..) |*num, i| {
-                num.* = self.get(i);
-            }
-            return arr;
+        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 main() !void {
+pub fn run() !void {
+    var gpa = std.heap.DebugAllocator(.{}){};
+    defer _ = gpa.deinit();
+    const allocator = gpa.allocator();
+
     // 初始化串列
-    var nums = MyList(i32){};
-    try nums.init(std.heap.page_allocator);
+    var nums = MyList.init(allocator);
     // 延遲釋放記憶體
     defer nums.deinit();
 
@@ -136,28 +175,36 @@ pub fn main() !void {
     try nums.add(2);
     try nums.add(5);
     try nums.add(4);
-    std.debug.print("串列 nums = ", .{});
-    inc.PrintUtil.printArray(i32, try nums.toArray());
-    std.debug.print(" ，容量 = {} ，長度 = {}", .{nums.capacity(), nums.size()});
+    std.debug.print("串列 nums = {} ，容量 = {} ，長度 = {}\n", .{
+        utils.fmt.slice(nums.items),
+        nums.getCapacity(),
+        nums.getSize(),
+    });
 
     // 在中間插入元素
     try nums.insert(3, 6);
-    std.debug.print("\n在索引 3 處插入數字 6 ，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, try nums.toArray());
+    std.debug.print(
+        "在索引 3 處插入數字 6 ，得到 nums = {}\n",
+        .{utils.fmt.slice(nums.items)},
+    );
 
     // 刪除元素
     _ = nums.remove(3);
-    std.debug.print("\n刪除索引 3 處的元素，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, try nums.toArray());
+    std.debug.print(
+        "刪除索引 3 處的元素，得到 nums = {}\n",
+        .{utils.fmt.slice(nums.items)},
+    );
 
     // 訪問元素
-    var num = nums.get(1);
-    std.debug.print("\n訪問索引 1 處的元素，得到 num = {}", .{num});
+    const num = nums.get(1);
+    std.debug.print("訪問索引 1 處的元素，得到 num = {}\n", .{num});
 
     // 更新元素
     nums.set(1, 0);
-    std.debug.print("\n將索引 1 處的元素更新為 0 ，得到 nums = ", .{});
-    inc.PrintUtil.printArray(i32, try nums.toArray());
+    std.debug.print(
+        "將索引 1 處的元素更新為 0 ，得到 nums = {}\n",
+        .{utils.fmt.slice(nums.items)},
+    );
 
     // 測試擴容機制
     var i: i32 = 0;
@@ -165,9 +212,22 @@ pub fn main() !void {
         // 在 i = 5 時，串列長度將超出串列容量，此時觸發擴容機制
         try nums.add(i);
     }
-    std.debug.print("\n擴容後的串列 nums = ", .{});
-    inc.PrintUtil.printArray(i32, try nums.toArray());
-    std.debug.print(" ，容量 = {} ，長度 = {}\n", .{nums.capacity(), nums.size()});
+    std.debug.print(
+        "擴容後的串列 nums = {} ，容量 = {} ，長度 = {}\n",
+        .{
+            utils.fmt.slice(nums.items),
+            nums.getCapacity(),
+            nums.getSize(),
+        },
+    );
 
-    _ = try std.io.getStdIn().reader().readByte();
+    std.debug.print("\n", .{});
+}
+
+pub fn main() !void {
+    try run();
+}
+
+test "my_list" {
+    try run();
 }