Exercices corrigés : algorithmique et programmation Python (Seconde)

On suit l'exécution LIGNE PAR LIGNE, en notant après chaque instruction la valeur de chaque variable. Après les deux premières lignes, $a$ vaut $5$ et $b$ vaut $3$. La ligne a = a + b donne $a=8$, $b$ restant à $3$. La ligne b = a - b utilise le NOUVEAU $a$ : $b=8-3=5$, $a$ restant à $8$. La ligne a = a - b utilise le nouveau $b$ : $a=8-5=3$. Le programme affiche donc 3 5.

Il ÉCHANGE le contenu des deux variables, sans utiliser de variable supplémentaire. On est parti de $a=5$ et $b=3$, on arrive à $a=3$ et $b=5$. Le mécanisme est général : la somme $a+b$ est stockée dans $a$ et sert de mémoire temporaire, dont on extrait successivement l'ancien $a$ puis l'ancien $b$.

Avec une variable auxiliaire, on écrit c = a puis a = b puis b = c. C'est la version que l'on écrit en pratique, pour deux raisons : elle se lit immédiatement, et elle fonctionne avec n'importe quel type de données, alors que la version de l'énoncé n'a de sens que pour des NOMBRES. On ne peut pas additionner deux chaînes de caractères et espérer les séparer ensuite.

Il affiche $7$. Au moment de l'affectation y = x, Python range dans $y$ la VALEUR que $x$ contient alors, c'est-à-dire $7$. Modifier $x$ ensuite ne modifie pas $y$ : une affectation copie une valeur à l'instant où elle s'exécute, elle ne crée aucun lien permanent entre les deux variables.

mention(14) renvoie 'Bien' : $14$ n'est pas supérieur ou égal à $16$, le premier test échoue, mais il l'est à $14$ et le second réussit. mention(11.5) renvoie 'Pas de mention', aucun test n'étant satisfait. mention(16) renvoie 'Tres bien', car le test utilise une inégalité LARGE et $16\geq 16$. mention(20) renvoie également 'Tres bien'.

Tous les tests suivants deviendraient INACCESSIBLES pour les notes élevées : une note de $18$ vérifie déjà note >= 12, donc la fonction renverrait 'Assez bien' et s'arrêterait là, sans jamais examiner les autres branches. Dans une cascade de elif, il faut ordonner les tests du plus RESTRICTIF au plus large, car le premier qui réussit met fin à la cascade.

Il suffit d'insérer un test supplémentaire avant le else final : on ajoute elif note >= 10: renvoyant 'Pas de mention', et le else renvoie alors 'Refuse'. L'ordre décroissant est conservé, $10$ venant après $12$ dans la cascade.

La condition équivaut à note >= 16 tout court : si une note est supérieure ou égale à $16$, elle est AUTOMATIQUEMENT supérieure ou égale à $14$, donc le second test n'apporte rien. L'élève voulait sans doute exprimer un INTERVALLE, ce qui s'écrit note >= 14 and note < 16, avec deux bornes différentes et surtout un test strict d'un côté.

Il calcule la SOMME des entiers de $1$ à $10$, puisque range(1, 11) parcourt $1$, $2$, jusqu'à $10$, la borne $11$ étant exclue. La valeur affichée est $55$, ce que confirme la formule $\frac{10\times 11}{2}=55$. Écrire range(1, 10) donnerait $45$ : oublier que la borne de droite est exclue est l'erreur la plus fréquente du chapitre.

Il suffit de remplacer la ligne du corps par s = s + k*k, la structure de la boucle restant identique. Le résultat est $1+4+9+16+25+36+49+64+81+100=385$.

La variable $k$ prend les valeurs $0$, $5$, $10$ et $15$. Le TROISIÈME argument est le pas ; la valeur $20$ est exclue, exactement comme dans range(a, b). Il y a donc quatre valeurs et non cinq, et l'on notera que $15+5=20$ tombe précisément sur la borne exclue.

Il calcule le PRODUIT des entiers de $1$ à $5$, c'est-à-dire la factorielle de $5$. À la fin, $p$ vaut $1\times 2\times 3\times 4\times 5=120$. Le point important est l'INITIALISATION : il faut partir de $1$ et non de $0$, sinon tous les produits successifs seraient nuls et le résultat vaudrait $0$. L'élément neutre de la multiplication n'est pas celui de l'addition.

Elle représente le nombre d'HEURES au bout desquelles la population atteint ou dépasse $10\,000$ bactéries, c'est-à-dire le temps de doublement arrondi à l'heure supérieure. La variable t compte les tours de boucle, et chaque tour correspond à une heure.

Après $9$ heures, la population vaut $5\,000\times 1{,}9990\approx 9\,995$ bactéries : c'est encore strictement inférieur à $10\,000$, donc la condition n < 10000 reste vraie et la boucle continue. Après $10$ heures, elle vaut $5\,000\times 2{,}1589\approx 10\,795$ bactéries, la condition devient fausse et la boucle s'arrête. Le programme affiche $10$. Le cas à neuf heures est à cinq bactéries près du seuil : conclure sans calculer aurait conduit à répondre $9$.

Parce que le nombre de tours n'est pas CONNU avant l'exécution. Une boucle for exige de fixer le nombre d'itérations à l'avance, alors qu'ici c'est justement ce nombre que l'on cherche. La boucle while est donc l'outil des problèmes de SEUIL, où l'on répète tant qu'une condition tient sans savoir combien de temps.

La valeur de n resterait bloquée à $5\,000$, la condition n < 10000 resterait vraie indéfiniment et la boucle ne s'arrêterait JAMAIS : le programme tournerait sans fin. Une boucle while n'est sûre que si quelque chose progresse réellement vers la sortie à chaque tour, et c'est au programmeur de le garantir.

La fonction se réduit à une ligne : return L * l. On obtient aire_rectangle(7, 3) $=21$. Le mot-clé return est indispensable, comme la question c) va le montrer.

On teste le reste de la division par $2$ : return n % 2 == 0. L'expression n % 2 == 0 vaut DÉJÀ True ou False, il est donc inutile d'écrire une structure if renvoyant l'un ou l'autre, même si c'est correct. Un test est une expression comme une autre, on peut le renvoyer directement.

y vaut None. La fonction affiche bien $10$ à l'écran, mais elle ne RENVOIE rien : en l'absence de return, Python renvoie automatiquement None. C'est la distinction essentielle entre AFFICHER et RENVOYER, et elle explique la plupart des programmes qui semblent fonctionner mais dont on ne peut pas réutiliser le résultat.

$f(0)=2\times 0+3=3$ et $f(5)=10+3=13$. Pour résoudre $f(x)=17$, on résout $2x+3=17$, soit $2x=14$ et $x=7$. On vérifie : $f(7)=14+3=17$ ✓. Une fonction Python et une fonction mathématique se manipulent donc de la même façon, la première n'étant qu'une écriture de la seconde.

len(notes) vaut $6$, notes[0] vaut $12$, notes[2] vaut $15$ et notes[len(notes) - 1] vaut $11$. Les indices commencent à ZÉRO, donc le dernier indice est $5$ et non $6$ : écrire notes[6] provoquerait une erreur d'indice. L'écriture notes[len(notes) - 1] est la façon standard de désigner le dernier élément sans connaître la taille.

On écrit moyenne = sum(notes) / len(notes). La somme vaut $12+8+15+9+18+11=73$, donc la moyenne vaut $\frac{73}{6}\approx 12{,}17$. Utiliser len(notes) plutôt que $6$ rend l'instruction valable pour n'importe quelle liste, ce qui est toujours préférable.

On initialise un COMPTEUR à $0$, puis on parcourt la liste en l'incrémentant à chaque note qui vérifie la condition. Les notes concernées sont $12$, $15$ et $18$, donc le compteur vaut $3$ à la fin. On notera que $12$ compte, l'inégalité étant large.

On initialise avec notes[0], puis on compare chaque élément suivant au maximum courant en le remplaçant s'il est plus grand. Le résultat est $18$. Initialiser à $0$ serait DANGEREUX : si toutes les valeurs étaient négatives, par exemple des températures hivernales à Montréal comme $-12$, $-8$, $-15$ et $-3$, l'algorithme renverrait $0$, valeur qui n'appartient même pas à la liste. Partir du premier élément garantit que le résultat est toujours une valeur réellement présente.

La condition de poursuite est capital < 3000 et la ligne de calcul est capital = capital * 1.03. Augmenter de $3\ \%$ revient à MULTIPLIER par $1+\frac{3}{100}=1{,}03$, et non à ajouter $3$ : la confusion entre hausse relative et hausse absolue est l'erreur classique de ce type d'énoncé.

Après $13$ ans, le capital vaut $2\,000\times 1{,}4685\approx 2\,937{,}07$ dollars, encore inférieur à $3\,000$ : la boucle continue. Après $14$ ans, il vaut $2\,000\times 1{,}5126\approx 3\,025{,}18$ dollars, la condition devient fausse et la boucle s'arrête. Le programme affiche $14$.

Le capital atteint est d'environ $3\,025{,}18$ dollars. Il DÉPASSE le seuil de $25{,}18$ dollars, ce qui est normal : la croissance étant discontinue, année par année, on n'atterrit jamais exactement sur le seuil. Une boucle de seuil renvoie donc toujours le premier instant où la condition est franchie, jamais l'instant exact du franchissement.

L'affichage se trouvant DANS le corps de la boucle, il s'exécute une fois par tour. Comme la boucle effectue $14$ tours, $14$ lignes s'affichent. Si l'affichage était placé APRÈS la boucle, au même niveau d'indentation que le print final, il n'y en aurait qu'une : en Python, c'est l'INDENTATION seule qui décide de ce qui est répété, là où d'autres langages utilisent des accolades.

Elle représente la FRÉQUENCE d'apparition du $6$ sur mille lancers simulés, c'est-à-dire le nombre de $6$ obtenus divisé par le nombre de lancers. C'est une fréquence OBSERVÉE, résultat d'une expérience, et non une probabilité, qui est une valeur théorique.

Le dé étant équilibré, la probabilité d'obtenir un $6$ vaut $\frac{1}{6}\approx 0{,}167$. La fréquence observée doit donc se situer AUTOUR de cette valeur, sans nécessairement l'atteindre.

Non, c'est parfaitement normal : c'est la FLUCTUATION D'ÉCHANTILLONNAGE. Deux échantillons de même taille tirés de la même expérience donnent en général des fréquences différentes, et c'est le propre du hasard. Un programme qui renverrait exactement $0{,}1666$ à chaque exécution serait au contraire suspect, et signalerait probablement un générateur défectueux.

Pour $n=100$, l'intervalle vaut $\left[\frac{1}{6}-0{,}1\,;\,\frac{1}{6}+0{,}1\right]$, soit environ $[0{,}067\,;\,0{,}267]$, de largeur $0{,}2$. Les deux résultats observés, $0{,}14$ et $0{,}19$, y figurent bien ✓. Pour $n=10\,000$, l'intervalle vaut $\left[\frac{1}{6}-0{,}01\,;\,\frac{1}{6}+0{,}01\right]$, soit environ $[0{,}157\,;\,0{,}177]$, de largeur $0{,}02$.

m vaut None. La fonction affiche bien $5$ à l'écran, mais elle ne renvoie AUCUNE valeur, et Python renvoie alors None par défaut. La correction consiste à remplacer print par return : return (a + b)/2. On peut toujours afficher le résultat ensuite, depuis l'extérieur, avec print(moyenne(4, 6)). C'est exactement le piège de l'exercice 5 c).

À la fin, s vaut $10$ : à chaque tour on ÉCRASE la valeur précédente au lieu de l'accumuler, si bien que seul le dernier passage laisse une trace. On voulait la somme des entiers de $1$ à $10$, soit $55$. La correction est s = s + k, qui ajoute au lieu de remplacer. La différence entre $10$ et $55$ montre à quel point un seul caractère manquant change tout.

La variable n n'est jamais modifiée dans la boucle, donc la condition n > 0 reste vraie indéfiniment : la boucle est INFINIE et le programme affiche $10$ sans jamais s'arrêter. Il faut ajouter n = n - 1 dans le corps, ce qui affichera alors $10$, $9$, $8$, jusqu'à $1$, soit dix lignes. C'est la même faute qu'à l'exercice 4 d), sous une autre forme.

C'est une erreur de SYNTAXE. Le simple = est l'affectation, qui range une valeur dans une variable ; le test d'égalité s'écrit avec un double ==. La ligne correcte est if x == 5:. Python refuse d'exécuter le programme, ce qui est ici une chance : l'erreur est signalée immédiatement plutôt que de produire silencieusement un mauvais résultat, comme le font les trois précédentes.

La boucle continue TANT QUE le carré reste strictement inférieur à $7$, et s'arrête dès qu'il l'atteint. On a $2{,}6^{2}=6{,}76<7$, donc la boucle continue, et $2{,}7^{2}=7{,}29\geq 7$, donc elle s'arrête. Le programme affiche environ $2{,}7$ et fournit l'encadrement $2{,}6<\sqrt{7}<2{,}7$. La valeur affichée est la borne SUPÉRIEURE, la borne inférieure étant la valeur précédente.

Il suffit de remplacer le pas par $0{,}01$, c'est-à-dire d'écrire x = x + 0.01. On a $2{,}64^{2}=6{,}9696<7$ et $2{,}65^{2}=7{,}0225\geq 7$, d'où l'encadrement $2{,}64<\sqrt{7}<2{,}65$. La calculatrice confirme $\sqrt{7}\approx 2{,}6458$ ✓.

Le nombre $0{,}1$ n'a pas d'écriture BINAIRE exacte, pas plus que $\frac{1}{3}$ n'en a en décimal : en l'ajoutant des centaines de fois, les petites erreurs s'accumulent et la variable finit par valoir un nombre légèrement différent de celui attendu. On contourne le problème en comptant avec un ENTIER et en ne divisant qu'au moment du test : on initialise n à $0$, la condition devient while (n/100)*(n/100) < 7:, le corps devient n = n + 1, et l'on affiche n/100 à la fin. Les entiers, eux, sont représentés exactement.

La boucle s'arrête pour $n=265$, puisque $\left(\frac{265}{100}\right)^{2}=7{,}0225\geq 7$ alors que la valeur précédente est inférieure : elle effectue donc $265$ tours. Pour gagner une décimale, il faudrait un pas dix fois plus petit, donc environ dix fois plus de tours, soit $2\,650$. Le coût croît LINÉAIREMENT avec la précision demandée.

La boucle teste $d=1$, $2$, ..., $12$ et compte ceux pour lesquels le reste est nul : $1$, $2$, $3$, $4$, $6$, $12$. La fonction renvoie $6$. Le range(1, n + 1) est nécessaire pour que $n$ lui-même soit testé, la borne de droite étant exclue.

$13$ n'a que deux diviseurs, $1$ et $13$ : la fonction renvoie $2$. La boucle a tourné $13$ fois, autant que la valeur de $n$ : pour un grand nombre, cette méthode est lente.

Un nombre premier a EXACTEMENT deux diviseurs : return nb_diviseurs(n) == 2. Pour $n=1$, nb_diviseurs(1) vaut $1$, donc la fonction renvoie False : $1$ n'est pas premier, et la définition par « exactement deux diviseurs » règle ce cas sans exception à écrire.

Les nombres premiers inférieurs à $30$ sont $2$, $3$, $5$, $7$, $11$, $13$, $17$, $19$, $23$, $29$ : il y en a $10$. Une boucle for n in range(1, 31) qui incrémente un compteur quand est_premier(n) est vrai donne ce résultat.

Si $n$ a un diviseur autre que $1$ et lui-même, il en a un qui vérifie $d\times d\leq n$. Pour $n=97$, on teste $d=2$, $3$, ..., $9$, car $9\times 9=81\leq 97$ mais $10\times 10=100>97$ : $8$ tours au lieu de $97$. Aucun ne divise $97$, qui est donc premier.

// est la division ENTIÈRE : $17=3\times 5+2$, donc 17 // 5 vaut $3$ et 17 % 5, le reste, vaut $2$. La division / donne le quotient décimal : $3{,}4$.

** est la puissance : 2 ** 10 vaut $1\,024$ (et non 2 * 10). -7 // 2 vaut $-4$ et non $-3$ : la division entière arrondit vers le BAS, et $-3{,}5$ arrondi vers le bas donne $-4$. C'est le piège classique des nombres négatifs.

La division / renvoie toujours un flottant, même quand le résultat tombe juste : 10 / 2 vaut 5.0, de type float. Pour obtenir l'entier $5$, il faut 10 // 2.

Multiplier une chaîne par un entier la RÉPÈTE : 'ha' * 3 vaut 'hahaha'. Additionner deux chaînes les COLLE : '3' + '4' vaut '34', et non $7$. Les guillemets font toute la différence entre le nombre $3$ et le caractère '3'.

5 > 3 vaut True et 2 == 3 vaut False ; and exige les deux, donc le résultat est False. 4 < 2 vaut False, et not le transforme en True.

Départ $a=84$, $b=36$. Tour 1 : $r=84\ \%\ 36=12$, puis $a=36$, $b=12$. Tour 2 : $r=36\ \%\ 12=0$, puis $a=12$, $b=0$. La condition b != 0 est fausse : la boucle s'arrête après $2$ tours et la fonction renvoie $12$. Contrôle : $84=12\times 7$ et $36=12\times 3$ ✓.

$1071=2\times 462+147$ ; $462=3\times 147+21$ ; $147=7\times 21+0$. Trois tours, et la fonction renvoie $21$. Chercher tous les diviseurs de $1071$ aurait été bien plus long.

$17\ \%\ 5=2$, puis $5\ \%\ 2=1$, puis $2\ \%\ 1=0$ : la fonction renvoie $1$ après $3$ tours. Le seul diviseur commun est $1$ : les nombres $17$ et $5$ sont PREMIERS ENTRE EUX.

Tour 1 : $r=36\ \%\ 84=36$, puis $a=84$, $b=36$. Le premier tour a simplement ÉCHANGÉ les deux nombres. On retrouve ensuite la question a) : $3$ tours au total, résultat $12$. L'algorithme n'a donc pas besoin qu'on range les nombres dans l'ordre.

On divise numérateur et dénominateur par le PGCD $21$ : $\frac{1071}{462}=\frac{51}{22}$. Comme on a divisé par le plus grand diviseur commun, la fraction obtenue est irréductible.

tarif(1) : $1\leq 2$, première branche, $4$ euros. tarif(10) : deuxième branche, $4+1{,}5\times 8=16$ euros. tarif(30) : troisième branche, $4+1{,}5\times 18+1{,}2\times 10=4+27+12=43$ euros. On retire bien les $2$ km inclus, puis les $18$ km facturés à $1{,}50$.

Deuxième branche : $4+1{,}5\times 18=31$. Troisième branche : $4+27+1{,}2\times 0=31$. Les deux coïncident : pas de saut à $20$ km, le tarif est continu. Un tarif mal écrit, par exemple $4+1{,}2\times(d-2)$ après $20$ km, ferait brutalement baisser le prix de $5{,}40$ euros à $20{,}01$ km.

$13$ euros est entre $4$ et $31$ : deuxième branche. $4+1{,}5(d-2)=13$ donne $1{,}5(d-2)=9$, $d-2=6$ et $d=8$ km.

$50$ euros dépasse $31$ : troisième branche. $31+1{,}2(d-20)=50$ donne $d-20=\frac{19}{1{,}2}\approx 15{,}83$, donc $d\approx 35{,}83$ km.

Deuxième branche : $4+1{,}5(d-2)>25$ équivaut à $d-2>14$, soit $d>16$. Pour $d=16$, le prix vaut exactement $25$ ; pour $d=17$, il vaut $26{,}50$. Le plus petit entier est $17$ km. Une boucle while tarif(d) <= 25: d = d + 1 partant de $d=0$ donne le même résultat.

$f(1)=1+1-5=-3$ et $f(2)=8+2-5=5$. La fonction est croissante et passe d'une valeur négative à une valeur positive : elle s'annule une fois entre $1$ et $2$.

$m=\frac{1+2}{2}=1{,}5$ et $f(1{,}5)=3{,}375+1{,}5-5=-0{,}125$. Comme $f(1)\times f(1{,}5)=(-3)\times(-0{,}125)>0$, les deux sont de même signe : la solution n'est pas dans $[1\ ;\ 1{,}5]$. On pose a = m et le nouvel intervalle est $[1{,}5\ ;\ 2]$.

Tour 2 : $m=1{,}75$, $f(1{,}75)\approx 2{,}109>0$, changement de signe avec $f(1{,}5)<0$ : on pose b = m, intervalle $[1{,}5\ ;\ 1{,}75]$. Tour 3 : $m=1{,}625$, $f(1{,}625)\approx 0{,}916>0$ : intervalle $[1{,}5\ ;\ 1{,}625]$.

L'amplitude vaut $1$ au départ et est divisée par $2$ à chaque tour. La boucle continue tant que l'amplitude dépasse $0{,}01$ : après $6$ tours elle vaut $\frac{1}{64}\approx 0{,}0156$, encore trop grande ; après $7$ tours, $\frac{1}{128}\approx 0{,}0078$. La boucle effectue $7$ tours.

Après $7$ tours, l'intervalle est $[1{,}515625\ ;\ 1{,}5234375]$. Tous ses nombres arrondis au centième donnent $1{,}52$ : la solution vaut environ $1{,}52$. Contrôle : $f(1{,}52)\approx 0{,}032$, proche de $0$ ✓.