Como posso verificar se uma lista é um subconjunto de outra?

Preciso verificar se uma lista é um subconjunto de outra - um retorno booleano é tudo que procuro.

Testar a igualdade na lista menor após uma interseção é a maneira mais rápida de fazer isso? O desempenho é de extrema importância, considerando o número de conjuntos de dados que precisam ser comparados.

Adicionando fatos adicionais com base em discussões:

1. Qualquer uma das listas será a mesma para muitos testes? Faz como um deles é uma tabela de pesquisa estática.

2. Precisa ser uma lista? Isso não acontece - a tabela de pesquisa estática pode ser qualquer coisa que tenha melhor desempenho. O dinâmico é um ditado a partir do qual extraímos as chaves para executar uma pesquisa estática.

Qual seria a solução ideal diante do cenário?

A função de desempenho que o Python fornece para isso é set.issubset. No entanto, existem algumas restrições que tornam claro se é a resposta para sua pergunta.

Uma lista pode conter itens várias vezes e tem um pedido específico. Um conjunto não. Além disso, os conjuntos funcionam apenas em objetos hashable .

Você está perguntando sobre subconjunto ou subsequência (o que significa que você desejará um algoritmo de pesquisa de cadeias)? Qualquer uma das listas será a mesma para muitos testes? Quais são os tipos de dados contidos na lista? E, nesse caso, precisa ser uma lista?

Sua outra postagem intercepta um ditado e a lista tornou os tipos mais claros e recebeu uma recomendação para usar as visualizações de chave do dicionário para a funcionalidade de conjunto. Nesse caso, sabia-se que funcionava porque as chaves de dicionário se comportam como um conjunto (tanto que, antes de termos conjuntos em Python, usamos dicionários). É de se perguntar como o problema ficou menos específico em três horas.

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

Explicação: Gerador criando booleanos percorrendo a lista oneverificando se esse item está na lista two. all()retorna Truese cada item é verdadeiro, caso contrário False.

Há também uma vantagem que allretorna False na primeira instância de um elemento ausente, em vez de precisar processar cada item.

Supondo que os itens sejam laváveis

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

Se você não se importa com itens duplicados, por exemplo. [1, 2, 2]e [1, 2]então basta usar:

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

Testar a igualdade na lista menor após uma interseção é a maneira mais rápida de fazer isso?

.issubsetserá a maneira mais rápida de fazer isso. A verificação do comprimento antes do teste issubsetnão melhora a velocidade, porque você ainda possui itens O (N + M) para percorrer e verificar.

Mais uma solução seria usar a intersection.

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

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

A interseção dos conjuntos conteria de set one

(OU)

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

Se a lista1 estiver na lista 2:

• (x in two for x in one)gera uma lista de True.

• quando fazemos a set(x in two for x in one)tem apenas um elemento (True).

A teoria dos conjuntos é inadequada para listas, pois duplicatas resultarão em respostas erradas usando a teoria dos conjuntos.

Por exemplo:

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

não tem significado. Sim, fornece uma resposta falsa, mas isso não está correto, uma vez que a teoria dos conjuntos está apenas comparando: 1,3,5 versus 1,3,4,5. Você deve incluir todas as duplicatas.

Em vez disso, você deve contar cada ocorrência de cada item e fazer um valor maior que igual para verificar. Isso não é muito caro, porque não está usando operações O (N ^ 2) e não requer classificação rápida.

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

Ao executar isso, você obtém:

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

Como ninguém considerou comparar duas strings, aqui está minha proposta.

Obviamente, você pode querer verificar se o canal ("|") não faz parte de nenhuma das listas e talvez escolheu automaticamente outro caractere, mas você entendeu.

Usar uma string vazia como separador não é uma solução, pois os números podem ter vários dígitos ([12,3]! = [1,23])

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

Perdoe-me se eu estiver atrasado para a festa. ;)

Para verificar se um set Aé um subconjunto de set B, Pythonpossui A.issubset(B)e A <= B. Ele funciona setapenas e funciona muito bem, mas a complexidade da implementação interna é desconhecida. Referência: https://docs.python.org/2/library/sets.html#set-objects

Eu vim com um algoritmo para verificar se list Aé um subconjunto das list Bseguintes observações.

• Para reduzir a complexidade da localização de um subconjunto, considero apropriado as sortduas listas antes de comparar os elementos para qualificar para o subconjunto.
• Ajudou-me breaka loopquando o valor do elemento da segunda lista B[j]é maior que o valor do elemento da primeira lista A[i].
• last_index_jé usado para iniciar loopsobre list Bonde último saiu fora. Ela ajuda a evitar começar comparações a partir do início list B(o que é, como você pode imaginar desnecessário, para começar list Ba partir index 0em posterior iterations.)

• O(n ln n)Cada complexidade será cada uma para classificar as duas listas e O(n)verificar o subconjunto.
  O(n ln n) + O(n ln n) + O(n) = O(n ln n).

• O código possui várias printinstruções para ver o que está acontecendo em cada uma iterationdas loop. Estes destinam-se apenas à compreensão.

Verifique se uma lista é subconjunto de outra lista

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

Resultado

[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

O código abaixo verifica se um determinado conjunto é um "subconjunto adequado" de outro conjunto

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

No python 3.5, você pode fazer um [*set()][index]para obter o elemento É uma solução muito mais lenta que outros métodos.

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

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

[*result][0] == True

ou apenas com len e definir

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

Aqui está como eu sei se uma lista é um subconjunto de outra, a sequência é importante para mim no meu caso.

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

A maioria das soluções considera que as listas não possuem duplicatas. Caso suas listas tenham duplicatas, você pode tentar o seguinte:

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

Ele garante que a sublista nunca tenha elementos diferentes da lista ou uma quantidade maior de um elemento comum.

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

Se você está perguntando se uma lista está "contida" em outra lista, então:

>>>if listA in listB: return True

Se você está perguntando se cada elemento da lista A tem um número igual de elementos correspondentes na lista B, tente:

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

Se a2 is subset of a1entãoLength 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))