Проверьте, имеют ли два массива одинаковое содержимое (в любом порядке)

Question

Я использую Ruby 1.8.6 с Rails 1.2.3 и вам нужно определить, имеют ли два массива одинаковые элементы независимо от того, являются ли они в том же порядке. Один из массивов гарантированно не содержит дубликатов (другой может быть, и в этом случае ответ будет отрицательным).

Моя первая мысль была

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

, но мне было интересно, если есть более эффективный или идиоматических способ сделать это.

Answer 1

Это не требует преобразования, чтобы установить:

a.sort == b.sort 

Answer 2

Если вы ожидаете, что [: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 3

Один подход заключается в итерации по массиву, без дублей

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

Это возвращает массив истин. Если появится какое-либо ложь, внешний include? вернет true. Таким образом, вы должны инвертировать все это, чтобы определить, является ли это совпадением.

Answer 4

для двух массивов А и В: А и В имеют такое же содержание, если: (A-B).blank? and (B-A).blank?

или вы можете просто проверить: ((A-B) + (B-A)).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` 

::::::::::: EDIT :::::::::::::

Как указывается в комментариях, выше решение не выполняется для duplicates.Although согласно вопрос, который даже не требуется, так как искатель не заинтересован в дубликатах (он преобразует свои массивы для установки перед проверкой, и это маскирует дубликаты, и даже если вы посмотрите на accepeted ответ, он использует оператор .uniq перед проверкой и это слишком маскирует дубликаты.). Но все же, если вас интересуют дубликаты, просто добавление проверки количества будет исправлять то же самое (по одному вопросу только один массив может содержать дубликаты). Таким образом, окончательное решение будет: A.size == B.size and ((A-B) + (B-A)).blank?

Answer 5

Если вы знаете, массивы имеют одинаковую длину и ни один массив содержит дубликаты, этот способ хорош

(array1 & array2) == array1 

Answer 6

Когда элементы a и b являются Comparable,

a.sort == b.sort 

Коррекция ответа @ Мори на основе @ steenslag замечании

Answer 7

Скорость comparsions

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