检查两个数组是否具有相同的内容（按任何顺序）

Question

我正在使用带有Rails 1.2.3的Ruby 1.8.6，并且需要确定两个数组是否具有相同的元素，无论它们是否处于相同的顺序。 保证其中一个数组不包含重复项（另一个可能，在这种情况下答案是否定的）。

我的第一个想法是

require 'set'
a.to_set == b.to_set

但我想知道是否有更高效或惯用的方式。

Answer 1

这不需要转换为设置：

a.sort == b.sort

Answer 2

对于两个阵列A和B：A和B具有相同的内容，如果： (AB).blank? and (BA).blank? (AB).blank? and (BA).blank?

或者您可以检查： ((AB) + (BA)).blank?

同样如@ cort3z所示，这个解决方案als0适用于多态数组，即

 A = [1 , "string", [1,2,3]]
 B = [[1,2,3] , "string", 1]
 (A-B).blank? and (B-A).blank? => true
 # while A.uniq.sort == B.uniq.sort will throw error `ArgumentError: comparison of Fixnum with String failed` 

:::::::::::编辑::::::::::::::

正如评论中所建议的那样，上述解决方案无法复制。虽然问题甚至不需要，因为提问者对重复不感兴趣（他在检查之前将他的数组转换为设置并且掩盖重复，即使你看一下在检查之前他正在使用.uniq运算符的加速答案，这也掩盖了重复。） 但是，如果重复你感兴趣，只需添加一个计数检查将修复相同（根据问题只有一个数组可以包含重复）。 所以最终的解决方案是： A.size == B.size and ((AB) + (BA)).blank?

Answer 3

速度比较

require 'benchmark/ips'
require 'set'

a = [1, 2, 3, 4, 5, 6]
b = [1, 2, 3, 4, 5, 6]

Benchmark.ips do |x|
  x.report('sort')   { a.sort == b.sort }  
  x.report('sort!')  { a.sort! == b.sort! }  
  x.report('to_set') { a.to_set == b.to_set }  
  x.report('minus')  { ((a - b) + (b - a)).empty? }  
end  

Warming up --------------------------------------
            sort    88.338k i/100ms
           sort!   118.207k i/100ms
          to_set    19.339k i/100ms
           minus    67.971k i/100ms
Calculating -------------------------------------
            sort      1.062M (± 0.9%) i/s -      5.389M in   5.075109s
           sort!      1.542M (± 1.2%) i/s -      7.802M in   5.061364s
          to_set    200.302k (± 2.1%) i/s -      1.006M in   5.022793s
           minus    783.106k (± 1.5%) i/s -      3.942M in   5.035311s

Answer 4

当a和b的元素是Comparable ，

a.sort == b.sort

根据@ steenslag的评论纠正@ mori的答案

Answer 5

如果你期望[:a, :b] != [:a, :a, :b] to_set不起作用。 您可以使用频率代替：

class Array
  def frequency
    p = Hash.new(0)
    each{ |v| p[v] += 1 }
    p
  end
end

[:a, :b].frequency == [:a, :a, :b].frequency #=> false
[:a, :b].frequency == [:b, :a].frequency #=> true

Answer 6

如果您知道数组长度相等且两个数组都不包含重复项，那么这也适用：

( array1 & array2 ) == array1

说明：在这种情况下， &运算符返回a1的副本sans sans在a2中找不到的任何项目，如果两个数组具有相同的内容且没有重复项，则与原始a1相同。

分析：鉴于订单没有改变，我猜这是实现了一个双重迭代，所以一致的O(n*n) ，对于大型数组而言尤其比a1.sort == a2.sort更糟糕，这应该在最坏情况下执行O(n*logn) 。

Answer 7

Ruby 2.6+

Ruby引入了2.6的difference 。

这给出了一个非常快速，非常易读的解决方案，如下所示：

a = [1, 2, 3, 4, 5, 6]
b = [1, 2, 3, 4, 5, 6]

a.difference(b).any?
# => false
a.difference(b.reverse).any?
# => false

a = [1, 2, 3, 4, 5, 6]
b = [1, 2, 3]
a.difference(b).any?
# => true

运行基准测试：

a = Array.new(1000) { rand(100) }
b = Array.new(1000) { rand(100) }

Benchmark.ips do |x|
  x.report('sort')   { a.sort == b.sort }  
  x.report('sort!')  { a.sort! == b.sort! }  
  x.report('to_set') { a.to_set == b.to_set }  
  x.report('minus')  { ((a - b) + (b - a)).empty? }  
  x.report('difference') { a.difference(b).any? }
end

      sort     13.908k (± 2.6%) i/s -     69.513k in   5.001443s
     sort!     14.656k (± 3.0%) i/s -     73.736k in   5.035744s
    to_set     5.125k  (± 2.9%) i/s -     26.023k in   5.082083s
     minus     16.398k (± 2.2%) i/s -     83.181k in   5.074938s
difference     27.839k (± 5.2%) i/s -    141.048k in   5.080706s

希望有人帮助！

Answer 8

一种方法是迭代数组而不重复

# assume array a has no duplicates and you want to compare to b
!a.map { |n| b.include?(n) }.include?(false)

这将返回一个trues数组。 如果出现任何错误，那么外部include? 将返回真实。 因此，您必须反转整个事物以确定它是否匹配。

Answer 9

组合&和size也可能很快。

require 'benchmark/ips'
require 'set'

Benchmark.ips do |x|
  x.report('sort')   { a.sort == b.sort }  
  x.report('sort!')  { a.sort! == b.sort! }  
  x.report('to_set') { a.to_set == b.to_set }  
  x.report('minus')  { ((a - b) + (b - a)).empty? }
  x.report('&.size') { a.size == b.size && (a & b).size == a.size }  
end  

Calculating -------------------------------------
                sort    896.094k (±11.4%) i/s -      4.458M in   5.056163s
               sort!      1.237M (± 4.5%) i/s -      6.261M in   5.071796s
              to_set    224.564k (± 6.3%) i/s -      1.132M in   5.064753s
               minus      2.230M (± 7.0%) i/s -     11.171M in   5.038655s
              &.size      2.829M (± 5.4%) i/s -     14.125M in   5.010414s