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

鉴于：

a1 = [5, 1, 6, 14, 2, 8]

我想确定它是否包含以下所有元素：

a2 = [2, 6, 15]

在这种情况下，结果为false。

是否有内置的Ruby / Rails方法来识别这种数组包含？

一种实现方法是：

a2.index{ |x| !a1.include?(x) }.nil?

有没有更好，更易读的方法？

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

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

b - a
=> [15]

(b - a).empty?
=> false

也许这更容易阅读：

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

您还可以使用数组交集：

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

请注意，size此处仅用于提高速度，您也可以这样做（速度较慢）：

(a1 & a2) == a1

但是我想第一个更具可读性。这3个是纯红宝石（不是铁轨）。

这可以通过以下方式实现

(a2 & a1) == a2

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

仅当其中的所有元素a2互不相同时，此方法才有效。如果有双打，此方法将失败。Tempos的那个仍然可以使用，所以我全力推荐他的方法（可能还更快）。

如果没有重复的元素或您不在乎它们，则可以使用Set类：

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

在幕后使用

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

您可以猴子修补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

根据阵列的大小，您可以考虑一种有效的算法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），因此该算法为O（n log n）。使用未排序的数组，其他算法不能更快（渐近地）。

如果任一数组中都有重复的元素，则基于（a1-a2）或（a1＆a2）的大多数答案将不起作用。我到达这里是为了寻找一种方法来查看一个单词的所有字母（拆分为数组）是否属于一组字母（例如，拼字游戏）。这些答案均无效，但此答案可以：

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