Bagaimana saya bisa memverifikasi jika satu daftar adalah bagian dari yang lain?

Saya perlu memverifikasi apakah daftar adalah subset dari yang lain - pengembalian boolean yang saya cari.

Apakah menguji kesetaraan pada daftar yang lebih kecil setelah persimpangan merupakan cara tercepat untuk melakukan ini? Kinerja sangat penting mengingat jumlah dataset yang perlu dibandingkan.

Menambahkan fakta lebih lanjut berdasarkan diskusi:

1. Apakah salah satu daftar akan sama untuk banyak tes? Itu karena salah satu dari mereka adalah tabel pencarian statis.

2. Apakah itu perlu daftar? Tidak - tabel pencarian statis dapat berupa apa saja yang berkinerja terbaik. Yang dinamis adalah dict dari mana kita mengekstrak kunci untuk melakukan pencarian statis.

Apa solusi optimal yang diberikan skenario?

Fungsi performansi yang disediakan oleh Python untuk ini adalah set.issubset. Namun ada beberapa batasan yang membuatnya tidak jelas apakah itu jawaban untuk pertanyaan Anda.

Daftar dapat berisi item beberapa kali dan memiliki urutan tertentu. Satu set tidak. Selain itu, set hanya berfungsi pada objek hashable .

Apakah Anda bertanya tentang subset atau urutan (yang berarti Anda ingin algoritma pencarian string)? Apakah salah satu daftar akan sama untuk banyak tes? Apa tipe data yang ada dalam daftar? Dan untuk itu, apakah perlu daftar?

Posting Anda yang lain memotong dict dan daftar membuat jenis lebih jelas dan memang mendapat rekomendasi untuk menggunakan tampilan kunci kamus untuk fungsionalitas seperti set mereka. Dalam kasus itu diketahui berfungsi karena kunci kamus berperilaku seperti satu set (sangat banyak sehingga sebelum kita memiliki set di Python kami menggunakan kamus). Orang bertanya-tanya bagaimana masalah menjadi kurang spesifik dalam tiga jam.

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

Penjelasan: Generator membuat booleans dengan mengulang daftar onememeriksa apakah item itu ada dalam daftar two. all()kembali Truejika setiap item benar, selain itu False.

Ada juga keuntungan yang allmengembalikan False pada elemen pertama elemen yang hilang daripada harus memproses setiap item.

Dengan asumsi barang-barang itu bisa dipecahkan

>>> 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

Jika Anda tidak peduli dengan item duplikat misalnya. [1, 2, 2]dan [1, 2]kemudian hanya menggunakan:

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

Apakah menguji kesetaraan pada daftar yang lebih kecil setelah persimpangan merupakan cara tercepat untuk melakukan ini?

.issubsetakan menjadi cara tercepat untuk melakukannya. Memeriksa panjang sebelum pengujian issubsettidak akan meningkatkan kecepatan karena Anda masih memiliki item O (N + M) untuk diulangi dan diperiksa.

Satu lagi solusi adalah menggunakan a intersection.

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

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

Perpotongan set akan berisi set one

(ATAU)

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])

Jika list1 ada dalam daftar 2:

• (x in two for x in one)menghasilkan daftar True.

• ketika kita melakukan set(x in two for x in one)hanya memiliki satu elemen (Benar).

Teori himpunan tidak sesuai untuk daftar karena duplikat akan menghasilkan jawaban yang salah menggunakan teori himpunan.

Sebagai contoh:

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

tidak ada artinya. Ya, itu memberikan jawaban yang salah tetapi ini tidak benar karena teori himpunan hanya membandingkan: 1,3,5 vs 1,3,4,5. Anda harus memasukkan semua duplikat.

Alih-alih, Anda harus menghitung setiap kemunculan setiap item dan melakukan yang lebih besar dari yang sama untuk memeriksanya. Ini tidak terlalu mahal, karena tidak menggunakan operasi O (N ^ 2) dan tidak memerlukan penyortiran cepat.

#!/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)

Kemudian menjalankan ini Anda dapatkan:

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

Karena tidak ada yang mempertimbangkan membandingkan dua string, inilah proposal saya.

Anda tentu saja ingin memeriksa apakah pipa ("|") bukan bagian dari salah satu daftar dan mungkin memilih secara otomatis char lain, tetapi Anda mendapatkan idenya.

Menggunakan string kosong sebagai pemisah bukanlah solusi karena angka dapat memiliki beberapa digit ([12,3]! = [1,23])

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

Maafkan saya jika saya terlambat ke pesta. ;)

Untuk memeriksa apakah set Aada subset dari set B, Pythonmemiliki A.issubset(B)dan A <= B. Ini sethanya berfungsi dan berfungsi dengan baik, tetapi kerumitan implementasi internal tidak diketahui. Referensi: https://docs.python.org/2/library/sets.html#set-objects

Saya datang dengan sebuah algoritma untuk memeriksa apakah list Aada himpunan bagian list Bdengan komentar berikut.

• Untuk mengurangi kerumitan menemukan subset, saya merasa cocok untuk sortkedua daftar terlebih dahulu sebelum membandingkan elemen untuk memenuhi syarat untuk subset.
• Ini membantu saya untuk breakyang loopketika nilai elemen daftar kedua B[j]lebih besar dari nilai elemen daftar pertama A[i].
• last_index_jdigunakan untuk memulai loopdari list Bmana terakhir kali ditinggalkan. Ini membantu menghindari memulai perbandingan dari awal list B(yang, seperti yang Anda duga tidak perlu, untuk memulai list Bdari yang index 0berikutnya iterations.)

• Kompleksitas akan menjadi O(n ln n)masing-masing untuk mengurutkan kedua daftar dan O(n)untuk memeriksa subset.
  O(n ln n) + O(n ln n) + O(n) = O(n ln n).

• Kode memiliki banyak printpernyataan untuk melihat apa yang terjadi di masing iteration- masing loop. Ini dimaksudkan hanya untuk pengertian.

Periksa apakah satu daftar adalah himpunan bagian dari daftar lain

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

Keluaran

[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

Kode di bawah ini memeriksa apakah suatu himpunan merupakan "himpunan bagian yang tepat" dari himpunan lain

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

Dalam python 3.5 Anda bisa melakukan [*set()][index]untuk mendapatkan elemen. Ini adalah solusi yang jauh lebih lambat daripada metode lain.

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

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

[*result][0] == True

atau hanya dengan len dan set

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

Berikut adalah bagaimana saya tahu jika satu daftar adalah bagian dari yang lain, urutannya penting bagi saya dalam kasus saya.

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

Sebagian besar solusi menganggap bahwa daftar tidak memiliki duplikat. Jika daftar Anda memiliki duplikat, Anda dapat mencoba ini:

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

Ini memastikan bahwa sublist tidak pernah memiliki elemen yang berbeda dari daftar atau elemen umum dalam jumlah yang lebih besar.

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

Jika Anda bertanya apakah satu daftar "terkandung" di daftar lain, maka:

>>>if listA in listB: return True

Jika Anda bertanya apakah setiap elemen dalam listA memiliki jumlah elemen pencocokan yang sama di listB coba:

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

Jika a2 is subset of a1demikianLength 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))