Comprendre, compléter et modifier un programme

Comprendre un programme, c’est l’analyser pour interpréter ce qu’il fait.

1. repérer les entrées et sorties du programme ;
2. repérer les principales fonctions et opérateurs ;
3. exécuter pas-à-pas le programme pour une ou plusieurs valeurs différentes en entrée (construire des tableaux pour les boucles) ;
4. conclure.

On considère le programme suivant :

On souhaite comprendre ce programme. Pour cela :

1. On repère ses entrées et sorties.
   L’entrée est indiquée par la fonction input() en ligne 1.
   Le programme prend un nombre qui est affecté à la variable n de type entier en entrée de programme.
   La sortie est indiquée par la fonction print() en ligne 6. Le programme affiche donc en sortie un nombre u. En remarquant que print(u) est dans la boucle while, on peut même conclure que le programme affiche plusieurs valeurs de u.
    
2. On repère les principales fonctions et/ou opérateurs.

   Il y a deux opérateurs :

   • a%b qui donne le reste de la division euclidienne de a par b ;
   • a//b qui donne le quotient de la division euclidienne de a par b.
      
3. On exécute le programme sur papier.
    
4. On choisit une valeur n et on exécute l’algorithme pas-à-pas.
   L1 : Prenons n = 12.
   L2 : On obtient k = 12.
   L3/4/5 : while k>0 est l’annonce d’une boucle. On construit un tableau :
   

   Étape	1	2	3
   k > 0	oui (k = 12)	oui (k = 1)	non (k = 0) sortie de la boucle
   u	2	1
   k	1	0

   Les nombres 2 et 1 sont affichés (valeur de u à chaque étape).
   En cas de doute sur l’objectif du programme, on peut éventuellement recommencer avec une autre valeur de n. Pour n = 1223, le programme affiche 3, puis 2, ensuite 2 et finalement 1.

5. On conclut.
   Le programme décompose un nombre entier en donnant son chiffre des unités, puis son chiffre des dizaines, puis son chiffre des centaines.

1. comprendre ce qu’il fait, si ce n’est pas précisé dans l’énoncé ;
2. analyser ce qui manque et l’ajouter.

On considère le programme de la partie 1, qui décompose un nombre entier en donnant son chiffre des unités, puis son chiffre des dizaines, puis son chiffre des centaines…

On souhaite compléter les lignes 7, 8, 9 du programme afin qu’il indique le nombre de chiffres 1 contenus dans le nombre n saisi.

Pour cela :

1. On comprend ce que fait le programme.
   C’est indiqué dans l’énoncé. On remarque que c’est la variable u qui donne un par un les chiffres du nombre n.
    
2. On analyse ce qui manque et on l’ajoute.
   Pour compter les chiffres 1, il suffit d’augmenter de 1 une variable à chaque fois que la variable u est égale à 1. Le compteur est appelé nbre. Cette variable est initialisée à 0 à la ligne 3. Il reste à l’augmenter de 1 à chaque fois que u est égal à 1. On obtient donc :

1. comprendre le programme d’origine, si ce n’est pas précisé dans l’énoncé ;
2. analyser les nouveaux besoins :
   • entrées à modifier ou à ajouter ;
   • sorties à modifier ou à ajouter ;
   • instructions à modifier ou à ajouter ;
3. modifier le programme.

On reprend le programme de la partie 2. Soit c un chiffre proposé par l’utilisateur. On souhaite modifier le programme afin qu’il indique le nombre de chiffres c contenus dans le nombre n. Par exemple, pour n = 1773 et c = 7, le programme doit afficher 2.

1. On comprend ce que fait le programme.
   Ce programme indique le nombre de chiffres 1 contenus dans le nombre n saisi (voir partie 2b). 

   
    

2. On analyse les besoins.
   On veut que le programme garde la même fonction, mais avec un chiffre c saisi par l’utilisateur. Il faut donc ajouter une entrée afin que l’utilisateur propose le chiffre à compter dans le nombre. Cette variable sera de type entier (int()).
    
3. On modifie le programme.
   On ajoute en début de programme l’instruction : c=int(input()).
   Ensuite, on vérifie si chaque chiffre u du nombre n est égal à c (et non 1) avant d’augmenter le compteur nbre de 1.
   On remplace donc le test de la ligne 7 par u==c.
   On obtient le programme final :