Hướng dẫn how do you check if a set is a subset of another set in python? - làm cách nào để kiểm tra xem một tập hợp có phải là tập hợp con của một tập hợp khác trong python không?

Question

Các bộ là các cấu trúc dữ liệu không có thứ tự không chứa các bản sao. Trong bức ảnh này, chúng tôi sẽ thảo luận về cách xác định xem một bộ là một tập hợp con của một bộ khác. are unordered data structures that do not contain duplicates. In this shot, we will discuss how to determine if a set is a subset of another set.

Nội dung chính Show

Một tập hợp con là gì?
1. Cách sử dụng issubset()
2. Cách sử dụng setA = {1, 2, 3, 4, 5}setB = {1, 2, 3}setC = {1, 2, 3, 6, 7}print("setA: ", setA)print("setB: ", setB)print("setC: ", setC)print("Is setB a subset of setA?: ", setB.issubset(setA))print("Is setA a subset of setB?: ", setA.issubset(setB))print("Is setC a subset of setA?: ", setC.issubset(setA))6
3. Cách sử dụng vòng lặp setA = {1, 2, 3, 4, 5}setB = {1, 2, 3}setC = {1, 2, 3, 6, 7}print("setA: ", setA)print("setB: ", setB)print("setC: ", setC)print("Is setB a subset of setA?: ", setB.issubset(setA))print("Is setA a subset of setB?: ", setA.issubset(setB))print("Is setC a subset of setA?: ", setC.issubset(setA))9
Làm thế nào để bạn kiểm tra xem một bộ là một tập hợp con của một bộ khác?
Làm thế nào để bạn tìm thấy tập hợp con của một bộ trong Python?
Làm thế nào để bạn kiểm tra xem một danh sách là tập hợp con vào một danh sách khác trong Python?
Là một tập hợp tập hợp con của một bộ khác?

Một tập hợp con là gì?

Nếu tất cả các giá trị của một tập hợp, A, cũng được chứa trong một tập hợp lớn hơn, B, thì A là một tập hợp con của B.

1. Cách sử dụng issubset()

Hàm tích hợp issubset() có thể được sử dụng để xác định xem một bộ là tập hợp con của một bộ khác.issubset() can be used to determine if a set is a subset of another set.

setA.issubset(setB)

Hàm issubset() có một đối số: tập hợp lớn hơn. Ở đây, chúng tôi đang kiểm tra xem

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

0 có phải là tập hợp con của

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

1 không.

Hàm sẽ trả về

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

2 nếu

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

0 là tập hợp con của

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

1 và

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

5 nếu không.

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

2. Cách sử dụng setA = {1, 2, 3, 4, 5}setB = {1, 2, 3}setC = {1, 2, 3, 6, 7}print("setA: ", setA)print("setB: ", setB)print("setC: ", setC)print("Is setB a subset of setA?: ", setB.issubset(setA))print("Is setA a subset of setB?: ", setA.issubset(setB))print("Is setC a subset of setA?: ", setC.issubset(setA))6

Hàm

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

6 tích hợp trả về một tập hợp chứa các phần tử mà hai bộ chia sẻ.
setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))
6 function returns a set that contains the elements that the two sets share.

set.intersection(set1)

Nếu tập hợp

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

8 trả về bằng tập nhỏ hơn, bộ nhỏ hơn là một tập hợp con của tập hợp lớn hơn.

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)



print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

3. Cách sử dụng vòng lặp setA = {1, 2, 3, 4, 5}setB = {1, 2, 3}setC = {1, 2, 3, 6, 7}print("setA: ", setA)print("setB: ", setB)print("setC: ", setC)print("Is setB a subset of setA?: ", setB.issubset(setA))print("Is setA a subset of setB?: ", setA.issubset(setB))print("Is setC a subset of setA?: ", setC.issubset(setA))9

Chúng ta có thể sử dụng một vòng

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

9 đơn giản để đi qua tập hợp con tiềm năng, giả sử,

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

1.

Nếu bất kỳ yếu tố nào của

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

1 không nằm trong tập hợp khác,

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

0, thì

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

1 không phải là một tập hợp con của ____10. Nếu không,

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

1 là một tập hợp con của

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setB.issubset(setA))
print("Is setA a subset of setB?: ", setA.issubset(setB))
print("Is setC a subset of setA?: ", setC.issubset(setA))

0.

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
print("setA: ", setA)
print("setB: ", setB)
subSet = True
for i in setB:
  if i not in setA:
    subSet = False
if subSet == False:
  print("SetB is not a subset of SetA")
else:
  print("SetB is a subset of SetA")
for i in setA:
  if i not in setB:
    subSet = False
if subSet == False:
  print("SetA is not a subset of SetB")
else:
  print("SetA is a subset of SetB")

Xin tha thứ cho tôi nếu tôi đến trễ bữa tiệc. ;)

Để kiểm tra xem một

set.intersection(set1)

8 có phải là tập hợp con

set.intersection(set1)

9 không,

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

0 có

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

1 và

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

2. Nó chỉ hoạt động trên

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

3 và hoạt động tuyệt vời nhưng sự phức tạp của việc thực hiện nội bộ vẫn chưa được biết. Tham khảo: https://docs.python.org/2/l Library/sets.html#set- objectsBUT the complexity of internal implementation is unknown. Reference: https://docs.python.org/2/library/sets.html#set-objects

Tôi đã đưa ra một thuật toán để kiểm tra xem

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

4 có phải là tập hợp con của

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

5 với những nhận xét sau không.

Để giảm độ phức tạp của việc tìm tập hợp con, tôi thấy nó phù hợp với

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

6 cả hai danh sách trước khi so sánh các yếu tố để đủ điều kiện cho tập hợp con.

Nó đã giúp tôi

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

7

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

8 khi giá trị của phần tử của danh sách thứ hai

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

9 lớn hơn giá trị của phần tử của danh sách đầu tiên

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
print("setA: ", setA)
print("setB: ", setB)
subSet = True
for i in setB:
  if i not in setA:
    subSet = False
if subSet == False:
  print("SetB is not a subset of SetA")
else:
  print("SetB is a subset of SetA")
for i in setA:
  if i not in setB:
    subSet = False
if subSet == False:
  print("SetA is not a subset of SetB")
else:
  print("SetA is a subset of SetB")

0.

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
print("setA: ", setA)
print("setB: ", setB)
subSet = True
for i in setB:
  if i not in setA:
    subSet = False
if subSet == False:
  print("SetB is not a subset of SetA")
else:
  print("SetB is a subset of SetA")
for i in setA:
  if i not in setB:
    subSet = False
if subSet == False:
  print("SetA is not a subset of SetB")
else:
  print("SetA is a subset of SetB")

1 được sử dụng để bắt đầu

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)



print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

8 trên

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

5 nơi nó cuối cùng rời đi. Nó giúp tránh bắt đầu so sánh từ khi bắt đầu

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

5 (như bạn có thể đoán không cần thiết, để bắt đầu

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

5 từ

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
print("setA: ", setA)
print("setB: ", setB)
subSet = True
for i in setB:
  if i not in setA:
    subSet = False
if subSet == False:
  print("SetB is not a subset of SetA")
else:
  print("SetB is a subset of SetA")
for i in setA:
  if i not in setB:
    subSet = False
if subSet == False:
  print("SetA is not a subset of SetB")
else:
  print("SetA is a subset of SetB")

6 trong sau đó

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
print("setA: ", setA)
print("setB: ", setB)
subSet = True
for i in setB:
  if i not in setA:
    subSet = False
if subSet == False:
  print("SetB is not a subset of SetA")
else:
  print("SetB is a subset of SetA")
for i in setA:
  if i not in setB:
    subSet = False
if subSet == False:
  print("SetA is not a subset of SetB")
else:
  print("SetA is a subset of SetB")

7.)

Độ phức tạp sẽ là

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
print("setA: ", setA)
print("setB: ", setB)
subSet = True
for i in setB:
  if i not in setA:
    subSet = False
if subSet == False:
  print("SetB is not a subset of SetA")
else:
  print("SetB is a subset of SetA")
for i in setA:
  if i not in setB:
    subSet = False
if subSet == False:
  print("SetA is not a subset of SetB")
else:
  print("SetA is a subset of SetB")

8 mỗi để sắp xếp cả danh sách và

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
print("setA: ", setA)
print("setB: ", setB)
subSet = True
for i in setB:
  if i not in setA:
    subSet = False
if subSet == False:
  print("SetB is not a subset of SetA")
else:
  print("SetB is a subset of SetA")
for i in setA:
  if i not in setB:
    subSet = False
if subSet == False:
  print("SetA is not a subset of SetB")
else:
  print("SetA is a subset of SetB")

9 để kiểm tra tập hợp con.

is_subset = True;

A = [9, 3, 11, 1, 7, 2];
B = [11, 4, 6, 2, 15, 1, 9, 8, 5, 3];

print(A, B);

# skip checking if list A has elements more than list B
if len(A) > len(B):
    is_subset = False;
else:
    # complexity of sorting using quicksort or merge sort: O(n ln n)
    # use best sorting algorithm available to minimize complexity
    A.sort();
    B.sort();

    print(A, B);

    # complexity: O(n^2)
    # for a in A:
    #   if a not in B:
    #       is_subset = False;
    #       break;

    # complexity: O(n)
    is_found = False;
    last_index_j = 0;

    for i in range(len(A)):
        for j in range(last_index_j, len(B)):
            is_found = False;

            print("i=" + str(i) + ", j=" + str(j) + ", " + str(A[i]) + "==" + str(B[j]) + "?");

            if B[j] <= A[i]:
                if A[i] == B[j]:
                    is_found = True;
                last_index_j = j;
            else:
                is_found = False;
                break;

            if is_found:
                print("Found: " + str(A[i]));
                last_index_j = last_index_j + 1;
                break;
            else:
                print("Not found: " + str(A[i]));

        if is_found == False:
            is_subset = False;
            break;

print("subset") if is_subset else print("not subset");

0.

is_subset = True;

A = [9, 3, 11, 1, 7, 2];
B = [11, 4, 6, 2, 15, 1, 9, 8, 5, 3];

print(A, B);

# skip checking if list A has elements more than list B
if len(A) > len(B):
    is_subset = False;
else:
    # complexity of sorting using quicksort or merge sort: O(n ln n)
    # use best sorting algorithm available to minimize complexity
    A.sort();
    B.sort();

    print(A, B);

    # complexity: O(n^2)
    # for a in A:
    #   if a not in B:
    #       is_subset = False;
    #       break;

    # complexity: O(n)
    is_found = False;
    last_index_j = 0;

    for i in range(len(A)):
        for j in range(last_index_j, len(B)):
            is_found = False;

            print("i=" + str(i) + ", j=" + str(j) + ", " + str(A[i]) + "==" + str(B[j]) + "?");

            if B[j] <= A[i]:
                if A[i] == B[j]:
                    is_found = True;
                last_index_j = j;
            else:
                is_found = False;
                break;

            if is_found:
                print("Found: " + str(A[i]));
                last_index_j = last_index_j + 1;
                break;
            else:
                print("Not found: " + str(A[i]));

        if is_found == False:
            is_subset = False;
            break;

print("subset") if is_subset else print("not subset");

0.

Mã có rất nhiều câu lệnh

is_subset = True;

A = [9, 3, 11, 1, 7, 2];
B = [11, 4, 6, 2, 15, 1, 9, 8, 5, 3];

print(A, B);

# skip checking if list A has elements more than list B
if len(A) > len(B):
    is_subset = False;
else:
    # complexity of sorting using quicksort or merge sort: O(n ln n)
    # use best sorting algorithm available to minimize complexity
    A.sort();
    B.sort();

    print(A, B);

    # complexity: O(n^2)
    # for a in A:
    #   if a not in B:
    #       is_subset = False;
    #       break;

    # complexity: O(n)
    is_found = False;
    last_index_j = 0;

    for i in range(len(A)):
        for j in range(last_index_j, len(B)):
            is_found = False;

            print("i=" + str(i) + ", j=" + str(j) + ", " + str(A[i]) + "==" + str(B[j]) + "?");

            if B[j] <= A[i]:
                if A[i] == B[j]:
                    is_found = True;
                last_index_j = j;
            else:
                is_found = False;
                break;

            if is_found:
                print("Found: " + str(A[i]));
                last_index_j = last_index_j + 1;
                break;
            else:
                print("Not found: " + str(A[i]));

        if is_found == False:
            is_subset = False;
            break;

print("subset") if is_subset else print("not subset");

1 để xem những gì đang diễn ra ở mỗi

is_subset = True;

A = [9, 3, 11, 1, 7, 2];
B = [11, 4, 6, 2, 15, 1, 9, 8, 5, 3];

print(A, B);

# skip checking if list A has elements more than list B
if len(A) > len(B):
    is_subset = False;
else:
    # complexity of sorting using quicksort or merge sort: O(n ln n)
    # use best sorting algorithm available to minimize complexity
    A.sort();
    B.sort();

    print(A, B);

    # complexity: O(n^2)
    # for a in A:
    #   if a not in B:
    #       is_subset = False;
    #       break;

    # complexity: O(n)
    is_found = False;
    last_index_j = 0;

    for i in range(len(A)):
        for j in range(last_index_j, len(B)):
            is_found = False;

            print("i=" + str(i) + ", j=" + str(j) + ", " + str(A[i]) + "==" + str(B[j]) + "?");

            if B[j] <= A[i]:
                if A[i] == B[j]:
                    is_found = True;
                last_index_j = j;
            else:
                is_found = False;
                break;

            if is_found:
                print("Found: " + str(A[i]));
                last_index_j = last_index_j + 1;
                break;
            else:
                print("Not found: " + str(A[i]));

        if is_found == False:
            is_subset = False;
            break;

print("subset") if is_subset else print("not subset");

2 của

setA = {1, 2, 3, 4, 5}
setB = {1, 2, 3}
setC = {1, 2, 3, 6, 7}
print("setA: ", setA)
print("setB: ", setB)
print("setC: ", setC)
print("Is setB a subset of setA?: ", setA.intersection(setB) == setB)
print("Is setA a subset of setB?: ", setA.intersection(setB) == setA)
print("Is setC a subset of setA?: ", setA.intersection(setC) == setC)

8. Đây chỉ là để hiểu.

Kiểm tra xem một danh sách là tập hợp con của một danh sách khác

is_subset = True;

A = [9, 3, 11, 1, 7, 2];
B = [11, 4, 6, 2, 15, 1, 9, 8, 5, 3];

print(A, B);

# skip checking if list A has elements more than list B
if len(A) > len(B):
    is_subset = False;
else:
    # complexity of sorting using quicksort or merge sort: O(n ln n)
    # use best sorting algorithm available to minimize complexity
    A.sort();
    B.sort();

    print(A, B);

    # complexity: O(n^2)
    # for a in A:
    #   if a not in B:
    #       is_subset = False;
    #       break;

    # complexity: O(n)
    is_found = False;
    last_index_j = 0;

    for i in range(len(A)):
        for j in range(last_index_j, len(B)):
            is_found = False;

            print("i=" + str(i) + ", j=" + str(j) + ", " + str(A[i]) + "==" + str(B[j]) + "?");

            if B[j] <= A[i]:
                if A[i] == B[j]:
                    is_found = True;
                last_index_j = j;
            else:
                is_found = False;
                break;

            if is_found:
                print("Found: " + str(A[i]));
                last_index_j = last_index_j + 1;
                break;
            else:
                print("Not found: " + str(A[i]));

        if is_found == False:
            is_subset = False;
            break;

print("subset") if is_subset else print("not subset");

Đầu ra

[9, 3, 11, 1, 7, 2] [11, 4, 6, 2, 15, 1, 9, 8, 5, 3]
[1, 2, 3, 7, 9, 11] [1, 2, 3, 4, 5, 6, 8, 9, 11, 15]
i=0, j=0, 1==1?
Found: 1
i=1, j=1, 2==1?
Not found: 2
i=1, j=2, 2==2?
Found: 2
i=2, j=3, 3==3?
Found: 3
i=3, j=4, 7==4?
Not found: 7
i=3, j=5, 7==5?
Not found: 7
i=3, j=6, 7==6?
Not found: 7
i=3, j=7, 7==8?
not subset

Làm thế nào để bạn kiểm tra xem một bộ là một tập hợp con của một bộ khác?

Trong toán học, A Set A là một tập hợp con của tập B nếu tất cả các phần tử của A cũng là các yếu tố của B; B sau đó là một siêu âm của A. Có thể cho A và B bằng nhau; Nếu chúng không đồng đều, thì A là một tập hợp con thích hợp của B.if all elements of A are also elements of B; B is then a superset of A. It is possible for A and B to be equal; if they are unequal, then A is a proper subset of B.

Làm thế nào để bạn tìm thấy tập hợp con của một bộ trong Python?

Python có itertools.combinations (ITable, n) trả về n độ dài của các phần tử từ đầu vào có thể điều chỉnh được.Điều này có thể được sử dụng để in tất cả các tập hợp con có kích thước nhất định của một bộ.itertools. combinations(iterable, n) which Return n length subsequences of elements from the input iterable. This can be used to Print all subsets of a given size of a set.

Làm thế nào để bạn kiểm tra xem một danh sách là tập hợp con vào một danh sách khác trong Python?

Sử dụng giao điểm, hàm giao điểm Tìm các phần tử chung giữa hai bộ.Trong phương pháp này, chúng tôi chuyển đổi danh sách thành các bộ và áp dụng hàm giao điểm.Nếu kết quả của giao điểm giống như người phụ thì chúng tôi kết luận rằng người phụ là một phần của thelist.

Là một tập hợp tập hợp con của một bộ khác?

A Set A là một tập hợp con của một tập hợp B khác Nếu tất cả các phần tử của tập A là các phần tử của tập B. Nói cách khác, tập A được chứa bên trong tập B. Mối quan hệ tập hợp con được ký hiệu là A⊂B.. In other words, the set A is contained inside the set B. The subset relationship is denoted as A⊂B.

programming python Strict superset Python Subset Python Set Python

Hướng dẫn how do you check if a set is a subset of another set in python? - làm cách nào để kiểm tra xem một tập hợp có phải là tập hợp con của một tập hợp khác trong python không?

Một tập hợp con là gì?

1. Cách sử dụng issubset()

Làm thế nào để bạn kiểm tra xem một bộ là một tập hợp con của một bộ khác?

Làm thế nào để bạn tìm thấy tập hợp con của một bộ trong Python?

Làm thế nào để bạn kiểm tra xem một danh sách là tập hợp con vào một danh sách khác trong Python?

Là một tập hợp tập hợp con của một bộ khác?

Bài Viết Liên Quan

Quảng Cáo

Có thể bạn quan tâm

Toplist được quan tâm

Quảng cáo

Xem Nhiều

Quảng cáo

Chúng tôi

Điều khoản

Trợ giúp

Mạng xã hội