Python: comment faire pour voir si la liste contient des numéros consécutifs

Pour l'ensemble de la liste, il devrait être aussi simple que de

sorted(l) == list(range(min(l), max(l)+1))

Cela préserve la liste d'origine, mais en faire une copie (et puis tri) peut être coûteux si votre liste est particulièrement longue.

Noter qu'en Python 2, vous pouvez simplement utiliser le ci-dessous parce que range renvoyé un list objet. En 3.x et supérieur de la fonction a été modifié pour renvoyer un range objet, donc une conversion explicite à list est nécessaire avant de le comparer à sorted(l)

sorted(l) == range(min(l), max(l)+1))

Pour vérifier si n entrées sont consécutifs et non répétitif, il devient un peu plus compliqué:

def check(n, l):
    subs = [l[i:i+n] for i in range(len(l)) if len(l[i:i+n]) == n]
    return any([(sorted(sub) in range(min(l), max(l)+1)) for sub in subs])

OriginalL'auteur wnnmaw

Une fois que vous vérifiez que la liste n'a pas de doublons, juste calculer la somme des entiers compris entre min(l) et max(l):

def check(l):
    total = 0
    minimum = float('+inf')
    maximum = float('-inf')

    seen = set()

    for n in l:
        if n in seen:
            return False

        seen.add(n)

        if n < minimum:
            minimum = n

        if n > maximum:
            maximum = n

        total += n

    if 2 * total != maximum * (maximum + 1) - minimum * (minimum - 1):
        return False

    return True

OriginalL'auteur Blender

Le premier code supprime les doublons, mais maintient l'ordre:

from itertools import groupby, count

l = [1,2,4,5,2,1,5,6,5,3,5,5]

def remove_duplicates(values):
    output = []
    seen = set()
    for value in values:
        if value not in seen:
            output.append(value)
            seen.add(value)
    return output

l = remove_duplicates(l) # output = [1, 2, 4, 5, 6, 3]

Le jeu suivant est d'identifier ceux qui sont dans l'ordre, les prises de ici:

def as_range(iterable):
    l = list(iterable)
    if len(l) > 1:
        return '{0}-{1}'.format(l[0], l[-1])
    else:
        return '{0}'.format(l[0])

l = ','.join(as_range(g) for _, g in groupby(l, key=lambda n, c=count(): n-next(c)))

l sorties: 1-2,4-6,3

Vous pouvez personnaliser les fonctions en fonction de votre sortie.

OriginalL'auteur Leb

Ici est vraiment très courte, solution de facilité, sans avoir à utiliser d'importations:

range = range(10)
L = [1,3,5,2,4,6]
L = sorted(L, key = lambda L:L)
range[(L[0]):(len(L)+L[0])] == L

>>True

Cela fonctionne pour les listes numériques de n'importe quelle longueur et détecte les doublons.
Fondamentalement, vous êtes à la création d'un éventail de votre liste pourrait être, l'édition de cette gamme pour correspondre à votre liste de critères (longueur, valeur de départ) et de faire une comparaison de clichés. Je suis venu avec ce jeu de cartes, je suis de codage où j'ai besoin de détecter les lignes droites/s'exécute dans une main et il semble fonctionner assez bien.

OriginalL'auteur Bumperpants

L'entrée de cette fonction est à votre liste.Cette fonction retourne False si le nombre de répétition.
Le code ci-dessous fonctionne même si la liste ne démarre pas avec 1.

def check_is_consecutive(l):
    """
    sorts the list and 
    checks if the elements in the list are consecutive
    This function does not handle any exceptions.
    returns true if the list contains consecutive numbers, else False
    """
    l = list(filter(None,l))
    l = sorted(l)
    if len(l) > 1:
        maximum = l[-1]
        minimum = l[0] - 1
        if minimum == 0:
            if sum(l) == (maximum * (maximum+1) /2): 
                return True
            else:
                return False
        else:
            if sum(l) == (maximum * (maximum+1) /2) - (minimum * (minimum+1) /2) : 
                return True
            else:
                return False
    else:
        return True

OriginalL'auteur Alekhya Reddy