Comprueba si los elementos en una lista son consecutivos.

[True for x in lst[:-1] for y in lst[1:] if x + 1 == y]

Entonces lista [1, 2, 3, 4, 5] devuelve [True, True, True, True], lo que significa que la lista es consecutiva.

Lista [1,2,3,4,4] devuelve [True, True, True, True], lo que significa que la lista es consecutiva, pero no lo es.

Haciendo por cada declaración demuestra que

lst = [1,2,3,4,4]


def consecutive(lst):    
    lst.sort()
    return [True for x in lst[:-1] for y in lst[1:] if x + 1 == y]


print(consecutive(lst))

some_list = []
for i,j in zip(lst[:-1], lst[1:]):
    if i+1 == j:
        some_list.append(True)
    else:
        some_list.append(False)

print(some_list)

Que me estoy perdiendo aqui?

0
root 29 may. 2020 a las 22:03

5 respuestas

La mejor respuesta

Su comprensión de la lista está haciendo bucles anidados, no bucles paralelos. Está girando sobre el producto cruzado de las dos rebanadas. Puede ver esto si elimina if y devuelve los valores de x y y.

>>> [(x, y) for x in lst[:-1] for y in lst[1:]]
[(1, 2), (1, 3), (1, 4), (1, 4), (2, 2), (2, 3), (2, 4), (2, 4), (3, 2), (3, 3), (3, 4), (3, 4), (4, 2), (4, 3), (4, 4), (4, 4)]

El resultado contiene True siempre que los elementos emparejados sean consecutivos; cuando no son consecutivos no agrega nada al resultado. Hay 4 pares consecutivos, así que eso es lo que obtienes en el resultado.

Si desea probar solo elementos adyacentes, use zip() en la comprensión:

>>> [True for x, y in zip(lst[:-1], lst[1:]) if x + 1 == y]
[True, True, True]

Si desea devolver tanto True como False en la lista, no debe usar if, debe devolver el resultado de la prueba:

>>> [(x + 1 == y) for x, y in zip(lst[:-1], lst[1:])]
[True, True, True, False]
7
Barmar 29 may. 2020 a las 19:12

Prueba esto:

[True  if(lst[x]+1 == lst[x+1])  else False for x in range(len(lst)-1)]
0
Cristian Gabor 29 may. 2020 a las 19:41

Reescribiría la primera función de la siguiente manera:

lst = [1,2,3,4,4]


def consecutive(lst):    
    lst.sort()
    return [True if lst[:-1][i] +1 ==lst[1:][i] else False  for i,x in enumerate(lst[:-1])  ]  

print(consecutive(lst))
[True, True, True, False]

Esto muestra que los primeros tres elementos son consecutivos.
Si solo desea los pares consecutivos establecidos en True, use el siguiente código:

lst = [1,2,3,4,4]


def consecutive(lst):    
    lst.sort()
    return [True for i,x in enumerate(lst[:-1]) if lst[:-1][i] +1 ==lst[1:][i]   ]


print(consecutive(lst))
[True, True, True]
0
Code Pope 29 may. 2020 a las 19:20

Realmente solo necesitas UNA iteración para lograr esto

Ver código a continuación:

def consecutive(list_):
    n = len(list_)
    list_.sort()
    ans = [True if list_[i-1]+1 == list_[i] else False for i in range(1,n)]
    return ans
list_ = [2,5,1,2,6,3,7,7]
print(consecutive(list_))
[True, False, True, False, True, True, False]
0
whataconundrum 29 may. 2020 a las 19:42

No creo que tu código esté haciendo lo que crees que está haciendo.

Lo ajusté un poco y esto es lo que sucedió:

>>> [[x, y] for x in lst[:-1] for y in lst[1:]]
[[1, 2], [1, 3], [1, 4], [1, 4], [2, 2], [2, 3], [2, 4], [2, 4], [3, 2], [3, 3], [3, 4], [3, 4], [4, 2], [4, 3], [4, 4], [4, 4]]

La comprensión de su lista es en realidad un bucle 2D y solo está filtrando todas las combinaciones para un número semialeatorio de True 's de vuelta.

En su caso, [1, 2], [2, 3], [3, 4] y [3, 4] están cumpliendo la condición x + 1 == y.

Considere la posibilidad de reescribir consecutive, aquí hay una idea rápida, por ejemplo:

def consecutive(lst):
    return [lst[i] + 1 == lst[i + 1] for i in range(len(lst) - 1)]
    # implicitly does the same thing as return [True if lst[i] + 1 == lst[i + 1] else False for i in range(len(lst) - 1)]
1
notacorn 29 may. 2020 a las 19:15