Fiche – Algorithmique et programmation

Chapitre 9 | Terminale technologique (enseignement commun) | Mathématiques

Dernière mise à jour : 21 octobre 2026

L'essentiel :

Accumulateur : somme init. à \(0\), produit init. à \(1\), puis S = S + ... dans une boucle.
Compteur : c = c + 1 à chaque évènement à compter.
Fonction : des entrées (paramètres) et une sortie (return) ⇒ programmation modulaire.
Listes : extension, append, compréhension ; indices de \(0\) à len(liste) - 1.
Bernoulli : random() \(\in [0,1[\) ; succès si random() < p.

Définitions clés

Définition

Compteur : variable incrémentée de \(1\) pour compter des évènements. Accumulateur : variable qui cumule une somme (init. \(0\)) ou un produit (init. \(1\)).

Définition

Boucle bornée for : nombre de tours connu. Boucle non bornée while : on répète tant qu'une condition est vraie (algorithme de seuil).

Définition

Fonction : bloc nommé qui reçoit des paramètres (entrées) et renvoie une valeur avec return (sortie).

À connaître par cœur

Somme avec accumulateur

S = 0
for k in range(1, n + 1):
    S = S + k**2
return S

Simuler une épreuve de Bernoulli

from random import random

def bernoulli(p):
    if random() < p:
        return 1
    else:
        return 0

Listes — l'essentiel

Créer : [2, 3, 5] (extension), append (ajouts), [k**2 for k in range(5)] (compréhension).
Manipuler : a[0] (premier), a[-1] (dernier), len(a), a.append(x), a.remove(x).
Itérer : for x in a (éléments) ou for i in range(len(a)) (indices).

Méthode — Traduire une somme en programme

Méthode

Initialiser l'accumulateur (S = 0 pour une somme, P = 1 pour un produit).
Boucler sur l'indice avec range.
Accumuler à chaque tour (S = S + ...).
Renvoyer le résultat avec return.

Méthode — Lire ou corriger un programme

Identifier les entrées / sorties et le rôle de chaque variable.
« Dérouler » l'algorithme sur un petit exemple.
Repérer l'instruction fautive (initialisation, borne de boucle, indentation).

Erreurs fréquentes

Attention

❌ Écraser l'accumulateur au lieu de l'incrémenter.

✅ S = S + x, pas S = x.

❌ Se tromper de bornes de range.

✅ range(1, n+1) parcourt \(1\) à \(n\) : ne pas oublier le +1.

❌ Se tromper d'indice de liste.

✅ Premier indice \(0\), dernier len(liste) - 1 ; liste[-1] = dernier élément.

❌ Confondre == (test) et = (affectation), ou inverser le test de Bernoulli.

✅ Succès si random() < p. Attention aussi à l'indentation.

Exemple rapide

Exemple — fréquence de succès

On répète \(n\) épreuves de Bernoulli de paramètre \(p\) et on compte les succès :

def compte_succes(n, p):
    total = 0
    for _ in range(n):
        total = total + bernoulli(p)
    return total

Sur un grand nombre de simulations, la fréquence de succès est proche de \(p\) (lien avec la loi binomiale \(B(n,p)\)).