Comment comparer 4 éléments consécutifs dans une liste?

Question

Je suis novice en codage, je m'excuse d'avance si ce que je demande est simple ou n'a pas beaucoup de sens mais je vais essayer d'élaborer autant que possible. Tout d'abord, ce n'est pas pour un travail ou un projet que j'étudie simplement pour apprendre un peu de codage pour ma satisfaction. J'ai essayé de trouver des problèmes de la vie réelle à appliquer dans le codage (pseudo code principalement mais le langage python serait aussi compréhensible pour moi). Je voulais pouvoir avoir une liste d'éléments x et comparer 4 d'entre eux séquentiellement.

Par exemple, myList = [a, b, c, d, e, f, g, h, i, j, k, l]

D'abord, je veux comparer a, b, c et d. Si b>a, c>b, d>c et d> tous les 3 précédents (d>a, d>b, d>c) Je veux faire quelque chose sinon passer à la comparaison suivante. Puis j'ai voulu comparer b, c, d et e. Puis, je voulais comparer b, c, d et e. De même si c>b, d>c, e>d et e> tous les 3 précédents (e>b, e>c, e>d) je veux faire quelque chose sinon aller à la prochaine comparaison. Et si ma liste contient des éléments infinis? myList = [:] Par où commencer? Dois-je avoir un point de départ?

Je suppose que je dois utiliser une boucle for pour parcourir la liste mais je ne peux honnêtement pas comprendre comment parcourir les 4 premiers éléments, puis continuer à partir du second élément dans 4 lots d'éléments.

Depuis que j'étudie actuellement les tableaux et listes peut-être il y a une fonctionnalité qui me manque? Ou je simplement mon cerveau peut le saisir.

J'ai essayé de regarder d'autres articles dans stackoverflow mais honnêtement, je ne peux pas le comprendre à partir des réponses des autres. J'apprécierais toute aide ou orientation.

Merci d'avance.

Answer 1

Vous pouvez utiliser le haut-all() fonction de ce problème:

myList = [5, 4, 3, 6, 3, 5, 6, 2, 3, 10, 11, 3] 

def do_somthing(): 
    #your code here 
    pass 

for i in range(len(myList)-4): 
    new_list = myList[i:i+4] #here, using list slicing to jump ahead four elements. 
    if all(new_list[-1] > b for b in new_list[:-1]) and all(new_list[:-1][c] > new_list[:-1][c+1] for c in range(len(new_list)-2)): 
     do_something() 

Answer 2

L = [...] 
# get all the valid indices of the elements in the list, except for the last 4. These are the indices at which the 4-element windows start 
for i in range(len(L)-4): 
    window = L[i:i+4] # the 4 elements you want to compare 
    print("I am considering the elements starting at index", i, ". They are:", window) 
    a,b,c,d = window 
    if d>a>b>c<d and d>b: 
     print("The checks pass!") 

Maintenant, il est un moyen plus simple de le faire:

for a,b,c,d in (L[i:i+4] for i in range(len(L)-4): 
    if d>a>b>c<d and d>b: 
     print("The checks pass!") 

Answer 3

Puisque vous pouvez indexer un liste, que diriez-vous de commencer à partir de l'index 0, comparez le 0e, (0 + 1) th, (0 + 2) th, et (0 + 3) ème éléments. Ensuite, au tour suivant, augmentez votre indice à 1, et comparez les 1er, (1 + 1) e, (1 + 2) e et (1 + 3) ème éléments, et ainsi de suite. Pour le nième tour, vous comparez les éléments n, n + 1, n + 2 et (n + 3) ème, jusqu'à atteindre le 4ème élément avant la fin. C'est comme cela que vous faites généralement des choses comme 'tester m éléments à chaque fois à partir d'une séquence de longueur n', et vous pouvez facilement étendre ce modèle à des matrices ou des tableaux 3d. Le code que vous voyez dans les autres réponses est en fait tout cela, et certaines fonctionnalités de Python rendent ce travail très facile.

Maintenant, «et si la liste contient des éléments infinis»?Eh bien, alors vous aurez besoin d'un générateur, qui est un peu avancé à ce stade je suppose, mais le concept est très simple: vous laissez une fonction lire ce flux infini d'éléments dans une boucle (peut-être infinie), définir un curseur sur l'un d'entre eux, le retour (yield) l'élément sous le curseur, ainsi que les 3 éléments suivants chaque fois, et d'augmenter le curseur d'une avant la boucle suivante commence:

def unsc_infinity(somelist): 
    cur = 0 
    while True: 
     yield somelist[c:c+4] 
     cur = cur + 1 

infinity_reader = unsc_infinity(endless_stream) 
next(infinity_reader) 
# gives the 0, 1, 2, 3 th elements in endless_stream 
next(infinity_reader) 
# gives the 1, 2, 3, 4 th elements in endless_stream 
next(infinity_reader) 
# ... 

et vous pouvez boucler sur cette générateur aussi:

for a, b, c, d in unsc_infinity(endless_stream): 
    if d>a>b>c<d and d>b: 
     do_something() 

Espérons que cela aide un peu pour vous de construire un modèle mental sur la façon dont ce genre de problèmes est fait.

Answer 4

à consommer un seul élément à la fois d'un iterator et fonctionnent sur 4 retardées éléments tentent un tampon de cercle:

# make a generator as example of 'infinte list' 
import string 
agen = (e for e in string.ascii_lowercase) 

# initialize len 4 circle buffer 
cb = [next(agen) for _ in range(4)] # assumes there are at least 4 items 
ptr = 0 # initialize circle buffer pointer 

while True: 
    a,b,c,d = (cb[(i+ptr)%4] for i in range(4)) # get current 4 saved items 

    # some fuction here 
    print(a,b,c,d) 

    # get next item from generator, catch StopIteration on empty 
    try: 
     cb[ptr] = next(agen) 
    except StopIteration: 
     break 
    ptr = (ptr + 1)%4 # update circle buffer pointer 
a b c d 
b c d e 
c d e f 
d e f g 
e f g h 
f g h i 
g h i j 
h i j k 
i j k l 
j k l m 
k l m n 
l m n o 
m n o p 
n o p q 
o p q r 
p q r s 
q r s t 
r s t u 
s t u v 
t u v w 
u v w x 
v w x y 
w x y z 

« une fonction » pourrait inclure une condition d'arrêt trop:

# random.choice() as example of 'infinte iterator' 
import string 
import random 
random.choice(string.ascii_lowercase) 

# initialize len 4 circle buffer 
cb = [random.choice(string.ascii_lowercase) for _ in range(4)] # assumes there are at least 4 items 
ptr = 0 # initialize circile buffer pointer 


while True: 
    a,b,c,d = (cb[(i+ptr)%4] for i in range(4)) # get current 4 saved items 

    # some fuction here 
    print(a,b,c,d) 
    if a<b<c<d: # stopping condition 
     print("found ordered string: ", a,b,c,d) 
     break 

    # get next item from generator, catch StopIteration on empty 
    try: 
     cb[ptr] = random.choice(string.ascii_lowercase) 
    except StopIteration: 
     break 
    ptr = (ptr + 1)%4 # update circle buffer pointer 
o s w q 
s w q k 
w q k j 
q k j r 
k j r q 
j r q r 
r q r u 
q r u v 
found ordered string: q r u v