Exercices — Algorithmique et programmation en Python

1. À ce moment-là, a vaut 4, donc b = 4 + 3 : la variable b contient 7.

2. La troisième ligne recalcule a : a = 4 * 2, donc a contient 8. Et b contient toujours 7 : une affectation ne modifie que la variable à gauche du signe = — b ne se « met pas à jour » tout seul.

3. Ce sont des entiers (type int) : aucun calcul n’a produit de nombre à virgule.

4. Avec les guillemets, c est une chaine de caractères (type str). Ce n’est pas le nombre 8 : c’est le texte « 8 ». On ne peut pas calculer c + 1, alors que a + 1 vaut 9.

Réflexe à retenir : pour comprendre un programme, déroule-le ligne par ligne en notant la valeur de chaque variable après chaque instruction — exactement comme le ferait la machine.

1. On traduit la règle par une condition :

if montant >= 50:
    frais = 0
else:
    frais = 6
total = montant + frais

2. Pour montant = 62 : la condition 62 >= 50 est vraie, donc frais = 0 et le programme affiche 62. Pour montant = 40 : la condition est fausse, donc frais = 6 et il affiche 46.

3. Seule la condition change : if montant > 50: (inégalité stricte). Pour montant = 50, la condition 50 > 50 est fausse : frais = 6 et le total devient 56 — alors qu’avec >=, la livraison était offerte et le total valait 50.

Réflexe à retenir : traduis l’énoncé en une condition booléenne précise, et choisis entre >= et > en testant la valeur charnière (ici 50) : c’est elle qui fait la différence.

1. range(5) donne à i les valeurs 0, 1, 2, 3, 4 (la borne 5 est exclue !). La variable s accumule : $0 + 0 = 0$, puis $0 + 1 = 1$, puis $1 + 2 = 3$, puis $3 + 3 = 6$, puis $6 + 4 = 10$. Le programme affiche 10 — et non 15 : le 5 n’est jamais ajouté.

2. Il suffit de parcourir les entiers de 1 à 100, donc d’écrire range(1, 101) (borne de droite exclue) :

s = 0
for i in range(1, 101):
    s = s + i
print(s)   # affiche 5050

3. La boucle augmente n tant que son carré reste inférieur à 200 : elle s’arrête au premier entier dont le carré atteint 200. Or $14^2 = 196 < 200$ et $15^2 = 225 \geqslant 200$ : quand n vaut 14, la condition $196 < 200$ est encore vraie, donc n passe à 15 ; le test suivant ($225 < 200$) est faux et la boucle s’arrête. Le programme affiche 15.

Réflexe à retenir : fais tourner la boucle à la main sur les premiers tours, puis repère le tour où la condition bascule — c’est là que se joue le résultat (et le piège du « dernier tour »).

1. Aire = longueur × largeur :

def aire_rectangle(longueur, largeur):
    return longueur * largeur

L’appel aire_rectangle(7, 4) renvoie $7 \times 4 = 28$.

2. En Python, « puissance » s’écrit ** :

def image(x):
    return 3 * x**2 + 1

image(2) renvoie $3 \times 2^2 + 1 = 13$, et image(-1) renvoie $3 \times (-1)^2 + 1 = 4$ (le carré de $-1$ vaut $1$).

3. Avec les parenthèses obligatoires :

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

moyenne(12, 15) renvoie 13.5. Sans parenthèses, Python appliquerait les priorités de calcul : a + b / 2 signifie $a + \dfrac{b}{2}$, soit $12 + 7{,}5 = 19{,}5$ — faux.

4. La fonction additionne ses trois arguments puis divise par 3 : $(8 + 12 + 16) \div 3 = 36 \div 3 = 12$. L’appel renvoie 12.0 (la division / de Python donne toujours un nombre à virgule). Savoir lire une fonction écrite par quelqu’un d’autre est un attendu du programme, au même titre que savoir en écrire une.

Réflexe à retenir : une fonction, c’est arguments → calcul → return. Et teste chaque fonction avec des valeurs simples dont tu connais déjà le résultat : c’est le contrôle qualité du programmeur.

1. Chaque dé est un appel à randint(1, 6) (bornes comprises), et on additionne :

from random import randint

def somme_deux_des():
    return randint(1, 6) + randint(1, 6)

2. randint(2, 12) renverrait chaque somme de 2 à 12 avec la même probabilité $\dfrac{1}{11}$. Or les sommes ne sont pas équiprobables : une somme de 7 s’obtient de 6 façons — $(1\,;\,6)$, $(2\,;\,5)$, $(3\,;\,4)$, $(4\,;\,3)$, $(5\,;\,2)$, $(6\,;\,1)$ — alors qu’une somme de 2 ne s’obtient que d’une seule ($1$ et $1$). Il faut simuler chaque dé, pas la somme directement.

3. Une boucle répète l’expérience, un compteur totalise les succès :

def frequence_sept(n):
    compteur = 0
    for i in range(n):
        if somme_deux_des() == 7:
            compteur = compteur + 1
    return compteur / n

4. La probabilité théorique vaut $\dfrac{6}{36} = \dfrac{1}{6} \approx 0{,}167$. La fréquence observée $0{,}1683$ en est très proche : sur un grand nombre de répétitions, la fréquence se stabilise autour de la probabilité. C’est exactement ce que permet une simulation : estimer une probabilité en répétant l’expérience des milliers de fois.

Réflexe à retenir : une simulation, c’est toujours le même duo — une fonction pour une expérience, puis une boucle avec compteur pour la répéter ; la fréquence compteur / n se rapproche de la probabilité quand n grandit.