blocks|key|574127|text|您可以使用以下命令来完成此操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|574128|a.zip(s).flatten.compact|code-block|syntax|javascript|574129|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You can do that with:

<pre><code>a.zip(s).flatten.compact
</code></pre>

blocks|key|574253|text|这不会按照Chris要求的顺序给出结果数组，但是如果结果数组的顺序无关紧要，您可以只使用a+%7C=+b。如果不想改变a，可以编写a+%7C+b并将结果赋给一个变量。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|574254|请参阅http://www.ruby-doc.org/core/classes/Array.html#M000275上的数组类的set+union文档。|574255|这个答案假设你不想要重复的数组元素。如果你想在你的最终数组中允许重复的元素，a+%2B=+b应该做到这一点。同样，如果您不想改变a，请使用a+%2B+b并将结果赋给一个变量。|574256|为了回应本页上的一些评论，这两个解决方案将适用于任何大小的数组。|574257|entityMap|0|LINK|mutability|MUTABLE|url|http://www.ruby-doc.org/core/classes/Array.html#M000275^0|18|6|1L|1|1R|5|0|3|1J|0|0|12|6|1Q|1|1V|5|0|0^^$0|@$1|2|3|4|5|6|7|T|8|@$9|U|A|V|B|C]|$9|W|A|X|B|C]|$9|Y|A|Z|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|H|3|I|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]|$9|19|A|1A|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|1B|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|M|$N|$5|O|P|Q|E|$R|S]]]]

This won't give a result array in the order Chris asked for, but if the order of the resulting array doesn't matter, you can just use <code>a |= b</code>. If you don't want to mutate <code>a</code>, you can write <code>a | b</code> and assign the result to a variable.

See the set union documentation for the Array class at <a href="http://www.ruby-doc.org/core/classes/Array.html#M000275" rel="noreferrer">http://www.ruby-doc.org/core/classes/Array.html#M000275</a>.

This answer assumes that you don't want duplicate array elements. If you want to allow duplicate elements in your final array, <code>a += b</code> should do the trick. Again, if you don't want to mutate <code>a</code>, use <code>a + b</code> and assign the result to a variable.

In response to some of the comments on this page, these two solutions will work with arrays of any size.

blocks|key|574465|text|如果不想重复，为什么不直接使用union运算符：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|574466|new_array+=+a+%7C+s|code-block|syntax|javascript|574467|entityMap|0|LINK|mutability|MUTABLE|url|http://ruby-doc.org/core-2.1.5/Array.html#method-i-7C^0|F|5|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

If you don't want duplicate, why not just use the <a href="http://ruby-doc.org/core-2.1.5/Array.html#method-i-7C" rel="noreferrer">union</a> operator :

<pre><code>new_array = a | s
</code></pre>

blocks|key|574315|text|s.inject(a,+:<<)

s+++#=>+["and",+"&"]
a+++#=>+["Cat",+"Dog",+"Mouse",+"and",+"&"]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|574316|它没有给出你想要的顺序，但它是一种很好的合并两个数组的方法，通过附加到一个数组。|unstyled|574317|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>s.inject(a, :&lt;&lt;)

s #=&gt; ["and", "&amp;"]
a #=&gt; ["Cat", "Dog", "Mouse", "and", "&amp;"]
</code></pre>

It doesn't give you the order you asked for, but it's a nice way of merging two arrays by appending to the one.

blocks|key|790546|text|以下是一个允许交错多个不同大小的数组的解决方案(一般解决方案)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|790547|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"]|code-block|syntax|javascript|790548|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Here's a solution that allows interleaving multiple arrays of different sizes (general solution):

<pre><code>arr = [["Cat", "Dog", "Mouse", "boo", "zoo"],
 ["and", "&amp;"],
 ["hello", "there", "you"]]

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

blocks|key|574118|text|它不是很优雅，但它适用于任何大小的数组：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|574119|>>+a.map.with_index+{+%7Cx,+i%7C+[x,+i+==+a.size+-+2+?+s.last+:+s.first]+}.flatten[0..-2]+
#=>+["Cat",+"and",+"Dog",+"&",+"Mouse"]|code-block|syntax|javascript|574120|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

It's not exactly elegant, but it works for arrays of any size:

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

blocks|key|790607|text|一个更通用的解决方案如何，即使第一个数组不是最长的，并且可以接受任意数量的数组？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|790608|a+=+[
++++["and",+"&"],
++++["Cat",+"Dog",+"Mouse"]
]

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

+=>+["Cat",+"and",+"Dog",+"&",+"Mouse"]|code-block|syntax|javascript|790609|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

How about a more general solution that works even if the first array isn't the longest and accepts any number of arrays? 

<pre><code>a = [
 ["and", "&amp;"],
 ["Cat", "Dog", "Mouse"]
]

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

 =&gt; ["Cat", "and", "Dog", "&amp;", "Mouse"]
</code></pre>

blocks|key|574533|text|一种进行交错并保证哪个数组是zip方法的最大数组的方法是用nil填充其中一个数组，直到另一个数组大小。这样，您还可以保证哪个数组的哪个元素将位于第一个位置：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|574534|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"]|code-block|syntax|javascript|574535|entityMap^0|T|3|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

One way to do the interleave and also guarantee which one is the biggest array for the zip method, is to fill up one of the arrays with <code>nil</code> until the other array size. This way, you also guarantee which element of which array will be on first position:

<pre><code>preferred_arr = ["Cat", "Dog", "Mouse"]
other_arr = ["and","&amp;","are","great","friends"]

preferred_arr &lt;&lt; nil while preferred_arr.length &lt; other_arr.length
preferred_arr.zip(other_arr).flatten.compact
#=&gt; ["Cat", "and", "Dog", "&amp;", "Mouse", "are", "great", "friends"]
</code></pre>

blocks|key|790704|text|交错任意大小的二维数组|type|unstyled|depth|inlineStyleRanges|entityRanges|data|790705|arr+=+[["Cat",+"Dog",+"Mouse"],
+["and",+"&"],
+["hello",+"there",+"you",+"boo",+"zoo"]]

max_count+=+arr.map(&:count).max
max_count.times.map{%7Ci%7C+arr.map{%7Ca%7C+a[i]}}.flatten.compact

#=>+["Cat",+"and",+"hello",+"Dog",+"&",+"there",+"Mouse",+"you",+"boo",+"zoo"]|code-block|syntax|javascript|790706|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Interleave 2D array of any size
<pre><code>arr = [[&quot;Cat&quot;, &quot;Dog&quot;, &quot;Mouse&quot;],
 [&quot;and&quot;, &quot;&amp;&quot;],
 [&quot;hello&quot;, &quot;there&quot;, &quot;you&quot;, &quot;boo&quot;, &quot;zoo&quot;]]

max_count = arr.map(&amp;:count).max
max_count.times.map{|i| arr.map{|a| a[i]}}.flatten.compact

#=&gt; [&quot;Cat&quot;, &quot;and&quot;, &quot;hello&quot;, &quot;Dog&quot;, &quot;&amp;&quot;, &quot;there&quot;, &quot;Mouse&quot;, &quot;you&quot;, &quot;boo&quot;, &quot;zoo&quot;]
</code></pre>

blocks|key|790732|text|合并多个数组的一种非常明确的方法是将它们解包到一个数组中。对于许多语言，这种方法实际上都是以相同的方式工作的，所以我更喜欢这种方法，因为它很简单，开发人员对它也很熟悉。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|790733|a+=+["Cat",+"Dog",+"Mouse"]
s+=+["and",+"&"]

[*a,+*s]
#=>+["Cat",+"Dog",+"Mouse",+"and",+"&"]|code-block|syntax|javascript|790734|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

A very clear way to merge multiple arrays is to unpack them into one array. This works in practically the same way for many languages, so I'd prefer this method due to its simplicity and developer familiarity with it.
<pre><code>a = [&quot;Cat&quot;, &quot;Dog&quot;, &quot;Mouse&quot;]
s = [&quot;and&quot;, &quot;&amp;&quot;]

[*a, *s]
#=&gt; [&quot;Cat&quot;, &quot;Dog&quot;, &quot;Mouse&quot;, &quot;and&quot;, &quot;&amp;&quot;]
</code></pre>

blocks|key|790500|text|arr+=+[0,+1]
arr+%2B+[2,+3,+4]

//outputs+[0,+1,+2,+3,+4]|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|790501|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>arr = [0, 1]
arr + [2, 3, 4]

//outputs [0, 1, 2, 3, 4]
</code></pre>

I have the following code:

<pre><code>a = ["Cat", "Dog", "Mouse"]
s = ["and", "&amp;"]
</code></pre>

I want to merge the array <code>s</code> into array <code>a</code> which would give me:

<pre><code>["Cat", "and", "Dog", "&amp;", "Mouse"]
</code></pre>

Looking through the Ruby Array and Enumerable docs, I don't see such a method that will accomplish this. 

Is there a way I can do this without iterating through each array?

Merge and interleave two arrays in Ruby

我有以下代码：a = ["Cat", "Dog", "Mouse"]s = ["and", "&"]我想将数组s合并到数组a中，这样就可以得到：["Cat", "and", "Dog", "&", "Mouse"]纵观Ruby Array和Enumerable文档，我看不到这样的方法可以做到这一点。有没有办法不用遍历每个数组就能做到这一点呢？

问在Ruby中合并和交错两个数组
EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中合并和交错两个数组EN

回答 11

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在Ruby中合并和交错两个数组
EN