Flatten Hash with Values of Arrays By Order of Index in Ruby

I suggest:

def extract_values_ordered_by_index(hash)
  Array.new(hash.values.map(&:length).max) do |i| 
    hash.values.map { |array| array[i] } 
  end.flatten.compact
end

hash = {a: [1, 2, 3], b: [4, 5], c: [6, 7, 8, 9]}
extract_values_ordered_by_index(hash)
#=> [1, 4, 6, 2, 5, 7, 3, 8, 9]

hash = {i: ['A'], ii: ['B', 'C', 'D'], iii: ['E'], iv: ['F', 'G']}
extract_values_ordered_by_index(hash)
#=> ["A", "B", "E", "F", "C", "G", "D"]

Another option is:

Array.new(hash.values.map(&:length).max)
     .zip(*hash.values).flatten.compact

def extract_values_ordered_by_index(hash)
  vals = hash.values.map(&:dup)
  finish = [[]] * vals.size
  loop.with_object([]) do |_,a|
    break a if vals == finish
    vals.each { |v| a << v.shift unless v.empty? }
  end
end

doit({ a: [1, 2, 3], b: [4, 5], c: [6, 7, 8, 9], d:[] })
  #=> [1, 4, 6, 2, 5, 7, 3, 8, 9]

doit({i: ['A'], ii: ['B', 'C', 'D'], iii: ['E'], iv: ['F', 'G']})
  #=> ["A", "B", "E", "F", "C", "G", "D"]

I first extract the hash's values to an array vals, removing any empty arrays in the process.

I then build an array a until vals is empty, at which time I break the loop, returning a.

At each iteration I shift the first element of each element of vals (an array, guaranteed to be non-empty) and append the shifted element of a, then remove all (now-empty) elements (arrays) of vals.

I do it this way in part to avoid using Array#compact, which I regard as an ugly--though admittedly useful--method.

If, however, compact is to be used, one could write

def extract_values_ordered_by_index(hash)
  vals = hash.values
  vals.map { |a| Array.new(vals.max_by(&:size).size) { |i| a[i] } }
      .transpose
      .flatten
      .compact
end

Here's one way:

arr = {a: [1, 2, 3], b: [4, 5], c: [6, 7, 8, 9]}
arr.values.
    map{|ar| ar+Array.new(100)}.  # pad with nils
    inject{|a,ar| a.zip(ar)}.
    flatten.
    compact #=> [1, 4, 6, 2, 5, 7, 3, 8, 9]

it's pretty ugly though! In order to avoid the discarding of the elements of long arrays, pad them all with a lot of nils, and then discard the nils at the end with compact. You have to choose a padding length (I chose 100) that's "long enough" that elements are not discarded in the zip.

Here's Other:

arr = {a: [1, 2, 3], b: [4, 5], c: [6, 7, 8, 9]}

arr.values.reduce(:+)

# => [1,2,3,4,5,6,7,8,9]