Ruby: Как найти разницу между 2 массивами, вопросы заказа

Question

Я пытаюсь подсчитать различия между двумя массивами, где порядок имеет значение. Например:

array_one = ["A", "B", "C"] 
array_two = ["B", "C", "A"] 

Это даст 3 различия, потому что:

array_one[0] != array_two[0] 
array_one[1] != array_two[1] 
array_one[2] != array_two[2] 

Другой пример:

array_one = ["Z", "X", "Y"] 
array_two = ["Z", "W", "Y"] 

Это даст 1, потому что:

array_one[0] == array_two[0] 
array_one[1] != array_two[1] 
array_one[2] == array_two[2] 

Любые предложения значительно оценили.

Answer 1

как об этом

array_one = ["A", "B", "C"] 
array_two = ["A", "C", "A"] 

array_one.select.each_with_index { |item, index| 
    array_two[index] != item 
} => #B and C 

Answer 2

Вы можете объединить два массива с помощью zip и подсчитать внутренний массив, где два значения равны.

arr1 = [1,2,3] 
arr2 = [1,5,6] 

arr1.zip(arr2)    #=> [[1, 1], [2, 5], [3, 6]] 
    .count {|a, b| a == b} #=> 1 

Другой способ это просто перебирать как массив и запустить счетчик

count = 0 

(0...arr1.length).each do |idx| 
    count += 1 if arr1[idx] == arr2[idx] 
end 

Конечно, и предположим, что оба массива имеют одинаковую длину.

(0...arr1.length) такой же, как 0 to arr1.length-1, ... является исключительным.

Answer 3

@ davidhu2000 бить меня к нему, но, как этот подход является немного отличается, он все еще может быть стоит упомянуть:

array_one = ["A", "B", "C"] 
array_two = ["B", "C", "A"] 

array_one.zip(array_two).inject(0) { |memo, (left, right)| 
    unless left == right 
    memo + 1 
    else 
    memo 
    end 
} # => 3 

Answer 4

как об этом

array_one = ["A", "B", "C"] 
array_two = ["A", "C", "A"] 

array_one.select.each_with_index { |item, index| 
    array_two[index] != item 
} => #["B", "C"] 

Answer 5

Только потому, что мне нравятся такие вещи, я протестированные решения, просто хотел поделиться в случае, если кто заинтересован (я просто переключил массив побольше, чтобы получить более значимые результаты)

require "benchmark/ips" 

def method_1(ar_1, ar_2) 
    ar = ar_1.zip ar_2 

    ar.count { |els| els[0] == els[1] } 
end 

def method_2(ar_1, ar_2) 
    count = 0 
    ar_1.each_with_index { |el, i| count += 1 if el == ar_2[i] } 
end 

def method_3(ar_1, ar_2) 
    count = 0 

    (0...ar_1.length).each do |idx| 
    count += 1 if ar_1[idx] == ar_2[idx] 
    end 
end 

def method_4(ar_1, ar_2) 
    ar_1.zip(ar_2).inject(0) do |memo, (left, right)| 
    if left == right 
     memo 
    else 
     memo + 1 
    end 
    end 
end 

def method_5(ar_1, ar_2) 
    ar_1.select.each_with_index do |item, index| 
    ar_2[index] != item 
    end 
end 

Benchmark.ips do |x| 
    # ar_1 = ["A", "B", "C"] 
    # ar_2 = ["B", "C", "A"] 

    ar_1 = (0..1_000_000).to_a.shuffle 
    ar_2 = (0..1_000_000).to_a.shuffle 

    x.report("zip and count") do |times| 
    i = 0 
    while i < times 
     method_1 ar_1, ar_2 
     i += 1 
    end 
    end 

    x.report("each with index") do |times| 
    i = 0 
    while i < times 
     method_2 ar_1, ar_2 
     i += 1 
    end 
    end 

    x.report("0..length each") do |times| 
    i = 0 
    while i < times 
     method_3 ar_1, ar_2 
     i += 1 
    end 
    end 

    x.report("zip and inject") do |times| 
    i = 0 
    while i < times 
     method_4 ar_1, ar_2 
     i += 1 
    end 
    end 

    x.report("select each with index") do |times| 
    i = 0 
    while i < times 
     method_5 ar_1, ar_2 
     i += 1 
    end 
    end 

    x.compare! 
end 

################################################### 
# 10_000 elements per array      # 
################################################### 
# 
# Warming up -------------------------------------- 
#  zip and count 54.000 i/100ms 
#  each with index 92.000 i/100ms 
#  0..length each 87.000 i/100ms 
#  zip and inject 41.000 i/100ms 
# select each with index 
#       82.000 i/100ms 
# Calculating ------------------------------------- 
#  zip and count 545.700 (± 2.6%) i/s -  2.754k in 5.050362s 
#  each with index 919.259 (± 3.0%) i/s -  4.600k in 5.008972s 
#  0..length each 919.908 (± 1.4%) i/s -  4.611k in 5.013518s 
#  zip and inject 413.470 (± 1.7%) i/s -  2.091k in 5.058865s 
# select each with index 
#       828.774 (± 3.5%) i/s -  4.182k in 5.053036s 
# 
# Comparison: 
#  0..length each:  919.9 i/s 
#  each with index:  919.3 i/s - same-ish: difference falls within error 
# select each with index:  828.8 i/s - 1.11x slower 
#  zip and count:  545.7 i/s - 1.69x slower 
#  zip and inject:  413.5 i/s - 2.22x slower 


################################################### 
# 1_000_000 elements per array      # 
################################################### 
# 
# Warming up -------------------------------------- 
#  zip and count  1.000 i/100ms 
#  each with index  1.000 i/100ms 
#  0..length each  1.000 i/100ms 
#  zip and inject  1.000 i/100ms 
# select each with index 
#       1.000 i/100ms 
# Calculating ------------------------------------- 
#  zip and count  5.447 (±18.4%) i/s -  26.000 in 5.088342s 
#  each with index  9.292 (± 0.0%) i/s -  47.000 in 5.058805s 
#  0..length each  9.104 (± 0.0%) i/s -  46.000 in 5.053701s 
#  zip and inject  3.983 (± 0.0%) i/s -  20.000 in 5.042810s 
# select each with index 
#       7.777 (±12.9%) i/s -  39.000 in 5.053795s 
# 
# Comparison: 
#  each with index:  9.3 i/s 
#  0..length each:  9.1 i/s - 1.02x slower 
# select each with index:  7.8 i/s - 1.19x slower 
#  zip and count:  5.4 i/s - 1.71x slower 
#  zip and inject:  4.0 i/s - 2.33x slower 

Answer 6

array_one = ["A", "B", "C"] 
array_two = ["A", "C", "A"] 

enum_two = array_two.to_enum 
array_one.select { |s| s != enum_two.next } 
    #=> ["B", "C"]