Exercice 13 : résolution en Python

 Énoncé 13 

Le programme doit lire des nombres entiers positifs jusqu'à trouver 3 multiples de 5. Le programme doit alors afficher ces 3 multiples dans l'ordre de leur lecture.

 Analyse 

La succession de questions à se poser est la suivante :

  1. Ce programme nécessite-t-il une répétitive ?
    • La réponse est "Oui";
    • Il est maintenant superflu de se demander si ce sera un Répète ou un Tant que du fait qu'en Python, seul le Tant que existe.
  2. Ce programme nécessite-t-il un ou plusieurs tours de main ?
    • Le programme doit lire 3 multiples de 5... il faut donc les compter, ce qui nécessite le tour de main du compteur;
  3. Qu'est-ce qui viendra avant la répétitive ?
    • Le fait de prévenir l'utilisateur de ce que fera le programme;
    • Le fait d'initialiser le compteur compte_multiples à zéro.
      • L'astuce sera de ne compter que les multiples de 5, et non les nombres lus.
  4. Qu'est-ce qui viendra dans la répétitive ?
    • Le fait de demander un nombre à l'utilisateur et de le lire;
      • Attention, danger... il faudra surveiller l'entrée de l'utilisateur : lire un entier positif.
    • Le fait de repérer si nombre est un multiple de 5;
      • nombre sera un multiple de 5 si le reste de la division entière par 5 (modulo 5) = 0;
      • On incrémentera alors compte_multiples de 1 unité;
      • Si compte_multiples = 1 (premier multiple), nombre sera stocké dans multiple_1;
      • Si c'est le second multiple, il sera stocké dans multiple_2;
      • Le troisième multiple provoquera l'arrêt de la répétitive et restera dans nombre.
  5. Qu'est-ce qui arrêtera la répétitive ?
    • Le fait que compte_multiples = 3;
  6. Qu'est-ce qui viendra après la répétitive ?
    • L'affichage dans l'ordre des 3 multiples de 5 rencontrés.

 Le programme en pseudo-code 

Nous allons prendre l'habitude d'écrire le programme en pseudo-code avec un Répète, ce qui facilitera l'établissement de la condition d'arrêt (le cerveau réfléchit plus facilement "à l'endroit" qu'à "l'envers"). Il suffira alors de transformer le Répète en Tant que en appliquant le théorème de de Morgan à la condition d'arrêt que l'on aura trouvée.

Attention : La transformation n'est pas toujours aussi simple, il faut toujours veiller à ce que la condition vérifie "quelque chose" qui existe.

En fonction de toutes les réponses ci-dessus, voici le programme en pseudo-code :

Affiche+nl "Le programme va lire des nombres entiers positifs jusqu'à trouver 3 multiples de 5. Le programme affichera alors ces 3 multiples dans l'ordre de leur lecture."
compte_multiples ← 0
Répète
    Affiche "Donnez-moi un nombre : "
    Lis et colle sur nombre
    Tant Que (nombre n'est pas un entier positif *) Fais
        Affiche "Erreur, veuillez donner un entier positif : "
        Lis et colle sur nombre
    Fin Tant Que
    Si nombre mod 5 = 0 Alors
        compte_multiples ← compte_multiples + 1
        Si compte_multiples = 1 Alors
             multiple_1 ← nombre
        Fin Si
        Si compte_multiples = 2 Alors
             multiple_2 ← nombre
        Fin Si
    Fin Si
Jusqu'à ce que compte_multiples = 3
Affiche+nl "Le premier multiple de 5 rencontré était ", multiple_1, ";"
Affiche+nl "Le deusième multiple de 5 rencontré était ", multiple_2, ";"
Affiche+nl "Le troisième multiple de 5 rencontré était ", nombre, "."

* Nous n'allons pas nous appesantir sur la façon de vérifier si le nombre est un entier positif, une méthode toute faite existe en Python (voir exercice 1) et nous utiliserons celle-là.

Remarque : pour le stockage des multiples, on n'utilisera pas de Sinon car l'arrivée du 3ème multiple provoquerait une erreur.

L'inverse de la condition compte_multiples = 3 sera compte_multiples ≠ 3 ou, puisqu'on n'ira jamais au-dessus de 3, compte_multiples < 3.

 Le programme en Python 

Voici ce que cela donne en Python en tenant compte d'un certain nombre de points importants :

  1. Pour une rare fois, la première boucle while va tester une variable qui aura déjà été affectées avant. Le travail est donc déjà fait.
  2. La robustesse nous oblige à lire un nombre entier positif, une chaîne de caractères ne fonctionnerait pas dans la vérification du modulo (%);
  3. Lorsque vous maîtriserez mieux le langage, nous pourrons nous lancer dans la vérification de nombres négatifs... qui peuvent aussi être des multiples de 5, mais c'est encore un peu tôt.
print ("Le programme va lire des nombres entiers positifs jusqu'à trouver 3 multiples de 5. Le programme affichera alors ces 3 multiples dans l'ordre de leur lecture.")
compte_multiples = 0
while compte_multiples < 3 :
    nombre = input("Donnez-moi un nombre entier positif : ")
    while not nombre.isnumeric() :
        nombre = input("Erreur, veuillez entrer un nombre entier positif correct : ")
    nombre = int(nombre)
    if nombre % 5 == 0 :
        compte_multiples += 1
        if compte_multiples == 1 :
            multiple_1 = nombre
        if compte_multiples == 2 :
            multiple_2 = nombre
print ("Le premier multiple de 5 était", multiple_1, ";")
print ("Le deuxième multiple de 5 était", multiple_2, ";")
print ("Le troisième multiple de 5 était", nombre, ".")

Vous pouvez "copier-coller" ce programme dans votre éditeur IDLE pour vérifier s'il fonctionne selon les spécifications de départ.

 Codez "robuste" !!! 

Comme indiqué plus haut, la question de la robustesse doit se poser d'office dès que votre programme effectue une lecture au clavier. Vous devez anticiper ce qui peut se passer en fonction des réactions multiples et variées de l'utilisateur.

Dans le programme actuel, seules des chaînes de caractères en provenance du clavier sont manipulées et celles-ci ne sont acceptées que si elles correspondent à ce qui est attendu, il n'y a donc rien à craindre.

Bonne poursuite de votre apprentissage.

Retour