Écrire et vérifier un algorithme

Un parcours à ton rythme

Ce que tu vas savoir faire

Traduire une consigne en entrées, étapes et résultat.
Suivre les affectations et compter correctement les tours de boucle.
Écrire une fonction et vérifier son résultat sur des cas choisis.

Tu peux lire la fiche en plusieurs séances. Les exemples montrent chaque étape ; les indices et les corrections restent accessibles quand tu en as besoin.

Les bases utiles avant de commencer

Calculer une expression numérique et lire une condition simple.
Comprendre ce que désignent les termes d’une suite et leur rang.

1. Dire ce que le programme doit faire

Avant Python, écris une phrase précise : « À partir de ces données, je veux obtenir ce résultat. » Les données reçues sont les entrées ; la réponse produite est la sortie. Précise les valeurs autorisées. Pour calculer une somme jusqu’au rang n, n doit par exemple être un entier positif ou nul. Un programme qui fonctionne pour n = 5 n’est pas automatiquement correct pour n = 0.

Décris ensuite les étapes en français. Pour une somme : partir de zéro, parcourir les termes, ajouter chacun à un total, puis renvoyer ce total. Cette description permet de choisir les variables et la boucle. Une variable a un rôle : n compte un rang, u mémorise un terme, total accumule une somme. Des noms explicites aident à retrouver ce que représente chaque nombre.

Enfin, prépare quelques résultats à la main avant d’exécuter le code. Ils serviront de points de comparaison. On ne valide pas un algorithme seulement parce qu’il « ne plante pas » : il faut vérifier qu’il répond à la question exacte, avec le bon rang et la bonne valeur.

2. Suivre une affectation, ligne après ligne

En Python, x = expression calcule d’abord l’expression avec les valeurs actuelles, puis mémorise le résultat dans x. Ce signe égal n’est pas une égalité à résoudre. L’instruction x = x + 3 augmente la valeur stockée ; elle ne demande pas de trouver un nombre égal à lui-même plus trois.

Le test d’égalité s’écrit ==. La puissance s’écrit **, et ^ désigne une autre opération : il ne faut pas l’utiliser pour élever un nombre au carré. L’indentation regroupe les instructions d’une boucle, d’une condition ou d’une fonction. Elle fait partie du sens du programme.

Exemple 1 · une copie conserve la valeur du moment

x = 2
y = x
x = x + 3
z = x + y

Après la première ligne, x vaut 2. La deuxième copie ce nombre dans y : x et y valent 2. La troisième modifie x, qui devient 5 ; y reste égal à 2. Enfin z vaut $$5+2=7$$ . La variable y n’est pas une formule automatiquement recalculée quand x change.

Si tu intervertis les deuxième et troisième lignes, y reçoit 5 et z devient 10. L’ordre des instructions est donc essentiel. Un tableau avec une ligne par étape permet de voir exactement où deux algorithmes se séparent.

Suivre les variables, une instruction à la fois

Prévois z pour x = 2 au départ. Avance d’une ligne à la fois. Puis inverse l’ordre des deux lignes du milieu : y conserve-t-il le même nombre ?

La ligne bleue est la dernière instruction exécutée. Les cases montrent les valeurs mémorisées à cet instant. « Non définie » signifie qu’aucune valeur n’a encore été affectée à la variable.

Pour x = 2, copier y avant de modifier x donne successivement (x ; y) = (2 ; 2), puis (5 ; 2), et z = 7. Copier y après donne (5 ; 5), puis z = 10. L’affectation copie une valeur au moment où elle est exécutée.

Lire les valeurs et les coordonnées

Reviens à l’étape 2 et change l’ordre. Explique pourquoi modifier x ne met pas automatiquement y à jour. Puis prévois le résultat avec x = −1 au départ : 1 dans le premier ordre, 4 dans le second.

À toi de jouer · à ton rythme

Pause · prévoir avant de lancer

On exécute successivement a = 4, b = a - 1, a = 2 * b. Quelles sont les valeurs finales ? Que donnerait ensuite b = a + b ?

Tu peux chercher sur papier, demander une piste ou lire directement la correction. Reprends ensuite une étape avec tes propres mots.

Indice 1 · par où commencer

Après la deuxième instruction, b vaut 3. La troisième utilise cette valeur sans modifier b.

Indice 2 · avancer d’une étape

Avant la dernière ligne proposée, a vaut 6 et b vaut 3. Le membre droit est calculé avant de remplacer b.

Voir le corrigé entièrement rédigé

Les trois premières lignes donnent a = 6 et b = 3. La ligne supplémentaire calcule 6 + 3, puis mémorise 9 dans b. Au final, a vaut toujours 6 et b vaut 9. Il ne faut pas remplacer b pendant que l’on calcule le membre droit.

3. Choisir for quand le nombre de passages est connu

Une boucle for parcourt des valeurs prévues. range(n) fournit les entiers de 0 à n − 1 ; range(1, n + 1) fournit ceux de 1 à n. La borne de fin est exclue. Écris les premières et les dernières valeurs du parcours pour vérifier le nombre d’itérations.

Un accumulateur doit être initialisé avant la boucle : 0 pour une somme, 1 pour un produit. Le replacer à zéro à chaque tour efface le travail précédent. Pour compter les éléments qui satisfont une condition, on part de zéro et l’on augmente le compteur seulement quand la condition est vraie.

Exemple 2 · additionner les entiers de 1 à n

def somme_entiers(n):
    total = 0
    for k in range(1, n + 1):
        total = total + k
    return total

Cette fonction est prévue pour un entier n ≥ 0. Pour n = 4, les valeurs successives de k sont 1, 2, 3 et 4, et celles du total sont 1, 3, 6 et 10. Pour n = 0, la boucle ne s’exécute pas et la fonction renvoie 0, ce qui convient à une somme vide.

La ligne return est alignée avec for, à l’intérieur de la fonction mais à l’extérieur de la boucle. Si elle était dans la boucle, la fonction s’arrêterait dès le premier tour. La placer correctement fait partie du raisonnement.

Pour justifier l’algorithme, on peut énoncer un invariant : après le tour d’indice k, total vaut la somme des entiers de 1 à k. Il est vrai après le premier tour et se conserve lorsque l’on ajoute le suivant. Pour n ≥ 1, le dernier tour a l’indice n : le total est celui demandé. Pour n = 0, aucun tour ne s’exécute et le total initial vaut déjà la somme vide attendue.

4. Choisir while pour atteindre un seuil

Une boucle while répète ses instructions tant qu’une condition est vraie. Elle sert lorsqu’on ne connaît pas d’avance le nombre de répétitions, par exemple pour trouver le premier rang où une suite dépasse un seuil. Il faut que les variables de la condition évoluent et que l’on ait une raison de penser que l’arrêt sera atteint.

Exemple 3 · trouver le premier rang qui dépasse 1 000

La suite est définie par $$u_0=3$$ et $u_{n+1}=2u_n$ . On cherche le plus petit entier n tel que $$u_n>1000$$ .

def premier_depassement():
    n = 0
    u = 3
    while u <= 1000:
        u = 2 * u
        n = n + 1
    return n, u

Au début de chaque test, u contient bien le terme de rang n. Le corps de la boucle calcule le terme suivant et augmente le rang ensemble. Le programme s’arrête quand u devient strictement supérieur à 1 000, d’où le test de continuation u <= 1000.

On obtient n = 9 et u = 1 536. Le terme précédent vaut $$u_8=768$$ , donc le seuil n’était pas encore dépassé. La suite est croissante et tend vers l’infini : le seuil sera atteint et le premier arrêt donne bien le premier rang cherché. Sans une justification du comportement de la suite, un essai réussi ne garantit pas l’arrêt dans tous les cas.

Pour des calculs décimaux, évite de tester sans réflexion une égalité exacte entre nombres approchés. Il faut souvent comparer à un seuil ou à une tolérance cohérente avec la question. Dans l’exemple ci-dessus, les calculs portent sur des entiers exacts.

5. Vérifier le résultat et les cas limites

Une fonction reçoit des arguments et renvoie un résultat avec return. print affiche une information, mais ne remplace pas le résultat renvoyé. Séparer calcul et affichage permet d’utiliser la même fonction dans un autre calcul et de la tester facilement.

Prépare un cas simple calculable de tête, un cas ordinaire et une frontière du domaine : zéro, un seul terme, seuil déjà atteint ou valeur exactement égale au seuil. Un test met en évidence une erreur possible ; plusieurs tests réussis ne constituent pas à eux seuls une preuve pour toutes les entrées.

À toi de jouer · à ton rythme

Exercice 2 · multiplier au lieu d’additionner

Écris une fonction produit_entiers(n) qui renvoie le produit des entiers de 1 à n pour un entier n ≥ 0. Par convention, le produit vide pour n = 0 vaut 1. Donne les résultats pour n = 0 et n = 4.

Tu peux chercher sur papier, demander une piste ou lire directement la correction. Reprends ensuite une étape avec tes propres mots.

Indice 1 · par où commencer

Quel nombre laisse un produit inchangé quand on commence à accumuler les facteurs ?

Indice 2 · avancer d’une étape

Initialise à 1, puis multiplie successivement par les valeurs de range(1, n + 1).

Voir le corrigé entièrement rédigé

def produit_entiers(n):
    produit = 1
    for k in range(1, n + 1):
        produit = produit * k
    return produit

Pour n = 0, aucun tour ne s’exécute et la fonction renvoie 1. Pour n = 4, elle calcule $1\times2\times3\times4=24$ . Une initialisation à zéro donnerait zéro pour tous les résultats et empêcherait tout produit de se construire.

À toi de jouer · à ton rythme

Bilan · réparer une erreur de rang

Une suite vérifie $$u_0=5$$ , puis on ajoute 2 à chaque étape. Écris une fonction terme(n) qui renvoie $$u_n$$ pour n entier ≥ 0. Vérifie n = 0, n = 1 et n = 4. Explique pourquoi range(n + 1) serait incorrect.

Tu peux chercher sur papier, demander une piste ou lire directement la correction. Reprends ensuite une étape avec tes propres mots.

Indice 1 · par où commencer

La variable commence déjà à $$u_0$$ . Pour atteindre $$u_n$$ , il reste n changements de terme à faire.

Indice 2 · avancer d’une étape

Utilise range(n), qui effectue exactement n tours. La formule explicite est $$u_n=5+2n$$ .

Voir le corrigé entièrement rédigé

def terme(n):
    u = 5
    for k in range(n):
        u = u + 2
    return u

La fonction renvoie 5, 7 et 13 pour n = 0, 1 et 4. Après k tours, u vaut $$5+2k$$ ; après n tours, elle vaut donc le terme demandé. Avec range(n + 1), on ferait un tour de trop et l’on renverrait $u_{n+1}$ . Le cas n = 0 révèle immédiatement ce décalage.

Pour relire ton programme, pose un doigt sur chaque ligne et décris ce qu’elle fait aux variables. Puis contrôle la sortie attendue, les valeurs autorisées, les bornes de boucle et la justification de l’arrêt. Cette lecture pas à pas fonctionne aussi lorsque le code est donné dans un exercice.