Слияние и чередование двух массивов в Ruby

У меня такой код:

a = ["Cat", "Dog", "Mouse"]
s = ["and", "&"]

Я хочу объединить массив sв массив, aкоторый даст мне:

["Cat", "and", "Dog", "&", "Mouse"]

Просматривая документы Ruby Array и Enumerable, я не вижу такого метода, который позволил бы это сделать.

Есть ли способ сделать это без перебора каждого массива?

Вы можете сделать это с помощью:

a.zip(s).flatten.compact

Это не даст результирующий массив в том порядке, который запрашивал Крис, но если порядок результирующего массива не имеет значения, вы можете просто использовать a |= b. Если вы не хотите мутировать a, вы можете записать a | bи присвоить результат переменной.

См. Документацию по объединению набора для класса Array по адресу http://www.ruby-doc.org/core/classes/Array.html#M000275 .

Этот ответ предполагает, что вам не нужны повторяющиеся элементы массива. Если вы хотите разрешить дублирование элементов в окончательном массиве, это a += bдолжно помочь. Опять же, если вы не хотите изменять a, используйте a + bи присвойте результат переменной.

В ответ на некоторые комментарии на этой странице, эти два решения будут работать с массивами любого размера.

Если вы не хотите дублировать, почему бы просто не использовать оператор объединения :

new_array = a | s

s.inject(a, :<<)

s   #=> ["and", "&"]
a   #=> ["Cat", "Dog", "Mouse", "and", "&"]

Он не дает вам того порядка, который вы просили, но это хороший способ объединения двух массивов путем добавления к одному.

Вот решение, которое позволяет чередовать несколько массивов разного размера (общее решение):

arr = [["Cat", "Dog", "Mouse", "boo", "zoo"],
 ["and", "&"],
 ["hello", "there", "you"]]

first, *rest = *arr; first.zip(*rest).flatten.compact
=> ["Cat", "and", "hello", "Dog", "&", "there", "Mouse", "you", "boo", "zoo"]

Это не совсем элегантно, но работает для массивов любого размера:

>> a.map.with_index { |x, i| [x, i == a.size - 2 ? s.last : s.first] }.flatten[0..-2] 
#=> ["Cat", "and", "Dog", "&", "Mouse"]

Как насчет более общего решения, которое работает, даже если первый массив не самый длинный и принимает любое количество массивов?

a = [
    ["and", "&"],
    ["Cat", "Dog", "Mouse"]
]

b = a.max_by(&:length)
a -= [b]
b.zip(*a).flatten.compact

 => ["Cat", "and", "Dog", "&", "Mouse"]

Чтобы справиться с ситуацией, когда оба a& sимеют разные размеры:

a.zip(s).flatten.compact | s

• .compactудалит, nilкогда aбольше чемs
• | sдобавит оставшиеся элементы, sкогда aменьше чемs

Один из способов сделать чередование, а также гарантировать, какой из них является самым большим массивом для метода zip, - это заполнить один из массивов nilдо тех пор, пока не будет размер другого массива. Таким образом, вы также гарантируете, какой элемент какого массива будет на первой позиции:

preferred_arr = ["Cat", "Dog", "Mouse"]
other_arr = ["and","&","are","great","friends"]

preferred_arr << nil while preferred_arr.length < other_arr.length
preferred_arr.zip(other_arr).flatten.compact
#=> ["Cat", "and", "Dog", "&", "Mouse", "are", "great", "friends"]

arr = [0, 1]
arr + [2, 3, 4]

//outputs [0, 1, 2, 3, 4]