Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]

Groups > fr.comp.lang.python > #4235 > unrolled thread

Les raisons de ma question de ce jour : panne de mémoire avec list et str

Back to article view | Back to fr.comp.lang.python

Contents

  Les raisons de ma question de ce jour : panne de mémoire avec list et str Dominique <dominique.sextant@orange.fr.invalid> - 2024-12-02 17:55 +0100
    Re: Les raisons de ma question de ce jour : panne de mémoire avec list et str Olivier Miakinen <om+news@miakinen.net> - 2024-12-02 22:13 +0100
      Re: Les raisons de ma question de ce jour : panne de mémoire avec list et str Dominique <dominique.sextant@orange.fr.invalid> - 2024-12-03 07:06 +0100
        Re: Les raisons de ma question de ce jour : panne de mémoire avec list et str Olivier Miakinen <om+news@miakinen.net> - 2024-12-03 10:38 +0100
    Re: Les raisons de ma question de ce jour : panne de mémoire avec list et str Olivier Miakinen <om+news@miakinen.net> - 2024-12-02 22:48 +0100
      Re: Les raisons de ma question de ce jour : panne de mémoire avec list et str Olivier Miakinen <om+news@miakinen.net> - 2024-12-02 23:02 +0100
        Re: Les raisons de ma question de ce jour : panne de mémoire avec list et str Olivier Miakinen <om+news@miakinen.net> - 2024-12-03 10:29 +0100
      Re: Les raisons de ma question de ce jour : panne de mémoire avec list et str Dominique <dominique.sextant@orange.fr.invalid> - 2024-12-03 07:16 +0100
        Re: Les raisons de ma question de ce jour : panne de mémoire avec list et str Olivier Miakinen <om+news@miakinen.net> - 2024-12-03 11:03 +0100
    Tri de crêpes (was: Les raisons de ma question de ce jour : panne de mémoire avec list et str) Olivier Miakinen <om+news@miakinen.net> - 2024-12-03 12:41 +0100
      Re: Tri de crêpes Olivier Miakinen <om+news@miakinen.net> - 2024-12-03 12:53 +0100
      [SOLUTION] Tri de crêpes Olivier Miakinen <om+news@miakinen.net> - 2024-12-03 15:08 +0100
        Re: [SOLUTION] Tri de crêpes Dominique <dominique.sextant@orange.fr.invalid> - 2024-12-03 18:07 +0100
          Re: [SOLUTION] Tri de crêpes Olivier Miakinen <om+news@miakinen.net> - 2024-12-03 18:57 +0100
        Re: [SOLUTION] Tri de crêpes Damien Wyart <damien.wyart@free.fr> - 2024-12-04 09:31 +0100
          Re: [SOLUTION] Tri de crêpes Olivier Miakinen <om+news@miakinen.net> - 2024-12-04 12:16 +0100
            Re: [SOLUTION] Tri de crêpes Damien Wyart <damien.wyart@free.fr> - 2024-12-04 13:09 +0100
              Re: [SOLUTION] Tri de crêpes Olivier Miakinen <om+news@miakinen.net> - 2024-12-05 19:42 +0100
                Signature d'une fonction (was: [SOLUTION] Tri de crêpes) Olivier Miakinen <om+news@miakinen.net> - 2024-12-05 19:56 +0100
                  Re: Signature d'une fonction Olivier Miakinen <om+news@miakinen.net> - 2024-12-06 00:34 +0100
        Trouver l'index du plus grand élément dans une liste (was: [SOLUTION] Tri de crêpes) Olivier Miakinen <om+news@miakinen.net> - 2024-12-04 12:24 +0100
        Re: [SOLUTION] Tri de crêpes Dominique <dominique.sextant@orange.fr.invalid> - 2024-12-21 18:22 +0100
        Re: [SOLUTION] Tri de crêpes Dominique <dominique.sextant@orange.fr.invalid> - 2024-12-22 06:41 +0100

Page 1 of 2  [1] 2  Next page →

#4235 — Les raisons de ma question de ce jour : panne de mémoire avec list et str

Re-bonjour,

Je m'amuse avec le livre « 15 énigmes ludiques pour s'initier à la 
programmation Python »

La 3e énigme parle d'un crêpier amateur qui empile des crêpes de tailles 
inégales. Il doit ensuite les empiler par ordre croissant, de la plus 
grande en bas à la plus petite en haut. Pour ce faire, il n'a qu'une 
spatule avec laquelle il peut prendre une pile d'une ou plusieurs 
crêpes, la retourner comme il veut et reclasser ses crêpes.

L'idée est alors de chercher la plus grande crêpe, la retourner avec la 
pile qui est a-dessus, puis de la retourner à nouveau, prendre cette 
pile moins la plus grande qui est en bas, la retourner plus la remettre 
puis la retourner encore sur la pile de départ, etc. Je ne sais pas si 
je suis clair...

Bref, voici mon code :
--------------------------------------------------
import random

result=list()
crepe=list()

nb=int(input('Nombre de crêpes '))
#Calcul de la taille des crêpes de 0 à 9
crepes=str(random.randint(9**nb,10**nb))
for i in crepes:
     crepe.append(i)
fin=False

while fin==False:
     #Je prends la crêpe la plus garnde ainsi que la pile au--dessus
     temp=crepe[0:crepe.index(max(crepe))+1]
     #J'ajoute à la pile reclassée (result) la crêpe la plus grande
     result.append(temp[-1:])
     #Je retire cette crêpe la plus grande de la pile initiale
     crepe.remove(max(temp))
     #Et là, je vois que j'ai un peu triché. En effet, je ne remets pas 
en haut de la pile  initiale les crêpres précédemment retirées en ligne 14
     if crepe==[]:
         fin=True
#Et c'est ici que je ne suis pas parvenu à formater correctement mon 
résultat en ligne 24
print(result)
result=reversed(result)
res=''.join(x for x, in result)
print (res)
--------------------------------------------------
Je suppose que ce code est tout moche, mais je n'ai pas regardé la 
solution du livre. Je vais essayer d'améliorer mon script en évitant de 
tricher :)
-- 
Dominique
Esto quod es

[toc] | [next] | [standalone]

#4237

Le 02/12/2024 17:55, Dominique a écrit :
> 
> La 3e énigme parle d'un crêpier amateur qui empile des crêpes de tailles 
> inégales. [...]
> 
> nb=int(input('Nombre de crêpes '))
> #Calcul de la taille des crêpes de 0 à 9
> crepes=str(random.randint(9**nb,10**nb))
> for i in crepes:
>      crepe.append(i)

Je ne comprends ni le commentaire, ni le code.

Prenons par exemple nb = 5. Tu demandes un nombre aléatoire entre 9^5 = 59049
et 10^5 = 100000, ça te donnera donc un nombre dont au moins l'un des chiffres
est supérieur ou égal à 5, mais tu pourrais par exemple obtenir 60000, avec donc
quatre fois le chiffre 0 et une fois le chiffre 6 : ça ne correspond pas à
l'énoncé qui demande des tailles inégales.

D'ailleurs, si nb > 10, il sera complètement impossible que toutes les tailles
soient différentes !

Voyons voir...

<https://docs.python.org/3/library/random.html>
 random.shuffle(x)
    Shuffle the sequence x in place.
</>

Du coup, je ferais plutôt un truc du genre :

 crepe = list(range(0, nb))
 random.shuffle(crepe)

Par exemple, avec nb = 13 ça m'a donné :

 [5, 12, 2, 7, 1, 6, 11, 3, 10, 0, 9, 4, 8]


-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4246

Le 02/12/2024 à 22:13, Olivier Miakinen a écrit :
> Le 02/12/2024 17:55, Dominique a écrit :
>>
>> La 3e énigme parle d'un crêpier amateur qui empile des crêpes de tailles
>> inégales. [...]
>>
>> nb=int(input('Nombre de crêpes '))
>> #Calcul de la taille des crêpes de 0 à 9
>> crepes=str(random.randint(9**nb,10**nb))
>> for i in crepes:
>>       crepe.append(i)
> 
> Je ne comprends ni le commentaire, ni le code.

Le nombre que mon random me propose représente, chiffre à chiffre, la 
taille d'une crêpe, le nombre de chiffre de ce random indique le nombre 
de crêpes.

Exemple : 580406 représente 6 crêpes avec 5 tailles différentes, peu 
importe que deux ou plusieurs crêpes aient la même taille 0, au cas 
particulier.

-- 
Dominique
Esto quod es

[toc] | [prev] | [next] | [standalone]

#4251

Le 03/12/2024 07:06, Dominique a écrit :
>>>
>>> La 3e énigme parle d'un crêpier amateur qui empile des crêpes de tailles
>>> inégales. [...]
>>>
>>> nb=int(input('Nombre de crêpes '))
>>> #Calcul de la taille des crêpes de 0 à 9
>>> crepes=str(random.randint(9**nb,10**nb))
>>> for i in crepes:
>>>       crepe.append(i)
>> 
>> Je ne comprends ni le commentaire, ni le code.
> 
> Le nombre que mon random me propose représente, chiffre à chiffre, la 
> taille d'une crêpe, le nombre de chiffre de ce random indique le nombre 
> de crêpes.
> 
> Exemple : 580406 représente 6 crêpes avec 5 tailles différentes, peu 
> importe que deux ou plusieurs crêpes aient la même taille 0, au cas 
> particulier.

Ok. Tu as bien noté que c'était en contradiction avec l'énoncé.

D'ailleurs le hasard pourrait faire que tu aies toutes les crêpes de la
même taille. Par exemple, avec nb = 6, tu auras un nombre compris entre
531441 et 999999, qui pourrait être l'un des nombres 555555, 666666,
777777, 888888 ou 999999.

Soit dit en passant, je n'ai pas compris pourquoi ce 9**nb plutôt que,
par exemple, 10**(nb-1), si tu veux un nombre de nb chiffres. À partir
de nb = 22 tu pourrais même obtenir un nombre de 21 chiffres au lieu
de 22 chiffres !


-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4240

Le 02/12/2024 17:55, Dominique a écrit :
> 
> [...] Je vais essayer d'améliorer mon script en évitant de 
> tricher :)

Avant de te lancer dans le problème complet, commence par faire *une*
étape de deux retournements, en partant d'un exemple que tu maîtrises.

***

Par exemple, si tu pars de :

  crepe = [1, 2, 7, 8, 3, 4, 5, 6, 9, 10]

***

Ton programme doit :

a) déterminer que sur les dix crêpes, huit ne sont pas encore triées, puisque
   la 9 et la 10 sont déjà à leur place.

   N_non_triees = 8

b) déterminer que la plus grande crêpe non triée est la 8, à la 4e position.

   N_a_retourner = 4

c) retourner les N_a_retourner premières crêpes, pour donner :

   crepe = [8, 7, 2, 1, 3, 4, 5, 6, 9, 10]

d) retourner les N_non_triees premières crêpes, pour donner :

   crepe = [6, 5, 4, 3, 1, 2, 7, 8, 9, 10]

***

Et donc là, ton programme calculera en (a) et (b) :

   N_non_triees = 6
   N_a_retourner = 1

Il devrait se rendre compte que l'étape (c) est inutile (on ne retourne pas
une crêpe toute seule), et donnera à l'étape (d) :

   crepe = [2, 1, 3, 4, 5, 6, 7, 8, 9, 10]

***

De là, il sautera encore l'étape (c) ayant calculé que N_a_retourner vaut 1,
et il retournera en (d) les deux crêpes 2 et 1 pour le résultat final.

***

Comme tu le vois, tu auras besoin d'une fonction qui retourne les N premiers
éléments d'une liste de taille généralement supérieure à N.

-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4241

Le 02/12/2024 22:48, je répondais à Dominique :
> 
> Comme tu le vois, tu auras besoin d'une fonction qui retourne les N premiers
> éléments d'une liste de taille généralement supérieure à N.

J'ai trouvé sur internet une solution efficace pour faire cela :

   crepe[0:N] = crepe[0:N][::-1]

Mais je ne la comprends pas ! Quelqu'un pourrait me l'expliquer ?

-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4250

Le 02/12/2024 23:02, Olivier Miakinen a écrit :
> Le 02/12/2024 22:48, je répondais à Dominique :
>> 
>> Comme tu le vois, tu auras besoin d'une fonction qui retourne les N premiers
>> éléments d'une liste de taille généralement supérieure à N.
> 
> J'ai trouvé sur internet une solution efficace pour faire cela :
> 
>    crepe[0:N] = crepe[0:N][::-1]
> 
> Mais je ne la comprends pas ! Quelqu'un pourrait me l'expliquer ?

Ok, j'ai compris : [a:b:c] est un [a:b] mais en prenant un élément tous les
|c| (valeur absolue de c), de gauche à droite si c est positif et de droite
à gauche si c est négatif. Lorsque a et b sont vides, ça prend tous les
éléments, et -1 signifie de les prendre à l'envers.

>>> crepe
[4, 3, 2, 1, 5, 6, 7, 8, 9, 10]
>>> crepe[::1]
[4, 3, 2, 1, 5, 6, 7, 8, 9, 10]
>>> crepe[::-1]
[10, 9, 8, 7, 6, 5, 1, 2, 3, 4]
>>> crepe[::2]
[4, 2, 5, 7, 9]
>>> crepe[::-3]
[10, 7, 1, 4]


-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4247

Le 02/12/2024 à 22:48, Olivier Miakinen a écrit :
> Le 02/12/2024 17:55, Dominique a écrit :
>>
>> [...] Je vais essayer d'améliorer mon script en évitant de
>> tricher :)
> 
> Avant de te lancer dans le problème complet, commence par faire *une*
> étape de deux retournements, en partant d'un exemple que tu maîtrises.
> 
> ***
> 
> Par exemple, si tu pars de :
> 
>    crepe = [1, 2, 7, 8, 3, 4, 5, 6, 9, 10]

Je mets de côté ta progression et je t'en remercie, je la regarderai 
plus tard.

Voici ma démarche à partir de ton exemple que je vais simplifier avec 
50806 :

Je cherche le max, 8, je fais 508 que je retourne dans un autre tas : 805

Je prends 05 que je retourne sur le tas d'origine duquel j'ai retiré 8 
qui devient donc 5006.

Cherche le nouveau max, le 6. Je retourne 6 avec ce qu'il y a dessus = 
6005. Je retourne à nouveau ce tas sur le 8 qui était seul qui devient 
50068. De ce tas, je reprends ce qui est au-dessus du 6 : 500 que je 
retourne à nouveau sur le tas d'origine (qui était vide) et qui devient 005.

Je fais la même chose avec 5, puis avec 0 et enfin avec 0. J'obtiens 
bien un tas 00568

-- 
Dominique
Esto quod es

[toc] | [prev] | [next] | [standalone]

#4252

Le 03/12/2024 07:16, Dominique a écrit :
> 
> Voici ma démarche à partir de ton exemple que je vais simplifier avec 
> 50806 :
> 
> Je cherche le max, 8, je fais 508 que je retourne dans un autre tas : 805

Ok. Note que selon l'énoncé tu devrais immédiatement reposer ce tas (depuis
la spatule vers le plan de travail) : 80506.

> Je prends 05 que je retourne sur le tas d'origine duquel j'ai retiré 8 
> qui devient donc 5006.

Alors ça, c'est quelque chose que le crêpier amateur n'aura jamais. Il n'a
qu'une seule spatule, alors que pour soulever la crêpe 8 puis retourner le
05 en 50 il lui en faudrait une deuxième. Il ne doit pas obtenir 5006 mais
80506.

> Cherche le nouveau max, le 6. Je retourne 6 avec ce qu'il y a dessus = 
> 6005.

Et donc, là encore tu as gardé le 8 sur une spatule, puis tu prends une
seconde spatule pour retrourner 5006 en 6005. Ça n'a strictement rien à
voir avec l'énoncé de départ.

> Je retourne à nouveau ce tas sur le 8 qui était seul qui devient 
> 50068.

Note que le vrai crêpier, après avoir retourné 508 en 805, puis avoir
retourné 80506, obtient 60508. Ton résultat 50068 ne peut pas être obtenu
en seulement 2 opérations, et bien sûr il ne correspond pas à l'énoncé.

> [...] J'obtiens bien un tas 00568

C'est bien le résultat que tu obtiendras quelle que soit la méthode de tri.
Mais note bien que ce n'est pas le résultat final qui nous importe dans
cet exercice, mais tous les résultats intermédiaires, qui doivent être :

50806

508|06
80506|
6050|8
05|068
500|68
00568

(j'ai marqué par un « | » la position de la spatule avant chaque retournement)


-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4253 — Tri de crêpes (was: Les raisons de ma question de ce jour : panne de mémoire avec list et str)

Le 02/12/2024 17:55, Dominique a écrit :
> 
> La 3e énigme parle d'un crêpier amateur qui empile des crêpes de tailles 
> inégales. Il doit ensuite les empiler par ordre croissant, de la plus 
> grande en bas à la plus petite en haut. Pour ce faire, il n'a qu'une 
> spatule avec laquelle il peut prendre une pile d'une ou plusieurs 
> crêpes, la retourner comme il veut et reclasser ses crêpes.
> 
> L'idée est alors de chercher la plus grande crêpe, la retourner avec la 
> pile qui est a-dessus, puis de la retourner à nouveau, prendre cette 
> pile moins la plus grande qui est en bas, la retourner plus la remettre 
> puis la retourner encore sur la pile de départ, etc. Je ne sais pas si 
> je suis clair...

Pour peut-être un peu plus de clarté :
https://fr.wikipedia.org/wiki/Tri_de_cr%C3%AApes

J'ai fait un programme d'une quarantaine de lignes, commentaires compris,
qui fait cela. Je ne te donne pas le code puisque l'idée est que tu le
trouves par toi-même, mais je vais te donner un exemple d'affichage
lorsque je le lance :

=======================================================================
$ ./crepier.py
Nombre de crêpes : 10
Les crêpes sont dans l'ordre suivant : [2, 4, 1, 9, 0, 3, 5, 6, 8, 7]
On retourne 4 crêpes.
Les crêpes sont dans l'ordre suivant : [9, 1, 4, 2, 0, 3, 5, 6, 8, 7]
On retourne 10 crêpes.
Les crêpes sont dans l'ordre suivant : [7, 8, 6, 5, 3, 0, 2, 4, 1, 9]
On retourne 2 crêpes.
Les crêpes sont dans l'ordre suivant : [8, 7, 6, 5, 3, 0, 2, 4, 1, 9]
On retourne 9 crêpes.
Les crêpes sont dans l'ordre suivant : [1, 4, 2, 0, 3, 5, 6, 7, 8, 9]
On retourne 2 crêpes.
Les crêpes sont dans l'ordre suivant : [4, 1, 2, 0, 3, 5, 6, 7, 8, 9]
On retourne 5 crêpes.
Les crêpes sont dans l'ordre suivant : [3, 0, 2, 1, 4, 5, 6, 7, 8, 9]
On retourne 4 crêpes.
Les crêpes sont dans l'ordre suivant : [1, 2, 0, 3, 4, 5, 6, 7, 8, 9]
On retourne 2 crêpes.
Les crêpes sont dans l'ordre suivant : [2, 1, 0, 3, 4, 5, 6, 7, 8, 9]
On retourne 3 crêpes.
Les crêpes sont dans l'ordre suivant : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Les crêpes sont bien ordonnées.
=======================================================================

Je précise que mon programme utilise en tout et pour tout un seul
tableau de nombres, donc aucun tableau intermédiaire. Ah, je vais quand
même te donner le tout début de mon programme, celui qui s'occupe de
l'initialisation du tableau.

=======================================================================
#!/usr/bin/python3

import random

nb = int(input('Nombre de crêpes : '))

crepes = list(range(0, nb))
random.shuffle(crepes)
=======================================================================


-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4254 — Re: Tri de crêpes

Le 03/12/2024 12:41, Olivier Miakinen a écrit :
> 
> J'ai fait un programme d'une quarantaine de lignes, commentaires compris,
> qui fait cela. Je ne te donne pas le code puisque l'idée est que tu le
> trouves par toi-même, mais je vais te donner un exemple d'affichage
> lorsque je le lance :

Petite amélioration, avec à chaque fois le compte du nombre de crêpes bien
ordonnées :
==============================================================================
$ ./crepier.py
Nombre de crêpes : 10
Les crêpes sont dans l'ordre suivant : [3, 4, 9, 8, 7, 6, 0, 5, 1, 2] (0 ok)
On retourne 3 crêpes.
Les crêpes sont dans l'ordre suivant : [9, 4, 3, 8, 7, 6, 0, 5, 1, 2] (0 ok)
On retourne 10 crêpes.
Les crêpes sont dans l'ordre suivant : [2, 1, 5, 0, 6, 7, 8, 3, 4, 9] (1 ok)
On retourne 7 crêpes.
Les crêpes sont dans l'ordre suivant : [8, 7, 6, 0, 5, 1, 2, 3, 4, 9] (1 ok)
On retourne 9 crêpes.
Les crêpes sont dans l'ordre suivant : [4, 3, 2, 1, 5, 0, 6, 7, 8, 9] (4 ok)
On retourne 5 crêpes.
Les crêpes sont dans l'ordre suivant : [5, 1, 2, 3, 4, 0, 6, 7, 8, 9] (4 ok)
On retourne 6 crêpes.
Les crêpes sont dans l'ordre suivant : [0, 4, 3, 2, 1, 5, 6, 7, 8, 9] (5 ok)
On retourne 2 crêpes.
Les crêpes sont dans l'ordre suivant : [4, 0, 3, 2, 1, 5, 6, 7, 8, 9] (5 ok)
On retourne 5 crêpes.
Les crêpes sont dans l'ordre suivant : [1, 2, 3, 0, 4, 5, 6, 7, 8, 9] (6 ok)
On retourne 3 crêpes.
Les crêpes sont dans l'ordre suivant : [3, 2, 1, 0, 4, 5, 6, 7, 8, 9] (6 ok)
On retourne 4 crêpes.
Les crêpes sont dans l'ordre suivant : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] (10 ok)
Les crêpes sont bien ordonnées.
==============================================================================

-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4255 — [SOLUTION] Tri de crêpes

Solution du problème, ne pas lire tant que tu veux encore chercher.

En revanche, toute proposition d'amélioration est la bienvenue.


Le 03/12/2024 12:41, Olivier Miakinen a écrit :
> 
> https://fr.wikipedia.org/wiki/Tri_de_cr%C3%AApes

=============================================================================
#!/usr/bin/python3

import random

nb = int(input('Nombre de crêpes : '))

crepes = list(range(0, nb))     # crepes = [0, 1, ..., nb-1]
random.shuffle(crepes)          # là elles sont probablement dans le désordre

desordre = nb   # nombre de crêpes non triées

# Boucle infinie, mais dont on sortira par exit(0) quand tout sera trié.
while True:
    # Les dernières crêpes sont dans l'ordre si crepes[i] == i
    while desordre > 0 and crepes[desordre - 1] == desordre - 1:
        desordre = desordre - 1

    print("Les crêpes sont dans l'ordre suivant :", crepes,
            f"({nb - desordre} ok)")

    ###################################################################
    # Le seul point de sortie du programme est ici
    ###################################################################
    if desordre == 0:
        print("Les crêpes sont bien ordonnées.")
        exit(0)
    ###################################################################

    # On va chercher la plus grande crêpe parmi celles qui ne sont
    # pas encore triées
    maxcrepe = max(crepes[:desordre])
    maxindex = crepes.index(maxcrepe)
    if maxindex == 0:
        # La plus grande des crêpes non triées est en haut de la pile,
        # on va renverser l'ensemble des crêpes non triées pour la
        # mettre en bas.
        retourner = desordre
    else:
        # Le plus grande des crêpes non triées n'est pas en haut de la
        # pile, on va retourner suffisamment de crêpes pour l'y mettre.
        retourner = maxindex + 1

    print(f"On retourne {retourner} crêpes.")
    crepes[:retourner] = crepes[:retourner][::-1]

# Cette ligne du programme n'est jamais atteinte
=============================================================================

-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4256 — Re: [SOLUTION] Tri de crêpes

Le 03/12/2024 à 15:08, Olivier Miakinen a écrit :

Promis, je ne lis pas ta solution :)

Merci de l'avoir donnée.

Bien à toi
-- 
Dominique
Esto quod es

[toc] | [prev] | [next] | [standalone]

#4257 — Re: [SOLUTION] Tri de crêpes

Le 03/12/2024 18:07, Dominique a écrit :
> Le 03/12/2024 à 15:08, Olivier Miakinen a écrit :
> 
> Promis, je ne lis pas ta solution :)
> 
> Merci de l'avoir donnée.

De rien. Note quand même que tu t'étais énormément compliqué la vie en
passant par un unique nombre, transformé en chaîne de caractères, puis
découpé en caractères de '0' à '9' ; utiliser directement un tableau de
nombres de 0 à N-1 (ou de 1 à N, voir plus loin) est beaucoup plus
simple.

Et, oui, pour nous autres humains, utiliser les nombres de 1 à N est
quand même plus naturel que les nombres de 0 à N-1. Pour cela, il suffit
d'appliquer à mon programme précédent les modifs suivantes :
======================================================================
$ diff crepier.py crepier1.py
7c7
< crepes = list(range(0, nb))     # crepes = [0, 1, ..., nb-1]
---
> crepes = list(range(1, nb+1))   # crepes = [1, 2, ..., nb]
14,15c14,15
<     # Les dernières crêpes sont dans l'ordre si crepes[i] == i
<     while desordre > 0 and crepes[desordre - 1] == desordre - 1:
---
>     # Les dernières crêpes sont dans l'ordre si crepes[i] == i+1
>     while desordre > 0 and crepes[desordre - 1] == desordre:
======================================================================

Et voici deux exemples de lancement du programme modifié :
======================================================================
$ ./crepier1.py
Nombre de crêpes : 6
Les crêpes sont dans l'ordre suivant : [1, 5, 3, 2, 6, 4] (0 ok)
On retourne 5 crêpes.
Les crêpes sont dans l'ordre suivant : [6, 2, 3, 5, 1, 4] (0 ok)
On retourne 6 crêpes.
Les crêpes sont dans l'ordre suivant : [4, 1, 5, 3, 2, 6] (1 ok)
On retourne 3 crêpes.
Les crêpes sont dans l'ordre suivant : [5, 1, 4, 3, 2, 6] (1 ok)
On retourne 5 crêpes.
Les crêpes sont dans l'ordre suivant : [2, 3, 4, 1, 5, 6] (2 ok)
On retourne 3 crêpes.
Les crêpes sont dans l'ordre suivant : [4, 3, 2, 1, 5, 6] (2 ok)
On retourne 4 crêpes.
Les crêpes sont dans l'ordre suivant : [1, 2, 3, 4, 5, 6] (6 ok)
Les crêpes sont bien ordonnées.
======================================================================
$ ./crepier1.py
Nombre de crêpes : 10
Les crêpes sont dans l'ordre suivant : [3, 10, 8, 9, 2, 5, 4, 6, 7, 1] (0 ok)
On retourne 2 crêpes.
Les crêpes sont dans l'ordre suivant : [10, 3, 8, 9, 2, 5, 4, 6, 7, 1] (0 ok)
On retourne 10 crêpes.
Les crêpes sont dans l'ordre suivant : [1, 7, 6, 4, 5, 2, 9, 8, 3, 10] (1 ok)
On retourne 7 crêpes.
Les crêpes sont dans l'ordre suivant : [9, 2, 5, 4, 6, 7, 1, 8, 3, 10] (1 ok)
On retourne 9 crêpes.
Les crêpes sont dans l'ordre suivant : [3, 8, 1, 7, 6, 4, 5, 2, 9, 10] (2 ok)
On retourne 2 crêpes.
Les crêpes sont dans l'ordre suivant : [8, 3, 1, 7, 6, 4, 5, 2, 9, 10] (2 ok)
On retourne 8 crêpes.
Les crêpes sont dans l'ordre suivant : [2, 5, 4, 6, 7, 1, 3, 8, 9, 10] (3 ok)
On retourne 5 crêpes.
Les crêpes sont dans l'ordre suivant : [7, 6, 4, 5, 2, 1, 3, 8, 9, 10] (3 ok)
On retourne 7 crêpes.
Les crêpes sont dans l'ordre suivant : [3, 1, 2, 5, 4, 6, 7, 8, 9, 10] (5 ok)
On retourne 4 crêpes.
Les crêpes sont dans l'ordre suivant : [5, 2, 1, 3, 4, 6, 7, 8, 9, 10] (5 ok)
On retourne 5 crêpes.
Les crêpes sont dans l'ordre suivant : [4, 3, 1, 2, 5, 6, 7, 8, 9, 10] (6 ok)
On retourne 4 crêpes.
Les crêpes sont dans l'ordre suivant : [2, 1, 3, 4, 5, 6, 7, 8, 9, 10] (8 ok)
On retourne 2 crêpes.
Les crêpes sont dans l'ordre suivant : [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] (10 ok)
Les crêpes sont bien ordonnées.
======================================================================

-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4258 — Re: [SOLUTION] Tri de crêpes

Quelques petites suggestions :

* Olivier Miakinen <om+news@miakinen.net> in fr.comp.lang.python:
> crepes = list(range(0, nb))     # crepes = [0, 1, ..., nb-1]

Dans ce cas, le 0 est optionnel, on écrit plus couramment range(nb)

> # Boucle infinie, mais dont on sortira par exit(0) quand tout sera trié.

Peu gênant ici, car le code est court, mais il serait plus "standard" que le code
de tri soit dans une fonction séparée, suivie d'une section
if __name__ == '__main__':
avec l'exemple qui teste la fonction.

>         exit(0)

Cela fonctionne mais c'est trop "fort", il s'agit vraiment d'une interruption
complète du programme (c'est très "bas niveau"). S'il y avait autre chose à
faire après le while, cela serait impossible. Donc ici, il faut vraiment
utiliser "break", qui va juste sortir de la boucle, rien de plus.

>     crepes[:retourner] = crepes[:retourner][::-1]

L'inversion par les derniers [] fonctionne mais en Python "moderne", on écrirait plutôt :

crepes[:retourner] = reversed(crepes[:retourner])

-- 
DW

[toc] | [prev] | [next] | [standalone]

#4259 — Re: [SOLUTION] Tri de crêpes

Le 04/12/2024 09:31, Damien Wyart a écrit :
> Quelques petites suggestions :

Et je te remercie pour ça. Moi aussi je suis plutôt débutant en python, et
surtout complètement autodidacte.

> * Olivier Miakinen <om+news@miakinen.net> in fr.comp.lang.python:
>> crepes = list(range(0, nb))     # crepes = [0, 1, ..., nb-1]
> 
> Dans ce cas, le 0 est optionnel, on écrit plus couramment range(nb)

Bien vu. Je l'avais su mais je l'avais oublié.

>> # Boucle infinie, mais dont on sortira par exit(0) quand tout sera trié.
> 
> Peu gênant ici, car le code est court, mais il serait plus "standard" que le code
> de tri soit dans une fonction séparée, suivie d'une section
> if __name__ == '__main__':
> avec l'exemple qui teste la fonction.

Alors ça, je n'en ai jamais entendu parler. Dans quelle partie de la doc je
peux trouver des infos sur ces « __name__ » et « __main__ » ?

>>         exit(0)
> 
> Cela fonctionne mais c'est trop "fort", il s'agit vraiment d'une interruption
> complète du programme (c'est très "bas niveau"). S'il y avait autre chose à
> faire après le while, cela serait impossible. Donc ici, il faut vraiment
> utiliser "break", qui va juste sortir de la boucle, rien de plus.

J'aurais en effet utilisé « break » s'il y avait eu autre chose à faire après.
Ou alors j'aurais aussi pu mettre le code dans une fonction et utiliser un
« return ». Là j'ai utilisé « exit » parce que je savais qu'il n'y avait rien
d'autre à faire.

J'utilise les trois méthodes en C, langage que je pratique depuis bien plus
longtemps que Python.

>>     crepes[:retourner] = crepes[:retourner][::-1]
> 
> L'inversion par les derniers [] fonctionne mais en Python "moderne", on écrirait plutôt :
> 
> crepes[:retourner] = reversed(crepes[:retourner])

Merci. Je ne connaissais ni l'un ni l'autre, c'est en faisant une recherche sur
Internet que j'ai trouvé ce [::-1] − que d'ailleurs je n'avais pas compris tout
de suite.

Cordialement,
-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4261 — Re: [SOLUTION] Tri de crêpes

* Olivier Miakinen <om+news@miakinen.net> in fr.comp.lang.python:
> Alors ça, je n'en ai jamais entendu parler. Dans quelle partie de la doc je
> peux trouver des infos sur ces « __name__ » et « __main__ » ?

Dans la doc officielle, ici :
https://docs.python.org/3.13/library/__main__.html

Cet article est également bien expliqué :
https://realpython.com/if-name-main-python/

-- 
DW

[toc] | [prev] | [next] | [standalone]

#4263 — Re: [SOLUTION] Tri de crêpes

Le 04/12/2024 13:09, Damien Wyart m'a répondu :
>
>> Alors ça, je n'en ai jamais entendu parler. Dans quelle partie de la doc je
>> peux trouver des infos sur ces « __name__ » et « __main__ » ?
> 
> Dans la doc officielle, ici :
> https://docs.python.org/3.13/library/__main__.html

Merci !

Par ailleurs, j'y vois des définitions de fonctions précisant le type des
paramètres et le type de sortie. C'est seulement en 3.13, ou bien ça existe
déjà dans ma version qui est la 3.8.10 ?

Exemples sur cette page :

def echo(phrase: str) -> None:
   ...
   (pas de return)

def main() -> int:
   ...
   return 0


-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4265 — Signature d'une fonction (was: [SOLUTION] Tri de crêpes)

Le 05/12/2024 19:42, Olivier Miakinen a écrit :
> 
> Par ailleurs, j'y vois des définitions de fonctions précisant le type des
> paramètres et le type de sortie. C'est seulement en 3.13, ou bien ça existe
> déjà dans ma version qui est la 3.8.10 ?
> 
> Exemples sur cette page :
> 
> def echo(phrase: str) -> None:
>    ...
>    (pas de return)
> 
> def main() -> int:
>    ...
>    return 0

Je viens d'essayer en 3.8.10. La syntaxe est acceptée mais ça ne génère aucune
erreur si je fais un appel contredisant la signature.

>>> def test(machin:str, truc:int) -> int:
...     print(machin, truc)
...     return machin
...
>>> test(3, "7")
3 7
3
>>> test(3, "aed")
3 aed
3
>>> test("def", "aed")
def aed
'def'


-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

#4267 — Re: Signature d'une fonction

Le 05/12/2024 22:59, Stefan Ram m'a répondu :
> 
>   Ouais, c'est ouf ! 
> 
>   L'idée derrière tout ça, c'est que Python veut rester une
>   langue sans typage statique de base. On peut voir les types
>   comme des commentaires,

... ce qui est déjà une excellente idée.

> ou utiliser des outils supplémentaires
>   pour vérifier les types.
> 
>   Un exemple, c'est « mypy ». [...]
> 
> mypy: test.py:9: error: Incompatible return value type (got "str", expected "int")  [return-value]
> test.py:11: error: Argument 1 to "test" has incompatible type "int"; expected "str"  [arg-type]
> test.py:11: error: Argument 2 to "test" has incompatible type "str"; expected "int"  [arg-type]
> test.py:13: error: Argument 1 to "test" has incompatible type "int"; expected "str"  [arg-type]
> test.py:13: error: Argument 2 to "test" has incompatible type "str"; expected "int"  [arg-type]
> test.py:15: error: Argument 2 to "test" has incompatible type "str"; expected "int"  [arg-type]
> Found 6 errors in 1 file (checked 1 source file)

Ah oui, très bien !


-- 
Olivier Miakinen

[toc] | [prev] | [next] | [standalone]

Page 1 of 2  [1] 2  Next page →

Back to top | Article view | fr.comp.lang.python

csiph-web