Discussion :

[Cube11]

Bonjour, je souhaite comparer deux listes entre elles. J'ai besoin que ma fonction me renvoie le nombre d'élément identique entre les deux listes (même valeur et même position), et le nombre d'élément figurant dans les deux mais pas à la même position. En considérant la première liste comme la référence, voici un exemple.

[1,2,3,4] et [1,2,3,5] il y a 3 valeurs biens placés et 0 mal placés.
[1,2,3,4] et [2,5,2,2] il y a 0 valeurs biens placés et 1 mal placés.

Pour renvoyer le nombre de valeurs biens placés je n'ai pas de problème. une simple boucle et une condition suffit mais pour la deuxième partie je n'y arrive absolument pas et je n'arrive pas à avoir d'idée. Merci

[wiztricks]

Salut,

pour la deuxième partie je n'y arrive absolument pas et je n'arrive pas à avoir d'idée.

Un nombre n de la liste L1=[1,2,3,4] est dans la liste L2=[2,5,2,2], s'il existe un e de L2 tel que e égal n.
Comme vous apprenez à jouer avec les "list" et les boucles "for", vous devriez pouvoir écrire cela avec une boucle for... non?

Après vous avez d'autres techniques comme "in" ou d'autres algos. Par exemple, considérer ces listes comme des ensembles et en prendre l'intersection. Mais si vous n'avez pas encore vu cela, il n'est pas forcément futé de prendre ces raccourcis pour "apprendre" les bases boucles et listes.

- W

[tyrtamos]

Bonjour,

Petite tentative dans la mesure où j'ai compris le pb:

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
R = [1,2,3,4] # liste de référence
 
A = [1,2,3,5]
#A = [2,5,2,2]
 
VBP = 0 # compteur des valeurs bien placées
VMP = 0 # compteur des valeurs mal placées
 
for i in range(0, len(R)):
    if R[i]==A[i]:
        print("La valeur", R[i], "de l'indice", i, "est bien placée")
        VBP += 1
    if R[i] in A[:i]+A[i+1:]:
        print("La valeur", R[i], "de l'indice", i, "est mal placée")   
        VMP += 1 
 
print()
print("Nombre de valeurs bien placées:", VBP)
print("Nombre de valeurs mal placées:", VMP)

Avec A = [1,2,3,5], ça affiche:

Code :

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

1
2
3
4
5
6
La valeur 1 de l'indice 0 est bien placée
La valeur 2 de l'indice 1 est bien placée
La valeur 3 de l'indice 2 est bien placée
 
Nombre de valeurs bien placées: 3
Nombre de valeurs mal placées: 0

Et avec A = [2,5,2,2]:

Code :

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

1
2
3
4
La valeur 2 de l'indice 1 est mal placée
 
Nombre de valeurs bien placées: 0
Nombre de valeurs mal placées: 1

[Cube11]

Oui, Tyrtamos, merci c'est bel et bien ça mon problème. D'un point de vu formel je comprend ce que vous avez codé mais pas la logique pour la deuxième condition ligne 13.
Comment le fait de regarder les i+1 première valeur fonctionne. Merci

[wiztricks]

Comment le fait de regarder les i+1 première valeur fonctionne. Merci

R[i] in A[:i]+A[i+1:] construit une liste avec toutes les positions sauf la i-ème.
Il eut été plus simple d'écrire:

Code :

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

1
2
3
4
5
6
    if R[i]==A[i]:
        print("La valeur", R[i], "de l'indice", i, "est bien placée")
        VBP += 1
    elif R[i] in A:
        print("La valeur", R[i], "de l'indice", i, "est mal placée")   
        VMP += 1

=>pas la peine de construire de sous-liste puisqu'on sait déjà que A[i] != R[i]
Mais si vous ne connaissez pas encore séquences et "in", vous pouvez obtenir le résultat avec une boucle for.

- W

[tyrtamos]

Comment le fait de regarder les i+1 première valeur fonctionne. Merci

A chaque i, avec A[:i]+A[i+1:], je reconstruis une nouvelle liste A dans la quelle la valeur d'indice i a été retirée. il suffit alors de tester la présence de la valeur R[i] dans cette liste reconstruite (test avec "in") pour savoir si cette valeur se retrouve à un endroit mal placé.

Par exemple, reconstruction de la liste A pour A = [1,2,3,5]:

i=0 => [2.3.5]
i=1 => [1,3,5]
i=2 => [1,2,5]
i=3 => [1,2,3]

Au lieu de faire ça, on pourrait faire une boucle j imbriquée dans la boucle i, et tester l'égalité des valeurs R[i]==R[j], avec le cas particulier de i==j qui correspond à une "valeur bien placée".

[Clodion]

Bonsoir,
Les conseils de wiztricks et de tyrtamos sont pertinents.
Pour éviter l'utilisation de "in", il suffit de réaliser une boucle très simple:

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
lst1 = [1, 2, 3, 4]
lst2 = [1, 2, 3, 5]
#lst2 = [2, 5, 2, 2]
 
cpt_bon_index = 0
cpt_autre_ind = 0
 
for ind in range(len(lst1)):
    if lst1[ind] == lst2[ind]:
        cpt_bon_index += 1
    else:
        for ind2 in range(len(lst2)):
            if lst1[ind] == lst2[ind2]:
                cpt_autre_ind += 1
                break
print("Nombre d'éléments à position identique : ", cpt_bon_index)
print("Nombre d'éléments à poistion différente : ", cpt_autre_ind)

Clodion

PS: si le "break" n'est pas connu, un contournement serait de remplacer le "else" par:

Code :

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

1
2
3
4
5
6
        trouve = False
        for ind2 in range(len(lst2)):
            if lst1[ind] == lst2[ind2]:
                trouve = True
        if trouve:
            cpt_autre_ind += 1

[tyrtamos]

Bonjour wiztricks,

=>pas la peine de construire de sous-liste puisqu'on sait déjà que A[i] != R[i]

Sauf que l'énoncé n'interdit pas qu'une valeur de la liste de référence soit en même temps bien placée et mal placée!

Exemple: [1,2,3,4] et [5,2,7,2] pour la valeur 2

C'est pour ça que je n'ai pas fait la simplification.

[wiztricks]

Sauf que l'énoncé n'interdit pas qu'une valeur de la liste de référence soit en même temps bien placée et mal placée!

L'énoncé dit:

J'ai besoin que ma fonction me renvoie le nombre d'élément identique entre les deux listes (même valeur et même position), et le nombre d'élément figurant dans les deux mais pas à la même position.

Après c'est une question d'interprétation...
Mais les 2 codes sont équivalents: à vous de voir s'il est nécessaire de construire une s/liste ou pas.
- W

[Cube11]

Je connais les booléens et break mais également le "in" que je n'utilise pas trop.
Mais maintenant, à chaque solution son problème, si la liste référence est la suivante [1,2,3,4] et que l'autre liste est [1,2,1,2] le programme va me retourner 2 placés correctement et deux non alors qu'il y a zéro mal placé.
C'est la qu'est le nœud du problème.
Merci

[Clodion]

Je connais les booléens et break mais également le "in" que je n'utilise pas trop.
Mais maintenant, à chaque solution son problème, si la liste référence est la suivante [1,2,3,4] et que l'autre liste est [1,2,1,2] le programme va me retourner 2 placés correctement et deux non alors qu'il y a zéro mal placé.
C'est la qu'est le nœud du problème.
Merci

Bonjour,
D'où la discussion.
Dans le cas de cet exemple (avec "[1, 2, 1, 2]), c'est le "elif" qui est à privilégié.
Le code de wiztricks, ainsi que le miens, fonctionnent alors selon les attentes.
Mais le point de vue de tyrtamos se tient tout autant.

Clodion

PS: le "in" est un des concepts de base en Python. Facile d'utilisation, clair et évitant, tant que faire se peut, les variables d'indices.

[wiztricks]

Mais maintenant, à chaque solution son problème, si la liste référence est la suivante [1,2,3,4] et que l'autre liste est [1,2,1,2] le programme va me retourner 2 placés correctement et deux non alors qu'il y a zéro mal placé.

La solution Tyrtamos est aussi mauvaise que les autres pour les répétitions: il suffit d'en faire plus.
Exemple: référence [2, 2, 2] l'autre liste aussi [2, 2, 2]. De visu, tous les éléments sont bien placés alors que nos codes trouveront des mal placés.
Vous avez (au moins) 2 solutions:

• interdire les répétitions: les listes ont des éléments distincts. Ils ne peuvent être que bien ou mal placés puisqu'ils n'apparaitront qu'une seule fois.
• procéder en 2 temps: les bien placés puis comparaison des s/listes construites sans ces éléments là.

Ceci dit, quoi que vous choisissiez, çà n'a pas grande importance sinon de vous motiver à coder le truc qui vous semble le plus "réaliste" compte tenu des imprécisions de l'énoncé.

- W