Cách xác định nếu một mảng chứa tất cả các thành phần của mảng khác

Được:

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

Tôi muốn xác định xem nó có chứa tất cả các yếu tố của:

a2 = [2, 6, 15]

Trong trường hợp này kết quả là false.

Có bất kỳ phương thức Ruby / Rails tích hợp nào để xác định sự bao gồm mảng như vậy không?

Một cách để thực hiện điều này là:

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

Có cách nào tốt hơn, dễ đọc hơn không?

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

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

b - a
=> [15]

(b - a).empty?
=> false

Có lẽ điều này dễ đọc hơn:

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

Bạn cũng có thể sử dụng giao điểm mảng:

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

Lưu ý rằng sizeđược sử dụng ở đây chỉ để tăng tốc, bạn cũng có thể làm (chậm hơn):

(a1 & a2) == a1

Nhưng tôi đoán đầu tiên là dễ đọc hơn. Cả 3 đều là ruby ​​trơn (không phải đường ray).

Điều này có thể đạt được bằng cách làm

(a2 & a1) == a2

Điều này tạo ra giao điểm của cả hai mảng, trả về tất cả các phần tử a2cũng nằm trong đó a1. Nếu kết quả giống như a2, bạn có thể chắc chắn rằng bạn có tất cả các yếu tố được bao gồm a1.

Cách tiếp cận này chỉ hoạt động nếu tất cả các yếu tố a2khác nhau ở nơi đầu tiên. Nếu có đôi, cách tiếp cận này thất bại. Cái từ Tempose vẫn hoạt động sau đó, vì vậy tôi hết lòng khuyên bạn nên tiếp cận (cũng có thể nhanh hơn).

Nếu không có phần tử trùng lặp hoặc bạn không quan tâm đến chúng, thì bạn có thể sử dụng lớp Set :

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

Đằng sau hậu trường này

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

Bạn có thể vá lỗi lớp Array:

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

kiểm tra

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

Tất nhiên phương thức có thể được viết như một phương thức đơn tiêu chuẩn, vd

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

và bạn có thể gọi nó như

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

Thật vậy, sau khi định hình, phiên bản sau nhanh hơn nhiều và mã ngắn hơn.

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

Tùy thuộc vào mức độ lớn của mảng của bạn, bạn có thể xem xét một thuật toán hiệu quả 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

Sắp xếp chi phí O (n log n) và kiểm tra mỗi cặp chi phí O (n) do đó thuật toán này là O (n log n). Các thuật toán khác không thể nhanh hơn (không có triệu chứng) bằng cách sử dụng các mảng chưa được sắp xếp.

Hầu hết các câu trả lời dựa trên (a1 - a2) hoặc (a1 & a2) sẽ không hoạt động nếu có các phần tử trùng lặp trong một trong hai mảng. Tôi đến đây để tìm cách để xem liệu tất cả các chữ cái của một từ (được chia thành một mảng) là một phần của một tập hợp các chữ cái (ví dụ như viết nguệch ngoạc). Không có câu trả lời nào trong số này có hiệu quả, nhưng câu trả lời này có:

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