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

也许下面这个更容易理解:

a2.all? { |e| a1.include?(e) }

你也可以使用数组交集:

(a1 & a2).size == a1.size

注意，这里使用size只是为了提高速度，你也可以这样做(更慢):

(a1 & a2) == a1

但我想第一个更有可读性。这三个是普通的ruby(不是rails)。

这可以通过做来实现

(a2 & a1) == a2

这将创建两个数组的交集，返回a2中同样在a1中的所有元素。如果结果与a2相同，则可以确定所有元素都包含在a1中。

这种方法仅适用于a2中的所有元素首先彼此不同的情况。如果存在双精度，则此方法失败。Tempos的方法仍然有效，所以我全心全意地推荐他的方法(而且它可能更快)。

a = [5, 1, 6, 14, 2, 8]
b = [2, 6, 15]


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


b - a
# => [15]


(b - a).empty?
# => false

如果没有重复元素或者你不关心它们，那么你可以使用集类:

a1 = Set.new [5, 1, 6, 14, 2, 8]
a2 = Set.new [2, 6, 15]
a1.subset?(a2)
=> false

这在幕后使用

all? { |o| set.include?(o) }

根据数组的大小你可以考虑一种有效的算法O(n log n)

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

排序的代价是O(n log n)，检查每个对的代价是O(n log n)，因此这个算法是O(n log n)。使用未排序的数组，其他算法(渐近地)不能更快。

你可以给Array类打些小补丁:

class Array
def contains_all?(ary)
ary.uniq.all? { |x| count(x) >= ary.count(x) }
end
end

测验

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

当然，该方法可以写成标准单独的方法，例如

def contains_all?(a,b)
b.uniq.all? { |x| a.count(x) >= b.count(x) }
end

你可以调用它

contains_all?(%w[a b c c], %w[c c c])

实际上，在分析之后，下面的版本要快得多，代码也更短。

def contains_all?(a,b)
b.all? { |x| a.count(x) >= b.count(x) }
end

大多数答案基于(a1 - a2)或(a1 &如果两个数组中都有重复的元素，A2)将不起作用。我来到这里寻找一种方法来查看一个单词的所有字母(分割为一个数组)是否是一组字母的一部分(例如scrabble)。这些答案都没用，但这个答案有用:

def contains_all?(a1, a2)
try = a1.chars.all? do |letter|
a1.count(letter) <= a2.count(letter)
end
return try
end

当我试图找到一个数组["a", "b", "c"]是否包含另一个数组["a", "b"]时，我被引导到这篇文章，在我的情况下，相同的顺序是这个问题的额外要求。

以下是我的解决方案(我相信它的复杂度是O(n))，适用于任何有额外要求的人:

def array_includes_array(array_to_inspect, array_to_search_for)
inspectLength = array_to_inspect.length
searchLength = array_to_search_for.length


if searchLength == 0 then
return true
end


if searchLength > inspectLength then
return false
end


buffer = []


for i in 0..inspectLength
buffer.push(array_to_inspect[i])


bufferLastIndex = buffer.length - 1
if(buffer[bufferLastIndex] != array_to_search_for[bufferLastIndex]) then
buffer.clear
next
end


if(buffer.length == searchLength) then
return true
end
end


return false
end

这会产生测试结果:

puts "1: #{array_includes_array(["a", "b", "c"], ["b", "c"])}" # true
puts "2: #{array_includes_array(["a", "b", "c"], ["a", "b"])}" # true
puts "3: #{array_includes_array(["a", "b", "c"], ["b", "b"])}" # false
puts "4: #{array_includes_array(["a", "b", "c"], ["c", "b", "a"])}" # false
puts "5: #{array_includes_array(["a", "b", "c"], [])}" # true
puts "6: #{array_includes_array([], ["a"])}" # false
puts "7: #{array_includes_array([], [])}" # true