ฉันจะตรวจสอบว่ารายการหนึ่งเป็นส่วนย่อยของอีกรายการได้อย่างไร

ฉันต้องตรวจสอบว่ารายการนั้นเป็นชุดย่อยของอีกชุดหรือไม่ - การส่งคืนบูลีนคือสิ่งที่ฉันต้องการ

การทดสอบความเท่าเทียมกันในรายการเล็ก ๆ หลังจากทางแยกเป็นวิธีที่เร็วที่สุดในการทำเช่นนี้หรือไม่ ประสิทธิภาพมีความสำคัญสูงสุดตามจำนวนชุดข้อมูลที่ต้องเปรียบเทียบ

การเพิ่มข้อเท็จจริงเพิ่มเติมตามการอภิปราย:

1. รายการใดรายการหนึ่งจะเหมือนกันสำหรับการทดสอบจำนวนมากหรือไม่ มันเป็นหนึ่งในนั้นคือตารางการค้นหาแบบคงที่

2. มันจำเป็นต้องเป็นรายการหรือไม่? ไม่ - ตารางการค้นหาแบบสแตติกสามารถเป็นอะไรก็ได้ที่ทำงานได้ดีที่สุด ไดนามิกหนึ่งเป็น dict จากที่เราดึงกุญแจออกเพื่อทำการค้นหาแบบคงที่

อะไรจะเป็นทางออกที่ดีที่สุดในสถานการณ์

ฟังก์ชั่น performant set.issubsetหลามให้สำหรับเรื่องนี้คือ อย่างไรก็ตามมีข้อ จำกัด เล็กน้อยที่ทำให้ไม่ชัดเจนหากเป็นคำตอบสำหรับคำถามของคุณ

รายการอาจมีรายการหลายครั้งและมีคำสั่งซื้อที่เฉพาะเจาะจง ชุดไม่ นอกจากนี้การตั้งค่าใช้งานได้เฉพาะกับวัตถุที่แฮช

คุณกำลังถามเกี่ยวกับเซตย่อยหรือส่วนประกอบ (ซึ่งหมายความว่าคุณต้องการอัลกอริธึมการค้นหาสตริง)? รายการใดรายการหนึ่งจะเหมือนกันสำหรับการทดสอบจำนวนมากหรือไม่ ประเภทข้อมูลที่มีอยู่ในรายการคืออะไร? และสำหรับเรื่องนั้นจำเป็นต้องมีรายชื่อหรือไม่?

โพสต์อื่นของคุณตัดกับ dict และรายการทำให้ประเภทชัดเจนขึ้นและได้รับคำแนะนำให้ใช้มุมมองคีย์พจนานุกรมสำหรับการทำงานเหมือนชุด ในกรณีดังกล่าวเป็นที่รู้จักกันดีว่าทำงานเพราะปุ่มพจนานุกรมทำงานเหมือนชุด (มากก่อนที่เราจะมีชุดใน Python เราใช้พจนานุกรม) หนึ่งสงสัยว่าปัญหานี้เกิดขึ้นเฉพาะเจาะจงน้อยลงในสามชั่วโมง

>>> a = [1, 3, 5]
>>> b = [1, 3, 5, 8]
>>> c = [3, 5, 9]
>>> set(a) <= set(b)
True
>>> set(c) <= set(b)
False

>>> a = ['yes', 'no', 'hmm']
>>> b = ['yes', 'no', 'hmm', 'well']
>>> c = ['sorry', 'no', 'hmm']
>>> 
>>> set(a) <= set(b)
True
>>> set(c) <= set(b)
False

one = [1, 2, 3]
two = [9, 8, 5, 3, 2, 1]

all(x in two for x in one)

คำอธิบาย: ตัวสร้างสร้างบูลีนโดยวนลูปผ่านการoneตรวจสอบรายการว่ามีรายการนั้นอยู่ในรายการtwoหรือไม่ all()ผลตอบแทนTrueถ้าทุกรายการเป็น truthy Falseอื่น

นอกจากนี้ยังมีข้อได้เปรียบที่allคืนค่าเท็จในอินสแตนซ์แรกขององค์ประกอบที่หายไปแทนที่จะต้องประมวลผลทุกรายการ

สมมติว่ารายการนั้นแฮช

>>> from collections import Counter
>>> not Counter([1, 2]) - Counter([1])
False
>>> not Counter([1, 2]) - Counter([1, 2])
True
>>> not Counter([1, 2, 2]) - Counter([1, 2])
False

หากคุณไม่สนใจรายการที่ซ้ำกันเช่น [1, 2, 2]และ[1, 2]จากนั้นใช้:

>>> set([1, 2, 2]).issubset([1, 2])
True

การทดสอบความเท่าเทียมกันในรายการเล็ก ๆ หลังจากทางแยกเป็นวิธีที่เร็วที่สุดในการทำเช่นนี้หรือไม่?

.issubsetจะเป็นวิธีที่เร็วที่สุดที่จะทำ การตรวจสอบความยาวก่อนการทดสอบissubsetจะไม่เพิ่มความเร็วเนื่องจากคุณยังมีรายการ O (N + M) เพื่อวนซ้ำและตรวจสอบ

intersectionทางออกหนึ่งที่มากขึ้นจะใช้

one = [1, 2, 3]
two = [9, 8, 5, 3, 2, 1]

set(one).intersection(set(two)) == set(one)

จุดตัดของเซตจะประกอบด้วย set one

(หรือ)

one = [1, 2, 3]
two = [9, 8, 5, 3, 2, 1]

set(one) & (set(two)) == set(one)

one = [1, 2, 3]
two = [9, 8, 5, 3, 2, 1]

set(x in two for x in one) == set([True])

หาก list1 อยู่ในรายการ 2:

• (x in two for x in one)Trueสร้างรายการของ

• เมื่อเราทำset(x in two for x in one)มีเพียงองค์ประกอบเดียว (True)

ทฤษฎีเซตไม่เหมาะสมสำหรับรายการเนื่องจากรายการซ้ำจะส่งผลให้เกิดคำตอบที่ผิดโดยใช้ทฤษฎีเซต

ตัวอย่างเช่น:

a = [1, 3, 3, 3, 5]
b = [1, 3, 3, 4, 5]
set(b) > set(a)

ไม่มีความหมาย ใช่มันให้คำตอบที่ผิด แต่ไม่ถูกต้องเนื่องจากทฤษฎีเซตเพิ่งเปรียบเทียบ: 1,3,5 เทียบกับ 1,3,4,5 คุณต้องรวมรายการที่ซ้ำกันทั้งหมด

แต่คุณต้องนับการเกิดขึ้นของแต่ละรายการและทำมากกว่าการตรวจสอบ สิ่งนี้ไม่แพงมากเพราะไม่ได้ใช้การดำเนินการ O (N ^ 2) และไม่ต้องการการเรียงลำดับอย่างรวดเร็ว

#!/usr/bin/env python

from collections import Counter

def containedInFirst(a, b):
  a_count = Counter(a)
  b_count = Counter(b)
  for key in b_count:
    if a_count.has_key(key) == False:
      return False
    if b_count[key] > a_count[key]:
      return False
  return True


a = [1, 3, 3, 3, 5]
b = [1, 3, 3, 4, 5]
print "b in a: ", containedInFirst(a, b)

a = [1, 3, 3, 3, 4, 4, 5]
b = [1, 3, 3, 4, 5]
print "b in a: ", containedInFirst(a, b)

จากนั้นเรียกใช้สิ่งนี้คุณจะได้รับ:

$ python contained.py 
b in a:  False
b in a:  True

เนื่องจากไม่มีใครพิจารณาเปรียบเทียบสองสายนี่คือข้อเสนอของฉัน

แน่นอนคุณอาจต้องการตรวจสอบว่าไปป์ ("|") ไม่ได้เป็นส่วนหนึ่งของรายการใดรายการหนึ่งหรือไม่และอาจเลือกตัวเลือกอื่นโดยอัตโนมัติ แต่คุณมีความคิด

การใช้สตริงว่างเป็นตัวคั่นไม่ใช่วิธีการแก้ปัญหาเนื่องจากตัวเลขสามารถมีหลายหลัก ([12,3]! = = 1,23]

def issublist(l1,l2):
    return '|'.join([str(i) for i in l1]) in '|'.join([str(i) for i in l2])

ให้อภัยฉันถ้าฉันไปงานปาร์ตี้สาย ;)

ในการตรวจสอบหากset Aมีการย่อยของset B, PythonมีและA.issubset(B) A <= Bใช้งานได้setเฉพาะและใช้งานได้ดีแต่ไม่ทราบความซับซ้อนของการใช้งานภายใน การอ้างอิง: https://docs.python.org/2/library/sets.html#set-objects

ฉันใช้อัลกอริทึมเพื่อตรวจสอบว่าlist Aเป็นเซตย่อยของlist Bคำพูดต่อไปนี้หรือไม่

• เพื่อลดความซับซ้อนในการค้นหาชุดย่อยฉันพบว่ามันเหมาะสมกับ sortทั้งสองรายการก่อนที่จะเปรียบเทียบองค์ประกอบเพื่อมีสิทธิ์ได้รับชุดย่อย
• มันช่วยให้ฉันเพื่อเมื่อค่าขององค์ประกอบของรายการที่สองมีค่ามากกว่าค่าขององค์ประกอบของรายการแรกbreakloopB[j]A[i]
• last_index_jจะใช้เพื่อเริ่มต้นใหม่loopเมื่อlist Bที่เหลือ มันช่วยหลีกเลี่ยงการเริ่มเปรียบเทียบจากจุดเริ่มต้น list B(ซึ่งก็คือคุณอาจเดาว่าไม่จำเป็นที่จะเริ่มlist Bจากindex 0ในภายหลังiterations)

• ความซับซ้อนจะมีO(n ln n)การเรียงลำดับทั้งรายการและO(n)การตรวจสอบชุดย่อย
  O(n ln n) + O(n ln n) + O(n) = O(n ln n).

• รหัสมีจำนวนมากของprintงบที่จะเห็นสิ่งที่เกิดขึ้นในแต่ละของiteration loopสิ่งเหล่านี้มีไว้เพื่อความเข้าใจเท่านั้น

ตรวจสอบว่ารายการหนึ่งเป็นส่วนย่อยของรายการอื่น

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");

เอาท์พุต

[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

โค้ดด้านล่างตรวจสอบว่าชุดที่กำหนดเป็น "ชุดย่อยที่เหมาะสม" ของชุดอื่น

 def is_proper_subset(set, superset):
     return all(x in superset for x in set) and len(set)<len(superset)

ใน python 3.5 คุณสามารถทำ[*set()][index]เพื่อรับองค์ประกอบ มันเป็นทางออกที่ช้ากว่าวิธีอื่น ๆ

one = [1, 2, 3]
two = [9, 8, 5, 3, 2, 1]

result = set(x in two for x in one)

[*result][0] == True

หรือเพียงแค่มี len และตั้ง

len(set(a+b)) == len(set(a))

นี่คือวิธีที่ฉันรู้ว่าหากรายการหนึ่งเป็นส่วนย่อยของอีกรายการหนึ่งลำดับสำคัญสำหรับฉันในกรณีของฉัน

def is_subset(list_long,list_short):
    short_length = len(list_short)
    subset_list = []
    for i in range(len(list_long)-short_length+1):
        subset_list.append(list_long[i:i+short_length])
    if list_short in subset_list:
        return True
    else: return False

โซลูชันส่วนใหญ่พิจารณาว่ารายการไม่มีรายการที่ซ้ำกัน ในกรณีที่รายการของคุณมีรายการซ้ำคุณสามารถลอง:

def isSubList(subList,mlist):
    uniqueElements=set(subList)
    for e in uniqueElements:
        if subList.count(e) > mlist.count(e):
            return False     
    # It is sublist
    return True

มันทำให้รายการย่อยไม่เคยมีองค์ประกอบที่แตกต่างจากรายการหรือองค์ประกอบทั่วไปจำนวนมาก

lst=[1,2,2,3,4]
sl1=[2,2,3]
sl2=[2,2,2]
sl3=[2,5]

print(isSubList(sl1,lst)) # True
print(isSubList(sl2,lst)) # False
print(isSubList(sl3,lst)) # False

หากคุณถามว่ามีรายการ "มีอยู่" ในรายการอื่นหรือไม่:

>>>if listA in listB: return True

หากคุณถามว่าองค์ประกอบแต่ละรายการใน listA มีองค์ประกอบการจับคู่ใน listB เท่ากันหรือไม่ลอง:

all(True if listA.count(item) <= listB.count(item) else False for item in listA)

ถ้าเป็นa2 is subset of a1เช่นนั้นLength of set(a1 + a2) == Length of set(a1)

a1 = [1, 2, 3, 4, 5]
a2 = [1, 2, 3]

len(set(a1)) == len(set(a1 + a2))