Определение, содержит ли один массив содержимое другого массива в ruby

Question

В ruby, как мне проверить, что один массив не только содержит элементы другого массива, но и содержит их в определенном порядке?

correct_combination = [1, 2, 3, 4, 5]
[1, 5, 8, 2, 3, 4, 5].function_name(correct_combination) # => false
[8, 10, 1, 2, 3, 4, 5, 9].function_name(correct_combination) # => true

Я пытался использовать include, но это используется для проверки, является ли [1,2,3].include?(2) истинным или нет.

Answer 1

Вы можете использовать метод each_cons:

arr = [1, 2, 3, 4, 5]
[1, 5, 8, 2, 3, 4, 5].each_cons(arr.size).include? arr

В этом случае это будет работать для любых элементов.

Answer 2

Я думаю, что это можно сделать просто.

class Array
  def contain? other; (self & other) == other end
end

correct_combination = [1, 2, 3, 4, 5]
[1, 5, 8, 2, 3, 4, 5].contain?(correct_combination) # => false
[8, 10, 1, 2, 3, 4, 5, 9].contain?(correct_combination) # => true

Answer 3

Если вы хотите игнорировать порядок (как я сделал, когда наткнулся на этот пост), вы можете использовать Array.sort и <=> http://ruby -doc.org / ядро-1.8.7 / классы / Array.html # M000316

a = [1, 2, 3, 4, 5]
b = [2, 1, 5, 4, 3]
a.sort <=> b.sort

Затем необходимо проверить, что выходное значение равно 0.

Answer 4

Не совсем лучшее возможное решение, но, по крайней мере, оно краткое

(',' + [1, 5, 8, 2, 3, 4, 5].join(',') + ',').include?(',' + correct_combination.join(',') + ',')

Лучшее возможное решение - использовать один из алгоритмов поиска строк в массиве, но вам придется кодировать его самостоятельно, я не думаю, что есть стандартное решение.

Answer 5

Я хотел бы рассмотреть непрерывную последовательность элементов из другого массива в массиве контейнера и представить это: - код основан на коде Саввы

class Array
  def contain? other
   arr = self & other
   (arr.eql? other ) && ((self.index(arr.last) - self.index(arr.first)).eql?(other.size - 1))
  end
end

Результат: -

correct_combination = [1, 2, 3, 4, 5]
[1, 5, 8, 2, 3, 4, 5].contain?(correct_combination) # => false
[8, 10, 1, 2, 3, 4, 5, 9].contain?(correct_combination) # => true
[1, 8, 2, 3, 4, 5].contain?(correct_combination) # => false

Answer 6

Это то, что я придумал

a = [1, 2, 3, 4, 5]
b = [2, 3, 5]
c = [3, 9]

irb(main):037:0* (a + b).sort.uniq == a.sort.uniq
=> true
irb(main):038:0> (a + c).sort.uniq == a.sort.uniq
=> false

Answer 7

Я бы предложил цикл for, который сравнивает каждый

@out_of_order_elements = []

for i in 0.. @array_size do
  unless submission_array[i] == @correct_combination[i]
    @out_of_order_ids.push(@submission_array[i])
  end
end 

Answer 8

Очень быстрый способ сделать это - просто вычесть один массив из другого и проверить наличие пустого массива.

correct_combination = [1, 2, 3, 4, 5]
yep = [8, 10, 1, 2, 3, 4, 5, 9]
nope = [1, 8, 2, 3, 4]
if correct_combination - yep == []
  puts "yep has all the values"
end
if correct_combination - nope == []
  puts "nope has all the values"
end

Этот подход не заботится о положении, поэтому удалите его!

Извините ... Я тоже упустил вопрос. Не понял, что вы искали порядок старшинства. Я сталкивался с этим, когда искал решение для оценки того, содержит ли один большой массив все записи другого большого массива. .All? / Включить? подход требует очень много времени для завершения. Удачи!

Answer 9

Это лучшее, что я мог придумать. Все вызовы return немного уродливы, но это должно быть быстрее, чем сравнение строк, если это большие массивы.

class Array
  def same?(o)
    if self.size == o.size
      (0..self.size).each {|i| return false if self[i] != o[i] }
    else
      return false
    end

    return true
  end
end

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

puts a.same?(a.reverse) # => false
puts a.same?(a) # => true
puts a.same?(b) # => false
puts a.same?(c) # => false

Answer 10

Может быть <=> - это то, что вы ищете.

Сравнение - возвращает целое число (-1, 0 или +1), если этот массив меньше, равен или больше, чем other_array

* +1007 *

a = [1, 2, 3, 4, 5]
b = [1, 5, 8, 2, 3, 4, 5]
c = [8, 10, 1, 2, 3, 4, 5, 9]

puts a <=> b # => -1
puts a <=> c # => -1
puts a <=> a # => 0

Обновление: не имеет значения, только что заметил, что его не волнует положение.

puts a <=> a.reverse # => -1