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

a) Après les deux premières lignes, a vaut 5 et b vaut 3. La ligne `a = a + b` donne a = 8, b inchangé à 3. La ligne `b = a - b` donne b = 8 - 3 = 5, a inchangé à 8. La ligne `a = a - b` donne a = 8 - 5 = 3. Le programme affiche donc 3 5.

b) 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.

c) Avec une variable auxiliaire, on écrit : `c = a` puis `a = b` puis `b = c`. C'est la version que l'on écrit en pratique, car 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.

d) 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, elle ne crée pas de lien permanent entre deux variables.

c = a
a = b
b = c

a) mention(14) renvoie 'Bien', car 14 n'est pas supérieur ou égal à 16 mais l'est à 14. mention(11.5) renvoie 'Pas de mention'. mention(16) renvoie 'Tres bien', car le test utilise une inégalité large. mention(20) renvoie 'Tres bien'.

b) 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à. Dans une cascade de `elif`, il faut ordonner les tests du plus restrictif au plus large.

c) Il suffit d'ajouter un test avant le `else` final : `elif note >= 10:` renvoyant 'Pas de mention', et le `else` renvoie alors 'Refuse'. L'ordre reste décroissant.

d) 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 un `and` entre deux bornes différentes.

def mention(note):
    if note >= 16:
        return 'Tres bien'
    elif note >= 14:
        return 'Bien'
    elif note >= 12:
        return 'Assez bien'
    elif note >= 10:
        return 'Pas de mention'
    else:
        return 'Refuse'

a) Il calcule la somme des entiers de 1 à 10, puisque range(1, 11) s'arrête à 10. 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 est exclue est l'erreur la plus fréquente.

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

c) 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).

d) 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$. Remarquez qu'il faut initialiser p à 1 et non à 0, sinon tous les produits seraient nuls : l'élément neutre de la multiplication n'est pas celui de l'addition.

s = 0
for k in range(1, 11):
    s = s + k*k
print(s)

a) 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.

b) 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 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 à 9 heures est à 5 bactéries près du seuil : conclure sans calculer aurait conduit à répondre 9.

c) 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 l'outil des problèmes de seuil.

d) 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.

a) La fonction se réduit à une ligne : `return L * l`. On obtient aire_rectangle(7, 3) = 21.

b) 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 True ou False, même si c'est correct.

c) 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.

d) f(0) = 3 et f(5) = 13. Pour résoudre f(x) = 17, on résout $2x+3=17$, soit $2x=14$ et $x=7$. On vérifie que f(7) = 17.

def aire_rectangle(L, l):
    return L * l

def est_pair(n):
    return n % 2 == 0

def f(x):
    return 2*x + 3

a) len(notes) vaut 6, notes[0] vaut 12, notes[2] vaut 15 et notes[len(notes) - 1] vaut 11. Les indices commencent à 0, donc le dernier indice est 5 et non 6 : écrire notes[6] provoquerait une erreur.

b) 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$.

c) On initialise un compteur à 0, puis on parcourt la liste en 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.

d) 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, l'algorithme renverrait 0, qui n'appartient pas à la liste. Partir du premier élément garantit que le résultat est toujours une valeur réellement présente.

compteur = 0
for note in notes:
    if note >= 12:
        compteur = compteur + 1

maxi = notes[0]
for note in notes:
    if note > maxi:
        maxi = note

a) 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.

b) 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. Le programme affiche 14.

c) 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 est discontinue, on n'atterrit jamais exactement sur le seuil.

d) 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é.

capital = 2000
annee = 0
while capital < 3000:
    capital = capital * 1.03
    annee = annee + 1
    print(annee, capital)
print(annee)

a) Elle représente la fréquence d'apparition du 6 sur 1 000 lancers simulés, c'est-à-dire le nombre de 6 obtenus divisé par le nombre de lancers. C'est une fréquence observée, et non une probabilité.

b) Le dé étant équilibré, la probabilité d'obtenir un 6 vaut $\frac{1}{6}\approx 0{,}167$. La fréquence observée doit se situer autour de cette valeur.

c) 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. Un programme qui renverrait exactement 0.1666 à chaque exécution serait au contraire suspect.

d) 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$. Multiplier la taille de l'échantillon par 100 divise donc la largeur par 10 seulement, puisque c'est la racine carrée de $n$ qui intervient : gagner une décimale de précision coûte cent fois plus de lancers.

a) m vaut None. La fonction affiche bien 5 à l'écran, mais elle ne renvoie aucune valeur. La correction consiste à remplacer print par return : `return (a + b)/2`. On peut toujours afficher le résultat ensuite, avec `print(moyenne(4, 6))`.

b) À la fin, s vaut 10 : à chaque tour on écrase la valeur précédente au lieu de l'accumuler. On voulait la somme des entiers de 1 à 10, soit 55. La correction est `s = s + k`, qui ajoute au lieu de remplacer.

c) 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 de la boucle, ce qui affichera alors 10, 9, 8, jusqu'à 1.

d) 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.

def moyenne(a, b):
    return (a + b)/2

s = 0
for k in range(1, 11):
    s = s + k

n = 10
while n > 0:
    print(n)
    n = n - 1

a) La boucle s'arrête dès que le carré atteint 7. 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$.

b) 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$.

c) Le nombre 0,1 n'a pas d'écriture binaire exacte : 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 exacts.

d) 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. Une recherche par dichotomie sur l'intervalle $[2\ ;\ 3]$ atteindrait la même précision de 0,01 en 7 étapes seulement, car chaque étape divise l'amplitude par 2 et $\frac{1}{2^{7}}\approx 0{,}0078$.

n = 0
while (n/100)*(n/100) < 7:
    n = n + 1
print(n/100)