build

docs/chapter_appendix/terminology.md

@@ -112,7 +112,7 @@ comments: true
 | adjacency list                 | 邻接表         | 鄰接表         |
 | breadth-first search           | 广度优先搜索   | 廣度優先搜尋   |
 | depth-first search             | 深度优先搜索   | 深度優先搜尋   |
-| binary search                  | 二分查找       | 二分查找       |
+| binary search                  | 二分查找       | 二分搜尋       |
 | searching algorithm            | 搜索算法       | 搜尋演算法     |
 | sorting algorithm              | 排序算法       | 排序演算法     |
 | selection sort                 | 选择排序       | 選擇排序       |

docs/chapter_array_and_linkedlist/array.md

@@ -114,7 +114,17 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="array.kt"
+    /* 初始化数组 */
+    var arr = IntArray(5) // { 0, 0, 0, 0, 0 }
+    var nums = intArrayOf(1, 3, 2, 5, 4)
+    ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    # 初始化数组
+    arr = Array.new(5, 0)
+    nums = [1, 3, 2, 5, 4]
     ```
 
 === "Zig"
@@ -298,6 +308,19 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 随机访问元素 ###
+    def random_access(nums)
+      # 在区间 [0, nums.length) 中随机抽取一个数字
+      random_index = Random.rand 0...(nums.length - 1)
+
+      # 获取并返回随机元素
+      nums[random_index]
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"
@@ -492,6 +515,21 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 在数组的索引 index 处插入元素 num ###
+    def insert(nums, num, index)
+      # 把索引 index 以及之后的所有元素向后移动一位
+      for i in (nums.length - 1).downto(index + 1)
+        nums[i] = nums[i - 1]
+      end
+
+      # 将 num 赋给 index 处的元素
+      nums[index] = num
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"
@@ -665,6 +703,18 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 删除索引 index 处的元素 ###
+    def remove(nums, index)
+      # 把索引 index 之后的所有元素向前移动一位
+      for i in index...nums.length
+        nums[i] = nums[i + 1] || 0
+      end
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"
@@ -905,6 +955,25 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 遍历数组 ###
+    def traverse(nums)
+      count = 0
+
+      # 通过索引遍历数组
+      for i in 0...nums.length
+        count += nums[i]
+      end
+
+      # 直接遍历数组元素
+      for num in nums
+        count += num
+      end
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"
@@ -1092,6 +1161,19 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 在数组中查找指定元素 ###
+    def find(nums, target)
+      for i in 0...nums.length
+        return i if nums[i] == target
+      end
+
+      -1
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"
@@ -1315,6 +1397,26 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 扩展数组长度 ###
+    # 请注意，Ruby 的 Array 是动态数组，可以直接扩展
+    # 为了方便学习，本函数将 Array 看作长度不可变的数组
+    def extend(nums, enlarge)
+      # 初始化一个扩展长度后的数组
+      res = Array.new(nums.length + enlarge, 0)
+
+      # 将原数组中的所有元素复制到新数组
+      for i in 0...nums.length
+        res[i] = nums[i]
+      end
+
+      # 返回扩展后的新数组
+      res
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"

docs/chapter_array_and_linkedlist/linked_list.md

@@ -168,7 +168,27 @@ comments: true
 === "Kotlin"
 
     ```kotlin title=""
+    /* 链表节点类 */
+    // 构造方法
+    class ListNode(x: Int) {
+        val _val: Int = x          // 节点值
+        val next: ListNode? = null // 指向下一个节点的引用
+    }
+    ```
 
+=== "Ruby"
+
+    ```ruby title=""
+    # 链表节点类
+    class ListNode
+      attr_accessor :val  # 节点值
+      attr_accessor :next # 指向下一节点的引用
+
+      def initialize(val=nil, next_node=nil)
+        @val = val || 0
+        @next = next_node
+      end
+    end
     ```
 
 === "Zig"
@@ -388,7 +408,35 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="linked_list.kt"
+    /* 初始化链表 1 -> 3 -> 2 -> 5 -> 4 */
+    // 初始化各个节点
+    val n0 = ListNode(1)
+    val n1 = ListNode(3)
+    val n2 = ListNode(2)
+    val n3 = ListNode(5)
+    val n4 = ListNode(4)
+    // 构建节点之间的引用
+    n0.next = n1;
+    n1.next = n2;
+    n2.next = n3;
+    n3.next = n4;
+    ```
 
+=== "Ruby"
+
+    ```ruby title="linked_list.rb"
+    # 初始化链表 1 -> 3 -> 2 -> 5 -> 4
+    # 初始化各个节点
+    n0 = ListNode.new 1
+    n1 = ListNode.new 3
+    n2 = ListNode.new 2
+    n3 = ListNode.new 5
+    n4 = ListNode.new 4
+    # 构建节点之间的引用
+    n0.next = n1
+    n1.next = n2
+    n2.next = n3
+    n3.next = n4
     ```
 
 === "Zig"
@@ -557,6 +605,18 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linked_list.rb"
+    ### 在链表的节点 n0 之后插入节点 _p ###
+    # Ruby 的 `p` 是一个内置函数， `P` 是一个常量，所以可以使用 `_p` 代替
+    def insert(n0, _p)
+      n1 = n0.next
+      _p.next = n1
+      n0.next = _p
+    end
+    ```
+
 === "Zig"
 
     ```zig title="linked_list.zig"
@@ -757,6 +817,20 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linked_list.rb"
+    ### 删除链表的节点 n0 之后的首个节点 ###
+    def remove(n0)
+      return if n0.next.nil?
+
+      # n0 -> remove_node -> n1
+      remove_node = n0.next
+      n1 = remove_node.next
+      n0.next = n1
+    end
+    ```
+
 === "Zig"
 
     ```zig title="linked_list.zig"
@@ -950,6 +1024,20 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linked_list.rb"
+    ### 访问链表中索引为 index 的节点 ###
+    def access(head, index)
+      for i in 0...index
+        return nil if head.nil?
+        head = head.next
+      end
+
+      head
+    end
+    ```
+
 === "Zig"
 
     ```zig title="linked_list.zig"
@@ -1169,6 +1257,22 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linked_list.rb"
+    ### 在链表中查找值为 target 的首个节点 ###
+    def find(head, target)
+      index = 0
+      while head
+        return index if head.val == target
+        head = head.next
+        index += 1
+      end
+
+      -1
+    end
+    ```
+
 === "Zig"
 
     ```zig title="linked_list.zig"
@@ -1389,7 +1493,30 @@ comments: true
 === "Kotlin"
 
     ```kotlin title=""
+    /* 双向链表节点类 */
+    // 构造方法
+    class ListNode(x: Int) {
+        val _val: Int = x           // 节点值
+        val next: ListNode? = null  // 指向后继节点的引用
+        val prev: ListNode? = null  // 指向前驱节点的引用
+    }
+    ```
 
+=== "Ruby"
+
+    ```ruby title=""
+    # 双向链表节点类
+    class ListNode
+      attr_accessor :val    # 节点值
+      attr_accessor :next   # 指向后继节点的引用
+      attr_accessor :prev   # 指向前驱节点的引用
+
+      def initialize(val=nil, next_node=nil, prev_node=nil)
+        @val = val || 0
+        @next = next_node
+        @prev = prev_node
+      end
+    end
     ```
 
 === "Zig"

docs/chapter_array_and_linkedlist/list.md

@@ -133,7 +133,22 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="list.kt"
+    /* 初始化列表 */
+    // 无初始值
+    var nums1 = listOf<Int>()
+    // 有初始值
+    var numbers = arrayOf(1, 3, 2, 5, 4)
+    var nums = numbers.toMutableList()
+    ```
 
+=== "Ruby"
+
+    ```ruby title="list.rb"
+    # 初始化列表
+    # 无初始值
+    nums1 = []
+    # 有初始值
+    nums = [1, 3, 2, 5, 4]
     ```
 
 === "Zig"
@@ -262,7 +277,19 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="list.kt"
+    /* 访问元素 */
+    val num = nums[1]       // 访问索引 1 处的元素
+    /* 更新元素 */
+    nums[1] = 0             // 将索引 1 处的元素更新为 0
+    ```
 
+=== "Ruby"
+
+    ```ruby title="list.rb"
+    # 访问元素
+    num = nums[1]
+    # 更新元素
+    nums[1] = 0
     ```
 
 === "Zig"
@@ -493,7 +520,41 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="list.kt"
+    /* 清空列表 */
+    nums.clear();
 
+    /* 在尾部添加元素 */
+    nums.add(1);
+    nums.add(3);
+    nums.add(2);
+    nums.add(5);
+    nums.add(4);
+
+    /* 在中间插入元素 */
+    nums.add(3, 6);  // 在索引 3 处插入数字 6
+
+    /* 删除元素 */
+    nums.remove(3);  // 删除索引 3 处的元素
+    ```
+
+=== "Ruby"
+
+    ```ruby title="list.rb"
+    # 清空列表
+    nums.clear
+
+    # 在尾部添加元素
+    nums << 1
+    nums << 3
+    nums << 2
+    nums << 5
+    nums << 4
+
+    # 在中间插入元素
+    nums.insert 3, 6
+
+    # 删除元素
+    nums.delete_at 3
     ```
 
 === "Zig"
@@ -690,7 +751,32 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="list.kt"
+    /* 通过索引遍历列表 */
+    var count = 0
+    for (i in nums.indices) {
+        count += nums[i]
+    }
 
+    /* 直接遍历列表元素 */
+    for (num in nums) {
+        count += num
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title="list.rb"
+    # 通过索引遍历列表
+    count = 0
+    for i in 0...nums.length
+        count += nums[i]
+    end
+
+    # 直接遍历列表元素
+    count = 0
+    for num in nums
+        count += num
+    end
     ```
 
 === "Zig"
@@ -809,7 +895,17 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="list.kt"
+    /* 拼接两个列表 */
+    val nums1 = intArrayOf(6, 8, 7, 10, 9).toMutableList()
+    nums.addAll(nums1)  // 将列表 nums1 拼接到 nums 之后
+    ```
 
+=== "Ruby"
+
+    ```ruby title="list.rb"
+    # 拼接两个列表
+    nums1 = [6, 8, 7, 10, 9]
+    nums += nums1
     ```
 
 === "Zig"
@@ -910,7 +1006,15 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="list.kt"
+    /* 排序列表 */
+    nums.sort() // 排序后，列表元素从小到大排列
+    ```
 
+=== "Ruby"
+
+    ```ruby title="list.rb"
+    # 排序列表
+    nums = nums.sort { |a, b| a <=> b }
     ```
 
 === "Zig"
@@ -2171,6 +2275,100 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="my_list.rb"
+    ### 列表类 ###
+    class MyList
+      attr_reader :size       # 获取列表长度（当前元素数量）
+      attr_reader :capacity   # 获取列表容量
+
+      ### 构造方法 ###
+      def initialize
+        @capacity = 10
+        @size = 0
+        @extend_ratio = 2
+        @arr = Array.new capacity
+      end
+
+      ### 访问元素 ###
+      def get(index)
+        # 索引如果越界，则抛出异常，下同
+        raise IndexError, "索引越界" if index < 0 || index >= size
+        @arr[index]
+      end
+
+      ### 访问元素 ###
+      def set(index, num)
+        raise IndexError, "索引越界" if index < 0 || index >= size
+        @arr[index] = num
+      end
+
+      ### 在尾部添加元素 ###
+      def add(num)
+        # 元素数量超出容量时，触发扩容机制
+        extend_capacity if size == capacity
+        @arr[size] = num
+        
+        # 更新元素数量
+        @size += 1
+      end
+
+      ### 在中间插入元素 ###
+      def insert(index, num)
+        raise IndexError, "索引越界" if index < 0 || index >= size
+
+        # 元素数量超出容量时，触发扩容机制
+        extend_capacity if size == capacity
+
+        # 将索引 index 以及之后的元素都向后移动一位
+        for j in (size - 1).downto(index)
+          @arr[j + 1] = @arr[j] 
+        end
+        @arr[index] = num
+
+        # 更新元素数量
+        @size += 1
+      end
+
+      ### 删除元素 ###
+      def remove(index)
+        raise IndexError, "索引越界" if index < 0 || index >= size
+        num = @arr[index]
+
+        # 将将索引 index 之后的元素都向前移动一位
+        for j in index...size
+          @arr[j] = @arr[j + 1]
+        end
+
+        # 更新元素数量
+        @size -= 1
+
+        # 返回被删除的元素
+        num
+      end
+
+      ### 列表扩容 ###
+      def extend_capacity
+        # 新建一个长度为原数组 extend_ratio 倍的新数组，并将原数组复制到新数组
+        arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))
+        # 更新列表容量
+        @capacity = arr.length
+      end
+
+      ### 将列表转换为数组 ###
+      def to_array
+        sz = size
+        # 仅转换有效长度范围内的列表元素
+        arr = Array.new sz
+        for i in 0...sz
+          arr[i] = get i
+        end
+        arr
+      end
+    end
+    ```
+
 === "Zig"
 
     ```zig title="my_list.zig"

docs/chapter_backtracking/backtracking_algorithm.md

@@ -217,6 +217,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="preorder_traversal_i_compact.rb"
+    [class]{}-[func]{pre_order}
+    ```
+
 === "Zig"
 
     ```zig title="preorder_traversal_i_compact.zig"
@@ -513,6 +519,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="preorder_traversal_ii_compact.rb"
+    [class]{}-[func]{pre_order}
+    ```
+
 === "Zig"
 
     ```zig title="preorder_traversal_ii_compact.zig"
@@ -851,6 +863,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="preorder_traversal_iii_compact.rb"
+    [class]{}-[func]{pre_order}
+    ```
+
 === "Zig"
 
     ```zig title="preorder_traversal_iii_compact.zig"
@@ -1159,6 +1177,32 @@ comments: true
 === "Kotlin"
 
     ```kotlin title=""
+    /* 回溯算法框架 */
+    fun backtrack(state: State?, choices: List<Choice?>, res: List<State?>?) {
+        // 判断是否为解
+        if (isSolution(state)) {
+            // 记录解
+            recordSolution(state, res)
+            // 不再继续搜索
+            return
+        }
+        // 遍历所有选择
+        for (choice in choices) {
+            // 剪枝：判断选择是否合法
+            if (isValid(state, choice)) {
+                // 尝试：做出选择，更新状态
+                makeChoice(state, choice)
+                backtrack(state, choices, res)
+                // 回退：撤销选择，恢复到之前的状态
+                undoChoice(state, choice)
+            }
+        }
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 
@@ -1796,6 +1840,22 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="preorder_traversal_iii_template.rb"
+    [class]{}-[func]{is_solution}
+
+    [class]{}-[func]{record_solution}
+
+    [class]{}-[func]{is_valid}
+
+    [class]{}-[func]{make_choice}
+
+    [class]{}-[func]{undo_choice}
+
+    [class]{}-[func]{backtrack}
+    ```
+
 === "Zig"
 
     ```zig title="preorder_traversal_iii_template.zig"

docs/chapter_backtracking/n_queens_problem.md

@@ -706,6 +706,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="n_queens.rb"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{n_queens}
+    ```
+
 === "Zig"
 
     ```zig title="n_queens.zig"

docs/chapter_backtracking/permutations_problem.md

@@ -503,6 +503,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="permutations_i.rb"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutations_i}
+    ```
+
 === "Zig"
 
     ```zig title="permutations_i.zig"
@@ -1021,6 +1029,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="permutations_ii.rb"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{permutations_ii}
+    ```
+
 === "Zig"
 
     ```zig title="permutations_ii.zig"

docs/chapter_backtracking/subset_sum_problem.md

@@ -467,6 +467,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="subset_sum_i_naive.rb"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_i_naive}
+    ```
+
 === "Zig"
 
     ```zig title="subset_sum_i_naive.zig"
@@ -1000,6 +1008,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="subset_sum_i.rb"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_i}
+    ```
+
 === "Zig"
 
     ```zig title="subset_sum_i.zig"
@@ -1579,6 +1595,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="subset_sum_ii.rb"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{subset_sum_ii}
+    ```
+
 === "Zig"
 
     ```zig title="subset_sum_ii.zig"

docs/chapter_computational_complexity/iteration_and_recursion.md

@@ -182,6 +182,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="iteration.rb"
+    [class]{}-[func]{for_loop}
+    ```
+
 === "Zig"
 
     ```zig title="iteration.zig"
@@ -408,6 +414,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="iteration.rb"
+    [class]{}-[func]{while_loop}
+    ```
+
 === "Zig"
 
     ```zig title="iteration.zig"
@@ -649,6 +661,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="iteration.rb"
+    [class]{}-[func]{while_loop_ii}
+    ```
+
 === "Zig"
 
     ```zig title="iteration.zig"
@@ -883,6 +901,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="iteration.rb"
+    [class]{}-[func]{nested_for_loop}
+    ```
+
 === "Zig"
 
     ```zig title="iteration.zig"
@@ -1112,6 +1136,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="recursion.rb"
+    [class]{}-[func]{recur}
+    ```
+
 === "Zig"
 
     ```zig title="recursion.zig"
@@ -1318,8 +1348,9 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="recursion.kt"
-    /* Kotlin tailrec 关键词使函数实现尾递归优化 */
+    /* 尾递归 */
     tailrec fun tailRecur(n: Int, res: Int): Int {
+        // 添加 tailrec 关键词，以开启尾递归优化
         // 终止条件
         if (n == 0)
             return res
@@ -1328,6 +1359,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="recursion.rb"
+    [class]{}-[func]{tail_recur}
+    ```
+
 === "Zig"
 
     ```zig title="recursion.zig"
@@ -1554,6 +1591,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="recursion.rb"
+    [class]{}-[func]{fib}
+    ```
+
 === "Zig"
 
     ```zig title="recursion.zig"
@@ -1890,6 +1933,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="recursion.rb"
+    [class]{}-[func]{for_loop_recur}
+    ```
+
 === "Zig"
 
     ```zig title="recursion.zig"

docs/chapter_computational_complexity/space_complexity.md

@@ -318,6 +318,29 @@ comments: true
 === "Kotlin"
 
     ```kotlin title=""
+    /* 类 */
+    class Node(var _val: Int) {
+        var next: Node? = null
+    }
+
+    /* 函数 */
+    fun function(): Int {
+        // 执行某些操作...
+        return 0
+    }
+
+    fun algorithm(n: Int): Int { // 输入数据
+        val a = 0                // 暂存数据（常量）
+        var b = 0                // 暂存数据（变量）
+        val node = Node(0)       // 暂存数据（对象）
+        val c = function()       // 栈帧空间（调用函数）
+        return a + b + c         // 输出数据
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 
@@ -470,6 +493,18 @@ comments: true
 === "Kotlin"
 
     ```kotlin title=""
+    fun algorithm(n: Int) {
+        val a = 0                    // O(1)
+        val b = IntArray(10000)      // O(1)
+        if (n > 10) {
+            val nums = IntArray(n)   // O(n)
+        }
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 
@@ -683,7 +718,7 @@ comments: true
         }
     }
     /* 递归 O(n) */
-    void recur(n: i32) {
+    fn recur(n: i32) {
         if n == 1 {
             return;
         }
@@ -714,6 +749,26 @@ comments: true
 === "Kotlin"
 
     ```kotlin title=""
+    fun function(): Int {
+        // 执行某些操作
+        return 0
+    }
+    /* 循环 O(1) */
+    fun loop(n: Int) {
+        for (i in 0..<n) {
+            function()
+        }
+    }
+    /* 递归 O(n) */
+    fun recur(n: Int) {
+        if (n == 1) return
+        return recur(n - 1)
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 
@@ -1076,6 +1131,14 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{function}
+
+    [class]{}-[func]{constant}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"
@@ -1372,6 +1435,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{linear}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"
@@ -1548,6 +1617,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{linear_recur}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"
@@ -1782,6 +1857,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{quadratic}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"
@@ -1971,6 +2052,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{quadratic_recur}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"
@@ -2163,6 +2250,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{build_tree}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"

docs/chapter_computational_complexity/time_complexity.md

@@ -178,6 +178,21 @@ comments: true
 === "Kotlin"
 
     ```kotlin title=""
+    // 在某运行平台下
+    fun algorithm(n: Int) {
+        var a = 2 // 1 ns
+        a = a + 1 // 1 ns
+        a = a * 2 // 10 ns
+        // 循环 n 次
+        for (i in 0..<n) {  // 1 ns ，每轮都要执行 i++
+            println(0)      // 5 ns
+        }
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 
@@ -442,6 +457,27 @@ $$
 === "Kotlin"
 
     ```kotlin title=""
+    // 算法 A 的时间复杂度：常数阶
+    fun algoritm_A(n: Int) {
+        println(0)
+    }
+    // 算法 B 的时间复杂度：线性阶
+    fun algorithm_B(n: Int) {
+        for (i in 0..<n){
+            println(0)
+        }
+    }
+    // 算法 C 的时间复杂度：常数阶
+    fun algorithm_C(n: Int) {
+        for (i in 0..<1000000) {
+            println(0)
+        }
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 
@@ -644,6 +680,20 @@ $$
 === "Kotlin"
 
     ```kotlin title=""
+    fun algorithm(n: Int) {
+        var a = 1 // +1
+        a = a + 1 // +1
+        a = a * 2 // +1
+        // 循环 n 次
+        for (i in 0..<n) { // +1（每轮都执行 i ++）
+            println(0) // +1
+        }
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 
@@ -909,6 +959,25 @@ $T(n)$ 是一次函数，说明其运行时间的增长趋势是线性的，因
 === "Kotlin"
 
     ```kotlin title=""
+    fun algorithm(n: Int) {
+        var a = 1   // +0（技巧 1）
+        a = a + n   // +0（技巧 1）
+        // +n（技巧 2）
+        for (i in 0..<5 * n + 1) {
+            println(0)
+        }
+        // +n*n（技巧 3）
+        for (i in 0..<2 * n) {
+            for (j in 0..<n + 1) {
+                println(0)
+            }
+        }
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 
@@ -1144,6 +1213,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{constant}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -1316,6 +1391,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{linear}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -1503,6 +1584,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{array_traversal}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -1717,6 +1804,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{quadratic}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2017,6 +2110,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{bubble_sort}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2273,6 +2372,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{exponential}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2436,6 +2541,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{exp_recur}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2627,6 +2738,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{logarithmic}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2784,6 +2901,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{log_recur}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2992,6 +3115,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{linear_log_recur}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -3218,6 +3347,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{factorial_recur}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -3607,6 +3742,14 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="worst_best_time_complexity.rb"
+    [class]{}-[func]{random_numbers}
+
+    [class]{}-[func]{find_one}
+    ```
+
 === "Zig"
 
     ```zig title="worst_best_time_complexity.zig"

docs/chapter_data_structure/basic_data_types.md

@@ -164,6 +164,16 @@ comments: true
 === "Kotlin"
 
     ```kotlin title=""
+    // 使用多种基本数据类型来初始化数组
+    val numbers = IntArray(5)
+    val decinals = FloatArray(5)
+    val characters = CharArray(5)
+    val bools = BooleanArray(5)
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 

docs/chapter_divide_and_conquer/binary_search_recur.md

@@ -419,6 +419,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_search_recur.rb"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{binary_search}
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_recur.zig"

docs/chapter_divide_and_conquer/build_binary_tree_problem.md

@@ -476,6 +476,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="build_tree.rb"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{build_tree}
+    ```
+
 === "Zig"
 
     ```zig title="build_tree.zig"

docs/chapter_divide_and_conquer/hanota_problem.md

@@ -507,6 +507,16 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="hanota.rb"
+    [class]{}-[func]{move}
+
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{solve_hanota}
+    ```
+
 === "Zig"
 
     ```zig title="hanota.zig"

docs/chapter_dynamic_programming/dp_problem_features.md

@@ -301,6 +301,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="min_cost_climbing_stairs_dp.rb"
+    [class]{}-[func]{min_cost_climbing_stairs_dp}
+    ```
+
 === "Zig"
 
     ```zig title="min_cost_climbing_stairs_dp.zig"
@@ -560,6 +566,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="min_cost_climbing_stairs_dp.rb"
+    [class]{}-[func]{min_cost_climbing_stairs_dp_comp}
+    ```
+
 === "Zig"
 
     ```zig title="min_cost_climbing_stairs_dp.zig"
@@ -920,6 +932,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="climbing_stairs_constraint_dp.rb"
+    [class]{}-[func]{climbing_stairs_constraint_dp}
+    ```
+
 === "Zig"
 
     ```zig title="climbing_stairs_constraint_dp.zig"

docs/chapter_dynamic_programming/dp_solution_pipeline.md

@@ -370,6 +370,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="min_path_sum.rb"
+    [class]{}-[func]{min_path_sum_dfs}
+    ```
+
 === "Zig"
 
     ```zig title="min_path_sum.zig"
@@ -731,6 +737,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="min_path_sum.rb"
+    [class]{}-[func]{min_path_sum_dfs_mem}
+    ```
+
 === "Zig"
 
     ```zig title="min_path_sum.zig"
@@ -1111,6 +1123,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="min_path_sum.rb"
+    [class]{}-[func]{min_path_sum_dp}
+    ```
+
 === "Zig"
 
     ```zig title="min_path_sum.zig"
@@ -1505,6 +1523,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="min_path_sum.rb"
+    [class]{}-[func]{min_path_sum_dp_comp}
+    ```
+
 === "Zig"
 
     ```zig title="min_path_sum.zig"

docs/chapter_dynamic_programming/edit_distance_problem.md

@@ -455,6 +455,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="edit_distance.rb"
+    [class]{}-[func]{edit_distance_dp}
+    ```
+
 === "Zig"
 
     ```zig title="edit_distance.zig"
@@ -944,6 +950,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="edit_distance.rb"
+    [class]{}-[func]{edit_distance_dp_comp}
+    ```
+
 === "Zig"
 
     ```zig title="edit_distance.zig"

docs/chapter_dynamic_programming/intro_to_dynamic_programming.md

@@ -389,6 +389,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="climbing_stairs_backtrack.rb"
+    [class]{}-[func]{backtrack}
+
+    [class]{}-[func]{climbing_stairs_backtrack}
+    ```
+
 === "Zig"
 
     ```zig title="climbing_stairs_backtrack.zig"
@@ -680,6 +688,14 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="climbing_stairs_dfs.rb"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{climbing_stairs_dfs}
+    ```
+
 === "Zig"
 
     ```zig title="climbing_stairs_dfs.zig"
@@ -1043,6 +1059,14 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="climbing_stairs_dfs_mem.rb"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{climbing_stairs_dfs_mem}
+    ```
+
 === "Zig"
 
     ```zig title="climbing_stairs_dfs_mem.zig"
@@ -1329,6 +1353,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="climbing_stairs_dp.rb"
+    [class]{}-[func]{climbing_stairs_dp}
+    ```
+
 === "Zig"
 
     ```zig title="climbing_stairs_dp.zig"
@@ -1574,6 +1604,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="climbing_stairs_dp.rb"
+    [class]{}-[func]{climbing_stairs_dp_comp}
+    ```
+
 === "Zig"
 
     ```zig title="climbing_stairs_dp.zig"

docs/chapter_dynamic_programming/knapsack_problem.md

@@ -321,6 +321,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="knapsack.rb"
+    [class]{}-[func]{knapsack_dfs}
+    ```
+
 === "Zig"
 
     ```zig title="knapsack.zig"
@@ -691,6 +697,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="knapsack.rb"
+    [class]{}-[func]{knapsack_dfs_mem}
+    ```
+
 === "Zig"
 
     ```zig title="knapsack.zig"
@@ -1049,6 +1061,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="knapsack.rb"
+    [class]{}-[func]{knapsack_dp}
+    ```
+
 === "Zig"
 
     ```zig title="knapsack.zig"
@@ -1435,6 +1453,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="knapsack.rb"
+    [class]{}-[func]{knapsack_dp_comp}
+    ```
+
 === "Zig"
 
     ```zig title="knapsack.zig"

docs/chapter_dynamic_programming/unbounded_knapsack_problem.md

@@ -352,6 +352,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="unbounded_knapsack.rb"
+    [class]{}-[func]{unbounded_knapsack_dp}
+    ```
+
 === "Zig"
 
     ```zig title="unbounded_knapsack.zig"
@@ -706,6 +712,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="unbounded_knapsack.rb"
+    [class]{}-[func]{unbounded_knapsack_dp_comp}
+    ```
+
 === "Zig"
 
     ```zig title="unbounded_knapsack.zig"
@@ -1151,6 +1163,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="coin_change.rb"
+    [class]{}-[func]{coin_change_dp}
+    ```
+
 === "Zig"
 
     ```zig title="coin_change.zig"
@@ -1568,6 +1586,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="coin_change.rb"
+    [class]{}-[func]{coin_change_dp_comp}
+    ```
+
 === "Zig"
 
     ```zig title="coin_change.zig"
@@ -1975,6 +1999,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="coin_change_ii.rb"
+    [class]{}-[func]{coin_change_ii_dp}
+    ```
+
 === "Zig"
 
     ```zig title="coin_change_ii.zig"
@@ -2313,6 +2343,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="coin_change_ii.rb"
+    [class]{}-[func]{coin_change_ii_dp_comp}
+    ```
+
 === "Zig"
 
     ```zig title="coin_change_ii.zig"

docs/chapter_graph/graph_operations.md

@@ -1124,6 +1124,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="graph_adjacency_matrix.rb"
+    [class]{GraphAdjMat}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="graph_adjacency_matrix.zig"
@@ -2221,6 +2227,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="graph_adjacency_list.rb"
+    [class]{GraphAdjList}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="graph_adjacency_list.zig"

docs/chapter_graph/graph_traversal.md

@@ -444,6 +444,12 @@ BFS 通常借助队列来实现，代码如下所示。队列具有“先入先
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="graph_bfs.rb"
+    [class]{}-[func]{graph_bfs}
+    ```
+
 === "Zig"
 
     ```zig title="graph_bfs.zig"
@@ -885,6 +891,14 @@ BFS 通常借助队列来实现，代码如下所示。队列具有“先入先
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="graph_dfs.rb"
+    [class]{}-[func]{dfs}
+
+    [class]{}-[func]{graph_dfs}
+    ```
+
 === "Zig"
 
     ```zig title="graph_dfs.zig"

docs/chapter_greedy/fractional_knapsack_problem.md

@@ -528,6 +528,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="fractional_knapsack.rb"
+    [class]{Item}-[func]{}
+
+    [class]{}-[func]{fractional_knapsack}
+    ```
+
 === "Zig"
 
     ```zig title="fractional_knapsack.zig"

docs/chapter_greedy/greedy_algorithm.md

@@ -307,6 +307,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="coin_change_greedy.rb"
+    [class]{}-[func]{coin_change_greedy}
+    ```
+
 === "Zig"
 
     ```zig title="coin_change_greedy.zig"

docs/chapter_greedy/max_capacity_problem.md

@@ -394,6 +394,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="max_capacity.rb"
+    [class]{}-[func]{max_capacity}
+    ```
+
 === "Zig"
 
     ```zig title="max_capacity.zig"

docs/chapter_greedy/max_product_cutting_problem.md

@@ -368,6 +368,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="max_product_cutting.rb"
+    [class]{}-[func]{max_product_cutting}
+    ```
+
 === "Zig"
 
     ```zig title="max_product_cutting.zig"

docs/chapter_hashing/hash_algorithm.md

@@ -594,6 +594,18 @@ index = hash(key) % capacity
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="simple_hash.rb"
+    [class]{}-[func]{add_hash}
+
+    [class]{}-[func]{mul_hash}
+
+    [class]{}-[func]{xor_hash}
+
+    [class]{}-[func]{rot_hash}
+    ```
+
 === "Zig"
 
     ```zig title="simple_hash.zig"
@@ -911,6 +923,34 @@ $$
 === "Kotlin"
 
     ```kotlin title="built_in_hash.kt"
+    val num = 3
+    val hashNum = num.hashCode()
+    // 整数 3 的哈希值为 3
+
+    val bol = true
+    val hashBol = bol.hashCode()
+    // 布尔量 true 的哈希值为 1231
+
+    val dec = 3.14159
+    val hashDec = dec.hashCode()
+    // 小数 3.14159 的哈希值为 -1340954729
+
+    val str = "Hello 算法"
+    val hashStr = str.hashCode()
+    // 字符串“Hello 算法”的哈希值为 -727081396
+
+    val arr = arrayOf<Any>(12836, "小哈")
+    val hashTup = arr.hashCode()
+    // 数组 [12836, 小哈] 的哈希值为 189568618
+
+    val obj = ListNode(0)
+    val hashObj = obj.hashCode()
+    // 节点对象 utils.ListNode@1d81eb93 的哈希值为 495053715
+    ```
+
+=== "Ruby"
+
+    ```ruby title="built_in_hash.rb"
 
     ```
 

docs/chapter_hashing/hash_collision.md

@@ -1426,6 +1426,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="hash_map_chaining.rb"
+    [class]{HashMapChaining}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="hash_map_chaining.zig"
@@ -3072,6 +3078,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="hash_map_open_addressing.rb"
+    [class]{HashMapOpenAddressing}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="hash_map_open_addressing.zig"

docs/chapter_hashing/hash_map.md

@@ -280,6 +280,29 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="hash_map.kt"
+    /* 初始化哈希表 */
+    val map = HashMap<Int,String>()
+    
+    /* 添加操作 */
+    // 在哈希表中添加键值对 (key, value)
+    map[12836] = "小哈"
+    map[15937] = "小啰"
+    map[16750] = "小算"
+    map[13276] = "小法"
+    map[10583] = "小鸭"
+    
+    /* 查询操作 */
+    // 向哈希表中输入键 key ，得到值 value
+    val name = map[15937]
+    
+    /* 删除操作 */
+    // 在哈希表中删除键值对 (key, value)
+    map.remove(10583)
+    ```
+
+=== "Ruby"
+
+    ```ruby title="hash_map.rb"
 
     ```
 
@@ -482,6 +505,24 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="hash_map.kt"
+    /* 遍历哈希表 */
+    // 遍历键值对 key->value
+    for ((key, value) in map) {
+        println("$key -> $value")
+    }
+    // 单独遍历键 key
+    for (key in map.keys) {
+        println(key)
+    }
+    // 单独遍历值 value
+    for (_val in map.values) {
+        println(_val)
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title="hash_map.rb"
 
     ```
 
@@ -1697,6 +1738,14 @@ index = hash(key) % capacity
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array_hash_map.rb"
+    [class]{Pair}-[func]{}
+
+    [class]{ArrayHashMap}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="array_hash_map.zig"

docs/chapter_heap/build_heap.md

@@ -305,6 +305,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="my_heap.rb"
+    [class]{MaxHeap}-[func]{__init__}
+    ```
+
 === "Zig"
 
     ```zig title="my_heap.zig"

docs/chapter_heap/heap.md

@@ -378,6 +378,43 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="heap.kt"
+    /* 初始化堆 */
+    // 初始化小顶堆
+    var minHeap = PriorityQueue<Int>()
+    // 初始化大顶堆（使用 lambda 表达式修改 Comparator 即可）
+    val maxHeap = PriorityQueue { a: Int, b: Int -> b - a }
+    
+    /* 元素入堆 */
+    maxHeap.offer(1)
+    maxHeap.offer(3)
+    maxHeap.offer(2)
+    maxHeap.offer(5)
+    maxHeap.offer(4)
+    
+    /* 获取堆顶元素 */
+    var peek = maxHeap.peek() // 5
+    
+    /* 堆顶元素出堆 */
+    // 出堆元素会形成一个从大到小的序列
+    peek = maxHeap.poll() // 5
+    peek = maxHeap.poll() // 4
+    peek = maxHeap.poll() // 3
+    peek = maxHeap.poll() // 2
+    peek = maxHeap.poll() // 1
+    
+    /* 获取堆大小 */
+    val size = maxHeap.size
+    
+    /* 判断堆是否为空 */
+    val isEmpty = maxHeap.isEmpty()
+    
+    /* 输入列表并建堆 */
+    minHeap = PriorityQueue(mutableListOf(1, 3, 2, 5, 4))
+    ```
+
+=== "Ruby"
+
+    ```ruby title="heap.rb"
 
     ```
 
@@ -636,6 +673,16 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="my_heap.rb"
+    [class]{MaxHeap}-[func]{left}
+
+    [class]{MaxHeap}-[func]{right}
+
+    [class]{MaxHeap}-[func]{parent}
+    ```
+
 === "Zig"
 
     ```zig title="my_heap.zig"
@@ -767,6 +814,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="my_heap.rb"
+    [class]{MaxHeap}-[func]{peek}
+    ```
+
 === "Zig"
 
     ```zig title="my_heap.zig"
@@ -1155,6 +1208,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="my_heap.rb"
+    [class]{MaxHeap}-[func]{push}
+
+    [class]{MaxHeap}-[func]{sift_up}
+    ```
+
 === "Zig"
 
     ```zig title="my_heap.zig"
@@ -1703,6 +1764,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="my_heap.rb"
+    [class]{MaxHeap}-[func]{pop}
+
+    [class]{MaxHeap}-[func]{sift_down}
+    ```
+
 === "Zig"
 
     ```zig title="my_heap.zig"

docs/chapter_heap/top_k.md

@@ -434,6 +434,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="top_k.rb"
+    [class]{}-[func]{top_k_heap}
+    ```
+
 === "Zig"
 
     ```zig title="top_k.zig"

docs/chapter_preface/suggestions.md

@@ -173,6 +173,12 @@ comments: true
      */
     ```
 
+=== "Ruby"
+
+    ```ruby title=""
+
+    ```
+
 === "Zig"
 
     ```zig title=""

docs/chapter_searching/binary_search.md

@@ -336,6 +336,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_search.rb"
+    [class]{}-[func]{binary_search}
+    ```
+
 === "Zig"
 
     ```zig title="binary_search.zig"
@@ -658,6 +664,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_search.rb"
+    [class]{}-[func]{binary_search_lcro}
+    ```
+
 === "Zig"
 
     ```zig title="binary_search.zig"

docs/chapter_searching/binary_search_edge.md

@@ -209,6 +209,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_search_edge.rb"
+    [class]{}-[func]{binary_search_left_edge}
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_edge.zig"
@@ -452,6 +458,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_search_edge.rb"
+    [class]{}-[func]{binary_search_right_edge}
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_edge.zig"

docs/chapter_searching/binary_search_insertion.md

@@ -290,6 +290,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_search_insertion.rb"
+    [class]{}-[func]{binary_search_insertion_simple}
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_insertion.zig"
@@ -616,6 +622,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_search_insertion.rb"
+    [class]{}-[func]{binary_search_insertion}
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_insertion.zig"

docs/chapter_searching/replace_linear_by_hashing.md

@@ -225,6 +225,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="two_sum.rb"
+    [class]{}-[func]{two_sum_brute_force}
+    ```
+
 === "Zig"
 
     ```zig title="two_sum.zig"
@@ -522,6 +528,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="two_sum.rb"
+    [class]{}-[func]{two_sum_hash_table}
+    ```
+
 === "Zig"
 
     ```zig title="two_sum.zig"

docs/chapter_sorting/bubble_sort.md

@@ -271,6 +271,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="bubble_sort.rb"
+    [class]{}-[func]{bubble_sort}
+    ```
+
 === "Zig"
 
     ```zig title="bubble_sort.zig"
@@ -574,6 +580,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="bubble_sort.rb"
+    [class]{}-[func]{bubble_sort_with_flag}
+    ```
+
 === "Zig"
 
     ```zig title="bubble_sort.zig"

docs/chapter_sorting/bucket_sort.md

@@ -345,8 +345,8 @@ comments: true
         int k = size / 2;
         float **buckets = calloc(k, sizeof(float *));
         for (int i = 0; i < k; i++) {
-            // 每个桶最多可以分配 k 个元素
-            buckets[i] = calloc(ARRAY_SIZE, sizeof(float));
+            // 每个桶最多可以分配 size 个元素
+            buckets[i] = calloc(size, sizeof(float));
         }
 
         // 1. 将数组元素分配到各个桶中
@@ -359,7 +359,7 @@ comments: true
                 j++;
             }
             float temp = nums[i];
-            while (j < ARRAY_SIZE && buckets[bucket_idx][j] > 0) {
+            while (j < size && buckets[bucket_idx][j] > 0) {
                 swap(&temp, &buckets[bucket_idx][j]);
                 j++;
             }
@@ -368,12 +368,12 @@ comments: true
 
         // 2. 对各个桶执行排序
         for (int i = 0; i < k; i++) {
-            qsort(buckets[i], ARRAY_SIZE, sizeof(float), compare_float);
+            qsort(buckets[i], size, sizeof(float), compare_float);
         }
 
         // 3. 遍历桶合并结果
         for (int i = 0, j = 0; j < k; j++) {
-            for (int l = 0; l < ARRAY_SIZE; l++) {
+            for (int l = 0; l < size; l++) {
                 if (buckets[j][l] > 0) {
                     nums[i++] = buckets[j][l];
                 }
@@ -421,6 +421,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="bucket_sort.rb"
+    [class]{}-[func]{bucket_sort}
+    ```
+
 === "Zig"
 
     ```zig title="bucket_sort.zig"

docs/chapter_sorting/counting_sort.md

@@ -345,6 +345,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="counting_sort.rb"
+    [class]{}-[func]{counting_sort_naive}
+    ```
+
 === "Zig"
 
     ```zig title="counting_sort.zig"
@@ -845,6 +851,12 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="counting_sort.rb"
+    [class]{}-[func]{counting_sort}
+    ```
+
 === "Zig"
 
     ```zig title="counting_sort.zig"

docs/chapter_sorting/heap_sort.md

@@ -572,6 +572,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="heap_sort.rb"
+    [class]{}-[func]{sift_down}
+
+    [class]{}-[func]{heap_sort}
+    ```
+
 === "Zig"
 
     ```zig title="heap_sort.zig"

docs/chapter_sorting/insertion_sort.md

@@ -250,6 +250,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="insertion_sort.rb"
+    [class]{}-[func]{insertion_sort}
+    ```
+
 === "Zig"
 
     ```zig title="insertion_sort.zig"

docs/chapter_sorting/merge_sort.md

@@ -625,6 +625,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="merge_sort.rb"
+    [class]{}-[func]{merge}
+
+    [class]{}-[func]{merge_sort}
+    ```
+
 === "Zig"
 
     ```zig title="merge_sort.zig"

docs/chapter_sorting/quick_sort.md

@@ -351,6 +351,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="quick_sort.rb"
+    [class]{QuickSort}-[func]{partition}
+    ```
+
 === "Zig"
 
     ```zig title="quick_sort.zig"
@@ -609,6 +615,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="quick_sort.rb"
+    [class]{QuickSort}-[func]{quick_sort}
+    ```
+
 === "Zig"
 
     ```zig title="quick_sort.zig"
@@ -1073,6 +1085,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="quick_sort.rb"
+    [class]{QuickSortMedian}-[func]{median_three}
+
+    [class]{QuickSortMedian}-[func]{partition}
+    ```
+
 === "Zig"
 
     ```zig title="quick_sort.zig"
@@ -1364,6 +1384,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="quick_sort.rb"
+    [class]{QuickSortTailCall}-[func]{quick_sort}
+    ```
+
 === "Zig"
 
     ```zig title="quick_sort.zig"

docs/chapter_sorting/radix_sort.md

@@ -672,6 +672,16 @@ $$
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="radix_sort.rb"
+    [class]{}-[func]{digit}
+
+    [class]{}-[func]{counting_sort_digit}
+
+    [class]{}-[func]{radix_sort}
+    ```
+
 === "Zig"
 
     ```zig title="radix_sort.zig"

docs/chapter_sorting/selection_sort.md

@@ -300,6 +300,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="selection_sort.rb"
+    [class]{}-[func]{selection_sort}
+    ```
+
 === "Zig"
 
     ```zig title="selection_sort.zig"

docs/chapter_stack_and_queue/deque.md

@@ -293,7 +293,7 @@ comments: true
     int size = deque.length;
 
     /* 判断双向队列是否为空 */
-    bool isEmpty = deque.isEmpty;W
+    bool isEmpty = deque.isEmpty;
     ```
 
 === "Rust"
@@ -337,6 +337,34 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="deque.kt"
+    /* 初始化双向队列 */
+    val deque = LinkedList<Int>()
+    
+    /* 元素入队 */
+    deque.offerLast(2)  // 添加至队尾
+    deque.offerLast(5)
+    deque.offerLast(4)
+    deque.offerFirst(3) // 添加至队首
+    deque.offerFirst(1)
+    
+    /* 访问元素 */
+    val peekFirst = deque.peekFirst() // 队首元素
+    val peekLast = deque.peekLast()   // 队尾元素
+    
+    /* 元素出队 */
+    val popFirst = deque.pollFirst() // 队首元素出队
+    val popLast = deque.pollLast()   // 队尾元素出队
+    
+    /* 获取双向队列的长度 */
+    val size = deque.size
+    
+    /* 判断双向队列是否为空 */
+    val isEmpty = deque.isEmpty()
+    ```
+
+=== "Ruby"
+
+    ```ruby title="deque.rb"
 
     ```
 
@@ -1969,6 +1997,14 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linkedlist_deque.rb"
+    [class]{ListNode}-[func]{}
+
+    [class]{LinkedListDeque}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="linkedlist_deque.zig"
@@ -2635,7 +2671,7 @@ comments: true
         }
         // 计算队尾指针，指向队尾索引 + 1
         rear := q.index(q.front + q.queSize)
-        // 将 num 添加至队首
+        // 将 num 添加至队尾
         q.nums[rear] = num
         q.queSize++
     }
@@ -3451,6 +3487,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array_deque.rb"
+    [class]{ArrayDeque}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="array_deque.zig"

docs/chapter_stack_and_queue/queue.md

@@ -315,6 +315,32 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="queue.kt"
+    /* 初始化队列 */
+    val queue = LinkedList<Int>()
+    
+    /* 元素入队 */
+    queue.offer(1)
+    queue.offer(3)
+    queue.offer(2)
+    queue.offer(5)
+    queue.offer(4)
+    
+    /* 访问队首元素 */
+    val peek = queue.peek()
+    
+    /* 元素出队 */
+    val pop = queue.poll()
+    
+    /* 获取队列的长度 */
+    val size = queue.size
+    
+    /* 判断队列是否为空 */
+    val isEmpty = queue.isEmpty()
+    ```
+
+=== "Ruby"
+
+    ```ruby title="queue.rb"
 
     ```
 
@@ -1196,6 +1222,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linkedlist_queue.rb"
+    [class]{LinkedListQueue}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="linkedlist_queue.zig"
@@ -2176,6 +2208,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array_queue.rb"
+    [class]{ArrayQueue}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="array_queue.zig"

docs/chapter_stack_and_queue/stack.md

@@ -309,6 +309,32 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="stack.kt"
+    /* 初始化栈 */
+    val stack = Stack<Int>()
+    
+    /* 元素入栈 */
+    stack.push(1)
+    stack.push(3)
+    stack.push(2)
+    stack.push(5)
+    stack.push(4)
+    
+    /* 访问栈顶元素 */
+    val peek = stack.peek()
+    
+    /* 元素出栈 */
+    val pop = stack.pop()
+    
+    /* 获取栈的长度 */
+    val size = stack.size
+    
+    /* 判断是否为空 */
+    val isEmpty = stack.isEmpty()
+    ```
+
+=== "Ruby"
+
+    ```ruby title="stack.rb"
 
     ```
 
@@ -1068,6 +1094,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linkedlist_stack.rb"
+    [class]{LinkedListStack}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="linkedlist_stack.zig"
@@ -1621,10 +1653,7 @@ comments: true
 
         /* 出栈 */
         fn pop(&mut self) -> Option<T> {
-            match self.stack.pop() {
-                Some(num) => Some(num),
-                None => None,
-            }
+            self.stack.pop()
         }
 
         /* 访问栈顶元素 */
@@ -1745,6 +1774,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array_stack.rb"
+    [class]{ArrayStack}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="array_stack.zig"

docs/chapter_tree/array_representation_of_tree.md

@@ -123,6 +123,14 @@ comments: true
 === "Kotlin"
 
     ```kotlin title=""
+    /* 二叉树的数组表示 */
+    // 使用 null 来表示空位
+    val tree = mutableListOf( 1, 2, 3, 4, null, 6, 7, 8, 9, null, null, 12, null, null, 15 )
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 
@@ -1240,6 +1248,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array_binary_tree.rb"
+    [class]{ArrayBinaryTree}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="array_binary_tree.zig"

docs/chapter_tree/avl_tree.md

@@ -211,6 +211,17 @@ AVL 树既是二叉搜索树，也是平衡二叉树，同时满足这两类二
 === "Kotlin"
 
     ```kotlin title=""
+    /* AVL 树节点类 */
+    class TreeNode(val _val: Int) {  // 节点值
+        val height: Int = 0          // 节点高度
+        val left: TreeNode? = null   // 左子节点
+        val right: TreeNode? = null  // 右子节点
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 
@@ -441,6 +452,14 @@ AVL 树既是二叉搜索树，也是平衡二叉树，同时满足这两类二
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="avl_tree.rb"
+    [class]{AVLTree}-[func]{height}
+
+    [class]{AVLTree}-[func]{update_height}
+    ```
+
 === "Zig"
 
     ```zig title="avl_tree.zig"
@@ -616,6 +635,12 @@ AVL 树既是二叉搜索树，也是平衡二叉树，同时满足这两类二
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="avl_tree.rb"
+    [class]{AVLTree}-[func]{balance_factor}
+    ```
+
 === "Zig"
 
     ```zig title="avl_tree.zig"
@@ -885,6 +910,12 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="avl_tree.rb"
+    [class]{AVLTree}-[func]{right_rotate}
+    ```
+
 === "Zig"
 
     ```zig title="avl_tree.zig"
@@ -1140,6 +1171,12 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="avl_tree.rb"
+    [class]{AVLTree}-[func]{left_rotate}
+    ```
+
 === "Zig"
 
     ```zig title="avl_tree.zig"
@@ -1608,6 +1645,12 @@ AVL 树的特点在于“旋转”操作，它能够在不影响二叉树的中
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="avl_tree.rb"
+    [class]{AVLTree}-[func]{rotate}
+    ```
+
 === "Zig"
 
     ```zig title="avl_tree.zig"
@@ -1991,6 +2034,14 @@ AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="avl_tree.rb"
+    [class]{AVLTree}-[func]{insert}
+
+    [class]{AVLTree}-[func]{insert_helper}
+    ```
+
 === "Zig"
 
     ```zig title="avl_tree.zig"
@@ -2576,6 +2627,14 @@ AVL 树的节点插入操作与二叉搜索树在主体上类似。唯一的区
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="avl_tree.rb"
+    [class]{AVLTree}-[func]{remove}
+
+    [class]{AVLTree}-[func]{remove_helper}
+    ```
+
 === "Zig"
 
     ```zig title="avl_tree.zig"

docs/chapter_tree/binary_search_tree.md

@@ -310,6 +310,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_search_tree.rb"
+    [class]{BinarySearchTree}-[func]{search}
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_tree.zig"
@@ -756,6 +762,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_search_tree.rb"
+    [class]{BinarySearchTree}-[func]{insert}
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_tree.zig"
@@ -1512,6 +1524,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_search_tree.rb"
+    [class]{BinarySearchTree}-[func]{remove}
+    ```
+
 === "Zig"
 
     ```zig title="binary_search_tree.zig"

docs/chapter_tree/binary_tree.md

@@ -183,6 +183,16 @@ comments: true
 === "Kotlin"
 
     ```kotlin title=""
+    /* 二叉树节点类 */
+    class TreeNode(val _val: Int) {  // 节点值
+        val left: TreeNode? = null   // 左子节点引用
+        val right: TreeNode? = null  // 右子节点引用
+    }
+    ```
+
+=== "Ruby"
+
+    ```ruby title=""
 
     ```
 
@@ -414,6 +424,22 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="binary_tree.kt"
+    // 初始化节点
+    val n1 = TreeNode(1)
+    val n2 = TreeNode(2)
+    val n3 = TreeNode(3)
+    val n4 = TreeNode(4)
+    val n5 = TreeNode(5)
+    // 构建节点之间的引用（指针）
+    n1.left = n2
+    n1.right = n3
+    n2.left = n4
+    n2.right = n5
+    ```
+
+=== "Ruby"
+
+    ```ruby title="binary_tree.rb"
 
     ```
 
@@ -568,6 +594,17 @@ comments: true
 === "Kotlin"
 
     ```kotlin title="binary_tree.kt"
+    val P = TreeNode(0)
+    // 在 n1 -> n2 中间插入节点 P
+    n1.left = P
+    P.left = n2
+    // 删除节点 P
+    n1.left = n2
+    ```
+
+=== "Ruby"
+
+    ```ruby title="binary_tree.rb"
 
     ```
 

docs/chapter_tree/binary_tree_traversal.md

@@ -314,6 +314,12 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_tree_bfs.rb"
+    [class]{}-[func]{level_order}
+    ```
+
 === "Zig"
 
     ```zig title="binary_tree_bfs.zig"
@@ -781,6 +787,16 @@ comments: true
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="binary_tree_dfs.rb"
+    [class]{}-[func]{pre_order}
+
+    [class]{}-[func]{in_order}
+
+    [class]{}-[func]{post_order}
+    ```
+
 === "Zig"
 
     ```zig title="binary_tree_dfs.zig"

en/docs/chapter_array_and_linkedlist/array.md

@@ -293,6 +293,19 @@ Accessing elements in an array is highly efficient, allowing us to randomly acce
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 随机访问元素 ###
+    def random_access(nums)
+      # 在区间 [0, nums.length) 中随机抽取一个数字
+      random_index = Random.rand 0...(nums.length - 1)
+
+      # 获取并返回随机元素
+      nums[random_index]
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"
@@ -487,6 +500,21 @@ It's important to note that due to the fixed length of an array, inserting an el
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 在数组的索引 index 处插入元素 num ###
+    def insert(nums, num, index)
+      # 把索引 index 以及之后的所有元素向后移动一位
+      for i in (nums.length - 1).downto(index + 1)
+        nums[i] = nums[i - 1]
+      end
+
+      # 将 num 赋给 index 处的元素
+      nums[index] = num
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"
@@ -660,6 +688,18 @@ Please note that after deletion, the former last element becomes "meaningless,"
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 删除索引 index 处的元素 ###
+    def remove(nums, index)
+      # 把索引 index 之后的所有元素向前移动一位
+      for i in index...nums.length
+        nums[i] = nums[i + 1] || 0
+      end
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"
@@ -900,6 +940,25 @@ In most programming languages, we can traverse an array either by using indices
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 遍历数组 ###
+    def traverse(nums)
+      count = 0
+
+      # 通过索引遍历数组
+      for i in 0...nums.length
+        count += nums[i]
+      end
+
+      # 直接遍历数组元素
+      for num in nums
+        count += num
+      end
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"
@@ -1087,6 +1146,19 @@ Because arrays are linear data structures, this operation is commonly referred t
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 在数组中查找指定元素 ###
+    def find(nums, target)
+      for i in 0...nums.length
+        return i if nums[i] == target
+      end
+
+      -1
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"
@@ -1310,6 +1382,26 @@ To expand an array,  it's necessary to create a larger array and then copy the e
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array.rb"
+    ### 扩展数组长度 ###
+    # 请注意，Ruby 的 Array 是动态数组，可以直接扩展
+    # 为了方便学习，本函数将 Array 看作长度不可变的数组
+    def extend(nums, enlarge)
+      # 初始化一个扩展长度后的数组
+      res = Array.new(nums.length + enlarge, 0)
+
+      # 将原数组中的所有元素复制到新数组
+      for i in 0...nums.length
+        res[i] = nums[i]
+      end
+
+      # 返回扩展后的新数组
+      res
+    end
+    ```
+
 === "Zig"
 
     ```zig title="array.zig"

en/docs/chapter_array_and_linkedlist/linked_list.md

@@ -552,6 +552,18 @@ By comparison, inserting an element into an array has a time complexity of $O(n)
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linked_list.rb"
+    ### 在链表的节点 n0 之后插入节点 _p ###
+    # Ruby 的 `p` 是一个内置函数， `P` 是一个常量，所以可以使用 `_p` 代替
+    def insert(n0, _p)
+      n1 = n0.next
+      _p.next = n1
+      n0.next = _p
+    end
+    ```
+
 === "Zig"
 
     ```zig title="linked_list.zig"
@@ -752,6 +764,20 @@ It's important to note that even though node `P` continues to point to `n1` afte
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linked_list.rb"
+    ### 删除链表的节点 n0 之后的首个节点 ###
+    def remove(n0)
+      return if n0.next.nil?
+
+      # n0 -> remove_node -> n1
+      remove_node = n0.next
+      n1 = remove_node.next
+      n0.next = n1
+    end
+    ```
+
 === "Zig"
 
     ```zig title="linked_list.zig"
@@ -945,6 +971,20 @@ It's important to note that even though node `P` continues to point to `n1` afte
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linked_list.rb"
+    ### 访问链表中索引为 index 的节点 ###
+    def access(head, index)
+      for i in 0...index
+        return nil if head.nil?
+        head = head.next
+      end
+
+      head
+    end
+    ```
+
 === "Zig"
 
     ```zig title="linked_list.zig"
@@ -1164,6 +1204,22 @@ Traverse the linked list to locate a node whose value matches `target`, and then
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linked_list.rb"
+    ### 在链表中查找值为 target 的首个节点 ###
+    def find(head, target)
+      index = 0
+      while head
+        return index if head.val == target
+        head = head.next
+        index += 1
+      end
+
+      -1
+    end
+    ```
+
 === "Zig"
 
     ```zig title="linked_list.zig"

en/docs/chapter_array_and_linkedlist/list.md

@@ -2141,6 +2141,100 @@ To enhance our understanding of how lists work, we will attempt to implement a s
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="my_list.rb"
+    ### 列表类 ###
+    class MyList
+      attr_reader :size       # 获取列表长度（当前元素数量）
+      attr_reader :capacity   # 获取列表容量
+
+      ### 构造方法 ###
+      def initialize
+        @capacity = 10
+        @size = 0
+        @extend_ratio = 2
+        @arr = Array.new capacity
+      end
+
+      ### 访问元素 ###
+      def get(index)
+        # 索引如果越界，则抛出异常，下同
+        raise IndexError, "索引越界" if index < 0 || index >= size
+        @arr[index]
+      end
+
+      ### 访问元素 ###
+      def set(index, num)
+        raise IndexError, "索引越界" if index < 0 || index >= size
+        @arr[index] = num
+      end
+
+      ### 在尾部添加元素 ###
+      def add(num)
+        # 元素数量超出容量时，触发扩容机制
+        extend_capacity if size == capacity
+        @arr[size] = num
+        
+        # 更新元素数量
+        @size += 1
+      end
+
+      ### 在中间插入元素 ###
+      def insert(index, num)
+        raise IndexError, "索引越界" if index < 0 || index >= size
+
+        # 元素数量超出容量时，触发扩容机制
+        extend_capacity if size == capacity
+
+        # 将索引 index 以及之后的元素都向后移动一位
+        for j in (size - 1).downto(index)
+          @arr[j + 1] = @arr[j] 
+        end
+        @arr[index] = num
+
+        # 更新元素数量
+        @size += 1
+      end
+
+      ### 删除元素 ###
+      def remove(index)
+        raise IndexError, "索引越界" if index < 0 || index >= size
+        num = @arr[index]
+
+        # 将将索引 index 之后的元素都向前移动一位
+        for j in index...size
+          @arr[j] = @arr[j + 1]
+        end
+
+        # 更新元素数量
+        @size -= 1
+
+        # 返回被删除的元素
+        num
+      end
+
+      ### 列表扩容 ###
+      def extend_capacity
+        # 新建一个长度为原数组 extend_ratio 倍的新数组，并将原数组复制到新数组
+        arr = @arr.dup + Array.new(capacity * (@extend_ratio - 1))
+        # 更新列表容量
+        @capacity = arr.length
+      end
+
+      ### 将列表转换为数组 ###
+      def to_array
+        sz = size
+        # 仅转换有效长度范围内的列表元素
+        arr = Array.new sz
+        for i in 0...sz
+          arr[i] = get i
+        end
+        arr
+      end
+    end
+    ```
+
 === "Zig"
 
     ```zig title="my_list.zig"

en/docs/chapter_computational_complexity/iteration_and_recursion.md

@@ -182,6 +182,12 @@ The following function uses a `for` loop to perform a summation of $1 + 2 + \dot
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="iteration.rb"
+    [class]{}-[func]{for_loop}
+    ```
+
 === "Zig"
 
     ```zig title="iteration.zig"
@@ -408,6 +414,12 @@ Below we use a `while` loop to implement the sum $1 + 2 + \dots + n$.
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="iteration.rb"
+    [class]{}-[func]{while_loop}
+    ```
+
 === "Zig"
 
     ```zig title="iteration.zig"
@@ -649,6 +661,12 @@ For example, in the following code, the condition variable $i$ is updated twice
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="iteration.rb"
+    [class]{}-[func]{while_loop_ii}
+    ```
+
 === "Zig"
 
     ```zig title="iteration.zig"
@@ -883,6 +901,12 @@ We can nest one loop structure within another. Below is an example using `for` l
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="iteration.rb"
+    [class]{}-[func]{nested_for_loop}
+    ```
+
 === "Zig"
 
     ```zig title="iteration.zig"
@@ -1112,6 +1136,12 @@ Observe the following code, where simply calling the function `recur(n)` can com
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="recursion.rb"
+    [class]{}-[func]{recur}
+    ```
+
 === "Zig"
 
     ```zig title="recursion.zig"
@@ -1318,8 +1348,9 @@ For example, in calculating $1 + 2 + \dots + n$, we can make the result variable
 === "Kotlin"
 
     ```kotlin title="recursion.kt"
-    /* Kotlin tailrec 关键词使函数实现尾递归优化 */
+    /* 尾递归 */
     tailrec fun tailRecur(n: Int, res: Int): Int {
+        // 添加 tailrec 关键词，以开启尾递归优化
         // 终止条件
         if (n == 0)
             return res
@@ -1328,6 +1359,12 @@ For example, in calculating $1 + 2 + \dots + n$, we can make the result variable
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="recursion.rb"
+    [class]{}-[func]{tail_recur}
+    ```
+
 === "Zig"
 
     ```zig title="recursion.zig"
@@ -1554,6 +1591,12 @@ Using the recursive relation, and considering the first two numbers as terminati
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="recursion.rb"
+    [class]{}-[func]{fib}
+    ```
+
 === "Zig"
 
     ```zig title="recursion.zig"
@@ -1890,6 +1933,12 @@ Therefore, **we can use an explicit stack to simulate the behavior of the call s
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="recursion.rb"
+    [class]{}-[func]{for_loop_recur}
+    ```
+
 === "Zig"
 
     ```zig title="recursion.zig"

en/docs/chapter_computational_complexity/space_complexity.md

@@ -1077,6 +1077,14 @@ Note that memory occupied by initializing variables or calling functions in a lo
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{function}
+
+    [class]{}-[func]{constant}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"
@@ -1373,6 +1381,12 @@ Linear order is common in arrays, linked lists, stacks, queues, etc., where the
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{linear}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"
@@ -1549,6 +1563,12 @@ As shown below, this function's recursive depth is $n$, meaning there are $n$ in
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{linear_recur}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"
@@ -1783,6 +1803,12 @@ Quadratic order is common in matrices and graphs, where the number of elements i
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{quadratic}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"
@@ -1972,6 +1998,12 @@ As shown below, the recursive depth of this function is $n$, and in each recursi
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{quadratic_recur}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"
@@ -2164,6 +2196,12 @@ Exponential order is common in binary trees. Observe the below image, a "full bi
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="space_complexity.rb"
+    [class]{}-[func]{build_tree}
+    ```
+
 === "Zig"
 
     ```zig title="space_complexity.zig"

en/docs/chapter_computational_complexity/time_complexity.md

@@ -1140,6 +1140,12 @@ Constant order means the number of operations is independent of the input data s
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{constant}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -1312,6 +1318,12 @@ Linear order indicates the number of operations grows linearly with the input da
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{linear}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -1499,6 +1511,12 @@ Operations like array traversal and linked list traversal have a time complexity
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{array_traversal}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -1713,6 +1731,12 @@ Quadratic order means the number of operations grows quadratically with the inpu
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{quadratic}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2013,6 +2037,12 @@ For instance, in bubble sort, the outer loop runs $n - 1$ times, and the inner l
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{bubble_sort}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2269,6 +2299,12 @@ The following image and code simulate the cell division process, with a time com
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{exponential}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2432,6 +2468,12 @@ In practice, exponential order often appears in recursive functions. For example
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{exp_recur}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2623,6 +2665,12 @@ The following image and code simulate the "halving each round" process, with a t
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{logarithmic}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2780,6 +2828,12 @@ Like exponential order, logarithmic order also frequently appears in recursive f
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{log_recur}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -2988,6 +3042,12 @@ Linear-logarithmic order often appears in nested loops, with the complexities of
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{linear_log_recur}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -3214,6 +3274,12 @@ Factorials are typically implemented using recursion. As shown in the image and
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="time_complexity.rb"
+    [class]{}-[func]{factorial_recur}
+    ```
+
 === "Zig"
 
     ```zig title="time_complexity.zig"
@@ -3603,6 +3669,14 @@ The "worst-case time complexity" corresponds to the asymptotic upper bound, deno
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="worst_best_time_complexity.rb"
+    [class]{}-[func]{random_numbers}
+
+    [class]{}-[func]{find_one}
+    ```
+
 === "Zig"
 
     ```zig title="worst_best_time_complexity.zig"

en/docs/chapter_hashing/hash_algorithm.md

@@ -594,6 +594,18 @@ The design of hash algorithms is a complex issue that requires consideration of
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="simple_hash.rb"
+    [class]{}-[func]{add_hash}
+
+    [class]{}-[func]{mul_hash}
+
+    [class]{}-[func]{xor_hash}
+
+    [class]{}-[func]{rot_hash}
+    ```
+
 === "Zig"
 
     ```zig title="simple_hash.zig"

en/docs/chapter_hashing/hash_collision.md

@@ -1426,6 +1426,12 @@ The code below provides a simple implementation of a separate chaining hash tabl
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="hash_map_chaining.rb"
+    [class]{HashMapChaining}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="hash_map_chaining.zig"
@@ -3072,6 +3078,12 @@ The code below implements an open addressing (linear probing) hash table with la
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="hash_map_open_addressing.rb"
+    [class]{HashMapOpenAddressing}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="hash_map_open_addressing.zig"

en/docs/chapter_hashing/hash_map.md

@@ -1697,6 +1697,14 @@ The following code implements a simple hash table. Here, we encapsulate `key` an
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array_hash_map.rb"
+    [class]{Pair}-[func]{}
+
+    [class]{ArrayHashMap}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="array_hash_map.zig"

en/docs/chapter_stack_and_queue/deque.md

@@ -1968,6 +1968,14 @@ The implementation code is as follows:
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linkedlist_deque.rb"
+    [class]{ListNode}-[func]{}
+
+    [class]{LinkedListDeque}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="linkedlist_deque.zig"
@@ -2634,7 +2642,7 @@ The implementation only needs to add methods for "front enqueue" and "rear deque
         }
         // 计算队尾指针，指向队尾索引 + 1
         rear := q.index(q.front + q.queSize)
-        // 将 num 添加至队首
+        // 将 num 添加至队尾
         q.nums[rear] = num
         q.queSize++
     }
@@ -3450,6 +3458,12 @@ The implementation only needs to add methods for "front enqueue" and "rear deque
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array_deque.rb"
+    [class]{ArrayDeque}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="array_deque.zig"

en/docs/chapter_stack_and_queue/queue.md

@@ -1196,6 +1196,12 @@ Below is the code for implementing a queue using a linked list:
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linkedlist_queue.rb"
+    [class]{LinkedListQueue}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="linkedlist_queue.zig"
@@ -2176,6 +2182,12 @@ In a circular array, `front` or `rear` needs to loop back to the start of the ar
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array_queue.rb"
+    [class]{ArrayQueue}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="array_queue.zig"

en/docs/chapter_stack_and_queue/stack.md

@@ -1068,6 +1068,12 @@ Below is an example code for implementing a stack based on a linked list:
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="linkedlist_stack.rb"
+    [class]{LinkedListStack}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="linkedlist_stack.zig"
@@ -1621,10 +1627,7 @@ Since the elements to be pushed onto the stack may continuously increase, we can
 
         /* 出栈 */
         fn pop(&mut self) -> Option<T> {
-            match self.stack.pop() {
-                Some(num) => Some(num),
-                None => None,
-            }
+            self.stack.pop()
         }
 
         /* 访问栈顶元素 */
@@ -1745,6 +1748,12 @@ Since the elements to be pushed onto the stack may continuously increase, we can
     }
     ```
 
+=== "Ruby"
+
+    ```ruby title="array_stack.rb"
+    [class]{ArrayStack}-[func]{}
+    ```
+
 === "Zig"
 
     ```zig title="array_stack.zig"

overrides/stylesheets/extra.css

@@ -209,7 +209,7 @@ body {
 
 /* code block tabs */
 .md-typeset .tabbed-labels>label {
-  font-size: 0.59rem;
+  font-size: 0.545rem;
 }
 
 /* header banner */