Як визначити, чи містить один масив усі елементи іншого масиву

Подано:

a1 = [5, 1, 6, 14, 2, 8]

Я хотів би визначити, чи він містить усі елементи:

a2 = [2, 6, 15]

У цьому випадку результат є false.

Чи є якісь вбудовані методи Ruby / Rails для ідентифікації такого включення масиву?

Одним із способів здійснення цього є:

a2.index{ |x| !a1.include?(x) }.nil?

Чи є кращий, читабельніший спосіб?

a = [5, 1, 6, 14, 2, 8]
b = [2, 6, 15]

a - b
=> [5, 1, 14, 8]

b - a
=> [15]

(b - a).empty?
=> false

Можливо, це простіше читати:

a2.all? { |e| a1.include?(e) }

Ви також можете використовувати перетин масиву:

(a1 & a2).size == a1.size

Зауважте, що sizeтут використовується лише для швидкості, ви також можете робити (повільніше):

(a1 & a2) == a1

Але я здогадуюсь, перше читабельніше. Ці 3 - звичайний рубін (не рейки).

Цього можна досягти, роблячи

(a2 & a1) == a2

Це створює перетин обох масивів, повертаючи всі елементи, з a2яких також є a1. Якщо результат такий, як a2, ви можете бути впевнені, що всі елементи включені в a1.

Цей підхід працює лише в тому випадку, якщо всі елементи в a2першу чергу відрізняються один від одного. Якщо є парні, такий підхід не вдається. Той із Tempos все ще працює, тому я від усієї душі рекомендую його підхід (також, мабуть, швидше).

Якщо немає дублікатів елементів або ви не переймаєтесь ними, ви можете використовувати клас Set :

a1 = Set.new [5, 1, 6, 14, 2, 8]
a2 = Set.new [2, 6, 15]
a1.subset?(a2)
=> false

За лаштунками це використовується

all? { |o| set.include?(o) }

Ви можете промацувати клас Array:

class Array
    def contains_all?(ary)
        ary.uniq.all? { |x| count(x) >= ary.count(x) }
    end
end

тест

irb(main):131:0> %w[a b c c].contains_all? %w[a b c]
=> true
irb(main):132:0> %w[a b c c].contains_all? %w[a b c c]
=> true
irb(main):133:0> %w[a b c c].contains_all? %w[a b c c c]
=> false
irb(main):134:0> %w[a b c c].contains_all? %w[a]
=> true
irb(main):135:0> %w[a b c c].contains_all? %w[x]
=> false
irb(main):136:0> %w[a b c c].contains_all? %w[]
=> true
irb(main):137:0> %w[a b c d].contains_all? %w[d c h]
=> false
irb(main):138:0> %w[a b c d].contains_all? %w[d b c]
=> true

Звичайно, метод може бути записаний як стандартний метод, наприклад

def contains_all?(a,b)
    b.uniq.all? { |x| a.count(x) >= b.count(x) }
end

і ви можете посилатися на це так

contains_all?(%w[a b c c], %w[c c c])

Дійсно, після профілювання наступна версія набагато швидша, а код коротший.

def contains_all?(a,b)
    b.all? { |x| a.count(x) >= b.count(x) }
end

Залежно від того, наскільки великі ваші масиви, ви можете розглянути ефективний алгоритм O (n log n)

def equal_a(a1, a2)
  a1sorted = a1.sort
  a2sorted = a2.sort
  return false if a1.length != a2.length
  0.upto(a1.length - 1) do 
    |i| return false if a1sorted[i] != a2sorted[i]
  end
end

Сортування витрат O (n log n) та перевірка кожної пари коштує O (n), таким чином цей алгоритм є O (n log n). Інші алгоритми не можуть бути швидшими (асимптотично) за допомогою несортованих масивів.

Більшість відповідей на основі (a1 - a2) або (a1 & a2) не працюватимуть, якщо в будь-якому масиві є дублюючі елементи. Я приїхав сюди, шукаючи спосіб переконатися, чи всі букви слова (розділені на масив) входять до набору букв (наприклад, для скребблювання). Жодна з цих відповідей не спрацювала, але ця:

def contains_all?(a1, a2)
  try = a1.chars.all? do |letter|
    a1.count(letter) <= a2.count(letter)
  end
  return try
end