Algorithmique en STL

Utiliser fonctions, boucles et listes pour calculer un seuil, traiter des mesures et simuler des essais.

Environ 35 minutes

  • Décrire les entrées et sorties d’une fonction
  • Choisir une boucle et vérifier ses bornes
  • Traiter une liste et simuler des succès
Sommaire
  1. Définir les données et le résultat attendu
  2. Répéter tant qu’une condition reste vraie
  3. Parcourir des mesures et accumuler
  4. Combiner condition, compteur et fonction
  5. Au bac : expliquer et contrôler le programme
  6. S’entraîner

Comment vérifier qu’un programme répond exactement à la question scientifique ?

Un programme peut terminer sans erreur et produire une réponse fausse si ses variables, ses bornes ou son modèle sont mal choisis. Le travail algorithmique consiste à décomposer un calcul en étapes précises et contrôlables. Dans les situations STL, il sert notamment à suivre une évolution, à traiter des mesures ou à simuler des expériences aléatoires.

Définir les données et le résultat attendu

Avant de programmer, précise les entrées, les sorties et les conditions d’utilisation. Une fonction reçoit des arguments et renvoie un résultat. Pour calculer une moyenne, l’entrée peut être une liste non vide de mesures ; la sortie est un nombre exprimé dans la même unité. Une liste vide ne possède pas de moyenne calculable par division par son effectif. Cette condition doit être vérifiée, pas laissée au hasard.

Une variable porte une valeur qui peut changer pendant le calcul. L’affectation remplace sa valeur actuelle par une nouvelle valeur. En Python, l’instruction « n = n + 1 » signifie que l’on calcule l’ancienne valeur de n plus 1, puis que l’on range le résultat dans n. Ce n’est pas une équation mathématique à résoudre. Pour comparer deux valeurs, Python utilise notamment == ; pour leur affectation, il utilise =.

Le nom d’une variable aide à suivre le sens : n pour le nombre d’étapes, quantite pour une quantité, total pour une somme. Une même lettre ne doit pas changer de signification au milieu d’un raisonnement. Note aussi les unités hors du calcul : le programme manipule des nombres, mais il ne sait pas spontanément qu’une liste mélange des secondes et des minutes. Une conversion cohérente précède le traitement.

Vocabulaire

Entrée :
Donnée reçue par une fonction ou un programme.
Sortie :
Résultat renvoyé après le calcul.
Compteur :
Variable qui compte des occurrences ou des étapes.
Accumulateur :
Variable qui rassemble progressivement une somme ou un produit.

Répéter tant qu’une condition reste vraie

Une boucle while répète des instructions tant qu’une condition est vraie. Elle convient à une recherche de seuil lorsque le nombre d’étapes n’est pas connu à l’avance. On doit initialiser les variables avant la boucle, mettre à jour les bonnes variables à chaque passage et expliquer pourquoi la boucle s’arrêtera. Si aucune instruction ne fait évoluer la condition vers une valeur fausse, le calcul peut continuer indéfiniment.

Considérons une quantité initiale 100 multipliée par 0,8 à chaque étape. On cherche le premier entier n tel que la quantité soit inférieure ou égale à 40. On commence avec n = 0 et quantite = 100. Tant que quantite > 40, on remplace quantite par 0,8 fois sa valeur puis on augmente n de 1. Le signe strict dans la condition signifie que l’on s’arrête dès que la valeur est inférieure ou égale au seuil.

La quantité est multipliée par 0,8 à chaque étape. Le premier point sous le seuil 40 correspond à n = 5.

Exemple résolu

Déterminer le nombre d’étapes nécessaire pour que la quantité initiale 100, multipliée par 0,8 à chaque étape, soit au plus égale à 40.

  1. Étape 1 : À l’étape 0, la quantité vaut 100. Les valeurs successives sont 80 ; 64 ; 51,2 ; 40,96 ; 32,768.
  2. Étape 2 : Après quatre étapes, 40,96 est encore strictement supérieur à 40. La boucle doit continuer.
  3. Étape 3 : Après cinq étapes, 32,768 est inférieur à 40. La condition de continuation devient fausse et le compteur vaut 5.

Résultat : Le premier rang recherché est n = 5. La vérification des rangs 4 et 5 prouve que l’on a bien le premier franchissement.

Piège à éviter : Compter la valeur initiale comme une première transformation décale la réponse d’une étape.

À toi d'essayer

Une quantité initiale de 64 est divisée par 2 à chaque étape. Quel est le premier rang où elle devient inférieure ou égale à 8 ? Indique aussi la condition de continuation.

Voir la réponse

Les valeurs sont 64 au rang 0, puis 32, 16 et 8. Le premier rang est 3. La boucle continue tant que la quantité est strictement supérieure à 8.

Parcourir des mesures et accumuler

Une liste Python conserve des valeurs dans un ordre. La première occupe l’indice 0, la suivante l’indice 1. Une liste de longueur m possède donc les indices de 0 à m − 1. L’expression len(mesures) donne sa longueur ; mesures[0] lit sa première valeur. L’indice identifie une position, tandis que mesures[indice] donne la donnée située à cette position.

Les valeurs 1,2 ; 1,4 ; 1,1 occupent les indices 0, 1 et 2. L’indice repère une position, pas la valeur mesurée.

Une boucle for convient lorsque l’on parcourt les valeurs d’une liste ou un ensemble connu d’indices. Pour calculer une somme, on initialise un accumulateur à zéro et on ajoute chaque mesure une fois. Pour un produit, l’initialisation correcte est généralement 1 : partir de zéro rendrait tout le produit nul. Le choix de la valeur initiale dépend donc de l’opération effectuée.

Exemple résolu

La liste mesures contient 1,2 ; 1,4 ; 1,1. Calculer la somme et la moyenne par accumulation.

  1. Étape 1 : Avant le parcours, total vaut 0. Après la première mesure, il vaut 1,2.
  2. Étape 2 : Après la deuxième mesure, total vaut 2,6 ; après la troisième, il vaut 3,7.
  3. Étape 3 : La liste contient trois valeurs. La moyenne est donc 3,7/3, soit environ 1,2333 dans l’unité des mesures.

Résultat : La somme est 3,7 et la moyenne environ 1,23 si l’on arrondit au centième.

Piège à éviter : Diviser par le dernier indice, qui vaut 2, confond indice final et nombre de mesures.

En Python, sum(mesures) calcule la somme et len(mesures) l’effectif. Une fonction de moyenne peut donc renvoyer sum(mesures)/len(mesures), après avoir vérifié que la liste n’est pas vide. Même quand une fonction intégrée réalise le calcul, comprendre l’accumulation aide à contrôler la sortie et à modifier la méthode, par exemple pour ne retenir que certaines observations.

À toi d'essayer

La liste contient 8, 12, 9 et 15. On conserve seulement les valeurs strictement supérieures à 10. Donne la liste obtenue et sa moyenne.

Correction détaillée pas à pasDans ce chapitre : 2 corrections détaillées.

Combiner condition, compteur et fonction

Pour simuler une épreuve de Bernoulli de probabilité p, on compare un tirage uniforme U de [0 ; 1[ à p. Si U < p, on compte un succès ; sinon, on n’ajoute rien. Une fonction simulant n essais reçoit n et p, initialise succes à zéro, répète n tirages et renvoie le compteur. Une autre fonction peut appeler la première plusieurs fois pour produire une liste de nombres de succès.

Le compteur doit être remis à zéro au début de chaque nouvelle série. Si on le conserve d’une série à la suivante, on obtient un total cumulatif et non un résultat par échantillon. De même, tirer U une seule fois puis réutiliser sa valeur n fois ne simule pas n essais indépendants. La position du tirage dans la boucle fait partie du modèle probabiliste.

Exemple résolu

Avec p = 0,4, une série de tirages donne 0,12 ; 0,81 ; 0,39 ; 0,40 ; 0,05. Appliquer la règle U < p et calculer la fréquence de succès.

  1. Étape 1 : 0,12 est inférieur à 0,4 : succès. 0,81 est supérieur : échec.
  2. Étape 2 : 0,39 donne un succès. 0,40 n’est pas strictement inférieur à 0,4 : échec avec la règle choisie.
  3. Étape 3 : 0,05 donne un succès. Le compteur final vaut 3 sur 5 essais.

Résultat : La fréquence vaut 3/5 = 0,6. Ce résultat de série peut différer du paramètre p = 0,4.

Piège à éviter : Lire U < p comme U ≤ p modifie la condition exécutée, ce qui se voit ici pour le tirage égal à 0,40.

À toi d'essayer

Un programme réinitialise succes à zéro à l’intérieur de la boucle qui parcourt les essais, juste avant chaque tirage. Quelle erreur cela provoque-t-il ?

Correction détaillée pas à pasDans ce chapitre : 2 corrections détaillées.

Au bac : expliquer et contrôler le programme

Un test choisi au hasard ne suffit pas. Pour une fonction de seuil, teste un cas où la condition est déjà satisfaite : le résultat attendu doit être zéro étape. Teste aussi une égalité exacte au seuil pour contrôler les signes. Pour une moyenne, utilise une liste à une valeur et une liste de valeurs identiques. Pour une simulation, p = 0 doit produire zéro succès et p = 1 doit produire n succès.

Une boucle de seuil doit avoir une condition d’arrêt atteignable. Dans une décroissance strictement positive multipliée par 0,8, le seuil zéro n’est jamais atteint mathématiquement. Un programme numérique peut finir par produire zéro à cause de ses limites de représentation, ce qui ne constitue pas une démonstration du modèle. Il faut définir les entrées admissibles et, si nécessaire, prévoir une borne d’itérations signalant que le calcul n’a pas abouti.

Les nombres décimaux sont souvent approchés dans un ordinateur. Une égalité exacte entre résultats de calculs décimaux peut être fragile. Pour contrôler un résultat numérique, on peut comparer l’écart absolu à une tolérance adaptée. Cette tolérance doit avoir un sens dans le problème ; elle ne sert pas à masquer une erreur de raisonnement ou une mauvaise unité.

Au bac : lire ou compléter un algorithme

  1. Dire ce que représente chaque variable et préciser ses valeurs initiales.
  2. Suivre deux ou trois passages dans un tableau de trace, en respectant l’ordre exact des instructions.
  3. Relier la condition de boucle ou de test à la phrase de l’énoncé, notamment pour les inégalités strictes.
  4. Vérifier la sortie sur un cas simple et un cas limite, puis expliquer pourquoi elle répond à la question.
Attention :

Le mot return renvoie un résultat et termine l’appel d’une fonction. Un affichage avec print montre une valeur mais ne joue pas le même rôle. Une fonction qui affiche seulement sa réponse n’offre pas nécessairement un résultat réutilisable dans le calcul suivant.

Bilan

RepèreInterprétation
whileRépéter tant qu’une condition est vraie.
forParcourir une liste ou un nombre fixé de passages.
CompteurAjouter 1 quand un événement est compté.
AccumulateurAjouter les valeurs à une somme ou les multiplier dans un produit.

S’entraîner

Poursuis ton travail dans l’espace S’entraîner du site, accessible à l’adresse /exercices. Reprends d’abord les questions que tu n’as pas réussies sans aide, puis explique tes étapes à voix haute.

À retenir

  • Une fonction se décrit par ses entrées, ses sorties et ses conditions d’utilisation.
  • Une liste de longueur m est indexée de 0 à m − 1.
  • Une recherche de premier seuil se vérifie au rang trouvé et au rang précédent.
  • L’initialisation et l’ordre des instructions déterminent le sens du résultat.

Fiche de révision

Avant le code, définis la grandeur cherchée et l’unité de chaque donnée.

Trace les variables après chaque passage pour repérer une erreur d’une unité dans le compteur.

Réinitialise les compteurs au bon niveau de répétition.

Vérifie les cas nuls, les égalités au seuil et les petites listes avant d’interpréter une grande sortie.

Questions fréquentes

Pourquoi utiliser plusieurs fonctions ?

Pour isoler des tâches simples, les tester séparément et réutiliser leurs résultats sans recopier tout le programme.

Un programme qui s’arrête est-il forcément correct ?

Non. Il peut s’arrêter avec une mauvaise initialisation, une mauvaise condition ou une sortie qui ne correspond pas à la question.

Et maintenant ?

Tu as lu le cours. L’étape suivante tient en une action.

Relis le coursReprends l’essentiel avant de passer à la suite.

    Prolonge l’expérience !

    Continue à explorer ce chapitre à travers de nouvelles activités, des défis et des expériences interactives. Avec Premium, l’apprentissage continue !

    Ici, tu débloques aussi 2 corrections détaillées.

    Parent ? Suivez les progrès de votre enfant.

    Tous les cours de Mathématiques — terminale STL
    Scientia