blocks|key|568152|text|a+=+[5,+1,+6,+14,+2,+8]
b+=+[2,+6,+15]

a+-+b
#+=>+[5,+1,+14,+8]

b+-+a
#+=>+[15]

(b+-+a).empty?
#+=>+false|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|568153|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>a = [5, 1, 6, 14, 2, 8]
b = [2, 6, 15]

a - b
# =&gt; [5, 1, 14, 8]

b - a
# =&gt; [15]

(b - a).empty?
# =&gt; false
</code></pre>

blocks|key|568092|text|也许这更容易读懂：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|568093|a2.all?+{+%7Ce%7C+a1.include?(e)+}|code-block|syntax|javascript|568094|您还可以使用数组交集：|568095|(a1+&+a2).size+==+a1.size|568096|请注意，这里使用size只是为了提高速度，您也可以这样做(速度较慢)：|offset|length|style|CODE|568097|(a1+&+a2)+==+a1|568098|但我猜第一个更具可读性。这3个是纯ruby+(不是rails)。|568099|entityMap^0|0|0|0|0|8|4|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@$M|11|N|12|O|P]]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Perhaps this is easier to read:

<pre><code>a2.all? { |e| a1.include?(e) }
</code></pre>

You can also use array intersection:

<pre><code>(a1 &amp; a2).size == a1.size
</code></pre>

Note that <code>size</code> is used here just for speed, you can also do (slower):

<pre><code>(a1 &amp; a2) == a1
</code></pre>

But I guess the first is more readable. These 3 are plain ruby (not rails).

blocks|key|568133|text|这可以通过这样做来实现|type|unstyled|depth|inlineStyleRanges|entityRanges|data|568134|(a2+&+a1)+==+a2|code-block|syntax|javascript|568135|这将创建两个数组的交集，返回a2中也在a1中的所有元素。如果结果与a2相同，则可以确保a1中包含所有元素。|offset|length|style|CODE|568136|只有当a2中的所有元素都彼此不同时，这种方法才有效。如果有替身，这种方法就会失败。来自Tempos的方法仍然有效，所以我全心全意地推荐他的方法(而且它可能更快)。|568137|entityMap^0|0|0|E|2|J|2|X|2|17|2|0|3|2|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|S|8|@$I|T|J|U|K|L]|$I|V|J|W|K|L]|$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@$I|12|J|13|K|L]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$]]

This can be achieved by doing

<pre><code>(a2 &amp; a1) == a2
</code></pre>

This creates the intersection of both arrays, returning all elements from <code>a2</code> which are also in <code>a1</code>. If the result is the same as <code>a2</code>, you can be sure you have all elements included in <code>a1</code>.

This approach only works if all elements in <code>a2</code> are different from each other in the first place. If there are doubles, this approach fails. The one from Tempos still works then, so I wholeheartedly recommend his approach (also it's probably faster).

blocks|key|568199|text|如果没有重复的元素或者您不关心它们，那么可以使用Set类：|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|568200|a1+=+Set.new+[5,+1,+6,+14,+2,+8]
a2+=+Set.new+[2,+6,+15]
a1.subset?(a2)
=>+false|code-block|syntax|javascript|568201|在幕后，它使用|568202|all?+{+%7Co%7C+set.include?(o)+}|568203|entityMap|0|LINK|mutability|MUTABLE|url|http://ruby-doc.org/stdlib/libdoc/set/rdoc/index.html^0|O|3|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@$A|V|B|W|1|X]]|C|$]]|$1|D|3|E|5|F|7|Y|8|@]|9|@]|C|$G|H]]|$1|I|3|J|5|6|7|Z|8|@]|9|@]|C|$]]|$1|K|3|L|5|F|7|10|8|@]|9|@]|C|$G|H]]|$1|M|3|-4|5|6|7|11|8|@]|9|@]|C|$]]]|N|$O|$5|P|Q|R|C|$S|T]]]]

If there are are no duplicate elements or you don't care about them, then you can use the <a href="http://ruby-doc.org/stdlib/libdoc/set/rdoc/index.html">Set</a> class:

<pre><code>a1 = Set.new [5, 1, 6, 14, 2, 8]
a2 = Set.new [2, 6, 15]
a1.subset?(a2)
=&gt; false
</code></pre>

Behind the scenes this uses

<pre><code>all? { |o| set.include?(o) }
</code></pre>

blocks|key|568299|text|你可以对Array类进行补丁：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|568300|class+Array
++++def+contains_all?(ary)
++++++++ary.uniq.all?+{+%7Cx%7C+count(x)+>=+ary.count(x)+}
++++end
end|code-block|syntax|javascript|568301|测试|568302|irb(main):131:0>+%25w[a+b+c+c].contains_all?+%25w[a+b+c]
=>+true
irb(main):132:0>+%25w[a+b+c+c].contains_all?+%25w[a+b+c+c]
=>+true
irb(main):133:0>+%25w[a+b+c+c].contains_all?+%25w[a+b+c+c+c]
=>+false
irb(main):134:0>+%25w[a+b+c+c].contains_all?+%25w[a]
=>+true
irb(main):135:0>+%25w[a+b+c+c].contains_all?+%25w[x]
=>+false
irb(main):136:0>+%25w[a+b+c+c].contains_all?+%25w[]
=>+true
irb(main):137:0>+%25w[a+b+c+d].contains_all?+%25w[d+c+h]
=>+false
irb(main):138:0>+%25w[a+b+c+d].contains_all?+%25w[d+b+c]
=>+true|568303|当然，该方法也可以编写为独立的标准方法，例如|568304|def+contains_all?(a,b)
++++b.uniq.all?+{+%7Cx%7C+a.count(x)+>=+b.count(x)+}
end|568305|你可以像这样调用它|568306|contains_all?(%25w[a+b+c+c],+%25w[c+c+c])|568307|实际上，在分析之后，下面的版本要快得多，代码也更短。|568308|def+contains_all?(a,b)
++++b.all?+{+%7Cx%7C+a.count(x)+>=+b.count(x)+}
end|568309|entityMap^0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|10|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|12|8|@]|9|@]|A|$]]|$1|M|3|N|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|14|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|15|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|V|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|W|3|-4|5|6|7|18|8|@]|9|@]|A|$]]]|X|$]]

You can monkey-patch the Array class:

<pre><code>class Array
 def contains_all?(ary)
 ary.uniq.all? { |x| count(x) &gt;= ary.count(x) }
 end
end
</code></pre>

test

<pre><code>irb(main):131:0&gt; %w[a b c c].contains_all? %w[a b c]
=&gt; true
irb(main):132:0&gt; %w[a b c c].contains_all? %w[a b c c]
=&gt; true
irb(main):133:0&gt; %w[a b c c].contains_all? %w[a b c c c]
=&gt; false
irb(main):134:0&gt; %w[a b c c].contains_all? %w[a]
=&gt; true
irb(main):135:0&gt; %w[a b c c].contains_all? %w[x]
=&gt; false
irb(main):136:0&gt; %w[a b c c].contains_all? %w[]
=&gt; true
irb(main):137:0&gt; %w[a b c d].contains_all? %w[d c h]
=&gt; false
irb(main):138:0&gt; %w[a b c d].contains_all? %w[d b c]
=&gt; true
</code></pre>

Of course the method can be written as a standard-alone method, eg

<pre><code>def contains_all?(a,b)
 b.uniq.all? { |x| a.count(x) &gt;= b.count(x) }
end
</code></pre>

and you can invoke it like

<pre><code>contains_all?(%w[a b c c], %w[c c c])
</code></pre>

Indeed, after profiling, the following version is much faster, and the code is shorter.

<pre><code>def contains_all?(a,b)
 b.all? { |x| a.count(x) &gt;= b.count(x) }
end
</code></pre>

blocks|key|568239|text|根据你的数组有多大，你可以考虑一个有效的算法O(n+log+n)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|568240|def+equal_a(a1,+a2)
++a1sorted+=+a1.sort
++a2sorted+=+a2.sort
++return+false+if+a1.length+!=+a2.length
++0.upto(a1.length+-+1)+do+
++++%7Ci%7C+return+false+if+a1sorted[i]+!=+a2sorted[i]
++end
end|code-block|syntax|javascript|568241|排序成本为O(n)，检查每一对的成本为O(+n+)，因此该算法为O(+n+)。使用未排序的数组，其他算法无法(渐近地)更快。|568242|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Depending on how big your arrays are you might consider an efficient algorithm O(n log n)

<pre><code>def equal_a(a1, a2)
 a1sorted = a1.sort
 a2sorted = a2.sort
 return false if a1.length != a2.length
 0.upto(a1.length - 1) do 
 |i| return false if a1sorted[i] != a2sorted[i]
 end
end
</code></pre>

Sorting costs O(n log n) and checking each pair costs O(n) thus this algorithm is O(n log n). The other algorithms cannot be faster (asymptotically) using unsorted arrays.

blocks|key|784527|text|如果(a1+-+a2)或(a1+&+a2)数组中有重复的元素，则大多数基于这两个数组的答案都不起作用。我来到这里是为了寻找一种方法来查看一个单词的所有字母(拆分为一个数组)是否都是一组字母的一部分(例如拼写)。这些答案都不起作用，但这个答案起作用了：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|784528|def+contains_all?(a1,+a2)
++try+=+a1.chars.all?+do+%7Cletter%7C
++++a1.count(letter)+<=+a2.count(letter)
++end
++return+try
end|code-block|syntax|javascript|784529|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|$]]

Most answers based on (a1 - a2) or (a1 &amp; a2) would not work if there are duplicate elements in either array. I arrived here looking for a way to see if all letters of a word (split to an array) were part of a set of letters (for scrabble for example). None of these answers worked, but this one does:

<pre><code>def contains_all?(a1, a2)
 try = a1.chars.all? do |letter|
 a1.count(letter) &lt;= a2.count(letter)
 end
 return try
end
</code></pre>

Given:

<pre><code>a1 = [5, 1, 6, 14, 2, 8]
</code></pre>

I would like to determine if it contains all elements of:

<pre><code>a2 = [2, 6, 15]
</code></pre>

In this case the result is <code>false</code>.

Are there any built-in Ruby/Rails methods to identify such array inclusion?

One way to implement this is:

<pre><code>a2.index{ |x| !a1.include?(x) }.nil?
</code></pre>

Is there a better, more readable, way?

How to determine if one array contains all elements of another array

给定：a1 = [5, 1, 6, 14, 2, 8]我想确定它是否包含以下所有元素：a2 = [2, 6, 15]在本例中，结果是false。有没有内置的Ruby/Rails方法来识别这样的数组包含？实现这一点的一种方法是：a2.index{ |x| !a1.include?(x) }.nil?有没有更好、更易读的方法？

问如何确定一个数组是否包含另一个数组的所有元素
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何确定一个数组是否包含另一个数组的所有元素EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何确定一个数组是否包含另一个数组的所有元素
EN