Discussion :

[franchoix]

Bonjour, je suis en train d'apprendre à me servir de Python.
Pour celà je fais des exercices.
J'ai trouvé le site de Pascal Ortiz qui propose dans la rubrique "boucles imbriquées" un exercice que je pense avoir résolu après avoir beaucoup cherché et créé une "usine à gaz".
Persuadé qu'il y a une solution plus simple je propose ce que j'ai fait et demande si quelqu'un pourrait m'indiquer une méthode plus simple.
voila le résultat de mes efforts

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
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
''' exercice relevé sur le site de Pascal Ortiz dans le chapitre "boucles imbriquées
il s'agit de donner l'écart d'index maximal entre les valeurs identiques d'une liste
donnée  ici la liste l '''
 
l = [16, 14, 17, 13, 15, 14, 16, 15, 13, 14, 16, 15, 13, 16]
 
#constituer une liste de doublets nommée mix-valeur/indice dans la liste""""""
mix=[]
for x,y in enumerate(l):
    mix.append([y,x])
    mix = sorted(mix, key=lambda x:x[0])
 
print("mix",mix)
 
# constituer une liste sans doublons nommée lsd et l'ordonner
lsd=[]
 
for i in range(len(l)):
    if l[i] not in lsd:
        lsd.append(l[i])
lsd = sorted(lsd)
print("lsd",lsd)
 
 
#constituer une liste des occurrences des valeurs de la liste
#lsd=[16, 14, 17, 13, 15]
occur=[]       
for i in range(len(lsd)):
    occur.append(l.count(lsd[i]))
 
print("occurrences",occur)
 
#fusionner les deux liste lsd et loccur (nombre, nbre occurrences)
a=1
 
 
for i in range(len(lsd)):
 
    b=occur[i]
    lsd[a:a]=[b]  
    a +=2
 
print("lsd fusion ",lsd)
 
 
#calculer les écarts d'index pour chaque valeur
 
index=(len(lsd)/2)
index=int(index)
l_tempo = []
 
for j in range(index):
 
 
    val1=lsd[0]
    val2=lsd[1]
 
 
    for i in range(occur[0]):
        l_tempo.append(mix[0][1])
        del mix[0]
 
 
    print(val1,"écart  => ",l_tempo[-1]-l_tempo[0])
    l_tempo=[] 
 
    del lsd[0]
 
    del lsd[0]
    del occur[0]

merci pour vos conseils

[wiztricks]

Salut,

Persuadé qu'il y a une solution plus simple je propose ce que j'ai fait et demande si quelqu'un pourrait m'indiquer une méthode plus simple.

Le but de ces exercices est d'apprendre (par la pratique) à utiliser les constructions de base...
Et de constater lorsque vous progresserez, ces "constructions de base" sont souvent inutiles (remplaçables par...) appliquées à des types de bases... Mais, l'intérêt des types de base est de pouvoir visualiser simplement ce qu'il se passe (un entier, ça parle plus qu'un objet quelconque).

Par exemple:

Code :

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

1
2
3
4
5
>>> # constituer une liste sans doublons nommée lsd et l'ordonner
>>> lsd = sorted(set(l))
>>> lsd
[13, 14, 15, 16, 17]
>>>

mais c'est pas ça qui va vous permettre d'écrire des boucles...

Tout ça pur dire que programmer est une pratique... vous avez mis du temps à faire fonctionner ces exercices, abordez le chapitre suivant (et d'autres exercices) avant de vouloir faire "mieux".


- W

[franchoix]

bonjour et merci
les boucles, c'est bien ce qui m'a conduit à faire ce message. Je suis bien conscient que cet exo dans le chapitre boucles imbriquées devait être résolu à l'aide de celles-ci et je n'en ai pas trouvé le moyen.
la lumière viendra.
bonne journée

[wiztricks]

Salut,

Je suis bien conscient que cet exo dans le chapitre boucles imbriquées devait être résolu à l'aide de celles-ci et je n'en ai pas trouvé le moyen.

Peut être parce que votre niveau est un peu supérieur à celui attendu ou que vous ne vous appliquez pas assez. Si je reprend l'exemple précédent:

Code :

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

1
2
3
4
5
6
lsd=[]
 
for i in range(len(l)):
    if l[i] not in lsd:
        lsd.append(l[i])
lsd = sorted(lsd)

le if l[i] not in lsd est une boucle imbriquée qu'on délègue à Python mais on pourrait l'écrire:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
>>> lsd = []
>>> for i in range(len(l)):
...     for j in range(len(lsd)):
...         if lsd[j] == l[i]:
...            break
...     else:
...         lsd.append(l[i])
...
>>> lsd
[16, 14, 17, 13, 15]
>>>

et plutôt utiliser un drapeau (trouvé /pas trouvé) à la place du for... else... de Python.

Reste à faire la même chose pour faire apparaître les boucles dans votre code. Par exemple dans:

Code :

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

1
2
3
4
5
6
7
#constituer une liste des occurrences des valeurs de la liste
#lsd=[16, 14, 17, 13, 15]
occur=[]       
for i in range(len(lsd)):
    occur.append(l.count(lsd[i]))
 
print("occurrences",occur)

Il y a une boucle imbriquée "implicite" dans count... que vous n'êtes peut être pas supposé connaître (ou utiliser).
note: avec Python on utilisera plutôt collections.Counter appliqué à la liste de départ...

Tout ça pour redire que l'important c'est de se confronter à la machine pour faire l'exercice en essayant de mettre en pratique ce qui a été appris dans les chapitres précédent du cours... Sachant que de fait, vous programmerez rarement comme çà (mais vous êtes bien obligé d'apprendre et plus ou moins vous plier au exercices proposés).

- W

[franchoix]

bien.
j'ai de la matière à digérer pour les jours qui viennent.
un grand merci pour votre aide.

[Sve@r]

Bonjour

Pour celà je fais des exercices.

C'est effectivement le but d'un exercice que de s'exercer...

Persuadé qu'il y a une solution plus simple je propose ce que j'ai fait et demande si quelqu'un pourrait m'indiquer une méthode plus simple.

Oui, quand on connait Python, on trouve alors des méthodes plus simples, telle celle de wiztricks qui utilise un set() (=ensemble, c'est à dire une liste sans doublons) pour extraire les nombres sans avoir de doublons de ta liste d'origine).
Mais déjà ta façon de faire (qu'on peut appeler "méthode algorithmique standard") est pas mal. Prendre chaque élément un à un et examiner ledit élément par rapport à un contexte. C'est un peu la base de la programmation.

Bon quelques bêtises quand-même. Par exemple tu n'es pas obligé de trier ton mix à chaque itération, tu peux le traiter qu'une fois à la fin (ce n'est pas parce que l'instruction est minuscule que le travail derrière l'est aussi, un tri c'est super lourd). Surtout qu'en plus le tri ne semble pas demandé.
Ensuite pour la liste des occurences, tu peux simplifier. Au lieu d'utiliser un index "i" et traiter lsd[i] tu peux directement boucler sur "lsd" qui est un itérable (accepte qu'on boucle dessus).
Ainsi ton code

Code python :

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

1
2
for i in range(len(lsd)):
	occur.append(l.count(lsd[i]))

s'écrit plus simplement

Code python :

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

1
2
for x in lsd:
	occur.append(l.count(x))

Et tu évites alors un appel à range() et un autre à len().
Plus tard, tu apprendras les "listes en intension" (avec un "s" à "intension") qui permettent de remplacer

Code python :

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

1
2
for item in truc:
	dest.append(travail(item))

par dest=[travail(item) for item in truc].
Ce qui donne ici occur=[l.count(item) for item in lsd]. Plus efficace car "occur" est créé d'un bloc sans passer par append() lui-aussi assez lourd (ceux qui ont programmés en langages bas-niveau, tel que le C, savent le prix d'un agrandissement de tableau).
Et de là, ce sera une petite révolution dans tes algos qui se simplifieront assez naturellement. Mais tout ça s'apprend petit à petit...

Je suis bien conscient que cet exo dans le chapitre boucles imbriquées devait être résolu à l'aide de celles-ci et je n'en ai pas trouvé le moyen.
la lumière viendra.

Eclairons un peu cette obscurité...
Dernier exo: écarts max pour chaque valeur

Code python :

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
l = [16, 14, 17, 13, 15, 14, 16, 15, 13, 14, 16, 15, 13, 16]
 
#calculer les écarts d'index pour chaque valeur
ecart=dict()
# On boucle sur chaque nombre de la liste
for (i1, x1) in enumerate(l):
	if x1 in ecart: continue		# On saute un nombre déjà traité
 
	# L'écart de ce nombre est créé
	ecart[x1]=0
 
	# On boucle sur les nombres suivants
	for (i2, x2) in enumerate(l[i1:]):
		if x2 != x1: continue		# On cherche les nombres identiques
		# Si l'index2 (qui est pile poil l'écart avec le nombre évalué) est plus grand que l'écart trouvé, on le mémorise comme nouveau plus grand écart
		if i2 > ecart[x1]: ecart[x1]=i2
	# for
# for
print(ecart)

Je te conseille de commenter ce que tu fais (comme dans l'exemple), cela t'aidera aussi à organiser ton algo. De même fermer les blocs par un commentaire t'aideront aussi à mieux les identifier (en tout cas ça m'aide moi).

Tu pourras aussi trouver sur le forum toute une gamme d'exercices variés que nous avons créés justement pour apprendre ces notions. Ils ne se substituent pas aux tiens mais pourront les compléter.
C'est ici: https://python.developpez.com/exercices/.

[papajoker]

bonjour

avec un lien c'est plus facile de répondre
car au moins, on peut voir ce qui a été fait avant

algorithme à appliquer est le suivant : on parcourra la liste en utilisant deux boucles for imbriquées. Ce n’est pas une méthode optimale

Donc, tu ne réponds pas à la demande , il ne s'agit pas de faire simple ou rapide ou optimisé mais de ne faire que 2 boucle for ...

pas véritablement testé, mais semble relativement être bon par rapport à la demande

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
L = [16, 14, 17, 13, 15, 14, 16, 15, 13, 14, 16, 15, 13, 16]
resultat = (len(L)+1, 0)
for cle, valeur in enumerate(L):
    for recle, revaleur in enumerate(L):  # TODO débuter à "cle"+1
        if revaleur == valeur and cle != recle:
            diff = recle - cle
            if diff > 0:
                if diff < resultat[0]:  # 2 if sur la même ligne, voir les 4...
                    resultat = (diff, valeur)
print(resultat)

---------
ps: je découvre et je trouve ces cours assez confus dans l'ordre (pour un véritable débutant python)

[MPython Alaplancha]

Bonjour,
Une approche avec .index():

Code :

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

1
2
3
4
5
6
7
l = [16, 14, 17, 13, 15, 14, 16, 15, 13, 14, 16, 15, 13, 16]
s = set(l) 
 
for value in s:
    debut = l.index(value)
    fin = l[::-1].index(value)
    print(f"{value} ---------> indexmin ={debut}, indexmax = {len(l)-1-fin} - ecart={len(l)-1-fin-debut}"

Ceci dit, il n'y a pas de boucles imbriquées...

édit : Perso j'ai bien aimé ---> https://www.hackinscience.org/exercises/

[papajoker]

@Hominidé , pas ce qui est demandé, ici tu calcules l'écart entre le premier et le dernier, pas tous
c'est bien pour cela qu'il faut ajouter une boucle dans ta boucle pour prendre toutes les valeurs (pas uniquement la dernière)
Dans l'énoncé:

Cette valeur est 3 dans la liste ci-dessus ; en effet, 15 apparaît aux indices 4 et 7

[MPython Alaplancha]

J'ai lu:

il s'agit de donner l'écart d'index maximal entre les valeurs identiques d'une liste
donnée ici la liste l '''

Je pense y avoir répondu, non?

Code :

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

1
2
3
4
5
13 ---------> indexmin =3, indexmax = 12 - ecart=9
14 ---------> indexmin =1, indexmax = 9 - ecart=8
15 ---------> indexmin =4, indexmax = 11 - ecart=7
16 ---------> indexmin =0, indexmax = 13 - ecart=13
17 ---------> indexmin =2, indexmax = 2 - ecart=0

[BufferBob]

salut,

(...)

le propos est de travailler les boucles imbriquées, sous-entendu "l'une dans l'autre"
tu cherches l'écart maximal donc tu peux te servir d'une simple variable pour le stocker, si tu trouves une valeur plus grande tu mets juste la variable à jour
une façon de faire pourrait donc être de parcourir tous les nombres de la liste, et pour chaque nombre parcouru de parcourir la liste en sens inverse et comparer les deux nombres ; s'ils sont identiques tu peux envisager de mettre à jour la variable qui stocke l'écart maximal.

[franchoix]

merci à vous pour toutes ces réponses, il me faut du temps pour assimiler ces informations.
actuellement je n'arrive pas à faire fonctionner (comprendre plutôt) la solution proposée par Sve@r en la décortiquant.

J'ai bien compris qu'il y a plusieurs chemins pour arriver à un même endroit, mais que celui que j'ai choisi n'est pas le bon au regard de la question posée.

Une question:
la fonction enumerate() ne se décompose pas (pas à pas):
- ni avec breakpoint()
- ni dans le debugger de IDLE.

J'imagine qu'il faut voir le code de la fonction, tâche ardue.

[Sve@r]

actuellement je n'arrive pas à faire fonctionner (comprendre plutôt) la solution proposée par Sve@r en la décortiquant.

Soit la liste [16, 14, 17, 13, 15, 14, 16, 15, 13, 14, 16, 15, 13, 16]. Je prends le premier nombre (16). S'il a déjà été évalué (ie s'il est déjà présent dans le dictionnaire des écarts) je le saute sinon je pars de là je regarde les suivants
Le second (14) n'est pas 16, je le saute. De même pour les autres 17, 13, 15, 14
Le 7° (16) étant identique, je stocke l'écart trouvé avec le premier (6)
Je continue jusqu'à la fin où finalement le dernier nombre étant aussi 16, ce sera cet écart qui sera stocké. Ainsi pour 16 l'écart est de 13

Je prends maintenant le second nombre (14). S'il a déjà été évalué je le saute sinon je pars de là je regarde les suivants et etc etc etc.

Accessoirement ma solution n'est pas terrible (pas assez réfléchie). Déjà parce que je teste si le nouvel écart est plus grand que l'écart déjà trouvé ce qui est toujours le cas. Et ensuite parce que si on prend l'idée de BufferBob de parcourir la seconde liste à l'envers, on peut alors s'arrêter dès qu'on a trouvé un nombre identique au nombre testé.

[franchoix]

bonjour
Je suis un peu lent mais....
je m'y colle.
bon dimanche

[Sve@r]

je m'y colle.

Version Bufferbob (ça m'énervait)

Code python :

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
#!/usr/bin/env python3
# coding: utf-8
 
l = [16, 14, 17, 13, 15, 14, 16, 15, 13, 14, 16, 15, 13, 16]
 
#calculer les écarts d'index pour chaque valeur
ecart=dict()
# On boucle sur chaque nombre de la liste
for (i1, x1) in enumerate(l):
	if x1 in ecart: continue		# On saute un nombre déjà traité
 
	# On boucle sur la liste dans l'autre sens
	for (i2, x2) in enumerate(l[-1:i1:-1]):
		# Si le nombre est le même
		if x2 == x1:
			# On calcule son écart avec le nombre de départ
			ecart[x1]=len(l) - i2 - i1 - 1
 
			# Plus la peine de continuer
			break
		# if
	else:
		# Il n'y a qu'un seul nombre donc aucun écart
		ecart[x1]=0
	# for
# for
print(ecart)

[papajoker]

la fonction enumerate() ne se décompose pas (pas à pas):
J'imagine qu'il faut voir le code de la fonction, tâche ardue.

Il n'est pas possible de débuger les fonctions natives (pas écrites en python donc même le code source n'a pas d'intérêt)
Tu as la documentation, lorsque l'on débute dans un langage, on peut passer 50% (ou plus) de son temps à lire la documentation au lieu de véritablement coder.

Je suis un peu lent mais....

C'est la meilleure approche, on prend son temps pour assimiler les choses une à une. Prendre une année pour véritablement bien assimiler la programmation (et son langage) n'est pas chose rare, même plutôt normale.