Re-translate the Japanese version (#1871)

* Retranslate Japanese docs with GPT-5.4

* Retranslate Japanese code with GPT-5.4

ja/codes/ruby/chapter_sorting/bubble_sort.rb

@@ -0,0 +1,51 @@
+=begin
+File: bubble_sort.rb
+Created Time: 2024-05-02
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### バブルソート ###
+def bubble_sort(nums)
+  n = nums.length
+  # 外側のループ：未ソート区間は [0, i]
+  for i in (n - 1).downto(1)
+    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
+    for j in 0...i
+      if nums[j] > nums[j + 1]
+        # nums[j] と nums[j + 1] を交換
+        nums[j], nums[j + 1] = nums[j + 1], nums[j]
+      end
+    end
+  end
+end
+
+# ## バブルソート（フラグ最適化）###
+def bubble_sort_with_flag(nums)
+  n = nums.length
+  # 外側のループ：未ソート区間は [0, i]
+  for i in (n - 1).downto(1)
+    flag = false # フラグを初期化する
+
+    # 内側のループ：未ソート区間 [0, i] の最大要素をその区間の最右端へ交換
+    for j in 0...i
+      if nums[j] > nums[j + 1]
+        # nums[j] と nums[j + 1] を交換
+        nums[j], nums[j + 1] = nums[j + 1], nums[j]
+        flag = true # 交換する要素を記録
+      end
+    end
+
+    break unless flag # このバブル処理で要素交換が一度もなければそのまま終了
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [4, 1, 3, 1, 5, 2]
+  bubble_sort(nums)
+  puts "バブルソート完了後 nums = #{nums}"
+
+  nums1 = [4, 1, 3, 1, 5, 2]
+  bubble_sort_with_flag(nums1)
+  puts "バブルソート完了後 nums = #{nums1}"
+end

ja/codes/ruby/chapter_sorting/bucket_sort.rb

@@ -0,0 +1,43 @@
+=begin
+File: bucket_sort.rb
+Created Time: 2024-04-17
+Author: Martin Xu (martin.xus@gmail.com)
+=end
+
+### バケットソート ###
+def bucket_sort(nums)
+  # k = n/2 個のバケットを初期化し、各バケットに 2 要素ずつ割り当てる想定とする
+  k = nums.length / 2
+  buckets = Array.new(k) { [] }
+  
+  # 1. 配列要素を各バケットに振り分ける
+  nums.each do |num|
+    # 入力データの範囲は [0, 1) であり、num * k を用いてインデックス範囲 [0, k-1] に写像する
+    i = (num * k).to_i
+    # num をバケット i に追加
+    buckets[i] << num
+  end
+
+  # 2. 各バケットをソートする
+  buckets.each do |bucket|
+    # 組み込みのソート関数を使う。他のソートアルゴリズムに置き換えてもよい
+    bucket.sort!
+  end
+
+  # 3. バケットを走査して結果を結合
+  i = 0
+  buckets.each do |bucket|
+    bucket.each do |num|
+      nums[i] = num
+      i += 1
+    end
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 入力データは範囲 [0, 1) の浮動小数点数とする
+  nums = [0.49, 0.96, 0.82, 0.09, 0.57, 0.43, 0.91, 0.75, 0.15, 0.37]
+  bucket_sort(nums)
+  puts "バケットソート完了後 nums = #{nums}"
+end

ja/codes/ruby/chapter_sorting/counting_sort.rb

@@ -0,0 +1,62 @@
+=begin
+File: counting_sort.rb
+Created Time: 2024-05-02
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### 計数ソート ###
+def counting_sort_naive(nums)
+  # 簡易版。オブジェクトのソートには使えない
+  # 1. 配列の最大要素 m を求める
+  m = 0
+  nums.each { |num| m = [m, num].max }
+  # 2. 各数値の出現回数を数える
+  # counter[num] は num の出現回数を表す
+  counter = Array.new(m + 1, 0)
+  nums.each { |num| counter[num] += 1 }
+  # 3. counter を走査し、各要素を元の配列 nums に書き戻す
+  i = 0
+  for num in 0...(m + 1)
+    (0...counter[num]).each do
+      nums[i] = num
+      i += 1
+    end
+  end
+end
+
+### 計数ソート ###
+def counting_sort(nums)
+  # 完全版。オブジェクトをソートでき、かつ安定ソートである
+  # 1. 配列の最大要素 m を求める
+  m = nums.max
+  # 2. 各数値の出現回数を数える
+  # counter[num] は num の出現回数を表す
+  counter = Array.new(m + 1, 0)
+  nums.each { |num| counter[num] += 1 }
+  # 3. counter の累積和を求めて、「出現回数」を「末尾インデックス」に変換する
+  # つまり counter[num]-1 は、num が res に最後に現れるインデックス
+  (0...m).each { |i| counter[i + 1] += counter[i] }
+  # 4. nums を逆順に走査し、各要素を結果配列 res に格納する
+  # 結果を記録するための配列 res を初期化する
+  n = nums.length
+  res = Array.new(n, 0)
+  (n - 1).downto(0).each do |i|
+    num = nums[i]
+    res[counter[num] - 1] = num # num を対応するインデックスに配置
+    counter[num] -= 1 # 累積和を 1 減らして、次に num を配置するインデックスを得る
+  end
+  # 結果配列 res で元の配列 nums を上書きする
+  (0...n).each { |i| nums[i] = res[i] }
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
+
+  counting_sort_naive(nums)
+  puts "カウントソート（オブジェクトをソートできない）完了後 nums = #{nums}"
+
+  nums1 = [1, 0, 1, 2, 0, 4, 0, 2, 2, 4]
+  counting_sort(nums1)
+  puts "カウントソート完了後 nums1 = #{nums1}"
+end

ja/codes/ruby/chapter_sorting/heap_sort.rb

@@ -0,0 +1,45 @@
+=begin
+File: heap_sort.rb
+Created Time: 2024-04-10
+Author: junminhong (junminhong1110@gmail.com)
+=end
+
+### ヒープ長 n で、ノード i から上から下へヒープ化 ###
+def sift_down(nums, n, i)
+  while true
+    # ノード i, l, r のうち値が最大のノードを ma とする
+    l = 2 * i + 1
+    r = 2 * i + 2
+    ma = i
+    ma = l if l < n && nums[l] > nums[ma]
+    ma = r if r < n && nums[r] > nums[ma]
+    # ノード i が最大、またはインデックス l, r が範囲外なら、ヒープ化は不要なので抜ける
+    break if ma == i
+    # 2 つのノードを交換
+    nums[i], nums[ma] = nums[ma], nums[i]
+    # ループで上から下へヒープ化
+    i = ma
+  end
+end
+
+### ヒープソート ###
+def heap_sort(nums)
+  # ヒープ構築：葉ノード以外のすべてのノードをヒープ化する
+  (nums.length / 2 - 1).downto(0) do |i|
+    sift_down(nums, nums.length, i)
+  end
+  # ヒープから最大要素を取り出し、n-1 回繰り返す
+  (nums.length - 1).downto(1) do |i|
+    # 根ノードと最も右の葉ノードを交換（先頭要素と末尾要素を交換）
+    nums[0], nums[i] = nums[i], nums[0]
+    # 根ノードを起点に、上から下へヒープ化
+    sift_down(nums, i, 0)
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [4, 1, 3, 1, 5, 2]
+  heap_sort(nums)
+  puts "ヒープソート完了後 nums = #{nums.inspect}"
+end

ja/codes/ruby/chapter_sorting/insertion_sort.rb

@@ -0,0 +1,26 @@
+=begin
+File: insertion_sort.rb
+Created Time: 2024-04-02
+Author: Cy (3739004@gmail.com), Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### 挿入ソート ###
+def insertion_sort(nums)
+  n = nums.length
+  # 外側ループ：整列済み区間は [0, i-1]
+  for i in 1...n
+    base = nums[i]
+    j = i - 1
+    # 内側ループ: base をソート済み区間 [0, i-1] の正しい位置に挿入する
+    while j >= 0 && nums[j] > base
+      nums[j + 1] = nums[j] # nums[j] を 1 つ右へ移動する
+      j -= 1
+    end
+    nums[j + 1] = base # base を正しい位置に配置する
+  end
+end
+
+### Driver Code ###
+nums = [4, 1, 3, 1, 5, 2]
+insertion_sort(nums)
+puts "挿入ソート完了後 nums = #{nums}"

ja/codes/ruby/chapter_sorting/merge_sort.rb

@@ -0,0 +1,60 @@
+=begin
+File: merge_sort.rb
+Created Time: 2024-04-10
+Author: junminhong (junminhong1110@gmail.com)
+=end
+
+### 左部分配列と右部分配列をマージ ###
+def merge(nums, left, mid, right)
+  # 左部分配列の区間は [left, mid]、右部分配列の区間は [mid+1, right]
+  # マージ結果を格納する一時配列 tmp を作成
+  tmp = Array.new(right - left + 1, 0)
+  # 左右の部分配列の開始インデックスを初期化する
+  i, j, k = left, mid + 1, 0
+  # 左右の部分配列にまだ要素がある間は比較し、小さいほうを一時配列にコピーする
+  while i <= mid && j <= right
+    if nums[i] <= nums[j]
+      tmp[k] = nums[i]
+      i += 1
+    else
+      tmp[k] = nums[j]
+      j += 1
+    end
+    k += 1
+  end
+  # 左右の部分配列の残り要素を一時配列にコピーする
+  while i <= mid
+    tmp[k] = nums[i]
+    i += 1
+    k += 1
+  end
+  while j <= right
+    tmp[k] = nums[j]
+    j += 1
+    k += 1
+  end
+  # 一時配列 tmp の要素を元の配列 nums の対応区間にコピーする
+  (0...tmp.length).each do |k|
+    nums[left + k] = tmp[k]
+  end
+end
+
+### マージソート ###
+def merge_sort(nums, left, right)
+  # 終了条件
+  # 部分配列の長さが 1 になったら再帰を終了する
+  return if left >= right
+  # 分割フェーズ
+  mid = left + (right - left) / 2 # 中点を計算
+  merge_sort(nums, left, mid) # 左部分配列を再帰処理
+  merge_sort(nums, mid + 1, right) # 右部分配列を再帰処理
+  # マージフェーズ
+  merge(nums, left, mid, right)
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [7, 3, 2, 6, 0, 1, 5, 4]
+  merge_sort(nums, 0, nums.length - 1)
+  puts "マージソート完了後 nums = #{nums.inspect}"
+end

ja/codes/ruby/chapter_sorting/quick_sort.rb

@@ -0,0 +1,153 @@
+=begin
+File: quick_sort.rb
+Created Time: 2024-04-01
+Author: Cy (3739004@gmail.com), Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### クイックソートクラス ###
+class QuickSort
+  class << self
+    ### 番兵分割 ###
+    def partition(nums, left, right)
+      # nums[left] を基準値とする
+      i, j = left, right
+      while i < j
+        while i < j && nums[j] >= nums[left]
+          j -= 1 # 右から左へ基準値未満の最初の要素を探す
+        end
+        while i < j && nums[i] <= nums[left]
+          i += 1 # 左から右へ基準値より大きい最初の要素を探す
+        end
+        # 要素の交換
+        nums[i], nums[j] = nums[j], nums[i]
+      end
+      # 基準値を 2 つの部分配列の境界へ交換する
+      nums[i], nums[left] = nums[left], nums[i]
+      i # 基準値のインデックスを返す
+    end
+
+    ### クイックソートクラス ###
+    def quick_sort(nums, left, right)
+      # 部分配列の長さが 1 でない場合は再帰する
+      if left < right
+        # 番兵分割
+        pivot = partition(nums, left, right)
+        # 左右の部分配列を再帰処理
+        quick_sort(nums, left, pivot - 1)
+        quick_sort(nums, pivot + 1, right)
+      end
+      nums
+    end
+  end
+end
+
+# ## クイックソートクラス（中央値最適化）###
+class QuickSortMedian
+  class << self
+    ### 3 つの候補要素の中央値を選ぶ ###
+    def median_three(nums, left, mid, right)
+      # 3つの候補要素の中央値を選ぶ
+      _l, _m, _r = nums[left], nums[mid], nums[right]
+      # m は l と r の間
+      return mid if (_l <= _m && _m <= _r) || (_r <= _m && _m <= _l)
+      # l は m と r の間
+      return left if (_m <= _l && _l <= _r) || (_r <= _l && _l <= _m)
+      return right
+    end
+
+    # ## 番兵分割（三数中央値）###
+    def partition(nums, left, right)
+      # ## nums[left] を基準値とする
+      med = median_three(nums, left, (left + right) / 2, right)
+      # 中央値を配列の最左端に交換する
+      nums[left], nums[med] = nums[med], nums[left]
+      i, j = left, right
+      while i < j
+        while i < j && nums[j] >= nums[left]
+          j -= 1 # 右から左へ基準値未満の最初の要素を探す
+        end
+        while i < j && nums[i] <= nums[left]
+          i += 1 # 左から右へ基準値より大きい最初の要素を探す
+        end
+        # 要素の交換
+        nums[i], nums[j] = nums[j], nums[i]
+      end
+      # 基準値を 2 つの部分配列の境界へ交換する
+      nums[i], nums[left] = nums[left], nums[i]
+      i # 基準値のインデックスを返す
+    end
+
+    ### クイックソート ###
+    def quick_sort(nums, left, right)
+      # 部分配列の長さが 1 でない場合は再帰する
+      if left < right
+        # 番兵分割
+        pivot = partition(nums, left, right)
+        # 左右の部分配列を再帰処理
+        quick_sort(nums, left, pivot - 1)
+        quick_sort(nums, pivot + 1, right)
+      end
+      nums
+    end
+  end
+end
+
+# ## クイックソートクラス（再帰深度最適化）###
+class QuickSortTailCall
+  class << self
+    ### 番兵分割 ###
+    def partition(nums, left, right)
+      # nums[left] を基準値とする
+      i = left
+      j = right
+      while i < j
+        while i < j && nums[j] >= nums[left]
+          j -= 1 # 右から左へ基準値未満の最初の要素を探す
+        end
+        while i < j && nums[i] <= nums[left]
+          i += 1 # 左から右へ基準値より大きい最初の要素を探す
+        end
+        # 要素の交換
+        nums[i], nums[j] = nums[j], nums[i]
+      end
+      # 基準値を 2 つの部分配列の境界へ交換する
+      nums[i], nums[left] = nums[left], nums[i]
+      i # 基準値のインデックスを返す
+    end
+
+    # ## クイックソート（再帰深度最適化）###
+    def quick_sort(nums, left, right)
+      # 部分配列の長さが 1 でない場合は再帰する
+      while left < right
+        # 番兵分割
+        pivot = partition(nums, left, right)
+        # 2 つの部分配列のうち短いほうにクイックソートを適用する
+        if pivot - left < right - pivot
+          quick_sort(nums, left, pivot - 1)
+          left = pivot + 1 # 未ソート区間の残りは [pivot + 1, right]
+        else
+          quick_sort(nums, pivot + 1, right)
+          right = pivot - 1 # 未ソート区間の残りは [left, pivot - 1]
+        end
+      end
+    end
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # クイックソート
+  nums = [2, 4, 1, 0, 3, 5]
+  QuickSort.quick_sort(nums, 0, nums.length - 1)
+  puts "クイックソート完了後 nums = #{nums}"
+
+  # クイックソート（中央値の基準値で最適化）
+  nums1 = [2, 4, 1, 0, 3, 5]
+  QuickSortMedian.quick_sort(nums1, 0, nums1.length - 1)
+  puts "クイックソート（中央値ピボット最適化）完了後 nums1 = #{nums1}"
+
+  # クイックソート（再帰深度最適化）
+  nums2 = [2, 4, 1, 0, 3, 5]
+  QuickSortTailCall.quick_sort(nums2, 0, nums2.length - 1)
+  puts "クイックソート（再帰深度最適化）完了後 nums2 = #{nums2}"
+end

ja/codes/ruby/chapter_sorting/radix_sort.rb

@@ -0,0 +1,70 @@
+=begin
+File: radix_sort.rb
+Created Time: 2024-05-03
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### num の第 k 桁を取得する。ここで exp = 10^(k-1) ###
+def digit(num, exp)
+  # k ではなく exp を渡すことで、ここで高コストな累乗計算を繰り返し実行するのを避けられる
+  (num / exp) % 10
+end
+
+# ## 計数ソート（nums の k 桁目でソート）###
+def counting_sort_digit(nums, exp)
+  # 10 進数の各桁は 0~9 の範囲なので、長さ 10 のバケット配列が必要
+  counter = Array.new(10, 0)
+  n = nums.length
+  # 0~9 の各数字の出現回数を集計する
+  for i in 0...n
+    d = digit(nums[i], exp) # nums[i] の第 k 位を取得し、d とする
+    counter[d] += 1 # 数字 d の出現回数を数える
+  end
+  # 累積和を求め、「出現回数」を「配列インデックス」に変換する
+  (1...10).each { |i| counter[i] += counter[i - 1] }
+  # 逆順に走査し、バケット内の集計結果に従って各要素を res に格納する
+  res = Array.new(n, 0)
+  for i in (n - 1).downto(0)
+    d = digit(nums[i], exp)
+    j = counter[d] - 1 # d の配列内インデックス j を取得する
+    res[j] = nums[i] # 現在の要素をインデックス j に格納する
+    counter[d] -= 1 # d の個数を 1 減らす
+  end
+  # 結果で元の配列 nums を上書きする
+  (0...n).each { |i| nums[i] = res[i] }
+end
+
+### 基数ソート ###
+def radix_sort(nums)
+  # 最大桁数の判定用に配列の最大要素を取得
+  m = nums.max
+  # 下位桁から上位桁の順に走査する
+  exp = 1
+  while exp <= m
+    # 配列要素の k 桁目に対して計数ソートを行う
+    # k = 1 -> exp = 1
+    # k = 2 -> exp = 10
+    # つまり exp = 10^(k-1)
+    counting_sort_digit(nums, exp)
+    exp *= 10
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  # 基数ソート
+  nums = [
+    10546151,
+    35663510,
+    42865989,
+    34862445,
+    81883077,
+    88906420,
+    72429244,
+    30524779,
+    82060337,
+    63832996,
+  ]
+  radix_sort(nums)
+  puts "基数ソート完了後 nums = #{nums}"
+end

ja/codes/ruby/chapter_sorting/selection_sort.rb

@@ -0,0 +1,29 @@
+=begin
+File: selection_sort.rb
+Created Time: 2024-05-03
+Author: Xuan Khoa Tu Nguyen (ngxktuzkai2000@gmail.com)
+=end
+
+### 選択ソート ###
+def selection_sort(nums)
+  n = nums.length
+  # 外側ループ：未整列区間は [i, n-1]
+  for i in 0...(n - 1)
+    # 内側のループ：未ソート区間の最小要素を見つける
+    k = i
+    for j in (i + 1)...n
+      if nums[j] < nums[k]
+        k = j # 最小要素のインデックスを記録
+      end
+    end
+    # その最小要素を未整列区間の先頭要素と交換する
+    nums[i], nums[k] = nums[k], nums[i]
+  end
+end
+
+### Driver Code ###
+if __FILE__ == $0
+  nums = [4, 1, 3, 1, 5, 2]
+  selection_sort(nums)
+  puts "選択ソート完了後 nums = #{nums}"
+end