Comment puis-je vérifier si une liste est un sous-ensemble d'une autre?

Je dois vérifier si une liste est un sous-ensemble d'une autre - un retour booléen est tout ce que je recherche.

Tester l'égalité sur la plus petite liste après une intersection est-il le moyen le plus rapide de le faire? Les performances sont de la plus haute importance étant donné le nombre d'ensembles de données à comparer.

Ajout de faits supplémentaires en fonction des discussions:

1. L'une ou l'autre des listes sera-t-elle la même pour de nombreux tests? Il fait comme l'un d'eux est une table de recherche statique.

2. Doit-il être une liste? Ce n'est pas le cas - la table de recherche statique peut être tout ce qui fonctionne le mieux. Le dynamique est un dict à partir duquel nous extrayons les clés pour effectuer une recherche statique.

Quelle serait la solution optimale compte tenu du scénario?

La fonction performante fournie par Python pour cela est set.issubset. Il comporte cependant quelques restrictions qui ne permettent pas de savoir si c'est la réponse à votre question.

Une liste peut contenir des éléments plusieurs fois et a un ordre spécifique. Un ensemble ne le fait pas. De plus, les ensembles ne fonctionnent que sur les objets hachables .

Demandez-vous un sous-ensemble ou une sous-séquence (ce qui signifie que vous voudrez un algorithme de recherche de chaîne)? L'une ou l'autre des listes sera-t-elle la même pour de nombreux tests? Quels sont les types de données contenus dans la liste? Et d'ailleurs, faut-il que ce soit une liste?

Votre autre article croise un dict et une liste a rendu les types plus clairs et a obtenu une recommandation d'utiliser les vues clés du dictionnaire pour leurs fonctionnalités de type ensemble. Dans ce cas, il était connu pour fonctionner parce que les clés de dictionnaire se comportent comme un ensemble (à tel point qu'avant d'avoir des ensembles en Python, nous utilisions des dictionnaires). On se demande comment la question est devenue moins précise en trois heures.

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

Explication: Générateur créant des booléens en parcourant la liste en onevérifiant si cet élément est dans la liste two. all()renvoie Truesi chaque élément est véridique, sinon False.

Il y a aussi un avantage qui allrenvoie False sur la première instance d'un élément manquant plutôt que d'avoir à traiter chaque élément.

En supposant que les éléments sont hachables

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

Si vous ne vous souciez pas des éléments en double, par exemple. [1, 2, 2]et [1, 2]puis il suffit d' utiliser:

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

Tester l'égalité sur la plus petite liste après une intersection est-il le moyen le plus rapide de le faire?

.issubsetsera le moyen le plus rapide de le faire. Vérifier la longueur avant le test issubsetn'améliorera pas la vitesse car vous avez encore des éléments O (N + M) à parcourir et à vérifier.

Une autre solution serait d'utiliser un fichier intersection.

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

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

L'intersection des ensembles contiendrait 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])

Si list1 est dans la liste 2:

• (x in two for x in one)génère une liste de True.

• quand on fait a un set(x in two for x in one)seul élément (True).

La théorie des ensembles est inappropriée pour les listes car les doublons entraîneront de mauvaises réponses en utilisant la théorie des ensembles.

Par exemple:

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

n'a pas de sens. Oui, cela donne une fausse réponse, mais ce n'est pas correct car la théorie des ensembles ne fait que comparer: 1,3,5 contre 1,3,4,5. Vous devez inclure tous les doublons.

Au lieu de cela, vous devez compter chaque occurrence de chaque élément et effectuer une vérification supérieure à égale. Ce n'est pas très coûteux, car il n'utilise pas d'opérations O (N ^ 2) et ne nécessite pas de tri rapide.

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

Ensuite, en exécutant ceci, vous obtenez:

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

Puisque personne n'a envisagé de comparer deux chaînes, voici ma proposition.

Vous pouvez bien sûr vouloir vérifier si le tube ("|") ne fait pas partie de l'une ou l'autre des listes et peut-être choisi automatiquement un autre caractère, mais vous avez eu l'idée.

Utiliser une chaîne vide comme séparateur n'est pas une solution car les nombres peuvent avoir plusieurs chiffres ([12,3]! = [1,23])

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

Pardonnez-moi si je suis en retard à la fête. ;)

Pour vérifier si l'un set Aest un sous-ensemble de set B, Pythona A.issubset(B)et A <= B. Cela fonctionne setuniquement et fonctionne très bien MAIS la complexité de la mise en œuvre interne est inconnue. Référence: https://docs.python.org/2/library/sets.html#set-objects

Je suis venu avec un algorithme pour vérifier s'il list As'agit d'un sous-ensemble des list Bremarques suivantes.

• Pour réduire la complexité de la recherche d'un sous-ensemble, je trouve qu'il est approprié de sortcommencer par les deux listes avant de comparer les éléments pour se qualifier pour un sous-ensemble.
• Il m'a aidé à breakla looplorsque la valeur de l' élément de deuxième liste B[j]est supérieure à la valeur de l' élément de la première liste A[i].
• last_index_jest utilisé pour démarrer loopsur list Boù il avait laissé la dernière. Cela permet d'éviter de commencer les comparaisons depuis le début de list B(ce qui est, comme vous pourriez le deviner inutile, de commencer list Bpar la index 0suite iterations.)

• La complexité sera à la O(n ln n)fois pour le tri des deux listes et O(n)pour la vérification du sous-ensemble.
  O(n ln n) + O(n ln n) + O(n) = O(n ln n).

• Le code contient de nombreuses printinstructions pour voir ce qui se passe à chacun iterationdes loop. Ceux-ci sont uniquement destinés à la compréhension.

Vérifiez si une liste est un sous-ensemble d'une autre liste

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

Production

[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

Le code ci-dessous vérifie si un ensemble donné est un "sous-ensemble approprié" d'un autre ensemble

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

En python 3.5, vous pouvez faire un [*set()][index]pour obtenir l'élément. C'est une solution beaucoup plus lente que les autres méthodes.

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

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

[*result][0] == True

ou juste avec len et set

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

Voici comment je sais si une liste est un sous-ensemble d'une autre, la séquence m'importe dans mon cas.

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

La plupart des solutions considèrent que les listes ne comportent pas de doublons. Si vos listes ont des doublons, vous pouvez essayer ceci:

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

Cela garantit que la sous-liste n'a jamais d'éléments différents d'une liste ou d'une plus grande quantité d'un élément commun.

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

Si vous demandez si une liste est "contenue" dans une autre liste, alors:

>>>if listA in listB: return True

Si vous demandez si chaque élément de listA a un nombre égal d'éléments correspondants dans listB, essayez:

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

Si a2 is subset of a1, alorsLength 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))