Première STMG

Algorithmique, listes Python et tableur — 10 exercices corrigés Première STMG

Dix exercices progressifs : données, calculs inverses, choix de modèles, analyse critique et problèmes appliqués, avec des corrigés spécifiques à chaque question.

L'essentiel à retenir

  • Les indices d'une liste Python commencent à 0. len(L) donne son nombre d'éléments.
  • Une boucle for peut parcourir des valeurs ou des indices ; range(n) produit les entiers de 0 à n − 1.
  • Un accumulateur doit être initialisé avant la boucle. append ajoute un élément en fin de liste.
  • Une boucle while répète ses instructions tant que la condition est vraie ; il faut vérifier son arrêt.
  • Une simulation aléatoire donne une fréquence observée, à distinguer de la probabilité théorique.

Exercice 1 — Indices et moyenne des recettes

Les recettes quotidiennes, en euros, sont [120, 150, 90, 140]. 1. Donner les valeurs affichées par le programme. 
recettes = [120, 150, 90, 140]
print(recettes[0], recettes[-1], len(recettes))
2. Écrire un programme autonome calculant la moyenne avec une boucle et un accumulateur, sans utiliser sum.
Corrigé détaillé
1. Le programme affiche 120 140 4. L'indice 0 désigne la première recette ; −1 désigne la dernière ; la liste contient quatre valeurs. 2. Voici un programme complet : 
recettes = [120, 150, 90, 140]
total = 0
for recette in recettes:
    total = total + recette
moyenne = total / len(recettes)
print(total)
print(moyenne)
Il affiche 500, puis 125.0. Le total vaut 120 + 150 + 90 + 140 = 500 € et la moyenne vaut 500/4 = 125 € par jour. L'initialisation de total est placée avant la boucle pour ne pas effacer les sommes partielles.

Exercice 2 — Générer cinq termes d'une suite

Un stock théorique suit u₀ = 40 et uₙ₊₁ = uₙ + 12, en articles. 1. Donner la liste affichée par ce programme et préciser l'indice du dernier terme. 
u = 40
valeurs = []
for n in range(5):
    valeurs.append(u)
    u = u + 12
print(valeurs)
2. Expliquer pourquoi ajouter u à la liste après son augmentation ne produirait pas la même liste, puis donner la liste ainsi obtenue.
Corrigé détaillé
1. La boucle effectue cinq passages et ajoute les valeurs avant leur augmentation. Elle affiche [40, 52, 64, 76, 88], soit les stocks u₀ à u₄. Le dernier terme enregistré est donc u₄ = 88 articles. À la fin, la variable u vaut 100, mais cette valeur n'est pas enregistrée. 2. Si l'on augmente avant d'enregistrer, le premier terme ajouté devient u₁ = 52 et le dernier u₅ = 100. Programme autonome correspondant : 
u = 40
valeurs = []
for n in range(5):
    u = u + 12
    valeurs.append(u)
print(valeurs)
Il affiche [52, 64, 76, 88, 100]. L'ordre des instructions décale donc tous les indices d'une unité.

Exercice 3 — Trouver un seuil avec while

Une cagnotte contient 200 € au départ puis reçoit 25 € par semaine. 1. Écrire un programme autonome qui trouve le premier nombre de semaines permettant d'atteindre au moins 350 €. 2. Donner sa sortie et justifier à la fois l'arrêt de la boucle et le caractère minimal du nombre trouvé.
Corrigé détaillé
1. On répète l'ajout tant que la cagnotte est strictement inférieure au seuil : 
montant = 200
semaines = 0
while montant < 350:
    montant = montant + 25
    semaines = semaines + 1
print(semaines, montant)
2. La sortie est 6 350. Après cinq semaines, on a 200 + 5 × 25 = 325 €, encore insuffisants ; après six, 350 € sont atteints. La boucle s'arrête puisque montant augmente de 25 à chaque passage et finit par atteindre le seuil. Le test < 350 permet l'arrêt dès l'égalité.

Exercice 4 — Appliquer une remise sans perdre les prix initiaux

Une boutique veut appliquer 10 % de remise aux prix [20, 50, 80], en euros, tout en conservant la liste initiale. 1. Écrire un programme autonome construisant une nouvelle liste de prix remisés. 2. Donner les deux listes finales et expliquer pourquoi soustraire 10 à chaque prix serait incorrect.
Corrigé détaillé
1. Une remise de 10 % correspond à une multiplication par 0,9. 
prix = [20, 50, 80]
prix_remises = []
for p in prix:
    prix_remises.append(round(p * 0.9, 2))
print(prix)
print(prix_remises)
2. Les listes affichées sont [20, 50, 80] et [18.0, 45.0, 72.0]. Les prix remisés valent 18 €, 45 € et 72 €. Soustraire 10 enlèverait 10 € à chaque prix, pas 10 % ; les réductions correctes sont ici 2 €, 5 € et 8 €. La liste initiale n'est jamais modifiée.

Exercice 5 — Compter les journées atteignant l'objectif

Les ventes quotidiennes, en articles, sont [80, 120, 100, 90, 150]. L'objectif est atteint lorsque les ventes sont supérieures ou égales à 100. 1. Écrire un programme autonome calculant le nombre et la proportion de journées atteignant l'objectif. 2. Donner les résultats et expliquer ce qui changerait si l'on utilisait > 100.
Corrigé détaillé
1. On incrémente un compteur uniquement si la condition est vérifiée : 
ventes = [80, 120, 100, 90, 150]
compteur = 0
for v in ventes:
    if v >= 100:
        compteur = compteur + 1
proportion = compteur / len(ventes)
print(compteur)
print(proportion)
2. Les journées à 120, 100 et 150 articles conviennent. Le programme affiche 3, puis 0.6, soit 60 % des journées. Avec > 100, la journée à exactement 100 articles serait exclue : on obtiendrait 2 journées et une proportion de 2/5 = 0,4, soit 40 %.

Exercice 6 — Corriger un calcul d'espérance

La recette aléatoire X d'une opération a pour loi :
x, en €0510
P(X = x)0,20,50,3
Le programme suivant est erroné. 
valeurs = [0, 5, 10]
probabilites = [0.2, 0.5, 0.3]
esperance = 0
for i in range(len(valeurs)):
    esperance = valeurs[i] * probabilites[i]
print(esperance)
1. Donner sa sortie et expliquer l'erreur. 2. Fournir un programme autonome corrigé et interpréter son résultat.
Corrigé détaillé
1. Le programme affiche 3.0, car chaque affectation remplace la précédente : seul le dernier produit 10 × 0,3 reste mémorisé. Les contributions ne sont pas additionnées. 2. Il faut conserver le total précédent : 
valeurs = [0, 5, 10]
probabilites = [0.2, 0.5, 0.3]
esperance = 0
for i in range(len(valeurs)):
    esperance = esperance + valeurs[i] * probabilites[i]
print(esperance)
La sortie est 5.5, car E(X) = 0 × 0,2 + 5 × 0,5 + 10 × 0,3 = 5,50 €. Il s'agit de la recette moyenne théorique par opération.

Exercice 7 — Calculer des variations mensuelles

Les effectifs d'une association sont [100, 110, 99, 108] sur quatre mois consécutifs. 1. Écrire un programme autonome construisant la liste des trois variations absolues entre mois consécutifs. 2. Donner cette liste et expliquer pourquoi la boucle doit commencer à l'indice 1 plutôt qu'à l'indice 0.
Corrigé détaillé
1. Chaque variation est obtenue en retranchant l'effectif précédent : 
effectifs = [100, 110, 99, 108]
variations = []
for i in range(1, len(effectifs)):
    variations.append(effectifs[i] - effectifs[i - 1])
print(variations)
2. Les calculs sont 110 − 100 = 10, 99 − 110 = −11 et 108 − 99 = 9. La liste affichée est [10, -11, 9], en adhérents. À l'indice 0, i - 1 vaudrait −1 : Python utiliserait le dernier mois, créant une comparaison non chronologique entre le premier et le dernier mois.

Exercice 8 — Rechercher un minimum sur des quantités entières

Le coût C(q), en euros, est C(q) = q² − 6q + 20 pour une quantité entière q comprise entre 0 et 6. 1. Écrire un programme autonome qui teste les sept quantités et affiche la quantité de coût minimal ainsi que ce coût. 2. Vérifier le résultat en donnant la liste complète des coûts. Préciser la portée de cette recherche.
Corrigé détaillé
1. On initialise le meilleur résultat avec q = 0 puis on compare : 
def cout(q):
    return q * q - 6 * q + 20

meilleure_quantite = 0
cout_minimal = cout(0)
for q in range(1, 7):
    if cout(q) < cout_minimal:
        meilleure_quantite = q
        cout_minimal = cout(q)
print(meilleure_quantite, cout_minimal)
2. Pour q = 0, 1, 2, 3, 4, 5, 6, les coûts sont 20, 15, 12, 11, 12, 15, 20 €. Le programme affiche 3 11. Il trouve exactement le minimum parmi les sept quantités entières autorisées ; en général, une recherche sur des entiers ne suffit pas à étudier toutes les valeurs réelles d'un intervalle.

Exercice 9 — Simuler trois réponses indépendantes

Trois clients acceptent indépendamment une offre avec probabilité 0,5 chacun. 1. Écrire un programme autonome simulant 10 000 groupes de trois clients et affichant la fréquence des groupes ayant exactement deux acceptations. Utiliser une graine pour rendre l'expérience reproductible. 2. Calculer la probabilité théorique et expliquer pourquoi la fréquence simulée n'est pas forcément égale à celle-ci.
Corrigé détaillé
1. Chaque groupe contient seulement trois épreuves de Bernoulli ; c'est le nombre de groupes simulés qui est grand. 
from random import Random

generateur = Random(2026)
nombre_groupes = 10000
favorables = 0
for repetition in range(nombre_groupes):
    succes = 0
    for client in range(3):
        if generateur.random() < 0.5:
            succes = succes + 1
    if succes == 2:
        favorables = favorables + 1
print(favorables / nombre_groupes)
2. Les chemins favorables sont SSE, SES et ESS. Chacun a pour probabilité 0,5³ = 0,125, donc la probabilité théorique vaut 3 × 0,125 = 0,375, soit 37,5 %. La fréquence simulée est une proportion sur un nombre fini de groupes ; elle fluctue autour de cette valeur. La graine rend les tirages reproductibles, pas exactement conformes aux proportions théoriques.

Exercice 10 — Tableur et cumul d'une épargne

Une personne possède 50 € à la semaine 0 et ajoute 15 € par semaine. Dans un tableur, A1 contient « semaine », B1 « épargne », A2 contient 0 et B2 contient 50. 1. Donner les formules à saisir en A3 et B3 puis à recopier jusqu'à la ligne 6. Donner les valeurs de la ligne 6. 2. Écrire un programme Python autonome produisant les mêmes couples semaine-épargne, de la semaine 0 à la semaine 4.
Corrigé détaillé
1. En A3, on saisit =A2+1 ; en B3, =B2+15. Après recopie jusqu'à la ligne 6, cette ligne contient la semaine 4 et 50 + 4 × 15 = 110 €. Les références relatives désignent à chaque fois la ligne précédente. 2. Programme équivalent : 
epargne = 50
for semaine in range(5):
    print(semaine, epargne)
    epargne = epargne + 15
Il affiche successivement 0 50, 1 65, 2 80, 3 95 et 4 110, chaque couple sur une ligne. On affiche avant l'ajout pour commencer par l'épargne initiale de la semaine 0.

Besoin d'aide sur ce chapitre ?

Réserver le bilan offert de 30 minCours particuliers de maths Première STMG