วิธีการตรวจสอบว่าหนึ่งอาร์เรย์มีองค์ประกอบทั้งหมดของอาร์เรย์อื่น

ได้รับ:

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:

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) อัลกอริทึมอื่นไม่สามารถเร็วขึ้น (asymptotically) โดยใช้อาร์เรย์ที่ไม่เรียงลำดับ

คำตอบส่วนใหญ่จาก (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