Discussion :

[larchicha]

Bonjour à tous,

Je me présente, Jay, débutant en python.
Je rencontre quelques problèmes sur certains exercices...

On me demande de créer une fonction qui prend 2 listes d'entiers en argument, et qui vérifie que les éléments de la première liste sont dans la deuxième, dans le même ordre.
Tel que : list1 = [2,3,4] list2=[1,2,3,4,5] renvoie True
list1 = [2,3,4] list3=[1,2,4,3,5] renvoie False


Je lutte sur le même ordre... quoique je ne suis même pas sûr que le reste soit bon, enfin je vous laisse juger.

Mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
def test_list(list1, list2):
       for element in list1: # je parcours la liste 1
           for i in range(len(list1)): # j'indice la liste 1 pour respecter l'ordre
                 if list1[i] != list2[i]: #  problème  
                        return False    
            if element not in list2:    
       return True

le problème que je vois est que : en voulant respecter l'ordre, je fais en sorte que chaque élément de la liste 1 soit exactement dans la liste 2 à la même place, or ce qu'on me demande : pouvoir barrer des elements de la liste 2 pour retrouver la liste 1.

Je m'embrouille un peu beaucoup pour ce qui semble être la base de Python...

Je vous remercie d'avance pour vos réponses.

Jay.

PS : Merci pour le Tips ValAa

[valAa]

Bonjour à toi,

PS : Désolé l'indentation n'est pas respectée...

Il ne faut pas être désolé, il faut corriger ça : c'est que sans cette indentation, on ne peut même pas savoir ce qu'est sensé faire le bout de code que tu donnes, vu qu'on ne sait pas où s'arrêtent les différents blocs. Ça va être dur de t'aider.

Je te conseille de mettre ton bout de code en deux balises CODE, que tu obtiens en utilisant le bouton '#' dans la barre d'outil de rédaction de message.
Ainsi l'indentation sera respectée.

edit : et il faudrait compéter un peu ton énoncé :
que doit-il se passer :

list1 = [2,3,4]
et :
list2 = [5, 1, 2, 9, 3, 4]

à savoir qu'on retrouve les mêmes éléments, dans le même ordre, mais pas consécutifs ?

[larchicha]

list1 = [2,3,4]
et :
list2 = [5, 1, 2, 9, 3, 4]

à savoir qu'on retrouve les mêmes éléments, dans le même ordre, mais pas consécutifs ?

Exactement... de façon à ce que si je barre les éléments 5 , 1 , 9 de la 2eme liste, je retrouve la première liste.

[eyquem]

Bonjour, et bienvenue dans ce forum, Jay

vérifier que les éléments de la première liste sont dans la deuxième, dans le même ordre.

J’interpréte ainsi:
[26,3,9,13] est bien dans [2,4,89,26,908,3,14,9,75,13,10]

L’exemple que tu donnes ne me permet pas cependant pas d’être sûr que j’interprète correctement car il est restrictif par rapport à ce cas général.
En effet si li = [2,4,89,26,908,3,14,9,75,13,10]
alors li[2:6] == [89,26,908,3]
et on peut dire que la liste [89,26,908,3] est dans la liste li, et non plus ses éléments.
Si c’est le cas, l’algorithme pour vérifier cela est différent et plus simple que dans le cas général.




Il y avait un autre point ambigu. valAa en a obtenu l’éclaircissement.



Il y a encore une autre incertitude.
Si liste 1 = [76,84,93]
est-ce que ses éléments se trouvent dans liste2 dans le même ordre avec
li = [2,3,3,4,60,76,76,76,80,83,83,84,92,93]
ou
li = [2,3,3,1,4,60,76,78,76,80,76,83,83,84,92,93] ?





Concernant ton code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
           for i in range(len(list1)): # j'indice la liste 1 pour respecter l'ordre
                 if list1[i] != list2[i]: #  problème  
                        return False

se trouve dans une boucle for element in list1: mais ne comporte pas la référence element.

La présence de cette deuxième boucle en i dans la première boucle sur element consiste donc à refaire la même chose pour tous les éléments de liste1. L’intérêt en paraît faible.



Autre problème: tu limites la plage de variation de i à la longueur de liste1 alors que dans ton exemple l’élément 4 dans liste2 est à un indice au delà. Rien que sur ton exemple, on voit donc qu’il y a un problème.





Il faut commencer par avoir une idée claire de l’algorithme (stade papier crayon) avant de le mettre en code.

Il est de bon sens de commencer par for element in list1:

Mais ensuite, pour ne pas rester dans le vague de la formulation “dans le même ordre“ il faut la décomposer en une formulation plus concrète: “l’ordre des élements de liste1 dans liste1 est le même que l’ordre des éléments de liste1 dans liste2“. À partir de là, on peut se poser la bonne question: concrètement, qu’est ce que l’ordre d’éléments , comment le représente-t-on ?

[eyquem]

Impressionant, N.tox

Mais je pense qu’il y certainement des solutions plus simples. Je n’ai pas écrit les codes, mais j’en ai l’idée de deux.

En fait , il faudrait plus de précision encore sur les cas susceptibles d’être rencontrés: doublons dans une liste possible ? dans les deux ?

[N.tox]

Impressionant, N.tox

Mais je pense qu’il y certainement des solutions plus simples. Je n’ai pas écrit les codes, mais j’en ai l’idée de deux.

En fait , il faudrait plus de précision encore sur les cas susceptibles d’être rencontrés: doublons dans une liste possible ? dans les deux ?

Normalement, l'algorithme horrible que j'ai pondu couvre les cas des doublons dans chacune des listes ou dans une seule...

Ceci dit, je suis positivement curieux de voir un autre algorithme bien plus élégant (et performant, cause le mien... hum hum)

@larchicha : pour améliorer ton algorithmie, d'une manière générale, comme l'a très bien dit eyquem : pose noir sur blanc le but de façon clair, puis décompose le en étapes tout aussi clair (éventuellement corrige), et répète ce processus jusqu'à arriver pratiquement au code... en parallèle, y'a pas de secret : faut se planter, corriger, tester à nouveau, et encore corriger, tester, et ça même sur des petites choses, comme bien comprendre le mécanisme d'une boucle for, d'ailleurs à ton avis, pourquoi ais-je utiliser while plutôt que for ? (tu pourras demander la réponse si tu veux hein... j'te la donnerais alors) Trouve la réponse à cette question et t'auras bien compris une des particularités de for

[larchicha]

Awesome...

Le problème est beaucoup plus clair déja mais sur l'énoncé, il n'y a pas le cas des doublons, qui est certes important donc à mon avis implicite...

Par contre, pour le cas particulier, de la liste DANS la liste, et non plus le cas général des éléments dans la liste, je suis assez d'accord avec toi car cela respecte l'énoncé en réduisant le problème mais, cela revient à faire plusieurs parties dans mon code pour les différents cas ? (en étant très perfectionniste)

Merci encore de vos réponses .

[N.tox]

c'est peut-être pas ce qu'il y a de plus élégant ou propre, et je l'ai fait à l'arrache, mais ça fonctionne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
def func(lstI,lstII):
    lstII = lstII[:]
    lI,lII = len(lstI), len(lstII)
    if lI < lII:
        small, big = lstI, lstII
    elif lI>lII:
        small, big = lstII, lstI
    else:
        return lstI==lstII #retourne True ou False
    print "not same length"
 
    #elimination des éléments de big non présents dans small
    idx=0
    while 1:
        if big[idx] not in small:
            del big[idx]
        else :
            idx += 1
        if idx >= len(big): break
    print 'first cleaning', small, big
 
    #vérification de la présence de chaque élément de small dans big
    for x in small:
        if x not in big : return False
        elif small.count(x) > big.count(x): return False
    print 'each element of small are in big'
 
    #vérification de l'ordre
    idx_big = idx_small = 0
    ls                  = len(small)
    while 1:
        print 'compare', small[idx_small], big[idx_big]
        if big[idx_big]     == small[idx_small] :
            idx_big         += 1
            if idx_small+1   < ls : idx_small +=1
            elif big[:idx_big]==small : return True
        else :
            del big[idx_big]
        if small == big : return True
        elif idx_big >= len(big):
            print 'index error on big'
            return False

Test :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> func([2,3,4], [5, 1, 2, 9, 3,2,3, 4, 3, 4])
not same length
first cleaning [2, 3, 4] [2, 3, 2, 3, 4, 3, 4]
each element of small are in big
compare 2 2
compare 3 3
compare 4 2
compare 4 3
compare 4 4
True
>>> func([2,3,4], [5, 1, 2, 9, 4, 3])
not same length
first cleaning [2, 3, 4] [2, 4, 3]
each element of small are in big
compare 2 2
compare 3 4
compare 3 3
index error on big
False

[larchicha]

Joli coup...
Au premier coup d'oeil, je comprend ton code, mais bon la tu m'as donné la réponse...(ce dont je te remercie).

Maintenant, quand tu lis mon code, que me conseilles tu de faire pour améliorer mon code d'une part, et mon ' algorithmie ' d'autre part, parce que je sens bien que c'est une grosse lacune chez moi...:'(

[eyquem]

Eh bien oui, c’est ça, bravo, mais pourquoi introduis tu deux lettre ’e’ et ’d’ ?

Ce qui correspond à ma ligne camouflée, c’est

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

itif==[ inf for inf in it if inf in itif ]

On peut faire plus court si on veut:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
i = [2,4,89,107,22,26,908,77,1,542,14,3,13,9]
oo = [89,26,908,3,5]
print oo == [o for o in i if o in oo]

À part ça, Jay ne connaît sans doute encore pas les list comprehension et pour le mettre sur la voie d’une solution parmi d’autres , je réponds a la question que j’ai évoquée: concrètement, qu’est ce que l’ordre d’éléments , comment le représente-t-on ?

Je répondrais qu’une liste d’indices d’objets dans une liste représente leur ordre dans cette liste.

Mais que pour comparer deux listes d’indices, il ne faut pas procéder de façon brutale par égalité pure.

[N.tox]

Eh bien oui, c’est ça, bravo, mais pourquoi introduis tu deux lettre ’e’ et ’d’ ?

Ce qui correspond à ma ligne camouflée, c’est

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

itif==[ inf for inf in it if inf in itif ]

c'est un humour qui me fait penser qu'il faut que je m'aère un peu la tête