Exercices corrigés : algorithmique et programmation (Sixième)

1) On lit chaque point en descendant vers l'axe horizontal, puis en allant vers l'axe vertical : $A(2\,;6)$, $B(2\,;3)$, $C(8\,;7)$ et $D(5\,;1)$. On écrit toujours les deux nombres entre parenthèses, séparés par un point-virgule, dans l'ordre horizontal puis vertical.

2) Le premier nombre, appelé ABSCISSE, indique de combien de cases on se déplace vers la droite en partant de l'origine. Le second, appelé ORDONNÉE, indique de combien de cases on monte ensuite. Inverser les deux donne un autre point : $(2\,;6)$ et $(6\,;2)$ ne sont pas au même endroit, ce qui se voit immédiatement sur le quadrillage.

3) Le point $(0\,;0)$ est le coin en bas à gauche, là où les deux axes se croisent. On l'appelle l'ORIGINE du repère : c'est le point à partir duquel tous les autres sont décrits, et ses deux coordonnées sont nulles parce qu'on ne se déplace ni horizontalement ni verticalement pour l'atteindre.

4) Le point $(6\,;0)$ a une ordonnée nulle : le lutin ne monte pas du tout, il se trouve donc SUR l'axe horizontal, à $6$ cases à droite de l'origine. De la même façon, tous les points de la forme $(0\,;y)$ sont sur l'axe vertical.

5) Le point $E(3\,;5)$ a pour abscisse $3$, plus petite que celle de $C$ qui vaut $8$ : il est donc à GAUCHE de $C$. Son ordonnée vaut $5$, plus grande que celle de $B$ qui vaut $3$ : il est donc PLUS HAUT que $B$. La position horizontale se juge sur la première coordonnée, la position verticale sur la seconde, et jamais les deux en même temps.

6) Les points $A(2\,;6)$ et $B(2\,;3)$ ont la même abscisse, $2$. Ils sont donc sur la même colonne du quadrillage, et le segment $[AB]$ est VERTICAL. Sa longueur se lit sur la différence des ordonnées : $6-3=3$ cases. Deux points de même ordonnée donneraient au contraire un segment horizontal.

1) Le lutin est en $(1\,;1)$. Le bloc $\mathtt{aller\ à}$ ne déplace pas le lutin d'une certaine quantité : il le place directement au point indiqué, quelle que soit sa position précédente. C'est une POSITION, à ne pas confondre avec un déplacement.

2) Le lutin regarde vers la droite : avancer augmente son abscisse et laisse son ordonnée inchangée. Il passe de $(1\,;1)$ à $(1+4\,;1)$, c'est-à-dire $(5\,;1)$.

3) Le bloc $\mathtt{ajouter\ 3\ à\ y}$ ne touche qu'à l'ordonnée : $1+3=4$. Le lutin est donc en $(5\,;4)$. Ce bloc est un déplacement vertical, et il ne modifie pas la direction dans laquelle le lutin regarde.

4) Le lutin regarde toujours vers la droite, car aucun bloc $\mathtt{tourner}$ n'est intervenu. Il avance donc horizontalement de $2$ cases et arrive en $(5+2\,;4)$, c'est-à-dire $(7\,;4)$. Le tableau complet est : $(1\,;1)$, puis $(5\,;1)$, puis $(5\,;4)$, puis $(7\,;4)$.

5) NON, le point d'arrivée ne change pas. En échangeant, on obtient $(5\,;1)$, puis $(7\,;1)$ après $\mathtt{avancer\ de\ 2\ cases}$, puis $(7\,;4)$ après $\mathtt{ajouter\ 3\ à\ y}$ : c'est bien le même point. La raison est que ces deux instructions sont deux déplacements indépendants, l'un horizontal, l'autre vertical, et que l'ordre de deux additions ne change pas la somme. Attention, cette conclusion ne vaut QUE parce que la direction du lutin reste la même entre les deux.

6) Le lutin regarde vers le haut, donc $\mathtt{avancer}$ modifie maintenant l'ordonnée. Départ $(1\,;1)$ ; après $\mathtt{avancer\ de\ 4\ cases}$ il est en $(1\,;5)$ ; après $\mathtt{ajouter\ 3\ à\ y}$ il est en $(1\,;8)$ ; après $\mathtt{avancer\ de\ 2\ cases}$ il est en $(1\,;10)$, tout en haut du quadrillage. Une seule instruction a changé et le point d'arrivée passe de $(7\,;4)$ à $(1\,;10)$ : la direction du lutin est donc une information à tenir à jour au même titre que sa position.

1) La boucle contient deux instructions et elle est répétée $4$ fois : le lutin exécute donc $4\times 2=8$ instructions. Le bloc $\mathtt{répéter}$ ne fait rien d'autre que recopier ces deux lignes quatre fois de suite ; le script serait identique, mais quatre fois plus long à écrire.

2) Il trace un CARRÉ de $5$ cases de côté. À chaque tour, le lutin trace un côté de $5$ cases puis pivote d'un quart de tour : quatre côtés égaux et quatre angles droits, c'est bien la définition du carré. Attention à ne pas confondre le nombre de répétitions, $4$, avec la longueur du côté, $5$ : ce sont deux nombres qui jouent des rôles différents.

3) Le lutin revient exactement à son point de départ et regarde de nouveau vers la droite. En effet, il a tourné quatre fois de $90^\circ$, soit $4\times 90=360^\circ$ : un tour complet le ramène à sa direction initiale. C'est ce retour au point de départ qui prouve que la figure est bien fermée.

4) Le lutin trace $4$ côtés de $5$ cases, soit $4\times 5=20$ cases de trait. C'est le PÉRIMÈTRE du carré. Le nombre de cases situées à l'intérieur, lui, serait $5\times 5=25$ : périmètre et aire ne se confondent pas.

5) Avec $3$ répétitions et un pivot de $120^\circ$, le lutin trace trois côtés égaux et tourne en tout de $3\times 120=360^\circ$ : la figure se referme, c'est un TRIANGLE ÉQUILATÉRAL de $5$ cases de côté. La règle générale est que, pour un polygone régulier à $n$ côtés, l'angle de rotation vaut $360\div n$ degrés.

6) NON, la figure ne se referme pas. Le lutin ne tourne que de $4\times 60=240^\circ$, ce qui est moins qu'un tour complet : il termine son parcours loin de son point de départ, avec une ligne brisée ouverte de quatre segments. Pour refermer avec des pivots de $60^\circ$, il faudrait $6$ répétitions, puisque $6\times 60=360$, et l'on obtiendrait un hexagone régulier.

1) Le lutin part de $(1\,;1)$ vers la droite. Il avance de $3$ cases et arrive en $(4\,;1)$. Il tourne alors vers la gauche : il regarde désormais vers le haut. Il avance de $2$ cases, ce qui augmente cette fois son ordonnée : il arrive en $(4\,;3)$.

2) Le lutin avance d'abord de $2$ cases vers la droite et arrive en $(3\,;1)$. Il tourne vers la gauche, donc vers le haut, puis avance de $3$ cases : il arrive en $(3\,;4)$. Les deux scripts se terminent donc à des endroits différents, $(4\,;3)$ pour A et $(3\,;4)$ pour B.

3) Parce que le bloc $\mathtt{tourner}$ est placé ENTRE les deux déplacements. Le déplacement effectué avant le pivot est horizontal, celui effectué après est vertical. Échanger les deux nombres revient donc à échanger ce qui va à l'horizontale et ce qui va à la verticale, ce qui donne un autre point. Le résultat d'un script ne dépend pas seulement des blocs utilisés, mais de leur ordre.

4) NON, l'ordre n'a alors aucune importance. Avec $\mathtt{ajouter\ 3\ à\ x}$ puis $\mathtt{ajouter\ 2\ à\ y}$, on passe de $(1\,;1)$ à $(4\,;1)$ puis à $(4\,;3)$. Dans l'autre ordre, on passe de $(1\,;1)$ à $(1\,;3)$ puis à $(4\,;3)$ : c'est le même point d'arrivée. Ces deux blocs agissent en effet sur des coordonnées différentes, et aucun des deux ne modifie ce que fait l'autre.

5) Deux instructions peuvent être échangées sans conséquence lorsqu'elles sont INDÉPENDANTES, c'est-à-dire lorsque aucune des deux ne change ce dont l'autre a besoin. Dès qu'une instruction modifie la DIRECTION du lutin, elle change le sens de tous les $\mathtt{avancer}$ qui la suivent : elle n'est plus indépendante, et son ordre devient décisif.

6) NON, le point d'arrivée reste $(4\,;3)$. Le bloc $\mathtt{tourner}$ fait pivoter le lutin sur place : il change sa direction, pas sa position. Ce pivot final n'aurait d'effet que sur les instructions SUIVANTES, et il n'y en a aucune. C'est la raison pour laquelle il faut suivre deux informations différentes, la position et la direction : une instruction peut modifier l'une sans toucher à l'autre.

1) On suit le script ligne par ligne : après $\mathtt{mettre\ score\ à\ 0}$, la variable vaut $0$ ; après le premier $\mathtt{ajouter\ 5}$, elle vaut $5$ ; après le second, $10$ ; après $\mathtt{mettre\ score\ à\ 20}$, elle vaut $20$, car cette instruction EFFACE tout ce qui précède ; après $\mathtt{ajouter\ 3}$, elle vaut $23$. La valeur finale est donc $23$.

2) $\mathtt{mettre\ score\ à\ 20}$ range $20$ dans la case, quelle que soit la valeur qui s'y trouvait : le passé est perdu. $\mathtt{ajouter\ 20\ à\ score}$ conserve la valeur présente et lui ajoute $20$. Ici, à partir de $10$, le premier bloc donne $20$ et le second donnerait $30$. Confondre les deux est l'erreur la plus fréquente sur les variables.

3) Le bloc se lit de DROITE À GAUCHE : on calcule d'abord $\mathtt{score}+4$ avec la valeur actuelle, soit $23+4=27$, puis on range ce résultat dans $\mathtt{score}$. La variable vaut donc $27$.

4) NON, ce n'est pas une équation. En mathématiques, l'égalité « $s=s+4$ » n'a aucune solution, puisqu'un nombre ne peut pas être égal à lui-même augmenté de $4$. En programmation, le symbole ne signifie pas « est égal à » mais « reçoit la valeur de » : il désigne une ACTION, un rangement en mémoire, et non une affirmation. C'est le même mot d'apparence pour deux idées très différentes.

5) Le script devient : $\mathtt{mettre\ à\ 0}$, $\mathtt{ajouter\ 5}$, $\mathtt{ajouter\ 5}$, $\mathtt{ajouter\ 3}$, $\mathtt{mettre\ à\ 20}$. Les valeurs successives sont $0$, $5$, $10$, $13$, puis $20$. La valeur finale est $20$ au lieu de $23$ : les trois premiers ajouts ont été effacés par le $\mathtt{mettre\ à}$ final, et tout le travail du début a été perdu.

6) La boucle ajoute $5$ à six reprises en partant de $0$ : la valeur finale est $6\times 5=30$. On peut suivre les valeurs une à une, $5$, $10$, $15$, $20$, $25$, $30$, ou bien reconnaître qu'ajouter $6$ fois le même nombre revient à le multiplier par $6$. La boucle transforme ainsi une répétition d'additions en une multiplication, et c'est exactement ce qu'un ordinateur fait de mieux : répéter sans se lasser.

1) Le lutin trace un RECTANGLE de $6$ cases de longueur et $3$ cases de largeur. À chaque tour de boucle, il trace un côté long, pivote, trace un côté court, pivote encore : deux tours suffisent donc à faire les quatre côtés. Après les quatre pivots de $90^\circ$, soit $360^\circ$ en tout, il retrouve sa direction de départ.

2) La boucle contient $4$ instructions et elle est répétée $2$ fois : le lutin exécute $2\times 4=8$ instructions. Le script écrit sans boucle compterait ces mêmes huit lignes : la boucle ne réduit pas le travail de la machine, seulement celui de la personne qui écrit.

3) Le trait suit le contour, c'est-à-dire le PÉRIMÈTRE : $6+3+6+3=18$ cases, ou plus rapidement $2\times(6+3)=18$ cases.

4) La figure entoure $6\times 3=18$ cases, ce qui est son AIRE. Les deux nombres valent $18$, et c'est une coïncidence : ils ne mesurent pas la même chose et ne s'expriment pas dans la même unité, l'un en cases de trait, l'autre en cases de surface. Un rectangle de $8$ sur $2$ le montre bien : son périmètre vaut $20$ et son aire $16$.

5) Chaque marche est un déplacement vers la droite suivi d'un déplacement vers le haut, ce qui demande deux pivots opposés : $\mathtt{répéter\ 4\ fois}$ contenant $\mathtt{avancer\ de\ 2\ cases}$, $\mathtt{tourner\ de\ 90\ vers\ la\ gauche}$, $\mathtt{avancer\ de\ 2\ cases}$, $\mathtt{tourner\ de\ 90\ vers\ la\ droite}$. Les deux pivots sont indispensables et vont en sens contraire : sans le second, le lutin continuerait à tourner dans le même sens et dessinerait un carré au lieu de monter en escalier.

6) Chaque marche trace $2+2=4$ cases de trait, et il y a $4$ marches : le trait total mesure $4\times 4=16$ cases. On remarque que le lutin arrive en $8$ cases à droite et $8$ cases au-dessus de son point de départ : le trajet réel est plus long que le déplacement en ligne droite, ce qui est toujours le cas dès qu'on ne va pas tout droit.

1) La pièce est un rectangle de $8$ cases sur $5$ : elle compte $8\times 5=40$ cases. On multiplie le nombre de colonnes par le nombre de lignes, exactement comme pour une aire en cases.

2) Une ligne compte $8$ cases, et il y a $5$ lignes à parcourir. Le robot nettoie donc $5$ fois $8$ cases, soit bien les $40$ cases de la question 1 : les deux façons de compter doivent coïncider.

3) Sur une ligne, le robot nettoie $8$ cases mais ne se déplace que $7$ fois, car la première case est celle où il commence. Cela fait $5\times 7=35$ déplacements horizontaux. À cela s'ajoutent les montées d'une ligne à la suivante : il y en a $4$, et non $5$, puisqu'il n'a pas à monter après la dernière ligne. Le total est $35+4=39$ déplacements. Ce décalage de un, entre le nombre de cases et le nombre de déplacements, est le piège classique de tous les problèmes de parcours.

4) Il nettoie $40$ cases à raison de $3$ secondes chacune, soit $40\times 3=120$ secondes. Comme $120=2\times 60$, cela fait exactement $2$ minutes. On convertit toujours le résultat dans une unité parlante : $120$ secondes est correct, mais $2$ minutes se comprend mieux.

5) En commençant par la première ligne et en sautant une ligne sur deux, il nettoie les lignes $1$, $3$ et $5$, c'est-à-dire $3$ lignes sur $5$. Cela représente $3\times 8=24$ cases sur $40$, soit une part de $\frac{24}{40}=\frac{3}{5}$, autrement dit $60$ pour cent de la pièce. Attention à ne pas répondre « la moitié » : une ligne sur deux ne fait pas la moitié des lignes quand leur nombre est impair.

6) Il faut répéter l'instruction $\mathtt{avancer\ de\ 1\ case}$, et la répéter $7$ fois, pas $8$. On écrit donc $\mathtt{répéter\ 7\ fois\ :\ avancer\ de\ 1\ case}$. C'est la même différence qu'à la question 3 : la boucle compte les DÉPLACEMENTS, alors que l'énoncé parle des CASES, et il y a toujours une case de plus que de déplacements sur une ligne.

1) FAUX. Le bloc $\mathtt{aller\ à}$ donne une POSITION absolue : il place le lutin au point $(4\,;2)$, quel que soit l'endroit d'où il vient. Le bloc qui déplace de $4$ cases vers la droite est $\mathtt{ajouter\ 4\ à\ x}$. Énoncé correct : « le bloc $\mathtt{aller\ à\ x:\ 4\ y:\ 2}$ place le lutin au point $(4\,;2)$ ». Position et déplacement sont deux idées différentes, et c'est la distinction la plus importante du chapitre.

2) FAUX. $\mathtt{tourner}$ fait pivoter le lutin SUR PLACE : sa direction change, sa position ne bouge pas d'un millimètre. Énoncé correct : « le bloc $\mathtt{tourner\ de\ 90\ degrés}$ fait pivoter le lutin d'un quart de tour sans le déplacer ». Ce pivot n'a d'effet que sur les blocs $\mathtt{avancer}$ qui viennent après lui.

3) FAUX. En programmation, ce bloc ne prétend rien : il ORDONNE de calculer $\mathtt{score}+4$ avec la valeur actuelle, puis de ranger le résultat dans $\mathtt{score}$. Si $\mathtt{score}$ valait $23$, il vaut ensuite $27$, et aucune erreur ne se produit. Énoncé correct : « ce bloc augmente la valeur de $\mathtt{score}$ de $4$ ». Ce qui est impossible, c'est l'équation mathématique $s=s+4$, et c'est justement pourquoi le langage utilise un mot d'action, mettre à.

4) FAUX, les deux nombres ont été échangés. Le $4$ est le nombre de RÉPÉTITIONS, c'est-à-dire le nombre de côtés, et le $5$ est la longueur de chaque côté. Énoncé correct : « ce script trace un carré de $5$ cases de côté ». Un carré de $4$ cases de côté s'obtiendrait avec $\mathtt{avancer\ de\ 4}$, en gardant $4$ répétitions et des pivots de $90^\circ$.

5) FAUX. Contre-exemple vu à l'exercice 4 : en partant de $(1\,;1)$ vers la droite, avancer de $3$ puis tourner puis avancer de $2$ mène en $(4\,;3)$, alors que les mêmes blocs dans l'ordre $2$, tourner, $3$ mènent en $(3\,;4)$. Énoncé correct : « deux scripts formés des mêmes blocs peuvent donner des résultats différents si l'ordre change ». L'ordre n'est indifférent que pour des instructions indépendantes, comme deux déplacements sur des axes différents.

1) Le score part de $0$, puis vaut $15$ après le premier tour, $30$ après le deuxième, $45$ après le troisième et $60$ après le quatrième. Chaque tour ajoute la même quantité, ce qui donne la table de $15$.

2) Ajouter quatre fois $15$ revient à calculer $4\times 15=60$. Une boucle qui répète la même addition est donc exactement une multiplication : c'est ce qui permet de prévoir le résultat sans dérouler le script tour par tour, ce qui deviendrait impossible avec $500$ répétitions.

3) On cherche le nombre d'étoiles $n$ tel que $15\times n=120$, c'est-à-dire $n=120\div 15=8$. Il faut ramasser $8$ étoiles. Vérification : $15\times 8=120$.

4) On teste : $12\times 8=96$, ce qui ne dépasse pas encore $100$, et $12\times 9=108$, qui dépasse. Il faut donc $9$ étoiles. Attention au mot DÉPASSER : avec $8$ étoiles le joueur est à $96$, tout près du but mais en dessous, et la réponse $8$ serait fausse.

5) Les étoiles rapportent $7\times 15=105$ points, auxquels s'ajoute le bonus : $105+25=130$ points. On effectue la multiplication avant l'addition, car le bonus n'est versé qu'une fois et non à chaque étoile : dans une expression comme $7\times 15+25$, c'est bien la multiplication qui est prioritaire.

6) NON. Tous les scores possibles sont des multiples de $15$ : $0$, $15$, $30$, $45$, $60$, $75$, $90$, $105$... Or $100$ n'est pas un multiple de $15$, puisque $100=15\times 6+10$ : le reste n'est pas nul. Le joueur passe donc de $90$ à $105$ sans jamais s'arrêter sur $100$. C'est une question de divisibilité, et elle montre qu'un programme ne peut produire que les valeurs autorisées par ses règles.

1) La condition demande si l'âge est strictement inférieur à $12$. Comme $9<12$ est vrai, la borne exécute la branche du haut et répond « tarif enfant : $6$ dollars ». La branche du bas n'est pas lue du tout.

2) Elle répond « tarif adulte : $10$ dollars », car la condition $12<12$ est FAUSSE : $12$ n'est pas strictement inférieur à lui-même. Ce n'est probablement pas ce que voulait le musée, mais c'est bien ce que le script demande. Les conditions au bord, comme ici l'âge exactement égal à $12$, sont l'endroit où se cachent la plupart des erreurs de programmation.

3) Il suffit d'écrire $\mathtt{si\ reponse < 13}$, ou de façon équivalente $\mathtt{si\ reponse \le 12}$. Les deux conditions décrivent le même ensemble d'âges entiers, et le choix entre les deux est affaire de lisibilité : la seconde dit littéralement « jusqu'à $12$ ans inclus ».

4) Avec le script d'origine, les enfants de $8$ et $11$ ans paient le tarif enfant, soit $2\times 6=12$ dollars. Les deux parents et l'enfant de $14$ ans paient le tarif adulte, soit $3\times 10=30$ dollars. Le total est $12+30=42$ dollars. Il faut bien compter TROIS personnes au tarif adulte : l'adolescent de $14$ ans en fait partie d'après la règle écrite, même si le mot adulte semble mal choisi.

5) Une seule. Le bloc $\mathtt{si\ \ldots\ alors\ \ldots\ sinon}$ garantit que l'une des deux branches est exécutée, et que ce n'est jamais les deux. C'est d'ailleurs pour cela que la borne ne peut pas annoncer deux tarifs différents à la même personne.

6) Le nouveau test doit venir APRÈS le test des enfants et AVANT la conclusion adulte : $\mathtt{si\ reponse < 12}$, alors enfant ; sinon, $\mathtt{si\ reponse \ge 65}$, alors senior ; sinon, adulte. L'erreur à éviter est de conclure « adulte » dès que l'âge atteint $12$ ans : la branche du bas serait alors terminée, le test des $65$ ans ne serait jamais atteint et aucun visiteur ne paierait le tarif senior. Dans une suite de tests, l'ordre décide de ce qui est encore examinable, exactement comme l'ordre des instructions décide du trajet du lutin.

1) $\mathtt{résultat}$ vaut $4$, puis $4\times 3=12$, puis $12+5=17$, puis $17\times 2=34$. Le script affiche $34$.

2) $0$, puis $0\times 3=0$, puis $0+5=5$, puis $5\times 2=10$. Le script affiche $10$ : même en partant de $0$, le résultat n'est pas nul, à cause de l'ajout de $5$.

3) $2{,}5$, puis $2{,}5\times 3=7{,}5$, puis $7{,}5+5=12{,}5$, puis $12{,}5\times 2=25$.

4) On remonte le script à l'envers, en faisant l'opération CONTRAIRE à chaque étape, de la dernière à la première. Avant $\times 2$ : $58\div 2=29$. Avant $+5$ : $29-5=24$. Avant $\times 3$ : $24\div 3=8$. On avait choisi $8$. Contrôle : $8\times 3=24$, $24+5=29$, $29\times 2=58$.

5) $4$, puis $4\times 3=12$, puis $12\times 2=24$, puis $24+5=29$. Il affiche $29$ au lieu de $34$ : dans le script d'origine, le $5$ ajouté est lui aussi doublé, ce qui n'arrive plus quand on ajoute après avoir doublé.

1) Deux D : $2+2=4$. Trois H : $1+3=4$. Un G : $4-1=3$. Le robot arrive en $(3\,;4)$. L'ordre des flèches ne change rien ici, puisque chaque flèche est un déplacement fixe : seuls comptent les nombres de H, B, G et D.

2) Trois D et trois H : il arrive en $(2+3\,;1+3)=(5\,;4)$. Le trajet en zigzag mène au même point que « D D D H H H ».

3) Il faut avancer de $6-2=4$ cases vers la droite et de $3-1=2$ cases vers le haut. Le code le plus court compte $4+2=6$ flèches, par exemple « D D D D H H ». Aucune flèche G ou B ne doit y figurer, elle obligerait à revenir.

4) Le plus court en utilise $6$, donc $10-6=4$ flèches sont inutiles. Elles vont forcément par paires qui s'annulent, un H avec un B ou un G avec un D : ce code contient deux allers-retours.

5) Trois fois D et H : trois D et trois H, soit $(2+3\,;1+3)=(5\,;4)$. Puis G : $(4\,;4)$. Le robot arrive en $(4\,;4)$.

1) $\mathtt{total}$ vaut $7$ après le premier tour, $14$ après le deuxième, $21$ après le troisième : la table de $7$.

2) La boucle continue tant que $\mathtt{total}$ ne dépasse pas $50$. Après $7$ tours, $\mathtt{total}=49$, qui ne dépasse pas $50$ : on continue. Après $8$ tours, $\mathtt{total}=56>50$ : on s'arrête. La boucle fait $8$ tours.

3) Le lutin dit $56$, puis $8$.

4) Rien ne change. Après $7$ tours, $49>49$ est FAUX : un nombre n'est pas strictement plus grand que lui-même. La boucle fait encore un tour et s'arrête à $56$, après $8$ tours. Il faudrait écrire $\mathtt{total > 48}$ pour s'arrêter à $49$.

5) $\mathtt{total}$ vaut $10$, $20$, $30$, $40$, $50$ : à $50$, la condition $50>50$ est fausse, on continue. Au sixième tour, $60>50$ : arrêt. La boucle fait $6$ tours et le lutin dit $60$.

1) Première boucle : $13$, puis $8$, puis $3$, qui est plus petit que $5$ : deux pièces de $5$. Deuxième boucle : $3$, puis $1$, plus petit que $2$ : une pièce de $2$. Le reste vaut $1$ : une pièce de $1$. En tout $2+1+1=4$ pièces, et $2\times 5+2+1=13$.

2) Quatre pièces de $5$ : $24$, $19$, $14$, $9$, puis $4$, plus petit que $5$. Deux pièces de $2$ : $4$, $2$, puis $0$. Aucune pièce de $1$. En tout $6$ pièces.