如何交织不同长度的阵列，红宝石

Question

如果我想交错的一组中的Ruby阵列，每个阵列是相同的长度，我们可以这样做的：

a.zip(b).zip(c).flatten 

然而，我们如何解决这个问题，如果阵列可以是不同的大小？

我们可以这样做：

def interleave(*args) 
    raise 'No arrays to interleave' if args.empty? 
    max_length = args.inject(0) { |length, elem| length = [length, elem.length].max } 
    output = Array.new 
    for i in 0...max_length 
    args.each { |elem| 
     output << elem[i] if i < elem.length 
    } 
    end 
    return output 
end 

但有一个更好的“红宝石”的方式，可能使用zip或调换或一些这样？

Answer 1

如果源数组没有在他们nil，你只需要第一阵列nil S，拉链会自动垫的其他扩展与nil。这也意味着你使用compact清洁额外的条目出这是希望比显式循环

def interleave(a,*args) 
    max_length = args.map(&:size).max 
    padding = [nil]*[max_length-a.size, 0].max 
    (a+padding).zip(*args).flatten.compact 
end 

下面是如果阵列做的工作稍微复杂一点的版本包含nil

def interleave(*args) 
    max_length = args.map(&:size).max 
    pad = Object.new() 
    args = args.map{|a| a.dup.fill(pad,(a.size...max_length))} 
    ([pad]*max_length).zip(*args).flatten-[pad] 
end 

更有效

Answer 2

您的实施对我来说看起来不错。你可能实现这个使用#zip通过填充一些垃圾值的数组，压缩他们，然后展平和删除垃圾。但是这太令人费解的国际海事组织。你在这里干净，自我解释，只需要被磨光。

编辑：修正了booboo。

def interleave(*args) 
    raise 'No arrays to interleave' if args.empty? 
    max_length = args.map(&:size).max 
    output = [] 
    max_length.times do |i| 
    args.each do |elem| 
     output << elem[i] if i < elem.length 
    end 
    end 
    output 
end 

a = [*1..5] 
# => [1, 2, 3, 4, 5] 
b = [*6..15] 
# => [6, 7, 8, 9, 10, 11, 12, 13, 14, 15] 
c = [*16..18] 
# => [16, 17, 18] 

interleave(a,b,c) 
# => [1, 6, 16, 2, 7, 17, 3, 8, 18, 4, 9, 5, 10, 11, 12, 13, 14, 15] 

编辑：为了好玩

def interleave(*args) 
    raise 'No arrays to interleave' if args.empty? 
    max_length = args.map(&:size).max 
    # assumes no values coming in will contain nil. using dup because fill mutates 
    args.map{|e| e.dup.fill(nil, e.size...max_length)}.inject(:zip).flatten.compact 
end 

interleave(a,b,c) 
# => [1, 6, 16, 2, 7, 17, 3, 8, 18, 4, 9, 5, 10, 11, 12, 13, 14, 15] 

Answer 3

这是一个更简单的方法。这需要你通过阵列zip订单的优势：

def interleave(a, b) 
    if a.length >= b.length 
    a.zip(b) 
    else 
    b.zip(a).map(&:reverse) 
    end.flatten.compact 
end 

interleave([21, 22], [31, 32, 33]) 
# => [21, 31, 22, 32, 33] 

interleave([31, 32, 33], [21, 22]) 
# => [31, 21, 32, 22, 33] 

interleave([], [21, 22]) 
# => [21, 22] 

interleave([], []) 
# => [] 

被警告：这将删除所有nil的：

interleave([11], [41, 42, 43, 44, nil]) 
# => [11, 41, 42, 43, 44]