İki dizinin aynı içeriğe sahip olup olmadığını kontrol edin (herhangi bir sırada)

Ruby 1.8.6'yı Rails 1.2.3 ile kullanıyorum ve iki dizinin aynı sırada olup olmadıklarına bakılmaksızın aynı elemanlara sahip olup olmadığını belirlemem gerekiyor. Dizilerden birinin yineleme içermemesi garanti edilir (diğeri olabilir, bu durumda yanıt hayırdır).

İlk düşüncem

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

ama bunu yapmanın daha verimli veya deyimsel bir yolu olup olmadığını merak ediyordum.

Bu, aşağıdakilerin ayarlanmasını gerektirmez:

a.sort == b.sort

iki dizi A ve B için: A ve B aynı içeriğe sahipse: (A-B).blank? and (B-A).blank?

veya sadece kontrol edebilirsiniz: ((A-B) + (B-A)).blank?

Ayrıca @ cort3z tarafından önerildiği gibi, bu çözüm als0 polimorfik diziler için çalışır, yani

 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` 

::::::::::: DÜZENLE :::::::::::::

Yorumlarda önerildiği gibi, yukarıdaki çözüm kopyalar için başarısız olur. Soruya göre, soruyu soran kişi kopyalarla ilgilenmediğinden bile gerekli olmasa da (dizilerini kontrol etmeden önce ayarlanacak şekilde dönüştürüyor ve kopyaları maskeliyor ve hatta baksanız bile kabul edilen yanıtı kontrol etmeden önce bir .uniq operatörü kullanıyor ve bu da kopyaları maskeliyor.). Ancak yine de, yinelenenler ilginizi çekiyorsa, yalnızca bir sayım kontrolü eklemek aynı şeyi çözecektir (soruya göre yalnızca bir dizi yinelenen öğeler içerebilir). Dolayısıyla nihai çözüm şu şekilde olacaktır: A.size == B.size and ((A-B) + (B-A)).blank?

Hız karşılaştırmaları

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 difference2.6'da tanıtıldı .

Bu, burada aşağıdaki gibi çok hızlı, çok okunabilir bir çözüm sağlar:

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

Kıyaslamaları çalıştırmak:

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

Umarım bu birine yardımcı olur!

Unsurları zaman ave bvardır Comparable,

a.sort == b.sort

@ Mori'nin cevabının @ steenslag'in yorumuna göre düzeltilmesi

Eğer umarsan [:a, :b] != [:a, :a, :b] to_setişe yaramaz. Bunun yerine frekansı kullanabilirsiniz:

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

Dizilerin eşit uzunlukta olduğunu ve hiçbir dizinin yineleme içermediğini biliyorsanız, bu da işe yarar:

( array1 & array2 ) == array1

Açıklama:& Bu durumda işletmeci hem diziler hiçbir tekrarlar da aynı içeriğe sahip IFF orijinal a1 aynıdır a1 sans bir kopyasını herhangi ürün a2 bulunmayan döndürür.

Analyis: Sıranın değişmediği göz önüne alındığında, bunun çift yineleme olarak uygulandığını tahmin ediyorum, bu kadar tutarlı bir şekilde O(n*n), özellikle büyük diziler için a1.sort == a2.sorten kötü durumda performans göstermesi gerekenden daha kötü O(n*logn).

birleştirir &ve sizehızlı da olabilir.

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

Bir yaklaşım, kopya olmadan dizi üzerinde yineleme yapmaktır.

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

Bu bir dizi doğru döndürür. Herhangi bir yanlış gelirse, dış kısım include?doğruya dönecektir. Bu nedenle, bir eşleşme olup olmadığını belirlemek için her şeyi tersine çevirmelisiniz.