Verifique se duas matrizes têm o mesmo conteúdo (em qualquer ordem)

Estou usando Ruby 1.8.6 com Rails 1.2.3 e preciso determinar se dois arrays têm os mesmos elementos, independentemente de estarem ou não na mesma ordem. Um dos arrays tem garantia de não conter duplicatas (o outro pode, caso em que a resposta é não).

Meu primeiro pensamento foi

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

mas eu queria saber se havia uma maneira mais eficiente ou idiomática de fazer isso.

Isso não requer conversão para definir:

a.sort == b.sort

para duas matrizes A e B: A e B têm o mesmo conteúdo se: (A-B).blank? and (B-A).blank?

ou você pode apenas verificar: ((A-B) + (B-A)).blank?

Também como sugerido por @ cort3z, esta solução também funciona para matrizes polimórficas, ou seja

 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` 

::::::::::: EDITAR ::::::::::::::

Como sugerido nos comentários, a solução acima falha para duplicatas. Embora de acordo com a pergunta que nem mesmo seja necessária, uma vez que o solicitante não está interessado em duplicatas (ele está convertendo suas matrizes para definir antes de verificar e isso mascara as duplicatas e mesmo se você olhar para a resposta aceita, ele está usando um operador .uniq antes de verificar e isso também mascara as duplicatas). Mesmo assim, se você tiver interesse em duplicatas, basta adicionar uma verificação de contagem para corrigir o mesmo (de acordo com a pergunta, apenas um array pode conter duplicatas). Portanto, a solução final será: A.size == B.size and ((A-B) + (B-A)).blank?

Comparsões de velocidade

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

Ruby 2.6+

Ruby foi introduzido differenceem 2.6.

Isso fornece uma solução muito rápida e legível aqui, da seguinte maneira:

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

Executando os benchmarks:

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

Espero que ajude alguém!

Quando os elementos de ae bsão Comparable,

a.sort == b.sort

Correção da resposta de @mori com base no comentário de @steenslag

Se você espera [:a, :b] != [:a, :a, :b] to_setnão funciona. Em vez disso, você pode usar a frequência:

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

Se você souber que as matrizes têm o mesmo comprimento e nenhuma delas contém duplicatas, isso também funciona:

( array1 & array2 ) == array1

Explicação: o &operador, neste caso, retorna uma cópia de a1 sem quaisquer itens não encontrados em a2, que é o mesmo que o a1 original se ambas as matrizes tiverem o mesmo conteúdo sem duplicatas.

Análise: considerando que a ordem não foi alterada, estou supondo que isso seja implementado como uma iteração dupla de forma consistente O(n*n), notavelmente pior para grandes arrays do a1.sort == a2.sortque aquela que deveria funcionar com o pior caso O(n*logn).

Uma abordagem é iterar sobre a matriz sem duplicatas

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

Isso retorna uma série de verdades. Se algum falso aparecer, o externo include?retornará verdadeiro. Portanto, você tem que inverter tudo para determinar se é uma correspondência.

combinando &e sizepode ser rápido também.

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