Bir dizinin başka bir dizinin tüm öğelerini içerip içermediğini belirleme

Verilen:

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

Tüm unsurları içerip içermediğini belirlemek istiyorum:

a2 = [2, 6, 15]

Bu durumda sonuç false.

Bu tür bir dizi dahil etmeyi tanımlamak için yerleşik Ruby / Rails yöntemleri var mı?

Bunu uygulamanın bir yolu:

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

Daha iyi, daha okunabilir bir yol var mı?

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

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

b - a
=> [15]

(b - a).empty?
=> false

Belki de bunu okumak daha kolaydır:

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

Dizi kesişimini de kullanabilirsiniz:

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

sizeBurada sadece hız için kullanıldığını da unutmayın (daha yavaş):

(a1 & a2) == a1

Ama sanırım birincisi daha okunabilir. Bu üçü düz yakuttur (ray değil).

Bu,

(a2 & a1) == a2

Bu gelen tüm unsurları dönen, her iki dizilerin kesişimini yaratır a2da vardır ki a1. Sonuç ile aynıysa a2, tüm öğelerin içinde bulunduğundan emin olabilirsiniz.a1 .

Bu yaklaşım, ancak başlangıçta tüm unsurlar a2birbirinden farklıysa işe yarar . Çiftler varsa, bu yaklaşım başarısız olur. O zaman Tempos'tan biri hala çalışıyor, bu yüzden gönülden yaklaşımını öneriyorum (muhtemelen daha hızlı).

Yinelenen öğe yoksa veya bu öğelerle ilgilenmiyorsanız Set sınıfını kullanabilirsiniz :

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

Kullandığı perde arkasında

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

Array sınıfını maymun yaması yapabilirsiniz:

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

Ölçek

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

Elbette yöntem standart bir yöntem olarak yazılabilir, örn.

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

ve onu şöyle çağırabilirsiniz

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

Aslında, profil oluşturduktan sonra, aşağıdaki sürüm çok daha hızlıdır ve kod daha kısadır.

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

Dizilerinizin ne kadar büyük olduğuna bağlı olarak verimli bir algoritma O (n log n) düşünebilirsiniz.

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

Sıralama maliyetleri O (n log n) ve her bir çifti kontrol etmek O (n) maliyeti dolayısıyla algoritma O (n log n) olur. Diğer algoritmalar sıralanmamış diziler kullanılarak daha hızlı (asimptotik) olamaz.

Her iki dizide de yinelenen öğeler varsa (a1 - a2) veya (a1 & a2) temelli yanıtların çoğu çalışmaz. Buraya bir kelimenin tüm harflerinin (bir diziye bölünmüş) harf kümesinin (örneğin scrabble için) bir parçası olup olmadığını görmek için bir yol aramaya geldi. Bu cevapların hiçbiri işe yaramadı, ama bu cevap verdi:

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