Як я можу перевірити, чи є один список підмножиною іншого?

Мені потрібно перевірити, чи список є підмножиною іншого - булеве повернення - все, що я прагну.

Чи тестування рівності за меншим списком після перетину є найшвидшим способом зробити це? Продуктивність має надзвичайно важливе значення, враховуючи кількість наборів даних, які потрібно порівняти.

Додавання додаткових фактів на основі дискусій:

1. Чи буде один із списків однаковим для багатьох тестів? Один із них - це статична таблиця пошуку.

2. Чи потрібен це список? Це не так - статична таблиця пошуку може бути будь-якою, яка працює найкраще. Динамічний - це дікт, з якого ми дістаємо ключі для здійснення статичного пошуку.

Яке було б оптимальне рішення з огляду на сценарій?

Виконаюча функція, яку Python передбачає, це set.issubset. Однак у нього є кілька обмежень, завдяки яким стає незрозумілим, чи це відповідь на ваше запитання.

Список може містити елементи кілька разів і має певний порядок. Набір не робить. Крім того, встановлює роботу лише на об'єктах, що переміщуються .

Ви запитуєте про підмножину або підряд (що означає, що вам потрібно алгоритм пошуку рядків)? Чи буде один із списків однаковим для багатьох тестів? Які типи даних містяться у списку? І з цього приводу, чи повинен бути список?

Ваша інша публікація перетинає диктант та список, які пояснюють типи та отримують рекомендації щодо використання ключових поглядів словника для їх функціонування на зразок. У цьому випадку було відомо, що ключі словника поводяться як набір (настільки, що до того, як ми мали набори в 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повертає False на першому екземплярі відсутнього елемента, а не обробляти кожен елемент.

Якщо припустити, що елементи є хешируемими

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

• коли ми робимо a 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 ви можете зробити a, [*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 та set

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

Якщо ви запитуєте, чи кожен елемент у спискуA має рівну кількість відповідних елементів у спискуB, спробуйте:

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