build

docs/chapter_array_and_linkedlist/array.md

@@ -99,7 +99,12 @@ comments: true
 
     ```rust title="array.rs"
     /* 初始化数组 */
-    let arr: Vec<i32> = vec![0; 5]; // [0, 0, 0, 0, 0]
+    let arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]
+    let slice: &[i32] = &[0; 5];
+    // 在 Rust 中，指定长度时（[i32; 5]）为数组，不指定长度时（&[i32]）为切片
+    // 由于 Rust 的数组被设计为在编译期确定长度，因此只能使用常量来指定长度
+    // Vector 是 Rust 一般情况下用作动态数组的类型
+    // 为了方便实现扩容 extend() 方法，以下将 vector 看作数组（array）
     let nums: Vec<i32> = vec![1, 3, 2, 5, 4];
     ```
 
@@ -477,7 +482,7 @@ comments: true
 
     ```rust title="array.rs"
     /* 在数组的索引 index 处插入元素 num */
-    fn insert(nums: &mut Vec<i32>, num: i32, index: usize) {
+    fn insert(nums: &mut [i32], num: i32, index: usize) {
         // 把索引 index 以及之后的所有元素向后移动一位
         for i in (index + 1..nums.len()).rev() {
             nums[i] = nums[i - 1];
@@ -670,7 +675,7 @@ comments: true
 
     ```rust title="array.rs"
     /* 删除索引 index 处的元素 */
-    fn remove(nums: &mut Vec<i32>, index: usize) {
+    fn remove(nums: &mut [i32], index: usize) {
         // 把索引 index 之后的所有元素向前移动一位
         for i in index..nums.len() - 1 {
             nums[i] = nums[i + 1];
@@ -1350,7 +1355,7 @@ comments: true
 
     ```rust title="array.rs"
     /* 扩展数组长度 */
-    fn extend(nums: Vec<i32>, enlarge: usize) -> Vec<i32> {
+    fn extend(nums: &[i32], enlarge: usize) -> Vec<i32> {
         // 初始化一个扩展长度后的数组
         let mut res: Vec<i32> = vec![0; nums.len() + enlarge];
         // 将原数组中的所有元素复制到新

docs/chapter_array_and_linkedlist/summary.md

@@ -77,4 +77,4 @@ comments: true
 
 **Q**：初始化列表 `res = [0] * self.size()` 操作，会导致 `res` 的每个元素引用相同的地址吗？
 
-不会。但二维数组会有这个问题，例如初始化二维列表 `res = [[0] * self.size()]` ，则多次引用了同一个列表 `[0]` 。
+不会。但二维数组会有这个问题，例如初始化二维列表 `res = [[0]] * self.size()` ，则多次引用了同一个列表 `[0]` 。

docs/chapter_divide_and_conquer/binary_search_recur.md

@@ -422,9 +422,32 @@ comments: true
 === "Ruby"
 
     ```ruby title="binary_search_recur.rb"
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{binary_search}
+    ### 二分查找：问题 f(i, j) ###
+    def dfs(nums, target, i, j)
+      # 若区间为空，代表无目标元素，则返回 -1
+      return -1 if i > j
+      
+      # 计算中点索引 m
+      m = (i + j) / 2
+
+      if nums[m] < target
+        # 递归子问题 f(m+1, j)
+        return dfs(nums, target, m + 1, j)
+      elsif nums[m] > target
+        # 递归子问题 f(i, m-1)
+        return dfs(nums, target, i, m - 1)
+      else
+        # 找到目标元素，返回其索引
+        return m
+      end
+    end
+
+    ### 二分查找 ###
+    def binary_search(nums, target)
+      n = nums.length
+      # 求解问题 f(0, n-1)
+      dfs(nums, target, 0, n - 1)
+    end
     ```
 
 === "Zig"

docs/chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -485,9 +485,31 @@ comments: true
 === "Ruby"
 
     ```ruby title="build_tree.rb"
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{build_tree}
+    ### 构建二叉树：分治 ###
+    def dfs(preorder, inorder_map, i, l, r)
+      # 子树区间为空时终止
+      return if r - l < 0
+
+      # 初始化根节点
+      root = TreeNode.new(preorder[i])
+      # 查询 m ，从而划分左右子树
+      m = inorder_map[preorder[i]]
+      # 子问题：构建左子树
+      root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)
+      # 子问题：构建右子树
+      root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)
+
+      # 返回根节点
+      root
+    end
+
+    ### 构建二叉树 ###
+    def build_tree(preorder, inorder)
+      # 初始化哈希表，存储 inorder 元素到索引的映射
+      inorder_map = {}
+      inorder.each_with_index { |val, i| inorder_map[val] = i }
+      dfs(preorder, inorder_map, 0, 0, inorder.length - 1)
+    end
     ```
 
 === "Zig"

docs/chapter_divide_and_conquer/hanota_problem.md

@@ -409,7 +409,7 @@ comments: true
     /* 移动一个圆盘 */
     fn move_pan(src: &mut Vec<i32>, tar: &mut Vec<i32>) {
         // 从 src 顶部拿出一个圆盘
-        let pan = src.remove(src.len() - 1);
+        let pan = src.pop().unwrap();
         // 将圆盘放入 tar 顶部
         tar.push(pan);
     }
@@ -510,11 +510,36 @@ comments: true
 === "Ruby"
 
     ```ruby title="hanota.rb"
-    [class]{}-[func]{move}
-
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{solve_hanota}
+    ### 移动一个圆盘 ###
+    def move(src, tar)
+      # 从 src 顶部拿出一个圆盘
+      pan = src.pop
+      # 将圆盘放入 tar 顶部
+      tar << pan
+    end
+
+    ### 求解汉诺塔问题 f(i) ###
+    def dfs(i, src, buf, tar)
+      # 若 src 只剩下一个圆盘，则直接将其移到 tar
+      if i == 1
+        move(src, tar)
+        return
+      end
+
+      # 子问题 f(i-1) ：将 src 顶部 i-1 个圆盘借助 tar 移到 buf
+      dfs(i - 1, src, tar, buf)
+      # 子问题 f(1) ：将 src 剩余一个圆盘移到 tar
+      move(src, tar)
+      # 子问题 f(i-1) ：将 buf 顶部 i-1 个圆盘借助 src 移到 tar
+      dfs(i - 1, buf, src, tar)
+    end
+
+    ### 求解汉诺塔问题 ###
+    def solve_hanota(_A, _B, _C)
+      n = _A.length
+      # 将 A 顶部 n 个圆盘借助 B 移到 C
+      dfs(n, _A, _B, _C)
+    end
     ```
 
 === "Zig"

docs/chapter_greedy/fractional_knapsack_problem.md

@@ -496,9 +496,39 @@ comments: true
 === "Ruby"
 
     ```ruby title="fractional_knapsack.rb"
-    [class]{Item}-[func]{}
-
-    [class]{}-[func]{fractional_knapsack}
+    ### 物品 ###
+    class Item
+      attr_accessor :w # 物品重量
+      attr_accessor :v # 物品价值
+
+      def initialize(w, v)
+        @w = w
+        @v = v
+      end
+    end
+
+    ### 分数背包：贪心 ###
+    def fractional_knapsack(wgt, val, cap)
+      # 创建物品列表，包含两个属性：重量，价值
+      items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }
+      # 按照单位价值 item.v / item.w 从高到低进行排序
+      items.sort! { |a, b| (b.v.to_f / b.w) <=> (a.v.to_f / a.w) }
+      # 循环贪心选择
+      res = 0
+      for item in items
+        if item.w <= cap
+          # 若剩余容量充足，则将当前物品整个装进背包
+          res += item.v
+          cap -= item.w
+        else
+          # 若剩余容量不足，则将当前物品的一部分装进背包
+          res += (item.v.to_f / item.w) * cap
+          # 已无剩余容量，因此跳出循环
+          break
+        end
+      end
+      res
+    end
     ```
 
 === "Zig"

docs/chapter_greedy/greedy_algorithm.md

@@ -310,7 +310,24 @@ comments: true
 === "Ruby"
 
     ```ruby title="coin_change_greedy.rb"
-    [class]{}-[func]{coin_change_greedy}
+    ### 零钱兑换：贪心 ###
+    def coin_change_greedy(coins, amt)
+      # 假设 coins 列表有序
+      i = coins.length - 1
+      count = 0
+      # 循环进行贪心选择，直到无剩余金额
+      while amt > 0
+        # 找到小于且最接近剩余金额的硬币
+        while i > 0 && coins[i] > amt
+          i -= 1
+        end
+        # 选择 coins[i]
+        amt -= coins[i]
+        count += 1
+      end
+      # 若未找到可行方案， 则返回 -1
+      amt == 0 ? count : -1
+    end
     ```
 
 === "Zig"

docs/chapter_greedy/max_capacity_problem.md

@@ -397,7 +397,28 @@ $$
 === "Ruby"
 
     ```ruby title="max_capacity.rb"
-    [class]{}-[func]{max_capacity}
+    ### 最大容量：贪心 ###
+    def max_capacity(ht)
+      # 初始化 i, j，使其分列数组两端
+      i, j = 0, ht.length - 1
+      # 初始最大容量为 0
+      res = 0
+
+      # 循环贪心选择，直至两板相遇
+      while i < j
+        # 更新最大容量
+        cap = [ht[i], ht[j]].min * (j - i)
+        res = [res, cap].max
+        # 向内移动短板
+        if ht[i] < ht[j]
+          i += 1
+        else
+          j -= 1
+        end
+      end
+
+      res
+    end
     ```
 
 === "Zig"

docs/chapter_greedy/max_product_cutting_problem.md

@@ -371,7 +371,19 @@ $$
 === "Ruby"
 
     ```ruby title="max_product_cutting.rb"
-    [class]{}-[func]{max_product_cutting}
+    ### 最大切分乘积：贪心 ###
+    def max_product_cutting(n)
+      # 当 n <= 3 时，必须切分出一个 1
+      return 1 * (n - 1) if n <= 3
+      # 贪心地切分出 3 ，a 为 3 的个数，b 为余数
+      a, b = n / 3, n % 3
+      # 当余数为 1 时，将一对 1 * 3 转化为 2 * 2
+      return (3.pow(a - 1) * 2 * 2).to_i if b == 1
+      # 当余数为 2 时，不做处理
+      return (3.pow(a) * 2).to_i if b == 2
+      # 当余数为 0 时，不做处理
+      3.pow(a).to_i
+    end
     ```
 
 === "Zig"

docs/chapter_introduction/what_is_dsa.md

@@ -14,7 +14,7 @@ comments: true
 
 ## 1.2.2   数据结构定义
 
-<u>数据结构（data structure）</u>是计算机中组织和存储数据的方式，具有以下设计目标。
+<u>数据结构（data structure）</u>是组织和存储数据的方式，涵盖数据内容、数据之间关系和数据操作方法，它具有以下设计目标。
 
 - 空间占用尽量少，以节省计算机内存。
 - 数据操作尽可能快速，涵盖数据访问、添加、删除、更新等。

docs/chapter_sorting/bubble_sort.md

@@ -225,9 +225,7 @@ comments: true
             for j in 0..i {
                 if nums[j] > nums[j + 1] {
                     // 交换 nums[j] 与 nums[j + 1]
-                    let tmp = nums[j];
-                    nums[j] = nums[j + 1];
-                    nums[j + 1] = tmp;
+                    nums.swap(j, j + 1);
                 }
             }
         }
@@ -538,9 +536,7 @@ comments: true
             for j in 0..i {
                 if nums[j] > nums[j + 1] {
                     // 交换 nums[j] 与 nums[j + 1]
-                    let tmp = nums[j];
-                    nums[j] = nums[j + 1];
-                    nums[j + 1] = tmp;
+                    nums.swap(j, j + 1);
                     flag = true; // 记录交换元素
                 }
             }

docs/chapter_sorting/bucket_sort.md

@@ -314,7 +314,7 @@ comments: true
         let k = nums.len() / 2;
         let mut buckets = vec![vec![]; k];
         // 1. 将数组元素分配到各个桶中
-        for &mut num in &mut *nums {
+        for &num in nums.iter() {
             // 输入数据范围为 [0, 1)，使用 num * k 映射到索引范围 [0, k-1]
             let i = (num * k as f64) as usize;
             // 将 num 添加进桶 i
@@ -327,8 +327,8 @@ comments: true
         }
         // 3. 遍历桶合并结果
         let mut i = 0;
-        for bucket in &mut buckets {
-            for &mut num in bucket {
+        for bucket in buckets.iter() {
+            for &num in bucket.iter() {
                 nums[i] = num;
                 i += 1;
             }

docs/chapter_sorting/counting_sort.md

@@ -266,11 +266,11 @@ comments: true
     // 简单实现，无法用于排序对象
     fn counting_sort_naive(nums: &mut [i32]) {
         // 1. 统计数组最大元素 m
-        let m = *nums.into_iter().max().unwrap();
+        let m = *nums.iter().max().unwrap();
         // 2. 统计各数字的出现次数
         // counter[num] 代表 num 的出现次数
         let mut counter = vec![0; m as usize + 1];
-        for &num in &*nums {
+        for &num in nums.iter() {
             counter[num as usize] += 1;
         }
         // 3. 遍历 counter ，将各元素填入原数组 nums
@@ -764,16 +764,16 @@ $$
     // 完整实现，可排序对象，并且是稳定排序
     fn counting_sort(nums: &mut [i32]) {
         // 1. 统计数组最大元素 m
-        let m = *nums.into_iter().max().unwrap();
+        let m = *nums.iter().max().unwrap() as usize;
         // 2. 统计各数字的出现次数
         // counter[num] 代表 num 的出现次数
-        let mut counter = vec![0; m as usize + 1];
-        for &num in &*nums {
+        let mut counter = vec![0; m + 1];
+        for &num in nums.iter() {
             counter[num as usize] += 1;
         }
         // 3. 求 counter 的前缀和，将“出现次数”转换为“尾索引”
         // 即 counter[num]-1 是 num 在 res 中最后一次出现的索引
-        for i in 0..m as usize {
+        for i in 0..m {
             counter[i + 1] += counter[i];
         }
         // 4. 倒序遍历 nums ，将各元素填入结果数组 res
@@ -786,9 +786,7 @@ $$
             counter[num as usize] -= 1; // 令前缀和自减 1 ，得到下次放置 num 的索引
         }
         // 使用结果数组 res 覆盖原数组 nums
-        for i in 0..n {
-            nums[i] = res[i];
-        }
+        nums.copy_from_slice(&res)
     }
     ```
 

docs/chapter_sorting/heap_sort.md

@@ -463,9 +463,7 @@ comments: true
                 break;
             }
             // 交换两节点
-            let temp = nums[i];
-            nums[i] = nums[ma];
-            nums[ma] = temp;
+            nums.swap(i, ma);
             // 循环向下堆化
             i = ma;
         }
@@ -474,15 +472,13 @@ comments: true
     /* 堆排序 */
     fn heap_sort(nums: &mut [i32]) {
         // 建堆操作：堆化除叶节点以外的其他所有节点
-        for i in (0..=nums.len() / 2 - 1).rev() {
+        for i in (0..nums.len() / 2).rev() {
             sift_down(nums, nums.len(), i);
         }
         // 从堆中提取最大元素，循环 n-1 轮
-        for i in (1..=nums.len() - 1).rev() {
+        for i in (1..nums.len()).rev() {
             // 交换根节点与最右叶节点（交换首元素与尾元素）
-            let tmp = nums[0];
-            nums[0] = nums[i];
-            nums[i] = tmp;
+            nums.swap(0, i);
             // 以根节点为起点，从顶至底进行堆化
             sift_down(nums, i, 0);
         }

en/docs/chapter_array_and_linkedlist/array.md

@@ -99,7 +99,12 @@ Arrays can be initialized in two ways depending on the needs: either without ini
 
     ```rust title="array.rs"
     /* Initialize array */
-    let arr: Vec<i32> = vec![0; 5]; // [0, 0, 0, 0, 0]
+    let arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]
+    let slice: &[i32] = &[0; 5];
+    // In Rust, specifying the length ([i32; 5]) denotes an array, while not specifying it (&[i32]) denotes a slice.
+    // Since Rust's arrays are designed to have compile-time fixed length, only constants can be used to specify the length.
+    // Vectors are generally used as dynamic arrays in Rust.
+    // For convenience in implementing the extend() method, the vector will be considered as an array here.
     let nums: Vec<i32> = vec![1, 3, 2, 5, 4];
     ```
 

en/docs/chapter_array_and_linkedlist/summary.md

@@ -78,7 +78,7 @@ On the other hand, linked lists are primarily necessary for binary trees and gra
 
 **Q**: Does initializing a list `res = [0] * self.size()` result in each element of `res` referencing the same address?
 
-No. However, this issue arises with two-dimensional arrays, for example, initializing a two-dimensional list `res = [[0] * self.size()]` would reference the same list `[0]` multiple times.
+No. However, this issue arises with two-dimensional arrays, for example, initializing a two-dimensional list `res = [[0]] * self.size()` would reference the same list `[0]` multiple times.
 
 **Q**: In deleting a node, is it necessary to break the reference to its successor node?
 

zh-Hant/docs/chapter_array_and_linkedlist/array.md

@@ -99,7 +99,12 @@ comments: true
 
     ```rust title="array.rs"
     /* 初始化陣列 */
-    let arr: Vec<i32> = vec![0; 5]; // [0, 0, 0, 0, 0]
+    let arr: [i32; 5] = [0; 5]; // [0, 0, 0, 0, 0]
+    let slice: &[i32] = &[0; 5];
+    // 在 Rust 中，指定長度時（[i32; 5]）為陣列，不指定長度時（&[i32]）為切片
+    // 由於 Rust 的陣列被設計為在編譯期確定長度，因此只能使用常數來指定長度
+    // Vector 是 Rust 一般情況下用作動態陣列的型別
+    // 為了方便實現擴容 extend() 方法，以下將 vector 看作陣列（array）
     let nums: Vec<i32> = vec![1, 3, 2, 5, 4];
     ```
 
@@ -477,7 +482,7 @@ comments: true
 
     ```rust title="array.rs"
     /* 在陣列的索引 index 處插入元素 num */
-    fn insert(nums: &mut Vec<i32>, num: i32, index: usize) {
+    fn insert(nums: &mut [i32], num: i32, index: usize) {
         // 把索引 index 以及之後的所有元素向後移動一位
         for i in (index + 1..nums.len()).rev() {
             nums[i] = nums[i - 1];
@@ -670,7 +675,7 @@ comments: true
 
     ```rust title="array.rs"
     /* 刪除索引 index 處的元素 */
-    fn remove(nums: &mut Vec<i32>, index: usize) {
+    fn remove(nums: &mut [i32], index: usize) {
         // 把索引 index 之後的所有元素向前移動一位
         for i in index..nums.len() - 1 {
             nums[i] = nums[i + 1];
@@ -1350,7 +1355,7 @@ comments: true
 
     ```rust title="array.rs"
     /* 擴展陣列長度 */
-    fn extend(nums: Vec<i32>, enlarge: usize) -> Vec<i32> {
+    fn extend(nums: &[i32], enlarge: usize) -> Vec<i32> {
         // 初始化一個擴展長度後的陣列
         let mut res: Vec<i32> = vec![0; nums.len() + enlarge];
         // 將原陣列中的所有元素複製到新

zh-Hant/docs/chapter_array_and_linkedlist/summary.md

@@ -77,4 +77,4 @@ comments: true
 
 **Q**：初始化串列 `res = [0] * self.size()` 操作，會導致 `res` 的每個元素引用相同的位址嗎？
 
-不會。但二維陣列會有這個問題，例如初始化二維串列 `res = [[0] * self.size()]` ，則多次引用了同一個串列 `[0]` 。
+不會。但二維陣列會有這個問題，例如初始化二維串列 `res = [[0]] * self.size()` ，則多次引用了同一個串列 `[0]` 。

zh-Hant/docs/chapter_divide_and_conquer/binary_search_recur.md

@@ -422,9 +422,32 @@ comments: true
 === "Ruby"
 
     ```ruby title="binary_search_recur.rb"
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{binary_search}
+    ### 二分搜尋：問題 f(i, j) ###
+    def dfs(nums, target, i, j)
+      # 若區間為空，代表無目標元素，則返回 -1
+      return -1 if i > j
+      
+      # 計算中點索引 m
+      m = (i + j) / 2
+
+      if nums[m] < target
+        # 遞迴子問題 f(m+1, j)
+        return dfs(nums, target, m + 1, j)
+      elsif nums[m] > target
+        # 遞迴子問題 f(i, m-1)
+        return dfs(nums, target, i, m - 1)
+      else
+        # 找到目標元素，返回其索引
+        return m
+      end
+    end
+
+    ### 二分搜尋 ###
+    def binary_search(nums, target)
+      n = nums.length
+      # 求解問題 f(0, n-1)
+      dfs(nums, target, 0, n - 1)
+    end
     ```
 
 === "Zig"

zh-Hant/docs/chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -485,9 +485,31 @@ comments: true
 === "Ruby"
 
     ```ruby title="build_tree.rb"
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{build_tree}
+    ### 構建二元樹：分治 ###
+    def dfs(preorder, inorder_map, i, l, r)
+      # 子樹區間為空時終止
+      return if r - l < 0
+
+      # 初始化根節點
+      root = TreeNode.new(preorder[i])
+      # 查詢 m ，從而劃分左右子樹
+      m = inorder_map[preorder[i]]
+      # 子問題：構建左子樹
+      root.left = dfs(preorder, inorder_map, i + 1, l, m - 1)
+      # 子問題：構建右子樹
+      root.right = dfs(preorder, inorder_map, i + 1 + m - l, m + 1, r)
+
+      # 返回根節點
+      root
+    end
+
+    ### 構建二元樹 ###
+    def build_tree(preorder, inorder)
+      # 初始化雜湊表，儲存 inorder 元素到索引的對映
+      inorder_map = {}
+      inorder.each_with_index { |val, i| inorder_map[val] = i }
+      dfs(preorder, inorder_map, 0, 0, inorder.length - 1)
+    end
     ```
 
 === "Zig"

zh-Hant/docs/chapter_divide_and_conquer/hanota_problem.md

@@ -409,7 +409,7 @@ comments: true
     /* 移動一個圓盤 */
     fn move_pan(src: &mut Vec<i32>, tar: &mut Vec<i32>) {
         // 從 src 頂部拿出一個圓盤
-        let pan = src.remove(src.len() - 1);
+        let pan = src.pop().unwrap();
         // 將圓盤放入 tar 頂部
         tar.push(pan);
     }
@@ -510,11 +510,36 @@ comments: true
 === "Ruby"
 
     ```ruby title="hanota.rb"
-    [class]{}-[func]{move}
-
-    [class]{}-[func]{dfs}
-
-    [class]{}-[func]{solve_hanota}
+    ### 移動一個圓盤 ###
+    def move(src, tar)
+      # 從 src 頂部拿出一個圓盤
+      pan = src.pop
+      # 將圓盤放入 tar 頂部
+      tar << pan
+    end
+
+    ### 求解河內塔問題 f(i) ###
+    def dfs(i, src, buf, tar)
+      # 若 src 只剩下一個圓盤，則直接將其移到 tar
+      if i == 1
+        move(src, tar)
+        return
+      end
+
+      # 子問題 f(i-1) ：將 src 頂部 i-1 個圓盤藉助 tar 移到 buf
+      dfs(i - 1, src, tar, buf)
+      # 子問題 f(1) ：將 src 剩餘一個圓盤移到 tar
+      move(src, tar)
+      # 子問題 f(i-1) ：將 buf 頂部 i-1 個圓盤藉助 src 移到 tar
+      dfs(i - 1, buf, src, tar)
+    end
+
+    ### 求解河內塔問題 ###
+    def solve_hanota(_A, _B, _C)
+      n = _A.length
+      # 將 A 頂部 n 個圓盤藉助 B 移到 C
+      dfs(n, _A, _B, _C)
+    end
     ```
 
 === "Zig"

zh-Hant/docs/chapter_dynamic_programming/dp_problem_features.md

@@ -457,7 +457,7 @@ $$
 === "JS"
 
     ```javascript title="min_cost_climbing_stairs_dp.js"
-    /* 爬樓梯最小代價：狀態壓縮後的動態規劃 */
+    /* 爬樓梯最小代價：空間最佳化後的動態規劃 */
     function minCostClimbingStairsDPComp(cost) {
         const n = cost.length - 1;
         if (n === 1 || n === 2) {
@@ -477,7 +477,7 @@ $$
 === "TS"
 
     ```typescript title="min_cost_climbing_stairs_dp.ts"
-    /* 爬樓梯最小代價：狀態壓縮後的動態規劃 */
+    /* 爬樓梯最小代價：空間最佳化後的動態規劃 */
     function minCostClimbingStairsDPComp(cost: Array<number>): number {
         const n = cost.length - 1;
         if (n === 1 || n === 2) {

zh-Hant/docs/chapter_dynamic_programming/dp_solution_pipeline.md

@@ -1361,7 +1361,7 @@ $$
 === "JS"
 
     ```javascript title="min_path_sum.js"
-    /* 最小路徑和：狀態壓縮後的動態規劃 */
+    /* 最小路徑和：空間最佳化後的動態規劃 */
     function minPathSumDPComp(grid) {
         const n = grid.length,
             m = grid[0].length;
@@ -1388,7 +1388,7 @@ $$
 === "TS"
 
     ```typescript title="min_path_sum.ts"
-    /* 最小路徑和：狀態壓縮後的動態規劃 */
+    /* 最小路徑和：空間最佳化後的動態規劃 */
     function minPathSumDPComp(grid: Array<Array<number>>): number {
         const n = grid.length,
             m = grid[0].length;

zh-Hant/docs/chapter_dynamic_programming/edit_distance_problem.md

@@ -746,7 +746,7 @@ $$
 === "JS"
 
     ```javascript title="edit_distance.js"
-    /* 編輯距離：狀態壓縮後的動態規劃 */
+    /* 編輯距離：空間最佳化後的動態規劃 */
     function editDistanceDPComp(s, t) {
         const n = s.length,
             m = t.length;
@@ -780,7 +780,7 @@ $$
 === "TS"
 
     ```typescript title="edit_distance.ts"
-    /* 編輯距離：狀態壓縮後的動態規劃 */
+    /* 編輯距離：空間最佳化後的動態規劃 */
     function editDistanceDPComp(s: string, t: string): number {
         const n = s.length,
             m = t.length;

zh-Hant/docs/chapter_dynamic_programming/knapsack_problem.md

@@ -1307,7 +1307,7 @@ $$
 === "JS"
 
     ```javascript title="knapsack.js"
-    /* 0-1 背包：狀態壓縮後的動態規劃 */
+    /* 0-1 背包：空間最佳化後的動態規劃 */
     function knapsackDPComp(wgt, val, cap) {
         const n = wgt.length;
         // 初始化 dp 表
@@ -1329,7 +1329,7 @@ $$
 === "TS"
 
     ```typescript title="knapsack.ts"
-    /* 0-1 背包：狀態壓縮後的動態規劃 */
+    /* 0-1 背包：空間最佳化後的動態規劃 */
     function knapsackDPComp(
         wgt: Array<number>,
         val: Array<number>,

zh-Hant/docs/chapter_dynamic_programming/unbounded_knapsack_problem.md

@@ -554,7 +554,7 @@ $$
 === "JS"
 
     ```javascript title="unbounded_knapsack.js"
-    /* 完全背包：狀態壓縮後的動態規劃 */
+    /* 完全背包：空間最佳化後的動態規劃 */
     function unboundedKnapsackDPComp(wgt, val, cap) {
         const n = wgt.length;
         // 初始化 dp 表
@@ -578,7 +578,7 @@ $$
 === "TS"
 
     ```typescript title="unbounded_knapsack.ts"
-    /* 完全背包：狀態壓縮後的動態規劃 */
+    /* 完全背包：空間最佳化後的動態規劃 */
     function unboundedKnapsackDPComp(
         wgt: Array<number>,
         val: Array<number>,
@@ -1417,7 +1417,7 @@ $$
 === "JS"
 
     ```javascript title="coin_change.js"
-    /* 零錢兌換：狀態壓縮後的動態規劃 */
+    /* 零錢兌換：空間最佳化後的動態規劃 */
     function coinChangeDPComp(coins, amt) {
         const n = coins.length;
         const MAX = amt + 1;
@@ -1443,7 +1443,7 @@ $$
 === "TS"
 
     ```typescript title="coin_change.ts"
-    /* 零錢兌換：狀態壓縮後的動態規劃 */
+    /* 零錢兌換：空間最佳化後的動態規劃 */
     function coinChangeDPComp(coins: Array<number>, amt: number): number {
         const n = coins.length;
         const MAX = amt + 1;
@@ -2190,7 +2190,7 @@ $$
 === "JS"
 
     ```javascript title="coin_change_ii.js"
-    /* 零錢兌換 II：狀態壓縮後的動態規劃 */
+    /* 零錢兌換 II：空間最佳化後的動態規劃 */
     function coinChangeIIDPComp(coins, amt) {
         const n = coins.length;
         // 初始化 dp 表
@@ -2215,7 +2215,7 @@ $$
 === "TS"
 
     ```typescript title="coin_change_ii.ts"
-    /* 零錢兌換 II：狀態壓縮後的動態規劃 */
+    /* 零錢兌換 II：空間最佳化後的動態規劃 */
     function coinChangeIIDPComp(coins: Array<number>, amt: number): number {
         const n = coins.length;
         // 初始化 dp 表

zh-Hant/docs/chapter_greedy/fractional_knapsack_problem.md

@@ -496,9 +496,39 @@ comments: true
 === "Ruby"
 
     ```ruby title="fractional_knapsack.rb"
-    [class]{Item}-[func]{}
-
-    [class]{}-[func]{fractional_knapsack}
+    ### 物品 ###
+    class Item
+      attr_accessor :w # 物品重量
+      attr_accessor :v # 物品價值
+
+      def initialize(w, v)
+        @w = w
+        @v = v
+      end
+    end
+
+    ### 分數背包：貪婪 ###
+    def fractional_knapsack(wgt, val, cap)
+      # 建立物品串列，包含兩個屬性：重量，價值
+      items = wgt.each_with_index.map { |w, i| Item.new(w, val[i]) }
+      # 按照單位價值 item.v / item.w 從高到低進行排序
+      items.sort! { |a, b| (b.v.to_f / b.w) <=> (a.v.to_f / a.w) }
+      # 迴圈貪婪選擇
+      res = 0
+      for item in items
+        if item.w <= cap
+          # 若剩餘容量充足，則將當前物品整個裝進背包
+          res += item.v
+          cap -= item.w
+        else
+          # 若剩餘容量不足，則將當前物品的一部分裝進背包
+          res += (item.v.to_f / item.w) * cap
+          # 已無剩餘容量，因此跳出迴圈
+          break
+        end
+      end
+      res
+    end
     ```
 
 === "Zig"

zh-Hant/docs/chapter_greedy/greedy_algorithm.md

@@ -310,7 +310,24 @@ comments: true
 === "Ruby"
 
     ```ruby title="coin_change_greedy.rb"
-    [class]{}-[func]{coin_change_greedy}
+    ### 零錢兌換：貪婪 ###
+    def coin_change_greedy(coins, amt)
+      # 假設 coins 串列有序
+      i = coins.length - 1
+      count = 0
+      # 迴圈進行貪婪選擇，直到無剩餘金額
+      while amt > 0
+        # 找到小於且最接近剩餘金額的硬幣
+        while i > 0 && coins[i] > amt
+          i -= 1
+        end
+        # 選擇 coins[i]
+        amt -= coins[i]
+        count += 1
+      end
+      # 若未找到可行方案， 則返回 -1
+      amt == 0 ? count : -1
+    end
     ```
 
 === "Zig"

zh-Hant/docs/chapter_greedy/max_capacity_problem.md

@@ -397,7 +397,28 @@ $$
 === "Ruby"
 
     ```ruby title="max_capacity.rb"
-    [class]{}-[func]{max_capacity}
+    ### 最大容量：貪婪 ###
+    def max_capacity(ht)
+      # 初始化 i, j，使其分列陣列兩端
+      i, j = 0, ht.length - 1
+      # 初始最大容量為 0
+      res = 0
+
+      # 迴圈貪婪選擇，直至兩板相遇
+      while i < j
+        # 更新最大容量
+        cap = [ht[i], ht[j]].min * (j - i)
+        res = [res, cap].max
+        # 向內移動短板
+        if ht[i] < ht[j]
+          i += 1
+        else
+          j -= 1
+        end
+      end
+
+      res
+    end
     ```
 
 === "Zig"

zh-Hant/docs/chapter_greedy/max_product_cutting_problem.md

@@ -371,7 +371,19 @@ $$
 === "Ruby"
 
     ```ruby title="max_product_cutting.rb"
-    [class]{}-[func]{max_product_cutting}
+    ### 最大切分乘積：貪婪 ###
+    def max_product_cutting(n)
+      # 當 n <= 3 時，必須切分出一個 1
+      return 1 * (n - 1) if n <= 3
+      # 貪婪地切分出 3 ，a 為 3 的個數，b 為餘數
+      a, b = n / 3, n % 3
+      # 當餘數為 1 時，將一對 1 * 3 轉化為 2 * 2
+      return (3.pow(a - 1) * 2 * 2).to_i if b == 1
+      # 當餘數為 2 時，不做處理
+      return (3.pow(a) * 2).to_i if b == 2
+      # 當餘數為 0 時，不做處理
+      3.pow(a).to_i
+    end
     ```
 
 === "Zig"

zh-Hant/docs/chapter_heap/heap.md

@@ -1874,6 +1874,6 @@ comments: true
 
 ## 8.1.3   堆積的常見應用
 
-- **優先佇列**：堆積通常作為實現優先佇列的首選資料結構，其入列和出列操作的時間複雜度均為 $O(\log n)$ ，而建隊操作為 $O(n)$ ，這些操作都非常高效。
+- **優先佇列**：堆積通常作為實現優先佇列的首選資料結構，其入列和出列操作的時間複雜度均為 $O(\log n)$ ，而建堆積操作為 $O(n)$ ，這些操作都非常高效。
 - **堆積排序**：給定一組資料，我們可以用它們建立一個堆積，然後不斷地執行元素出堆積操作，從而得到有序資料。然而，我們通常會使用一種更優雅的方式實現堆積排序，詳見“堆積排序”章節。
 - **獲取最大的 $k$ 個元素**：這是一個經典的演算法問題，同時也是一種典型應用，例如選擇熱度前 10 的新聞作為微博熱搜，選取銷量前 10 的商品等。

zh-Hant/docs/chapter_introduction/what_is_dsa.md

@@ -14,7 +14,7 @@ comments: true
 
 ## 1.2.2   資料結構定義
 
-<u>資料結構（data structure）</u>是計算機中組織和儲存資料的方式，具有以下設計目標。
+<u>資料結構（data structure）</u>是組織和儲存資料的方式，涵蓋資料內容、資料之間關係和資料操作方法，它具有以下設計目標。
 
 - 空間佔用儘量少，以節省計算機記憶體。
 - 資料操作儘可能快速，涵蓋資料訪問、新增、刪除、更新等。

zh-Hant/docs/chapter_sorting/bubble_sort.md

@@ -225,9 +225,7 @@ comments: true
             for j in 0..i {
                 if nums[j] > nums[j + 1] {
                     // 交換 nums[j] 與 nums[j + 1]
-                    let tmp = nums[j];
-                    nums[j] = nums[j + 1];
-                    nums[j + 1] = tmp;
+                    nums.swap(j, j + 1);
                 }
             }
         }
@@ -538,9 +536,7 @@ comments: true
             for j in 0..i {
                 if nums[j] > nums[j + 1] {
                     // 交換 nums[j] 與 nums[j + 1]
-                    let tmp = nums[j];
-                    nums[j] = nums[j + 1];
-                    nums[j + 1] = tmp;
+                    nums.swap(j, j + 1);
                     flag = true; // 記錄交換元素
                 }
             }

zh-Hant/docs/chapter_sorting/bucket_sort.md

@@ -314,7 +314,7 @@ comments: true
         let k = nums.len() / 2;
         let mut buckets = vec![vec![]; k];
         // 1. 將陣列元素分配到各個桶中
-        for &mut num in &mut *nums {
+        for &num in nums.iter() {
             // 輸入資料範圍為 [0, 1)，使用 num * k 對映到索引範圍 [0, k-1]
             let i = (num * k as f64) as usize;
             // 將 num 新增進桶 i
@@ -327,8 +327,8 @@ comments: true
         }
         // 3. 走訪桶合併結果
         let mut i = 0;
-        for bucket in &mut buckets {
-            for &mut num in bucket {
+        for bucket in buckets.iter() {
+            for &num in bucket.iter() {
                 nums[i] = num;
                 i += 1;
             }

zh-Hant/docs/chapter_sorting/counting_sort.md

@@ -266,11 +266,11 @@ comments: true
     // 簡單實現，無法用於排序物件
     fn counting_sort_naive(nums: &mut [i32]) {
         // 1. 統計陣列最大元素 m
-        let m = *nums.into_iter().max().unwrap();
+        let m = *nums.iter().max().unwrap();
         // 2. 統計各數字的出現次數
         // counter[num] 代表 num 的出現次數
         let mut counter = vec![0; m as usize + 1];
-        for &num in &*nums {
+        for &num in nums.iter() {
             counter[num as usize] += 1;
         }
         // 3. 走訪 counter ，將各元素填入原陣列 nums
@@ -764,16 +764,16 @@ $$
     // 完整實現，可排序物件，並且是穩定排序
     fn counting_sort(nums: &mut [i32]) {
         // 1. 統計陣列最大元素 m
-        let m = *nums.into_iter().max().unwrap();
+        let m = *nums.iter().max().unwrap() as usize;
         // 2. 統計各數字的出現次數
         // counter[num] 代表 num 的出現次數
-        let mut counter = vec![0; m as usize + 1];
-        for &num in &*nums {
+        let mut counter = vec![0; m + 1];
+        for &num in nums.iter() {
             counter[num as usize] += 1;
         }
         // 3. 求 counter 的前綴和，將“出現次數”轉換為“尾索引”
         // 即 counter[num]-1 是 num 在 res 中最後一次出現的索引
-        for i in 0..m as usize {
+        for i in 0..m {
             counter[i + 1] += counter[i];
         }
         // 4. 倒序走訪 nums ，將各元素填入結果陣列 res
@@ -786,9 +786,7 @@ $$
             counter[num as usize] -= 1; // 令前綴和自減 1 ，得到下次放置 num 的索引
         }
         // 使用結果陣列 res 覆蓋原陣列 nums
-        for i in 0..n {
-            nums[i] = res[i];
-        }
+        nums.copy_from_slice(&res)
     }
     ```
 

zh-Hant/docs/chapter_sorting/heap_sort.md

@@ -463,9 +463,7 @@ comments: true
                 break;
             }
             // 交換兩節點
-            let temp = nums[i];
-            nums[i] = nums[ma];
-            nums[ma] = temp;
+            nums.swap(i, ma);
             // 迴圈向下堆積化
             i = ma;
         }
@@ -474,15 +472,13 @@ comments: true
     /* 堆積排序 */
     fn heap_sort(nums: &mut [i32]) {
         // 建堆積操作：堆積化除葉節點以外的其他所有節點
-        for i in (0..=nums.len() / 2 - 1).rev() {
+        for i in (0..nums.len() / 2).rev() {
             sift_down(nums, nums.len(), i);
         }
         // 從堆積中提取最大元素，迴圈 n-1 輪
-        for i in (1..=nums.len() - 1).rev() {
+        for i in (1..nums.len()).rev() {
             // 交換根節點與最右葉節點（交換首元素與尾元素）
-            let tmp = nums[0];
-            nums[0] = nums[i];
-            nums[i] = tmp;
+            nums.swap(0, i);
             // 以根節點為起點，從頂至底進行堆積化
             sift_down(nums, i, 0);
         }