Many bug fixes and improvements (#1270)

* Add Ruby and Kotlin icons
Add the avatar of @curtishd

* Update README

* Synchronize zh-hant and zh versions.

* Translate the pythontutor blocks to traditional Chinese

* Fix en/mkdocs.yml

* Update the landing page of the en version.

* Fix the Dockerfile

* Refine the en landingpage

* Fix en landing page

* Reset the README.md

zh-hant/codes/ruby/chapter_array_and_linkedlist/array.rb

@@ -45,8 +45,8 @@ end
 ### 刪除索引 index 處的元素 ###
 def remove(nums, index)
   # 把索引 index 之後的所有元素向前移動一位
-  for i in index...nums.length
-    nums[i] = nums[i + 1] || 0
+  for i in index...(nums.length - 1)
+    nums[i] = nums[i + 1]
   end
 end
 
@@ -76,32 +76,33 @@ end
 
 
 ### Driver Code ###
+if __FILE__ == $0
+  # 初始化陣列
+  arr = Array.new(5, 0)
+  puts "陣列 arr = #{arr}"
+  nums = [1, 3, 2, 5, 4]
+  puts "陣列 nums = #{nums}"
 
-# 初始化陣列
-arr = Array.new(5, 0)
-puts "陣列 arr = #{arr}"
-nums = [1, 3, 2, 5, 4]
-puts "陣列 nums = #{nums}"
+  # 隨機訪問
+  random_num = random_access(nums)
+  puts "在 nums 中獲取隨機元素 #{random_num}"
 
-# 隨機訪問
-random_num = random_access(nums)
-puts "在 nums 中獲取隨機元素 #{random_num}"
+  # 長度擴展
+  nums = extend(nums, 3)
+  puts "將陣列長度擴展至 8 ，得到 nums = #{nums}"
 
-# 長度擴展
-nums = extend(nums, 3)
-puts "將陣列長度擴展至 8 ，得到 nums = #{nums}"
+  # 插入元素
+  insert(nums, 6, 3)
+  puts "在索引 3 處插入數字 6 ，得到 nums = #{nums}"
 
-# 插入元素
-insert(nums, 6, 3)
-puts "在索引 3 處插入數字 6 ，得到 nums = #{nums}"
+  # 刪除元素
+  remove(nums, 2)
+  puts "刪除索引 2 處的元素，得到 nums = #{nums}"
 
-# 刪除元素
-remove(nums, 2)
-puts "刪除索引 2 處的元素，得到 nums = #{nums}"
+  # 走訪陣列
+  traverse(nums)
 
-# 走訪陣列
-traverse(nums)
-
-# 查詢元素
-index = find(nums, 3)
-puts "在 nums 中查詢元素 3 ，得到索引 = #{index}"
+  # 查詢元素
+  index = find(nums, 3)
+  puts "在 nums 中查詢元素 3 ，得到索引 = #{index}"
+end

zh-hant/codes/ruby/chapter_array_and_linkedlist/linked_list.rb

@@ -48,35 +48,36 @@ def find(head, target)
 end
 
 ### Driver Code ###
+if __FILE__ == $0
+  # 初始化鏈結串列
+  # 初始化各個節點
+  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
+  puts "初始化的鏈結串列為"
+  print_linked_list(n0)
 
-# 初始化鏈結串列
-# 初始化各個節點
-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
-puts "初始化的鏈結串列為"
-print_linked_list(n0)
+  # 插入節點
+  insert(n0, ListNode.new(0))
+  print_linked_list n0
 
-# 插入節點
-insert(n0, ListNode.new(0))
-print_linked_list n0
+  # 刪除節點
+  remove(n0)
+  puts "刪除節點後的鏈結串列為"
+  print_linked_list(n0)
 
-# 刪除節點
-remove(n0)
-puts "刪除節點後的鏈結串列為"
-print_linked_list(n0)
+  # 訪問節點
+  node = access(n0, 3)
+  puts "鏈結串列中索引 3 處的節點的值 = #{node.val}"
 
-# 訪問節點
-node = access(n0, 3)
-puts "鏈結串列中索引 3 處的節點的值 = #{node.val}"
-
-# 查詢節點
-index = find(n0, 2)
-puts "鏈結串列中值為 2 的節點的索引 = #{index}"
+  # 查詢節點
+  index = find(n0, 2)
+  puts "鏈結串列中值為 2 的節點的索引 = #{index}"
+end

zh-hant/codes/ruby/chapter_array_and_linkedlist/list.rb

@@ -5,55 +5,56 @@ Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
 =end
 
 ### Driver Code ###
+if __FILE__ == $0
+  # 初始化串列
+  nums = [1, 3, 2, 5, 4]
+  puts "串列 nums = #{nums}"
 
-# 初始化串列
-nums = [1, 3, 2, 5, 4]
-puts "串列 nums = #{nums}"
+  # 訪問元素
+  num = nums[1]
+  puts "訪問索引 1 處的元素，得到 num = #{num}"
 
-# 訪問元素
-num = nums[1]
-puts "訪問索引 1 處的元素，得到 num = #{num}"
+  # 更新元素
+  nums[1] = 0
+  puts "將索引 1 處的元素更新為 0 ，得到 nums = #{nums}"
 
-# 更新元素
-nums[1] = 0
-puts "將索引 1 處的元素更新為 0 ，得到 nums = #{nums}"
+  # 清空串列
+  nums.clear
+  puts "清空串列後 nums = #{nums}"
 
-# 清空串列
-nums.clear
-puts "清空串列後 nums = #{nums}"
+  # 在尾部新增元素
+  nums << 1
+  nums << 3
+  nums << 2
+  nums << 5
+  nums << 4
+  puts "新增元素後 nums = #{nums}"
 
-# 在尾部新增元素
-nums << 1
-nums << 3
-nums << 2
-nums << 5
-nums << 4
-puts "新增元素後 nums = #{nums}"
+  # 在中間插入元素
+  nums.insert(3, 6)
+  puts "在索引 3 處插入元素 6 ，得到 nums = #{nums}"
 
-# 在中間插入元素
-nums.insert(3, 6)
-puts "在索引 3 處插入元素 6 ，得到 nums = #{nums}"
+  # 刪除元素
+  nums.delete_at(3)
+  puts "刪除索引 3 處的元素，得到 nums = #{nums}"
 
-# 刪除元素
-nums.delete_at(3)
-puts "刪除索引 3 處的元素，得到 nums = #{nums}"
+  # 透過索引走訪串列
+  count = 0
+  for i in 0...nums.length
+    count += nums[i]
+  end
 
-# 透過索引走訪串列
-count = 0
-for i in 0...nums.length
-  count += nums[i]
+  # 直接走訪串列元素
+  count = 0
+  nums.each do |x|
+    count += x
+  end
+
+  # 拼接兩個串列
+  nums1 = [6, 8, 7, 10, 9]
+  nums += nums1
+  puts "將串列 nums1 拼接到 nums 之後，得到 nums = #{nums}"
+
+  nums = nums.sort { |a, b| a <=> b }
+  puts "排序串列後 nums = #{nums}"
 end
-
-# 直接走訪串列元素
-count = 0
-nums.each do |x|
-  count += x
-end
-
-# 拼接兩個串列
-nums1 = [6, 8, 7, 10, 9]
-nums += nums1
-puts "將串列 nums1 拼接到 nums 之後，得到 nums = #{nums}"
-
-nums = nums.sort { |a, b| a <=> b }
-puts "排序串列後 nums = #{nums}"

zh-hant/codes/ruby/chapter_array_and_linkedlist/my_list.rb

@@ -35,7 +35,7 @@ class MyList
     # 元素數量超出容量時，觸發擴容機制
     extend_capacity if size == capacity
     @arr[size] = num
-    
+
     # 更新元素數量
     @size += 1
   end
@@ -49,7 +49,7 @@ class MyList
 
     # 將索引 index 以及之後的元素都向後移動一位
     for j in (size - 1).downto(index)
-      @arr[j + 1] = @arr[j] 
+      @arr[j + 1] = @arr[j]
     end
     @arr[index] = num
 
@@ -95,37 +95,38 @@ class MyList
 end
 
 ### Driver Code ###
+if __FILE__ == $0
+  # 初始化串列
+  nums = MyList.new
 
-# 初始化串列
-nums = MyList.new
+  # 在尾部新增元素
+  nums.add(1)
+  nums.add(3)
+  nums.add(2)
+  nums.add(5)
+  nums.add(4)
+  puts "串列 nums = #{nums.to_array} ，容量 = #{nums.capacity} ，長度 = #{nums.size}"
 
-# 在尾部新增元素
-nums.add(1)
-nums.add(3)
-nums.add(2)
-nums.add(5)
-nums.add(4)
-puts "串列 nums = #{nums.to_array} ，容量 = #{nums.capacity} ，長度 = #{nums.size}"
+  # 在中間插入元素
+  nums.insert(3, 6)
+  puts "在索引 3 處插入數字 6 ，得到 nums = #{nums.to_array}"
 
-# 在中間插入元素
-nums.insert(3, 6)
-puts "在索引 3 處插入數字 6 ，得到 nums = #{nums.to_array}"
+  # 刪除元素
+  nums.remove(3)
+  puts "刪除索引 3 的元素，得到 nums = #{nums.to_array}"
 
-# 刪除元素
-nums.remove(3)
-puts "刪除索引 3 的元素，得到 nums = #{nums.to_array}"
+  # 訪問元素
+  num = nums.get(1)
+  puts "訪問索引 1 處的元素，得到 num = #{num}"
 
-# 訪問元素
-num = nums.get(1)
-puts "訪問索引 1 處的元素，得到 num = #{num}"
+  # 更新元素
+  nums.set(1, 0)
+  puts "將索引 1 處的元素更新為 0 ，得到 nums = #{nums.to_array}"
 
-# 更新元素
-nums.set(1, 0)
-puts "將索引 1 處的元素更新為 0 ，得到 nums = #{nums.to_array}"
-
-# 測試擴容機制
-for i in 0...10
-  # 在 i = 5 時，串列長度將超出串列容量，此時觸發擴容機制
-  nums.add(i)
+  # 測試擴容機制
+  for i in 0...10
+    # 在 i = 5 時，串列長度將超出串列容量，此時觸發擴容機制
+    nums.add(i)
+  end
+  puts "擴容後的串列 nums = #{nums.to_array} ，容量 = #{nums.capacity} ，長度 = #{nums.size}"
 end
-puts "擴容後的串列 nums = #{nums.to_array} ，容量 = #{nums.capacity} ，長度 = #{nums.size}"

zh-hant/codes/ruby/chapter_computational_complexity/iteration.rb

@@ -62,17 +62,18 @@ def nested_for_loop(n)
 end
 
 ### Driver Code ###
+if __FILE__ == $0
+  n = 5
 
-n = 5
+  res = for_loop(n)
+  puts "\nfor 迴圈的求和結果 res = #{res}"
 
-res = for_loop(n)
-puts "\nfor 迴圈的求和結果 res = #{res}"
+  res = while_loop(n)
+  puts "\nwhile 迴圈的求和結果 res = #{res}"
 
-res = while_loop(n)
-puts "\nwhile 迴圈的求和結果 res = #{res}"
+  res = while_loop_ii(n)
+  puts "\nwhile 迴圈（兩次更新）求和結果 res = #{res}"
 
-res = while_loop_ii(n)
-puts "\nwhile 迴圈（兩次更新）求和結果 res = #{res}"
-
-res = nested_for_loop(n)
-puts "\n雙層 for 迴圈的走訪結果 #{res}"
+  res = nested_for_loop(n)
+  puts "\n雙層 for 迴圈的走訪結果 #{res}"
+end

zh-hant/codes/ruby/chapter_computational_complexity/recursion.rb

@@ -53,17 +53,18 @@ def fib(n)
 end
 
 ### Driver Code ###
+if __FILE__ == $0
+  n = 5
 
-n = 5
+  res = recur(n)
+  puts "\n遞迴函式的求和結果 res = #{res}"
 
-res = recur(n)
-puts "\n遞迴函式的求和結果 res = #{res}"
+  res = for_loop_recur(n)
+  puts "\n使用迭代模擬遞迴求和結果 res = #{res}"
 
-res = for_loop_recur(n)
-puts "\n使用迭代模擬遞迴求和結果 res = #{res}"
+  res = tail_recur(n, 0)
+  puts "\n尾遞迴函式的求和結果 res = #{res}"
 
-res = tail_recur(n, 0)
-puts "\n尾遞迴函式的求和結果 res = #{res}"
-
-res = fib(n)
-puts "\n費波那契數列的第 #{n} 項為 #{res}"
+  res = fib(n)
+  puts "\n費波那契數列的第 #{n} 項為 #{res}"
+end

zh-hant/codes/ruby/chapter_computational_complexity/space_complexity.rb

@@ -72,20 +72,21 @@ def build_tree(n)
 end
 
 ### Driver Code ###
+if __FILE__ == $0
+  n = 5
 
-n = 5
+  # 常數階
+  constant(n)
 
-# 常數階
-constant(n)
+  # 線性階
+  linear(n)
+  linear_recur(n)
 
-# 線性階
-linear(n)
-linear_recur(n)
+  # 平方階
+  quadratic(n)
+  quadratic_recur(n)
 
-# 平方階
-quadratic(n)
-quadratic_recur(n)
-
-# 指數階
-root = build_tree(n)
-print_tree(root)
+  # 指數階
+  root = build_tree(n)
+  print_tree(root)
+end

zh-hant/codes/ruby/chapter_computational_complexity/time_complexity.rb

@@ -128,37 +128,38 @@ def factorial_recur(n)
 end
 
 ### Driver Code ###
+if __FILE__ == $0
+  # 可以修改 n 執行，體會一下各種複雜度的操作數量變化趨勢
+  n = 8
+  puts "輸入資料大小 n = #{n}"
 
-# 可以修改 n 執行，體會一下各種複雜度的操作數量變化趨勢
-n = 8
-puts "輸入資料大小 n = #{n}"
+  count = constant(n)
+  puts "常數階的操作數量 = #{count}"
 
-count = constant(n)
-puts "常數階的操作數量 = #{count}"
+  count = linear(n)
+  puts "線性階的操作數量 = #{count}"
+  count = array_traversal(Array.new(n, 0))
+  puts "線性階（走訪陣列）的操作數量 = #{count}"
 
-count = linear(n)
-puts "線性階的操作數量 = #{count}"
-count = array_traversal(Array.new(n, 0))
-puts "線性階（走訪陣列）的操作數量 = #{count}"
+  count = quadratic(n)
+  puts "平方階的操作數量 = #{count}"
+  nums = Array.new(n) { |i| n - i } # [n, n-1, ..., 2, 1]
+  count = bubble_sort(nums)
+  puts "平方階（泡沫排序）的操作數量 = #{count}"
 
-count = quadratic(n)
-puts "平方階的操作數量 = #{count}"
-nums = Array.new(n) { |i| n - i } # [n, n-1, ..., 2, 1]
-count = bubble_sort(nums)
-puts "平方階（泡沫排序）的操作數量 = #{count}"
+  count = exponential(n)
+  puts "指數階（迴圈實現）的操作數量 = #{count}"
+  count = exp_recur(n)
+  puts "指數階（遞迴實現）的操作數量 = #{count}"
 
-count = exponential(n)
-puts "指數階（迴圈實現）的操作數量 = #{count}"
-count = exp_recur(n)
-puts "指數階（遞迴實現）的操作數量 = #{count}"
+  count = logarithmic(n)
+  puts "對數階（迴圈實現）的操作數量 = #{count}"
+  count = log_recur(n)
+  puts "對數階（遞迴實現）的操作數量 = #{count}"
 
-count = logarithmic(n)
-puts "對數階（迴圈實現）的操作數量 = #{count}"
-count = log_recur(n)
-puts "對數階（遞迴實現）的操作數量 = #{count}"
+  count = linear_log_recur(n)
+  puts "線性對數階（遞迴實現）的操作數量 = #{count}"
 
-count = linear_log_recur(n)
-puts "線性對數階（遞迴實現）的操作數量 = #{count}"
-
-count = factorial_recur(n)
-puts "階乘階（遞迴實現）的操作數量 = #{count}"
+  count = factorial_recur(n)
+  puts "階乘階（遞迴實現）的操作數量 = #{count}"
+end

zh-hant/codes/ruby/chapter_computational_complexity/worst_best_time_complexity.rb

@@ -24,11 +24,12 @@ def find_one(nums)
 end
 
 ### Driver Code ###
-
-for i in 0...10
-  n = 100
-  nums = random_numbers(n)
-  index = find_one(nums)
-  puts "\n陣列 [ 1, 2, ..., n ] 被打亂後 = #{nums}"
-  puts "數字 1 的索引為 #{index}"
+if __FILE__ == $0
+  for i in 0...10
+    n = 100
+    nums = random_numbers(n)
+    index = find_one(nums)
+    puts "\n陣列 [ 1, 2, ..., n ] 被打亂後 = #{nums}"
+    puts "數字 1 的索引為 #{index}"
+  end
 end

zh-hant/codes/ruby/chapter_stack_and_queue/array_deque.rb

@@ -0,0 +1,145 @@
+=begin
+File: array_deque.rb
+Created Time: 2024-04-05
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### 基於環形陣列實現的雙向佇列 ###
+class ArrayDeque
+  ### 獲取雙向佇列的長度 ###
+  attr_reader :size
+
+  ### 建構子 ###
+  def initialize(capacity)
+    @nums = Array.new(capacity, 0)
+    @front = 0
+    @size = 0
+  end
+
+  ### 獲取雙向佇列的容量 ###
+  def capacity
+    @nums.length
+  end
+
+  ### 判斷雙向佇列是否為空 ###
+  def is_empty?
+    size.zero?
+  end
+
+  ### 佇列首入列 ###
+  def push_first(num)
+    if size == capacity
+      puts '雙向佇列已滿'
+      return
+    end
+
+    # 佇列首指標向左移動一位
+    # 透過取餘操作實現 front 越過陣列頭部後回到尾部
+    @front = index(@front - 1)
+    # 將 num 新增至佇列首
+    @nums[@front] = num
+    @size += 1
+  end
+
+  ### 佇列尾入列 ###
+  def push_last(num)
+    if size == capacity
+      puts '雙向佇列已滿'
+      return
+    end
+
+    # 計算佇列尾指標，指向佇列尾索引 + 1
+    rear = index(@front + size)
+    # 將 num 新增至佇列尾
+    @nums[rear] = num
+    @size += 1
+  end
+
+  ### 佇列首出列 ###
+  def pop_first
+    num = peek_first
+    # 佇列首指標向後移動一位
+    @front = index(@front + 1)
+    @size -= 1
+    num
+  end
+
+  ### 佇列尾出列 ###
+  def pop_last
+    num = peek_last
+    @size -= 1
+    num
+  end
+
+  ### 訪問佇列首元素 ###
+  def peek_first
+    raise IndexError, '雙向佇列為空' if is_empty?
+
+    @nums[@front]
+  end
+
+  ### 訪問佇列尾元素 ###
+  def peek_last
+    raise IndexError, '雙向佇列為空' if is_empty?
+
+    # 計算尾元素索引
+    last = index(@front + size - 1)
+    @nums[last]
+  end
+
+  ### 返回陣列用於列印 ###
+  def to_array
+    # 僅轉換有效長度範圍內的串列元素
+    res = []
+    for i in 0...size
+      res << @nums[index(@front + i)]
+    end
+    res
+  end
+
+  private
+
+  ### 計算環形陣列索引 ###
+  def index(i)
+    # 透過取餘操作實現陣列首尾相連
+    # 當 i 越過陣列尾部後，回到頭部
+    # 當 i 越過陣列頭部後，回到尾部
+    (i + capacity) % capacity
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化雙向佇列
+  deque = ArrayDeque.new(10)
+  deque.push_last(3)
+  deque.push_last(2)
+  deque.push_last(5)
+  puts "雙向佇列 deque = #{deque.to_array}"
+
+  # 訪問元素
+  peek_first = deque.peek_first
+  puts "佇列首元素 peek_first = #{peek_first}"
+  peek_last = deque.peek_last
+  puts "佇列尾元素 peek_last = #{peek_last}"
+
+  # 元素入列
+  deque.push_last(4)
+  puts "元素 4 佇列尾入列後 deque = #{deque.to_array}"
+  deque.push_first(1)
+  puts "元素 1 佇列尾入列後 deque = #{deque.to_array}"
+
+  # 元素出列
+  pop_last = deque.pop_last
+  puts "佇列尾出列元素 = #{pop_last}，佇列尾出列後 deque = #{deque.to_array}"
+  pop_first = deque.pop_first
+  puts "佇列尾出列元素 = #{pop_first}，佇列尾出列後 deque = #{deque.to_array}"
+
+  # 獲取雙向佇列的長度
+  size = deque.size
+  puts "雙向佇列長度 size = #{size}"
+
+  # 判斷雙向佇列是否為空
+  is_empty = deque.is_empty?
+  puts "雙向佇列是否為空 = #{is_empty}"
+end

zh-hant/codes/ruby/chapter_stack_and_queue/array_queue.rb

@@ -0,0 +1,107 @@
+=begin
+File: array_queue.rb
+Created Time: 2024-04-05
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### 基於環形陣列實現的佇列 ###
+class ArrayQueue
+  ### 獲取佇列的長度 ###
+  attr_reader :size
+
+  ### 建構子 ###
+  def initialize(size)
+    @nums = Array.new(size, 0) # 用於儲存佇列元素的陣列
+    @front = 0 # 佇列首指標，指向佇列首元素
+    @size = 0 # 佇列長度
+  end
+
+  ### 獲取佇列的容量 ###
+  def capacity
+    @nums.length
+  end
+
+  ### 判斷佇列是否為空 ###
+  def is_empty?
+    size.zero?
+  end
+
+  ### 入列 ###
+  def push(num)
+    raise IndexError, '佇列已滿' if size == capacity
+
+    # 計算佇列尾指標，指向佇列尾索引 + 1
+    # 透過取餘操作實現 rear 越過陣列尾部後回到頭部
+    rear = (@front + size) % capacity
+    # 將 num 新增至佇列尾
+    @nums[rear] = num
+    @size += 1
+  end
+
+  ### 出列 ###
+  def pop
+    num = peek
+    # 佇列首指標向後移動一位，若越過尾部，則返回到陣列頭部
+    @front = (@front + 1) % capacity
+    @size -= 1
+    num
+  end
+
+  ### 訪問佇列首元素 ###
+  def peek
+    raise IndexError, '佇列為空' if is_empty?
+
+    @nums[@front]
+  end
+
+  ### 返回串列用於列印 ###
+  def to_array
+    res = Array.new(size, 0)
+    j = @front
+
+    for i in 0...size
+      res[i] = @nums[j % capacity]
+      j += 1
+    end
+
+    res
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化佇列
+  queue = ArrayQueue.new(10)
+
+  # 元素入列
+  queue.push(1)
+  queue.push(3)
+  queue.push(2)
+  queue.push(5)
+  queue.push(4)
+  puts "佇列 queue = #{queue.to_array}"
+
+  # 訪問佇列首元素
+  peek = queue.peek
+  puts "佇列首元素 peek = #{peek}"
+
+  # 元素出列
+  pop = queue.pop
+  puts "出列元素 pop = #{pop}"
+  puts "出列後 queue = #{queue.to_array}"
+
+  # 獲取佇列的長度
+  size = queue.size
+  puts "佇列長度 size = #{size}"
+
+  # 判斷佇列是否為空
+  is_empty = queue.is_empty?
+  puts "佇列是否為空 = #{is_empty}"
+
+  # 測試環形陣列
+  for i in 0...10
+    queue.push(i)
+    queue.pop
+    puts "第 #{i} 輪入列 + 出列後 queue = #{queue.to_array}"
+  end
+end

zh-hant/codes/ruby/chapter_stack_and_queue/array_stack.rb

@@ -0,0 +1,78 @@
+=begin
+File: array_stack.rb
+Created Time: 2024-04-06
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### 基於陣列實現的堆疊 ###
+class ArrayStack
+  ### 建構子 ###
+  def initialize
+    @stack = []
+  end
+
+  ### 獲取堆疊的長度 ###
+  def size
+    @stack.length
+  end
+
+  ### 判斷堆疊是否為空 ###
+  def is_empty?
+    @stack.empty?
+  end
+
+  ### 入堆疊 ###
+  def push(item)
+    @stack << item
+  end
+
+  ### 出堆疊 ###
+  def pop
+    raise IndexError, '堆疊為空' if is_empty?
+
+    @stack.pop
+  end
+
+  ### 訪問堆疊頂元素 ###
+  def peek
+    raise IndexError, '堆疊為空' if is_empty?
+
+    @stack.last
+  end
+
+  ### 返回串列用於列印 ###
+  def to_array
+    @stack
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化堆疊
+  stack = ArrayStack.new
+
+  # 元素入堆疊
+  stack.push(1)
+  stack.push(3)
+  stack.push(2)
+  stack.push(5)
+  stack.push(4)
+  puts "堆疊 stack = #{stack.to_array}"
+
+  # 訪問堆疊頂元素
+  peek = stack.peek
+  puts "堆疊頂元素 peek = #{peek}"
+
+  # 元素出堆疊
+  pop = stack.pop
+  puts "出堆疊元素 pop = #{pop}"
+  puts "出堆疊後 stack = #{stack.to_array}"
+
+  # 獲取堆疊的長度
+  size = stack.size
+  puts "堆疊的長度 size = #{size}"
+
+  # 判斷是否為空
+  is_empty = stack.is_empty?
+  puts "堆疊是否為空 = #{is_empty}"
+end

zh-hant/codes/ruby/chapter_stack_and_queue/deque.rb

@@ -0,0 +1,42 @@
+=begin
+File: deque.rb
+Created Time: 2024-04-06
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化雙向佇列
+  # Ruby 沒有內直的雙端佇列，只能把 Array 當作雙端佇列來使用
+  deque = []
+
+  # 元素如隊
+  deque << 2
+  deque << 5
+  deque << 4
+  # 請注意，由於是陣列，Array#unshift 方法的時間複雜度為 O(n)
+  deque.unshift(3)
+  deque.unshift(1)
+  puts "雙向佇列 deque = #{deque}"
+
+  # 訪問元素
+  peek_first = deque.first
+  puts "佇列首元素 peek_first = #{peek_first}"
+  peek_last = deque.last
+  puts "佇列尾元素 peek_last = #{peek_last}"
+
+  # 元素出列
+  # 請注意，由於是陣列， Array#shift 方法的時間複雜度為 O(n)
+  pop_front = deque.shift
+  puts "佇列首出列元素 pop_front = #{pop_front}，佇列首出列後 deque = #{deque}"
+  pop_back = deque.pop
+  puts "佇列尾出列元素 pop_back = #{pop_back}, 佇列尾出列後 deque = #{deque}"
+
+  # 獲取雙向佇列的長度
+  size = deque.length
+  puts "雙向佇列長度 size = #{size}"
+
+  # 判斷雙向佇列是否為空
+  is_empty = size.zero?
+  puts "雙向佇列是否為空 = #{is_empty}"
+end

zh-hant/codes/ruby/chapter_stack_and_queue/linkedlist_deque.rb

@@ -0,0 +1,168 @@
+=begin
+File: linkedlist_deque.rb
+Created Time: 2024-04-06
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### 雙向鏈結串列節點
+class ListNode
+  attr_accessor :val
+  attr_accessor :next # 後繼節點引用
+  attr_accessor :prev # 前軀節點引用
+
+  ### 建構子 ###
+  def initialize(val)
+    @val = val
+  end
+end
+
+### 基於雙向鏈結串列實現的雙向佇列 ###
+class LinkedListDeque
+  ### 獲取雙向佇列的長度 ###
+  attr_reader :size
+
+  ### 建構子 ###
+  def initialize
+    @front = nil  # 頭節點 front
+    @rear = nil   # 尾節點 rear
+    @size = 0     # 雙向佇列的長度
+  end
+
+  ### 判斷雙向佇列是否為空 ###
+  def is_empty?
+    size.zero?
+  end
+
+  ### 入列操作 ###
+  def push(num, is_front)
+    node = ListNode.new(num)
+    # 若鏈結串列為空， 則令 front 和 rear 都指向 node
+    if is_empty?
+      @front = @rear = node
+    # 佇列首入列操作
+    elsif is_front
+      # 將 node 新增至鏈結串列頭部
+      @front.prev = node
+      node.next = @front
+      @front = node # 更新頭節點
+    # 佇列尾入列操作
+    else
+      # 將 node 新增至鏈結串列尾部
+      @rear.next = node
+      node.prev = @rear
+      @rear = node # 更新尾節點
+    end
+    @size += 1 # 更新佇列長度
+  end
+
+  ### 佇列首入列 ###
+  def push_first(num)
+    push(num, true)
+  end
+
+  ### 佇列尾入列 ###
+  def push_last(num)
+    push(num, false)
+  end
+
+  ### 出列操作 ###
+  def pop(is_front)
+    raise IndexError, '雙向佇列為空' if is_empty?
+
+    # 佇列首出列操作
+    if is_front
+      val = @front.val # 暫存頭節點值
+      # 刪除頭節點
+      fnext = @front.next
+      unless fnext.nil?
+        fnext.prev = nil
+        @front.next = nil
+      end
+      @front = fnext # 更新頭節點
+    # 佇列尾出列操作
+    else
+      val = @rear.val # 暫存尾節點值
+      # 刪除尾節點
+      rprev = @rear.prev
+      unless rprev.nil?
+        rprev.next = nil
+        @rear.prev = nil
+      end
+      @rear = rprev # 更新尾節點
+    end
+    @size -= 1 # 更新佇列長度
+
+    val
+  end
+
+  ### 佇列首出列 ###
+  def pop_first
+    pop(true)
+  end
+
+  ### 佇列首出列 ###
+  def pop_last
+    pop(false)
+  end
+
+  ### 訪問佇列首元素 ###
+  def peek_first
+    raise IndexError, '雙向佇列為空' if is_empty?
+
+    @front.val
+  end
+
+  ### 訪問佇列尾元素 ###
+  def peek_last
+    raise IndexError, '雙向佇列為空' if is_empty?
+
+    @rear.val
+  end
+
+  ### 返回陣列用於列印 ###
+  def to_array
+    node = @front
+    res = Array.new(size, 0)
+    for i in 0...size
+      res[i] = node.val
+      node = node.next
+    end
+    res
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化雙向佇列
+  deque = LinkedListDeque.new
+  deque.push_last(3)
+  deque.push_last(2)
+  deque.push_last(5)
+  puts "雙向佇列 deque = #{deque.to_array}"
+
+  # 訪問元素
+  peek_first = deque.peek_first
+  puts "佇列首元素 peek_first = #{peek_first}"
+  peek_last = deque.peek_last
+  puts "佇列首元素 peek_last = #{peek_last}"
+
+  # 元素入列
+  deque.push_last(4)
+  puts "元素 4 佇列尾入列後 deque = #{deque.to_array}"
+  deque.push_first(1)
+  puts "元素 1 佇列首入列後 deque = #{deque.to_array}"
+
+  # 元素出列
+  pop_last = deque.pop_last
+  puts "佇列尾出列元素 = #{pop_last}, 佇列尾出列後 deque = #{deque.to_array}"
+  pop_first = deque.pop_first
+  puts "佇列首出列元素 = #{pop_first}，佇列首出列後 deque = #{deque.to_array}"
+
+  # 獲取雙向佇列的長度
+  size = deque.size
+  puts "雙向佇列長度 size = #{size}"
+
+  # 判斷雙向佇列是否為空
+  is_empty = deque.is_empty?
+  puts "雙向佇列是否為空 = #{is_empty}"
+end

zh-hant/codes/ruby/chapter_stack_and_queue/linkedlist_queue.rb

@@ -0,0 +1,101 @@
+=begin
+File: linkedlist_queue.rb
+Created Time: 2024-04-06
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+require_relative '../utils/list_node'
+
+### 基於鏈結串列頭現的佇列 ###
+class LinkedListQueue
+  ### 獲取佇列的長度 ###
+  attr_reader :size
+
+  ### 建構子 ###
+  def initialize
+    @front = nil  # 頭節點 front
+    @rear = nil   # 尾節點 rear
+    @size = 0
+  end
+
+  ### 判斷佇列是否為空 ###
+  def is_empty?
+    @front.nil?
+  end
+
+  ### 入列 ###
+  def push(num)
+    # 在尾節點後新增 num
+    node = ListNode.new(num)
+
+    # 如果佇列為空，則令頭，尾節點都指向該節點
+    if @front.nil?
+      @front = node
+      @rear = node
+    # 如果佇列不為空，則令該節點新增到尾節點後
+    else
+      @rear.next = node
+      @rear = node
+    end
+
+    @size += 1
+  end
+
+  ### 出列 ###
+  def pop
+    num = peek
+    # 刪除頭節點
+    @front = @front.next
+    @size -= 1
+    num
+  end
+
+  ### 訪問佇列首元素 ###
+  def peek
+    raise IndexError, '佇列為空' if is_empty?
+
+    @front.val
+  end
+
+  ### 將鏈結串列為 Array 並返回 ###
+  def to_array
+    queue = []
+    temp = @front
+    while temp
+      queue << temp.val
+      temp = temp.next
+    end
+    queue
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化佇列
+  queue = LinkedListQueue.new
+
+  # 元素如隊
+  queue.push(1)
+  queue.push(3)
+  queue.push(2)
+  queue.push(5)
+  queue.push(4)
+  puts "佇列 queue = #{queue.to_array}"
+
+  # 訪問佇列首元素
+  peek = queue.peek
+  puts "佇列首元素 front = #{peek}"
+
+  # 元素出列
+  pop_front = queue.pop
+  puts "出列元素 pop = #{pop_front}"
+  puts "出列後 queue = #{queue.to_array}"
+
+  # 獲取佇列的長度
+  size = queue.size
+  puts "佇列長度 size = #{size}"
+
+  # 判斷佇列是否為空
+  is_empty = queue.is_empty?
+  puts "佇列是否為空 = #{is_empty}"
+end

zh-hant/codes/ruby/chapter_stack_and_queue/linkedlist_stack.rb

@@ -0,0 +1,87 @@
+=begin
+File: linkedlist_stack.rb
+Created Time: 2024-04-06
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+require_relative '../utils/list_node'
+
+### 基於鏈結串列實現的堆疊 ###
+class LinkedListStack
+  attr_reader :size
+
+  ### 建構子 ###
+  def initialize
+    @size = 0
+  end
+
+  ### 判斷堆疊是否為空 ###
+  def is_empty?
+    @peek.nil?
+  end
+
+  ### 入堆疊 ###
+  def push(val)
+    node = ListNode.new(val)
+    node.next = @peek
+    @peek = node
+    @size += 1
+  end
+
+  ### 出堆疊 ###
+  def pop
+    num = peek
+    @peek = @peek.next
+    @size -= 1
+    num
+  end
+
+  ### 訪問堆疊頂元素 ###
+  def peek
+    raise IndexError, '堆疊為空' if is_empty?
+
+    @peek.val
+  end
+
+  ### 將鏈結串列轉化為 Array 並反回 ###
+  def to_array
+    arr = []
+    node = @peek
+    while node
+      arr << node.val
+      node = node.next
+    end
+    arr.reverse
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化堆疊
+  stack = LinkedListStack.new
+
+  # 元素入堆疊
+  stack.push(1)
+  stack.push(3)
+  stack.push(2)
+  stack.push(5)
+  stack.push(4)
+  puts "堆疊 stack = #{stack.to_array}"
+
+  # 訪問堆疊頂元素
+  peek = stack.peek
+  puts "堆疊頂元素 peek = #{peek}"
+
+  # 元素出堆疊
+  pop = stack.pop
+  puts "出堆疊元素 pop = #{pop}"
+  puts "出堆疊後 stack = #{stack.to_array}"
+
+  # 獲取堆疊的長度
+  size = stack.size
+  puts "堆疊的長度 size = #{size}"
+
+  # 判斷是否為空
+  is_empty = stack.is_empty?
+  puts "堆疊是否為空 = #{is_empty}"
+end

zh-hant/codes/ruby/chapter_stack_and_queue/queue.rb

@@ -0,0 +1,38 @@
+=begin
+File: queue.rb
+Created Time: 2024-04-06
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化佇列
+  # Ruby 內建的佇列（Thread::Queue) 沒有 peek 和走訪方法，可以把 Array 當作佇列來使用
+  queue = []
+
+  # 元素入列
+  queue.push(1)
+  queue.push(3)
+  queue.push(2)
+  queue.push(5)
+  queue.push(4)
+  puts "佇列 queue = #{queue}"
+
+  # 訪問佇列元素
+  peek = queue.first
+  puts "佇列首元素 peek = #{peek}"
+
+  # 元素出列
+  # 清注意，由於是陣列，Array#shift 方法時間複雜度為 O(n)
+  pop = queue.shift
+  puts "出列元素 pop = #{pop}"
+  puts "出列後 queue = #{queue}"
+
+  # 獲取佇列的長度
+  size = queue.length
+  puts "佇列長度 size = #{size}"
+
+  # 判斷佇列是否為空
+  is_empty = queue.empty?
+  puts "佇列是否為空 = #{is_empty}"
+end

zh-hant/codes/ruby/chapter_stack_and_queue/stack.rb

@@ -0,0 +1,37 @@
+=begin
+File: stack.rb
+Created Time: 2024-04-06
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 初始化堆疊
+  # Ruby 沒有內建的堆疊類別，可以把 Array 當作堆疊來使用
+  stack = []
+
+  # 元素入堆疊
+  stack << 1
+  stack << 3
+  stack << 2
+  stack << 5
+  stack << 4
+  puts "堆疊 stack = #{stack}"
+
+  # 訪問堆疊頂元素
+  peek = stack.last
+  puts "堆疊頂元素 peek = #{peek}"
+
+  # 元素出堆疊
+  pop = stack.pop
+  puts "出堆疊元素 pop = #{pop}"
+  puts "出堆疊後 stack = #{stack}"
+
+  # 獲取堆疊的長度
+  size = stack.length
+  puts "堆疊的長度 size = #{size}"
+
+  # 判斷是否為空
+  is_empty = stack.empty?
+  puts "堆疊是否為空 = #{is_empty}"
+end

zh-hant/codes/ruby/test_all.rb

@@ -0,0 +1,23 @@
+require 'open3'
+
+start_time = Time.now
+ruby_code_dir = File.dirname(__FILE__)
+files = Dir.glob("#{ruby_code_dir}/chapter_*/*.rb")
+
+errors = []
+
+files.each do |file|
+  stdout, stderr, status = Open3.capture3("ruby #{file}")
+  errors << stderr unless status.success?
+end
+
+puts "\x1b[34mTested #{files.count} files\x1b[m"
+
+unless errors.empty?
+  puts "\x1b[33mFound exception in #{errors.length} files\x1b[m"
+  raise errors.join("\n\n")
+else
+  puts "\x1b[32mPASS\x1b[m"
+end
+
+puts "Testing finishes after #{((Time.now - start_time) * 1000).round} ms"