Algorithmique, Python et tableur · Première STMG et STI2D · commun

Avant de commencer5 questions pour vérifier tes bases

1. Pars de 4, ajoute 3, puis multiplie le résultat par 2. Quel nombre obtiens-tu ?

141110

2. Quelle est la solution de 2x − 6 = 0 ?

−336

3. Quel est le plus petit entier n tel que 3n > 10 ?

10/334

4. Parmi 80 objets, 20 sont rouges. Quelle est la proportion d’objets rouges ?

20/80 = 1/480/20 = 420/100 = 1/5

5. Un tableau donne x : −1, 0, 2 et f(x) : 4, 1, −3. Quelle est l’image de 2 ?

−304

Pourquoi ce chapitre ?

Un programme répète une démarche que tu sais expliquer. Les variables et les boucles deviennent utiles pour suivre un stock et trouver un seuil. Ton parcours. Enseignement commun de mathématiques pour les séries STMG et STI2D. Les situations de gestion et les situations techniques mobilisent ici les mêmes notions du programme.

Variables, affectations et fonctions.
Choisir avec une condition.
Répéter un nombre connu de fois.
Répéter jusqu’à un objectif.
Listes, données et contrôles numériques.
Construire et recopier une formule de tableur.

L’idée avant la formule

Joue d’abord le rôle de l’ordinateur sur trois tours. Une affectation remplace une valeur ; la trace rend les mises à jour visibles.

Le cours formel

Variables, affectations et fonctions

Intuition · Construire la notion pas à pas

Partir d'une tâche que l'on sait faire à la main. Un atelier facture 15 euros de préparation et 3 euros par pièce. Pour quatre pièces, tu calcules d'abord le coût des pièces, puis tu ajoutes la préparation. Programmer consiste à décrire exactement ces opérations pour qu'elles puissent être refaites avec une autre quantité.

Donner un nom à une donnée. Écrire n = 4 range le nombre 4 sous le nom n. La lettre n'est pas une inconnue à résoudre : elle possède déjà une valeur. Dans cout = 15 + 3*n, Python lit cette valeur, calcule $15+3\times4$ , puis mémorise 27 sous le nom cout. L'ordre est donc : lire, calculer, ranger.

Comprendre ce qui reste en mémoire. Une variable conserve un résultat, pas une relation vivante. Si l'on écrit ensuite n = 10, le coût déjà mémorisé reste 27. Il faut exécuter à nouveau la formule pour obtenir le coût correspondant à dix pièces.

Rendre le calcul réutilisable. Une fonction reçoit une donnée d'entrée, effectue les instructions de son bloc et renvoie une sortie. Le paramètre de la fonction est un nom local : il reçoit la valeur fournie lors de l'appel. Les espaces au début des lignes indiquent quelles instructions appartiennent à cette fonction. Les deux-points annoncent le bloc.

Exemple · Exemple commenté

Objectif : calculer le coût de n pièces sans recopier la formule à chaque fois.

def cout(n):
    return 15 + 3*n

prix = cout(4)
print(prix)

def cout(n): définit une recette nommée cout. Cette ligne ne commande pas encore une fabrication et ne calcule pas le coût de quatre pièces.
L'appel cout(4) donne la valeur 4 au paramètre n. La multiplication est prioritaire : $3\times4=12$ .
L'addition donne $$15+12=27$$ . return transmet ce nombre à l'endroit où la fonction a été appelée.
L'affectation prix = cout(4) range donc 27 dans prix. Enfin, print(prix) affiche 27.

Contrôle indépendant. Quatre pièces à 3 euros coûtent 12 euros ; avec les 15 euros fixes, le total est bien 27 euros. Pour zéro pièce, la formule renvoie 15 : cela correspond aux frais fixes du modèle. Si aucun frais n'est réellement facturé en l'absence de commande, il faut modifier le modèle, pas accuser Python.

Pourquoi distinguer afficher et renvoyer ? On peut écrire cout(4) + 5 pour ajouter des frais, car cout(4) fournit un nombre. Une fonction qui se contente de l'afficher ne fournit pas automatiquement ce nombre au calcul suivant.

Choisir avec une condition

Intuition · Construire la notion pas à pas

Du règlement au choix. Une livraison est gratuite à partir de 50 euros, sinon elle coûte 5 euros. Avant d'écrire un programme, formule une question qui possède deux réponses : « le total est-il supérieur ou égal à 50 ? ». Si oui, les frais valent zéro ; si non, ils valent cinq.

Un test produit une valeur logique. Pour un total de 42, total >= 50 est faux. Pour 50 ou 70, il est vrai. Le signe égal dans « supérieur ou égal » décide précisément de ce qui arrive à la frontière : il ne s'agit pas d'un détail d'écriture.

Des branches, pas plusieurs calculs obligatoires. Dans une structure if/elif/else, Python évalue les conditions dans l'ordre et exécute la première branche dont la condition est vraie. Il ignore les branches suivantes. else couvre tous les cas qui n'ont pas été retenus ; cette dernière branche n'a donc pas besoin d'un nouveau test.

Combiner des exigences. « Avoir au moins 16 ans et présenter une autorisation » exige les deux informations. « Payer en espèces ou par carte » accepte au moins l'un des moyens. En logique, ce « ou » n'exclut pas que les deux conditions soient vraies. Cette lecture précise permet de choisir entre and et or.

Exemple · Exemple commenté

Traduire la règle de livraison.

def livraison(total):
    if total >= 50:
        return 0
    else:
        return 5

Pour livraison(49), le test $49\ge50$ est faux : Python va dans else, puis renvoie 5. Pour livraison(50), $50\ge50$ est vrai : il renvoie 0. Pour 51, la même première branche fournit 0. Les trois essais contrôlent les deux côtés et la frontière.

Pourquoi l'indentation compte. Les deux instructions return appartiennent à des branches différentes. Leur décalage indique leur rôle. Aligner return 5 à l'intérieur de la première branche rendrait le programme différent ; copier un code sans ses espaces peut donc modifier ou empêcher son exécution.

Ajouter une troisième tranche. Supposons 8 euros de frais sous 20 euros, 5 euros entre 20 euros inclus et 50 euros exclus, puis zéro. On teste d'abord total < 20, ensuite total < 50, enfin else. Dans le deuxième test, on sait déjà que le total n'est pas inférieur à 20 : l'échec du premier test apporte cette information. Pour vérifier cette variante, essaie 19, 20, 49 et 50.

Répéter un nombre connu de fois

Intuition · Construire la notion pas à pas

Repérer ce qui se répète. Pour additionner les cinq premiers entiers positifs, tu peux écrire $$1+2+3+4+5$$ . Pour cinq mille entiers, cette écriture devient peu pratique. L'opération répétée est « ajouter le prochain entier à la somme déjà obtenue ».

Séparer deux rôles. La variable k indique quel entier on est en train d'ajouter. La variable s conserve la somme des entiers déjà parcourus. Avant tout ajout, cette somme vaut zéro : c'est l'initialisation. Après chaque passage, s doit conserver son nouveau résultat pour le passage suivant.

Comprendre une borne exclue. Dans range(1, 6), le premier entier est 1 et l'on s'arrête avant 6. Les valeurs sont donc 1, 2, 3, 4, 5. Il y a cinq passages. Dans range(5), le début implicite est zéro : on obtient 0, 1, 2, 3, 4, toujours cinq passages. Le nombre de passages et la dernière valeur parcourue sont deux informations différentes.

La boucle exprime une répétition précise. Les instructions indentées sont exécutées pour chaque valeur. L'initialisation se place avant la boucle, car on ne veut pas effacer le travail déjà fait à chaque passage. Une fois la boucle terminée, la variable conserve le dernier résultat.

Exemple · Exemple commenté

Additionner les entiers de 1 à 5.

s = 0
for k in range(1, 6):
    s = s + k
print(s)

Avant le premier passage, s vaut 0. Pour k égal à 1, le membre droit vaut $$0+1=1$$ , donc s devient 1. Pour k égal à 2, on utilise cette nouvelle valeur : $$1+2=3$$ . Pour k égal à 3, on calcule $$3+3=6$$ . Les deux derniers passages donnent $$6+4=10$$ , puis $$10+5=15$$ .

k	1	2	3	4	5
s après l'ajout	1	3	6	10	15

Le print n'est pas indenté dans la boucle : il affiche seulement le résultat final 15. S'il était dans le bloc, les cinq sommes intermédiaires seraient affichées. Ce changement ne modifierait pas les calculs de s, seulement les affichages.

Contrôle. Le calcul direct $$1+2+3+4+5=15$$ retrouve le résultat. Pour sommer de 1 à n, la borne finale devient n+1. Le cas n égal à zéro donne une suite vide de valeurs et conserve la somme initiale zéro.

Répéter jusqu’à un objectif

Intuition · Construire la notion pas à pas

Quand le nombre de passages est inconnu. Un stock reçoit chaque jour une livraison jusqu'à atteindre une quantité souhaitée. Tu connais la règle d'évolution, mais le nombre de jours n'est pas toujours donné. Il faut répéter tant que l'objectif reste non atteint.

Séparer l'objectif et la condition de continuation. Pour atteindre au moins 100 unités, on s'arrête quand la réserve est supérieure ou égale à 100. On continue donc tant qu'elle est strictement inférieure à 100. Écrire la condition d'arrêt à la place de celle de continuation empêcherait souvent la boucle de commencer.

La chronologie d'un tour. On initialise les variables. On teste la condition. Si elle est vraie, on exécute le bloc, puis on revient tester avec les nouvelles valeurs. Si elle est fausse, on passe à l'instruction qui suit la boucle. Le test se fait avant le premier passage : zéro passage est une possibilité normale.

Expliquer pourquoi la boucle finit. Une instruction correcte doit faire progresser vers un état où le test devient faux. Ajouter une quantité positive à un stock initialement sous un seuil fini y conduit. Retirer une quantité positive peut au contraire éloigner indéfiniment du seuil. Une limite de sécurité protège un calcul expérimental, mais ne dispense pas de comprendre la progression.

Exemple · Exemple commenté

Trouver le premier entier naturel dont le carré dépasse 50.

n = 0
while n*n <= 50:
    n = n + 1
print(n)

Au départ, $0^2\le50$ est vrai : on remplace n par 1. Le nouveau test porte sur $$1^2$$ , pas sur l'ancien zéro. Le processus continue ainsi jusqu'à n égal à 7. À cet instant $7^2=49\le50$ est encore vrai ; un passage supplémentaire donne n égal à 8. Le test $8^2=64\le50$ est faux et la boucle s'arrête.

Justifier le mot « premier ». Le dernier entier refusé comme réponse est 7 : son carré ne dépasse pas 50. L'entier 8 convient. Comme les carrés des entiers naturels augmentent, aucun entier naturel plus petit que 8 ne convient. Vérifier seulement $$8^2>50$$ prouverait que 8 convient, sans prouver à lui seul qu'il est le premier.

Changer l'objectif. Pour rechercher un carré supérieur ou égal à 49, la continuation serait n*n < 49. Le résultat serait 7. Pour rechercher un carré strictement supérieur à 49, on conserverait <= 49 et le résultat serait 8. L'égalité au seuil doit donc être traitée avant d'écrire le code.

Listes, données et contrôles numériques

Intuition · Construire la notion pas à pas

Conserver plusieurs résultats. Une seule variable peut contenir la température actuelle, mais elle ne garde pas automatiquement les mesures précédentes. Une liste permet de conserver une suite ordonnée de données : temperatures = [12, 15, 14] contient trois nombres distinctement accessibles.

Distinguer numéro d'ordre et indice. Le premier élément possède l'indice 0, le deuxième l'indice 1, et ainsi de suite. Pour une liste de trois éléments, le dernier indice est donc 2. len donne le nombre d'éléments, pas le dernier indice. Cette convention doit être prise en compte quand on parcourt la liste.

Parcourir les valeurs ou les positions. for x in L donne successivement les valeurs contenues dans L. Si l'on a besoin de leur position, on peut parcourir les indices. Ne remplace pas un indice par une donnée : dans une liste de températures, 15 est une mesure, pas forcément une position disponible.

Préserver le sens des données. Lorsque deux listes contiennent des instants et des mesures, les éléments de même indice forment une observation. Changer l'ordre d'une seule liste modifie ces observations. Les opérations informatiques doivent respecter l'organisation des données, leur unité et les informations éventuellement manquantes.

Exemple · Exemple commenté

Construire la liste des carrés de 0 à 4.

carres = []
for k in range(5):
    carres.append(k*k)

[] crée une liste vide. append ajoute une nouvelle valeur à la fin sans effacer les précédentes. Les valeurs de k sont 0, 1, 2, 3 et 4.

Pour k égal à 0, le carré vaut 0. La liste devient [0].
Pour k égal à 1, le carré vaut 1. Elle devient [0, 1].
Pour k égal à 2, on ajoute 4 : [0, 1, 4].
Les passages suivants ajoutent 9 et 16 : la liste finale est [0, 1, 4, 9, 16].

On contrôle la longueur : cinq valeurs de k ont été parcourues et un élément a été ajouté à chaque tour, donc len(carres) vaut 5. L'élément d'indice 2 vaut 4 ; celui d'indice 4 vaut 16.

Calculer une moyenne. La somme de cette liste vaut $$0+1+4+9+16=30$$ ; son effectif est 5. Sa moyenne est donc $$30/5=6$$ . En Python, sum(carres)/len(carres) traduit exactement cette formule. La liste doit être non vide : sinon son effectif est nul et le quotient n'est pas défini.

Construire et recopier une formule de tableur

Intuition · Construire la notion pas à pas

Organiser les données avant les formules. Pour une facture, prépare une colonne de quantités, une de prix unitaires et une de montants. Mets les titres et les unités sur la première ligne : une valeur 12 seule ne dit pas si elle signifie douze pièces ou douze euros. Chaque ligne suivante doit correspondre à un même article.

Passer d'un calcul à une référence. Le montant de quatre pièces à 12 euros vaut $4\times12=48$ . Si 4 se trouve en A2 et 12 en B2, =A2*B2 indique au tableur où lire les données. Changer A2 modifie automatiquement le résultat. Écrire simplement 48 perdrait cette relation ; écrire =4*12 garderait le calcul mais ne suivrait pas les cellules.

Comprendre une recopie. Une formule placée en C2 qui lit A2 et B2 utilise les deux cellules de sa ligne. Recopiée en C3, elle devient =A3*B3. Ce déplacement est utile pour traiter l'article suivant. En revanche, un taux commun placé en D2 ne doit pas devenir D3 : il faut bloquer sa référence.

Lire un pourcentage enregistré. Une cellule affichant 20 % contient le nombre $$0{,}20$$ . Ajouter une TVA de 20 % revient à multiplier le prix HT par $$1+0{,}20=1{,}20$$ . Une cellule contenant simplement 20 n'est donc pas interchangeable avec une cellule contenant 20 %.

Définition · Comprendre la notion

Une cellule se repère par une lettre de colonne et un numéro de ligne : B2 est à l'intersection de la colonne B et de la ligne 2. Une formule commence par le signe égal et utilise les adresses des cellules contenant les données.

Dans une recopie, une référence relative comme B2 se déplace avec la formule. Le signe dollar bloque une coordonnée : $D$2 bloque la colonne D et la ligne 2. La formule calcule automatiquement avec les nouvelles données des cellules référencées.

Une plage comme C2:C5 comprend toutes les cellules de C2 à C5. Dans un tableur configuré en français, SOMME additionne une plage, MOYENNE calcule sa moyenne et SI(test;valeur_si_vrai;valeur_si_faux) exprime un choix. Les noms et séparateurs peuvent varier selon la langue du logiciel.

Exemple · Exemple commenté

Préparer une petite facture avec un taux commun. A2 contient 4, B2 contient 12 et D2 contient 20 %. En C2, on calcule le montant HT par =A2*B2, soit $4\times12=48$ euros. En E2, on écrit =C2*(1+$D$2), soit $48\times1{,}20=57{,}60$ euros TTC.

Pour un second article, A3 contient 3 et B3 contient 10. La recopie de C2 en C3 donne =A3*B3, soit 30 euros HT. La recopie de E2 en E3 donne =C3*(1+$D$2), soit 36 euros TTC. Le prix change de ligne, le taux reste en D2.

Contrôler le total de deux façons. =SOMME(E2:E3) donne $$57{,}60+36=93{,}60$$ euros. Comme les deux lignes utilisent le même taux, on peut aussi calculer le total HT $$48+30=78$$ euros, puis $78\times1{,}20=93{,}60$ . L'accord valide ici la construction des références.

Une formule de décision. Pour afficher « à contrôler » lorsque le montant d'une ligne dépasse 50 euros, on peut écrire =SI(E2>50;"à contrôler";"valide"). Avec 57,60, le test est vrai ; avec 36, il est faux. Pour 50 exactement, il serait faux car le signe est strict.

Boîte à outils

Exercices progressifs

Les exercices 1 à 6 consolident les bases ; 7 à 12 demandent plusieurs étapes ; 13 à 18 t’invitent à choisir, justifier et contrôler. Cherche avant de consulter les indices.

Exercice 1 : Suivre une affectation ★☆☆

Après x = 4, y = x + 3, puis x = 10, quelles sont les valeurs finales ?

Exercice 2 : Inclure une borne ★☆☆

Quel test Python traduit $3\le x<8$ ?

Exercice 3 : Les bornes de range ★☆☆

Quels entiers parcourt range(2, 6) ? Combien y en a-t-il ?

Exercice 4 : Zéro passage ★☆☆

On initialise x = 12, puis exécute while x < 10: x = x + 1. Quelle est la valeur finale ?

Exercice 5 : Lire un indice ★☆☆

Pour L = [12, 8, 15, 10], que valent L[2] et len(L) ?

Exercice 6 : Un montant calculé ★☆☆

A2 contient une quantité de 4 et B2 un prix unitaire de 12 euros. Quelle formule écrire en C2 pour calculer le montant ? Que devient ce montant si A2 passe à 5 ?

Exercice 7 : Coder une formule ★★☆

Écris une fonction Python qui renvoie $$2x^2-5x+1$$ , puis donne sa valeur en 3.

Exercice 8 : Le cas frontière ★★☆

Un code renvoie « accepté » si x > 10, sinon « refusé ». Que renvoie-t-il pour 10 et comment inclure 10 ?

Exercice 9 : Un accumulateur ★★☆

On initialise s = 0 puis on ajoute 2*k pour k dans range(1, 4). Quelle valeur finale obtient-on ?

Exercice 10 : Compter les passages ★★☆

On part de $$x=3$$ et on ajoute 4 tant que $$x<15$$ . Combien de passages ont lieu et quelle est la valeur finale ?

Exercice 11 : Une moyenne dans une liste ★★☆

Calcule le résultat de sum(L)/len(L) pour L = [6, 10, 14].

Exercice 12 : Recopier avec un taux fixe ★★☆

B2 contient 80 euros et D2 contient un taux de TVA de 20 %. On veut recopier vers le bas une formule en C2 calculant le montant TTC. Écris la formule et sa version après recopie en C3.

Exercice 13 : Afficher ou renvoyer ★★★

Une fonction contient seulement print(2*x). Pourquoi ne peut-on pas utiliser directement son résultat comme un nombre dans un autre calcul ?

Exercice 14 : L’ordre des tests ★★★

Un code teste d’abord note >= 10 puis, dans elif, note >= 16. Pourquoi la seconde branche ne s’exécute-t-elle jamais ?

Exercice 15 : Un produit mal initialisé ★★★

Un programme veut calculer $1\times2\times3\times4$ mais commence par p = 0. Explique l’erreur et corrige-la.

Exercice 16 : Une mise à jour dans le mauvais sens ★★★

Un code commence avec $$x=5$$ et répète $$x=x-1$$ tant que $$x<10$$ . Pourquoi est-il incorrect pour atteindre 10 ?

Exercice 17 : Garder les couples ★★★

On a les abscisses [1, 2, 3] et les ordonnées associées [30, 10, 20]. Pourquoi trier seulement les ordonnées est-il une erreur ?

Exercice 18 : Tester un seuil et totaliser ★★★

C2:C5 contient les montants 12, 18, 25 et 15 euros. Calcule le total avec une formule. Une cellule F2 doit afficher « gratuit » si ce total est au moins égal à 70, sinon « payant ». Propose la formule et contrôle le cas frontière.

Problème : Pour aller plus loin

Automatiser une planification

Une réserve commence à 20, gagne 7 unités par jour et doit atteindre au moins 100.

Nomme les variables et leurs valeurs initiales.
Écris une fonction Python renvoyant le jour et la réserve atteinte.
Fais la trace de trois tours puis calcule le résultat final.
Explique la condition de boucle et le risque d’un ajout nul.
Propose un tableur à deux colonnes et explique comment mémoriser les réserves dans une liste.

Corrigés détaillés

Corrigé 1

Démonstration · Solution expliquée

Comprendre la question. Il faut suivre trois instructions successives. On cherche l’état final des deux variables, et non une relation valable pour toutes leurs futures valeurs.

Construire la réponse.

Après x = 4, la valeur de x est 4. La variable y n’a pas encore reçu de valeur.
Pour y = x + 3, on calcule d’abord le membre droit avec la valeur actuelle de x : $$4+3=7$$ . On mémorise donc 7 dans y.
La dernière ligne x = 10 remplace uniquement la valeur de x. Aucune instruction ne redonne une valeur à y : elle reste à 7.

Vérifier. La table de trace contient les états $(4;\text{non définie})$ , $$(4;7)$$ puis $$(10;7)$$ . Obtenir $$y=13$$ supposerait d’exécuter une seconde fois y = x + 3, ce que l’énoncé ne demande pas.

Conclure. Les valeurs finales sont x = 10 et y = 7.

Corrigé 2

Corrigé 3

Corrigé 4

Corrigé 5

Corrigé 6

Démonstration · Solution expliquée

Comprendre la question. Le montant correspond au nombre de pièces multiplié par le prix d’une pièce. La formule doit utiliser les données des cellules pour suivre une modification.

Construire la réponse.

La quantité se trouve en A2 et le prix unitaire en B2. On écrit donc en C2 =A2*B2. Le signe égal annonce une formule et l’astérisque la multiplication.
Avec les données initiales, le tableur calcule $4\times12=48$ . La cellule C2 affiche donc un montant de 48 euros.
Quand A2 passe à 5, la formule n’est pas changée mais elle lit la nouvelle valeur. Elle calcule $5\times12=60$ euros.

Vérifier. La quantité augmente d’une pièce, donc le montant doit augmenter de 12 euros : $$60-48=12$$ . Écrire directement 48 dans C2 aurait empêché cette mise à jour automatique.

Conclure. La formule est =A2*B2. Le montant passe de 48 à 60 euros.

Corrigé 7

Démonstration · Solution expliquée

Comprendre la question. On doit traduire $$2x^2-5x+1$$ en une fonction qui renvoie un nombre, puis tester cette fonction en 3.

Construire la réponse.

Le carré de x se traduit par x**2. Les multiplications implicites de l’écriture mathématique doivent devenir explicites : 2*x**2 et 5*x.
On écrit :
```
def f(x):
    return 2*x**2 - 5*x + 1
```
La ligne indentée appartient à la fonction. return fournit le résultat à l’appelant.
Lors de f(3), Python utilise $$x=3$$ . Le carré vaut $$3^2=9$$ , puis $2\times9=18$ et $5\times3=15$ . Enfin $$18-15+1=3+1=4$$ .

Vérifier. Le calcul manuel doit retrouver la sortie 4. Une écriture comme 2x n’est pas une multiplication reconnue par Python ; x*2 calcule le double et non le carré.

Conclure. La fonction ci-dessus renvoie 4 pour l’entrée 3.

Corrigé 8

Démonstration · Solution expliquée

Comprendre la question. On doit d’abord exécuter la règle existante pour la valeur 10, puis modifier la frontière acceptée.

Construire la réponse.

Le test est x > 10. En remplaçant x par 10, on obtient $$10>10$$ , ce qui est faux : un nombre n’est pas strictement supérieur à lui-même.
La branche de réussite n’est donc pas exécutée. Le programme suit le cas « sinon » et renvoie « refusé ».
Pour inclure la valeur 10, on veut « supérieur ou égal ». On remplace > par >=, sans changer les messages ni les autres branches.

Vérifier. Avec le test corrigé, 9 reste refusé, 10 devient accepté et 11 reste accepté. Le seul changement à la frontière correspond bien à la demande.

Conclure. Le code initial refuse 10. Le test x >= 10 permet de l’accepter.

Corrigé 9

Corrigé 10

Corrigé 11

Corrigé 12

Démonstration · Solution expliquée

Comprendre la question. Le prix HT varie selon la ligne tandis que le taux commun doit toujours être lu en D2.

Construire la réponse.

Un taux de 20 % vaut $$0{,}20$$ . Le prix TTC est le prix HT plus sa TVA : $$HT+0{,}20HT=HT(1+0{,}20)$$ .
Le prix est en B2 et le taux en D2. On écrit =B2*(1+$D$2) dans C2. Les dollars empêchent la colonne D et la ligne 2 de changer lors d’une recopie.
En recopiant une ligne plus bas, B2 devient B3 car sa référence est relative. La formule en C3 est donc =B3*(1+$D$2).
Pour la première ligne, on obtient
$\begin{aligned}80\times(1+0{,}20) &= 80\times1{,}20\\[.35em] &= 96\end{aligned}$
euros.

Vérifier. La TVA seule vaut $80\times0{,}20=16$ euros ; $$80+16=96$$ confirme le TTC. Sans blocage, D2 deviendrait D3 et la formule pourrait lire une cellule vide ou un autre taux.

Conclure. La formule initiale calcule 96 euros TTC et conserve le taux fixe pendant la recopie.

Corrigé 13

Démonstration · Solution expliquée

Comprendre la question. On cherche pourquoi une valeur visible à l’écran ne peut pas forcément être utilisée dans une autre opération.

Construire la réponse.

print(2*x) calcule le double de x puis l’affiche. Son rôle est d’écrire à l’écran, pas de transmettre le résultat comme sortie de la fonction.
Une fonction qui termine sans return explicite renvoie la valeur spéciale None. Par exemple, pour x égal à 3, on voit 6, mais la sortie récupérée par l’appelant est None.
Si l’appelant tente d’ajouter 1 à cette sortie, il tente de calculer None + 1. Cette opération n’est pas définie comme une addition de nombres.
La correction consiste à écrire return 2*x dans la fonction. L’appelant peut ensuite mémoriser cette sortie, l’ajouter à une autre valeur, ou l’afficher avec print.

Vérifier. Avec le retour corrigé, l’entrée 3 donne le nombre 6 ; lui ajouter 1 donne 7. Ce test distingue la donnée transmise du texte affiché.

Conclure. Pour réutiliser le double dans un calcul, la fonction doit le renvoyer avec return.

Corrigé 14

Démonstration · Solution expliquée

Comprendre la question. Il faut contrôler l’ordre des branches : une note peut satisfaire plusieurs tests, mais seule la première branche vraie d’une chaîne est exécutée.

Construire la réponse.

Pour une note de 18, le test note >= 10 est déjà vrai. La première branche est donc choisie immédiatement.
Python ne poursuit pas la recherche dans le elif note >= 16, même si $18\ge16$ est vrai. Toute note qui atteint 16 atteint nécessairement 10 ; aucune valeur ne peut donc arriver dans la seconde branche.
On place d’abord if note >= 16, puis elif note >= 10, et enfin le cas restant. Après l’échec du premier test, le deuxième ne concerne plus que $10\le\texttt{note}<16$ .

Vérifier. Essaie 18 : première branche ; 12 : deuxième branche ; 8 : cas restant. Les notes frontières 16 et 10 sont incluses dans les branches correspondantes grâce au signe >=.

Conclure. Le test le plus restrictif doit précéder celui qui englobe ses valeurs.

Corrigé 15

Démonstration · Solution expliquée

Comprendre la question. Le programme doit accumuler un produit. Il faut choisir une valeur initiale qui ne fausse pas la multiplication.

Construire la réponse.

En partant de zéro, le premier calcul vaut $0\times1=0$ . Le suivant vaut encore $0\times2=0$ , puis $0\times3=0$ et $0\times4=0$ . Tous les facteurs sont absorbés par zéro.
La valeur initiale correcte est 1, car multiplier par 1 conserve une valeur. On écrit donc p = 1 avant la boucle.
Les états après multiplication sont $1\times1=1$ , $1\times2=2$ , $2\times3=6$ , puis $6\times4=24$ .
Le parcours doit être range(1, 5) pour inclure le facteur 4 et exclure 5.

Vérifier. Le calcul direct $1\times2\times3\times4=24$ confirme la sortie. Avec une somme on choisirait zéro, mais le choix doit dépendre de l’opération répétée.

Conclure. Initialiser p à 1 permet d’obtenir le produit attendu, 24.

Corrigé 16

Démonstration · Solution expliquée

Comprendre la question. Le programme doit atteindre 10 depuis 5, mais sa mise à jour fait diminuer la valeur. Il faut déterminer si le test pourra devenir faux.

Construire la réponse.

Au départ, $$5<10$$ est vrai. Le premier passage donne $$5-1=4$$ , qui reste inférieur à 10.
Les passages suivants donnent 3, 2, 1, puis des valeurs de plus en plus petites. Après n passages, $$x=5-n$$ .
Pour tout entier $n\ge0$ , $5-n\le5<10$ . La condition est donc toujours vraie : la boucle ne s’arrête pas dans ce modèle entier.
Pour atteindre 10 en augmentant depuis 5, on remplace la mise à jour par x = x + 1. Les états deviennent 5, 6, 7, 8, 9, 10.

Vérifier. À 9, le test reste vrai ; à 10, il devient faux. La boucle corrigée fait cinq passages, ce que confirme $$5+5=10$$ .

Conclure. La mise à jour initiale provoque une boucle infinie ; ajouter 1 au lieu de le retrancher résout le problème posé.

Corrigé 17

Démonstration · Solution expliquée

Comprendre la question. Chaque abscisse et l’ordonnée de même position décrivent une observation. On doit conserver ces couples pour ne pas modifier les données.

Construire la réponse.

Les couples initiaux sont $$(1;30)$$ , $$(2;10)$$ et $$(3;20)$$ . Le premier peut représenter une mesure 30 à l’instant 1.
Trier seulement les ordonnées donne [10, 20, 30], tandis que les abscisses restent [1, 2, 3]. Les couples deviennent $$(1;10)$$ , $$(2;20)$$ et $$(3;30)$$ .
Le premier couple n’a plus la même mesure, et aucun des trois couples nouveaux ne correspond au couple initial de même abscisse. On a créé artificiellement une tendance croissante.
Pour réordonner les observations, on trie des couples complets, en déplaçant toujours ensemble les deux coordonnées. Par exemple, trier selon l’ordonnée donnerait $$(2;10)$$ , $$(3;20)$$ , $$(1;30)$$ .

Vérifier. Après le tri correct, les trois couples d’origine sont toujours présents, seul leur ordre a changé. C’est ce contrôle qu’un tri d’une seule colonne ne satisfait pas.

Conclure. Il faut conserver les couples associés ; trier une seule colonne falsifie la relation étudiée.

Corrigé 18

Démonstration · Solution expliquée

Comprendre la question. Il faut additionner quatre montants puis appliquer une condition qui inclut exactement le seuil 70.

Construire la réponse.

La plage C2:C5 comprend C2, C3, C4 et C5. La formule =SOMME(C2:C5) donne $$12+18+25+15=30+40=70$$ euros.
« Au moins 70 » se traduit par >=70. Un test strict >70 refuserait à tort l’égalité.
On peut écrire en F2 =SI(SOMME(C2:C5)>=70;"gratuit";"payant"). Le premier argument est le test, le deuxième le texte si le test est vrai et le troisième le texte sinon.
Avec le total actuel, $70\ge70$ est vrai. La cellule doit donc afficher « gratuit ».

Vérifier. Pour un total de 69, le résultat serait « payant » ; pour 70 et 71, il serait « gratuit ». Ces trois essais vérifient les deux branches et la frontière.

Conclure. Le total est 70 euros et la condition de gratuité est satisfaite.

Corrigé du problème

Comprendre la question. Les variables doivent distinguer le temps écoulé, la quantité actuelle et les paramètres.

Construire la réponse.
1. Au départ, aucun jour n’est écoulé : jour vaut 0. La réserve initiale vaut 20.
2. L’ajout quotidien 7 et l’objectif 100 sont deux paramètres fixes : ils ne doivent pas être modifiés dans la boucle.
3. Après chaque tour, jour compte les jours terminés et reserve contient la quantité disponible à ce moment.
Vérifier. Cette convention associe bien le rang zéro à la réserve de départ ; elle évite un décalage d’un jour.

Conclure. Initialisation : jour = 0, reserve = 20, ajout = 7, objectif = 100.
Comprendre la question. La boucle doit continuer tant que la réserve n’a pas encore atteint le seuil.

Construire la réponse.
1. ```
def seuil(depart, ajout, objectif):
    if ajout <= 0 and depart < objectif:
        raise ValueError("Seuil inaccessible")
    jour, reserve = 0, depart
    while reserve < objectif:
        reserve += ajout
        jour += 1
    return jour, reserve
```
2. Le contrôle initial rejette un ajout nul ou négatif lorsque le départ ne suffit pas : le seuil ne pourrait jamais être atteint.
3. La condition while est strictement inférieure au seuil. À chaque tour, on ajoute la quantité quotidienne puis on augmente le jour de 1.
4. Le return est placé après la boucle : la fonction renvoie le premier jour où la condition devient fausse et la réserve correspondante.
Vérifier. Si la réserve initiale suffit, la boucle effectue zéro tour et renvoie le jour zéro. Le compteur avance une seule fois par ajout.

Conclure. L’appel avec les paramètres (20, 7, 100) calcule le premier jour où la réserve vaut au moins 100.
Comprendre la question. Une trace manuelle vérifie le programme, puis la formule de suite contrôle le résultat final.

Construire la réponse.
1. Après les jours 1, 2 et 3, les réserves valent 27, 34 et 41.
2. Après n jours, $$u_n=20+7n$$ . La condition $u_n\ge100$ donne $n\ge(100-20)/7=11{,}4286$ .
3. Le plus petit entier adapté est 12. La réserve vaut alors 104.
Vérifier. La veille, au jour 11, elle vaut 97, encore inférieure à 100. Le jour 12 respecte le seuil.

Conclure. La fonction renvoie le jour 12 et une réserve de 104.
Comprendre la question. La condition de continuation est le contraire de l’objectif d’arrêt.

Construire la réponse.
1. Atteindre au moins 100 signifie reserve supérieure ou égale au seuil. On continue donc tant que reserve est strictement inférieure.
2. Si l’on utilisait une condition inférieure ou égale, une égalité exacte provoquerait un tour supplémentaire inutile.
3. Avec un ajout nul et un départ insuffisant, reserve ne changerait jamais : la condition resterait vraie indéfiniment. Un ajout négatif éloignerait également du seuil.
Vérifier. Le test placé avant la boucle couvre ces cas inaccessibles. Il ne rejette pas un départ déjà suffisant, qui ne nécessite aucune progression.

Conclure. La condition stricte permet le bon arrêt ; le contrôle d’accessibilité évite une boucle sans fin.
Comprendre la question. Le tableur et la liste conservent l’historique au lieu de ne garder que la dernière valeur.

Construire la réponse.
1. En tableur, A2 contient 0 et B2 contient 20. A3 reçoit =A2+1 et B3 =B2+7, puis on recopie vers le bas.
2. Chaque formule utilise la ligne précédente : les références doivent donc rester relatives.
3. En Python, on initialise historique = [depart]. Après chaque mise à jour de la réserve, on exécute historique.append(reserve).
4. La valeur au rang n de la liste correspond alors à la réserve après n jours ; le départ occupe déjà le premier élément, d’indice zéro.
Vérifier. Au dernier jour 12, la liste contient 13 valeurs, car elle inclut aussi le jour zéro.

Conclure. Les deux outils rendent visibles le départ, chaque progression et le premier franchissement.

Variante autonome et bilan

Une réserve de 90 perd 7 unités par jour. Adapte la boucle pour trouver quand elle est au plus égale à 40.

À toi d’essayer

Vérifie ta démarche

Résous la variante, puis explique pourquoi ta méthode s’applique.

Tu peux chercher, prendre un indice ou lire l’explication, à ton rythme.

Indice 1 · Une piste

Repère les données utiles et l’inconnue. Reviens à la méthode correspondante dans la boîte à outils.

Indice 2 · Un pas de plus

Contrôle les unités, les bornes et la plausibilité du résultat avant de lire la correction.

Voir l’explication

Comprendre la question. La réserve diminue : la condition et la mise à jour doivent toutes deux être adaptées.

Construire la réponse.

On initialise jour = 0 et reserve = 90.
On continue while reserve > 40:, puis on effectue reserve -= 7 et jour += 1. L’égalité à 40 doit déjà arrêter la boucle.
Après n jours, $$u_n=90-7n$$ . L’objectif $90-7n\le40$ donne $-7n\le-50$ , puis $n\ge50/7\approx7{,}143$ .
Le premier entier est 8. La veille, $$u_7=41>40$$ ; au jour 8, $u_8=34\le40$ .

Vérifier. La baisse de 7 est strictement positive en valeur absolue : tant que le seuil n’est pas atteint, chaque tour rapproche la réserve de l’objectif.

Conclure. Le premier jour adapté est le jour 8, avec une réserve de 34 unités.

Je peux expliquer : variables, affectations et fonctions.
Je peux expliquer : choisir avec une condition.
Je peux expliquer : répéter un nombre connu de fois.
Je peux expliquer : répéter jusqu’à un objectif.
Je peux expliquer : listes, données et contrôles numériques.
Je peux expliquer : construire et recopier une formule de tableur.

Fiche-mémoire

Variables, affectations et fonctions.

Définis les entrées, leur unité et la sortie attendue. Pour une formule de coût, indique si les frais fixes sont toujours facturés.
Écris les opérations avec les symboles de Python : * pour multiplier, ** pour une puissance, un point pour un nombre décimal.
Exécute les instructions dans l’ordre. Après chaque affectation, recopie les valeurs inchangées dans une table de trace.
Pour une fonction, distingue sa définition et son appel. Vérifie que return fournit bien la valeur dont le reste du programme a besoin.
Teste une entrée simple à la main et une valeur frontière, comme zéro si cette valeur appartient au domaine.

Choisir avec une condition.

Traduis la règle en français et repère les mots « au moins », « strictement », « entre », « et » et « ou ».
Écris une condition vraie exactement pour les cas souhaités ; vérifie chaque borne séparément.
Classe les branches de manière à ce que les premiers tests ne capturent pas à tort les cas des branches suivantes.
Teste une valeur dans chaque branche et chaque valeur frontière. Explique le chemin suivi avant d’observer la sortie.

Répéter un nombre connu de fois.

Écris la liste des valeurs produites par range sur un petit cas. Vérifie le début et la borne exclue.
Définis le rôle de chaque variable : indice, compteur ou résultat accumulé.
Initialise avant la boucle : zéro pour une somme, un pour un produit. Justifie ce choix par l’opération répétée.
À chaque tour, calcule le membre droit avec les valeurs actuelles puis range le nouveau résultat.
Compare la trace à un calcul manuel et contrôle ce qui est placé après la boucle.

Répéter jusqu’à un objectif.

Écris la condition d’arrêt en français, puis sa négation pour obtenir la condition du while.
Fixe l’état initial et vérifie si le test est déjà faux. Si oui, explique pourquoi zéro passage est correct.
Identifie la mise à jour de toutes les variables nécessaires, y compris le compteur de passages.
Fais une trace contenant l’état initial, chaque modification et le premier test faux.
Pour un premier rang, contrôle le rang retenu et son prédécesseur. Explique la terminaison.

Listes, données et contrôles numériques.

Nomme les données et précise leur ordre. Si deux colonnes vont ensemble, conserve leur association.
Compte les éléments pour connaître la longueur, puis numérote leurs indices à partir de zéro.
Pour construire une liste, initialise-la avant la boucle et ajoute les résultats au fur et à mesure.
Pour une moyenne, calcule séparément somme et effectif et vérifie que l’effectif est strictement positif.
Contrôle une première valeur, une dernière valeur et la longueur totale avant d’interpréter le résultat.

Construire et recopier une formule de tableur.

Donne une signification et une unité à chaque colonne. Vérifie que les données d’une ligne concernent le même article ou la même observation.
Écris le calcul en mots, puis remplace les nombres par leurs adresses de cellules. Commence la formule par =.
Pour chaque référence, décide si elle doit se déplacer à la recopie. Bloque un paramètre fixe avec les signes dollar nécessaires.
Contrôle la formule de la première ligne, puis celle de la deuxième après recopie. Ne te contente pas d’un résultat numérique plausible.
Pour une fonction SI, teste un cas vrai, un cas faux et l’égalité à la frontière. Pour une somme, vérifie que la plage comprend toutes les lignes utiles.

Maîtrise du chapitre

Validation contrôlée

Réponds aux QCM, sélectionne les bonnes propositions ou remets les étapes dans l'ordre. Le site vérifie chaque réponse avant d'ouvrir la balise suivante.

Avant le cours, vérifie tes bases

Pourquoi ce chapitre ?

L’idée avant la formule

Le cours formel

Variables, affectations et fonctions

Choisir avec une condition

Répéter un nombre connu de fois

Répéter jusqu’à un objectif

Listes, données et contrôles numériques

Construire et recopier une formule de tableur

Boîte à outils

Exercices progressifs

Exercice 1 : Suivre une affectation ★☆☆

Exercice 2 : Inclure une borne ★☆☆

Exercice 3 : Les bornes de range ★☆☆

Exercice 4 : Zéro passage ★☆☆

Exercice 5 : Lire un indice ★☆☆

Exercice 6 : Un montant calculé ★☆☆

Exercice 7 : Coder une formule ★★☆

Exercice 8 : Le cas frontière ★★☆

Exercice 9 : Un accumulateur ★★☆

Exercice 10 : Compter les passages ★★☆

Exercice 11 : Une moyenne dans une liste ★★☆

Exercice 12 : Recopier avec un taux fixe ★★☆

Exercice 13 : Afficher ou renvoyer ★★★

Exercice 14 : L’ordre des tests ★★★

Exercice 15 : Un produit mal initialisé ★★★

Exercice 16 : Une mise à jour dans le mauvais sens ★★★

Exercice 17 : Garder les couples ★★★

Exercice 18 : Tester un seuil et totaliser ★★★

Problème : Pour aller plus loin

Automatiser une planification

Corrigés détaillés

Corrigé 1

Corrigé 2

Corrigé 3

Corrigé 4

Corrigé 5

Corrigé 6

Corrigé 7

Corrigé 8

Corrigé 9

Corrigé 10

Corrigé 11

Corrigé 12

Corrigé 13

Corrigé 14

Corrigé 15

Corrigé 16

Corrigé 17

Corrigé 18

Corrigé du problème

Variante autonome et bilan

Fiche-mémoire

Maîtrise du chapitre

Pour relier les notions