Chargement…

Algorithmique et programmation — Cours Mathématiques 3ème | KlarIA

🔢 Mathématiques3èmeCours

Algorithmique et programmation

Voir la fiche de révision →Tous les chapitres

📖

Cours

Algorithmique et programmation

L'algorithmique est un thème transversal : au brevet, les exercices d'algorithmique peuvent apparaître dans n'importe quel chapitre. Ce cours donne les outils pour lire, modifier et écrire des programmes en pseudo-code et en Scratch.

1. Les variables

1.1 Définition

Une variable est un espace mémoire qui porte un nom et qui stocke une valeur. On peut l'imaginer comme une boîte étiquetée dans laquelle on range une information.

En 3ème, on distingue trois types de variables :

Type	Description	Exemple
Nombre	Entier ou décimal	$x \leftarrow 7$ ou $\text{prix} \leftarrow 3{,}5$
Texte (chaîne de caractères)	Texte entre guillemets	$\text{nom} \leftarrow \text{"Alice"}$
Booléen	Vrai ou Faux	$\text{gagné} \leftarrow \text{Vrai}$

1.2 L'affectation

Affecter une variable, c'est lui donner une valeur. On note cela avec une flèche $\leftarrow$ en pseudo-code.

$\text{score} \leftarrow 0 \qquad \text{(on met 0 dans la boîte « score »)}$

⚠️ Piège fondamental : l'instruction $\text{score} \leftarrow \text{score} + 10$ n'est pas une équation ! Elle signifie : « prends l'ancienne valeur de score, ajoute $10$ , et range le résultat dans score ».

Exemple pas à pas :

a ← 5
b ← 3
a ← a + b

Instruction	Valeur de $a$	Valeur de $b$
$a \leftarrow 5$	$5$	—
$b \leftarrow 3$	$5$	$3$
$a \leftarrow a + b$	$5 + 3 = 8$	$3$

Après exécution : $a = 8$ et $b = 3$ .

1.3 La trace d'exécution

Tracer l'exécution d'un programme, c'est suivre pas à pas l'évolution des variables dans un tableau. C'est un exercice classique du brevet.

Exemple :

x ← 2
y ← 5
x ← x × y
y ← y - 1
x ← x + y

Instruction	$x$	$y$
$x \leftarrow 2$	$2$	—
$y \leftarrow 5$	$2$	$5$
$x \leftarrow x \times y$	$10$	$5$
$y \leftarrow y - 1$	$10$	$4$
$x \leftarrow x + y$	$14$	$4$

Résultat final : $x = 14$ , $y = 4$ .

2. Les conditions

2.1 La condition simple (rappel)

Si [condition] Alors
    [instructions]
Sinon
    [instructions]
Fin Si

La condition est un test qui renvoie Vrai ou Faux (exemples : $x > 0$ , $\text{score} = 100$ , $\text{âge} \geqslant 18$ ).

2.2 Les conditions composées

En 3ème, on combine plusieurs tests grâce aux opérateurs logiques :

Opérateur	Signification	Vrai quand...
ET	Les deux conditions sont vraies	$x > 0$ ET $x < 10$ → $x$ est entre $0$ et $10$
OU	Au moins une condition est vraie	$x < 0$ OU $x > 100$ → $x$ est négatif ou supérieur à $100$
NON	Inverse la condition	NON( $x = 5$ ) → $x$ est différent de $5$

Tables de vérité

$A$	$B$	$A$ ET $B$	$A$ OU $B$	NON $A$
Vrai	Vrai	Vrai	Vrai	Faux
Vrai	Faux	Faux	Vrai	Faux
Faux	Vrai	Faux	Vrai	Vrai
Faux	Faux	Faux	Faux	Vrai

💡 Moyen mnémotechnique :

ET : il faut que tout soit vrai (exigeant).
OU : il suffit qu'un seul soit vrai (tolérant).

2.3 Exemple résolu

Que fait ce programme pour $\text{moyenne} = 15$ ?

Si (moyenne ≥ 12) ET (moyenne ≤ 20) Alors
    Afficher "Mention obtenue !"
Sinon
    Afficher "Pas de mention"
Fin Si

$(15 \geqslant 12)$ est Vrai et $(15 \leqslant 20)$ est Vrai.
Vrai ET Vrai = Vrai.
→ Le programme affiche "Mention obtenue !"

Et pour $\text{moyenne} = 8$ ?

$(8 \geqslant 12)$ est Faux.
Faux ET Vrai = Faux (pas besoin de vérifier la deuxième condition !).
→ Le programme affiche "Pas de mention".

3. Les boucles

3.1 La boucle bornée (rappel)

Répéter n fois
    [instructions]
Fin Répéter

On sait à l'avance combien de fois on va répéter. C'est le cas le plus simple.

3.2 La boucle conditionnelle : « Tant que »

Tant que [condition] Faire
    [instructions]
Fin Tant que

On répète tant qu'une condition est vraie, sans savoir à l'avance combien de fois.

Fonctionnement :

On teste la condition.
Si elle est vraie → on exécute les instructions, puis on revient au test.
Si elle est fausse → on sort de la boucle et on continue le programme.

⚠️ Danger : la boucle infinie ! Si la variable testée n'évolue jamais, la condition reste toujours vraie et le programme tourne indéfiniment. Il faut toujours s'assurer que quelque chose change à chaque tour.

3.3 Exemple résolu

Trouver le plus petit entier $n$ tel que $2^n > 1\,000$ .

n ← 1
Tant que 2^n ≤ 1000 Faire
    n ← n + 1
Fin Tant que
Afficher n

Tour	$n$	$2^n$	Condition $2^n \leqslant 1\,000$ ?
1	$1$	$2$	Vrai → on continue
2	$2$	$4$	Vrai → on continue
3	$3$	$8$	Vrai → on continue
...	...	...	...
9	$9$	$512$	Vrai → on continue
10	$10$	$1\,024$	Faux → on sort

Le programme affiche $n = 10$ car $2^{10} = 1\,024 > 1\,000$ . ✅

3.4 Différence entre les deux boucles

	Boucle bornée	Boucle conditionnelle
Quand l'utiliser	On connaît le nombre de répétitions	On ne le connaît pas
Pseudo-code	« Répéter $n$ fois »	« Tant que [condition] Faire »
Scratch	« Répéter ( $n$ ) fois »	« Répéter jusqu'à [condition] »
Risque	Aucun	Boucle infinie si la condition ne change jamais

⚠️ Attention Scratch : le bloc Scratch dit « Répéter jusqu'à » (= on sort quand la condition devient vraie), alors que le pseudo-code dit « Tant que » (= on reste tant que la condition est vraie). C'est l'inverse ! Il faut inverser la condition.

4. Structurer un programme

4.1 Les trois phases

Tout programme bien structuré suit le même schéma :

Phase	Ce qu'on fait	Exemple
1. Initialisation	Créer et donner une valeur de départ aux variables	$\text{somme} \leftarrow 0$ , $\text{compteur} \leftarrow 1$
2. Traitement	Calculs, boucles, conditions	Boucle de calcul
3. Résultat	Afficher ou retourner le résultat	Afficher $\text{somme}$

4.2 Bonnes pratiques

Nommer clairement les variables : $\text{vitesse}$ plutôt que $v1x$ .
Indenter le code : décaler les instructions à l'intérieur des blocs (Si, Tant que, Répéter).
Commenter : expliquer les étapes en langage naturel.
Tester avec des valeurs concrètes avant de valider.

5. Exemples complets

5.1 Programme de calcul (type brevet)

« Choisir un nombre, le multiplier par $3$ , ajouter $5$ , multiplier par le nombre de départ. »

En pseudo-code :

Demander x
a ← x × 3
a ← a + 5
a ← a × x
Afficher a

Tester pour $x = 4$ :

$a = 4 \times 3 = 12$
$a = 12 + 5 = 17$
$a = 17 \times 4 = 68$
Résultat : $68$ .

En écriture algébrique : Le programme calcule $x(3x + 5) = 3x^2 + 5x$ . C'est le lien avec le calcul littéral.

5.2 Deviner un nombre

secret ← nombre aléatoire entre 1 et 100
essai ← 0

Tant que essai ≠ secret Faire
    Demander "Quel est le nombre ?" → essai
    Si essai > secret Alors
        Afficher "Trop grand !"
    Sinon Si essai < secret Alors
        Afficher "Trop petit !"
Fin Tant que

Afficher "Bravo, trouvé !"

Ce programme utilise toutes les notions du chapitre :

📦 Variables : $\text{secret}$ , $\text{essai}$
🔗 Condition composée : imbrication Si / Sinon Si
🔄 Boucle conditionnelle : Tant que $\text{essai} \neq \text{secret}$
🏗️ Structure : initialisation → boucle → résultat

5.3 Simuler un lancer de dé (lien avec les probabilités)

compteur6 ← 0

Répéter 1000 fois
    dé ← nombre aléatoire entre 1 et 6
    Si dé = 6 Alors
        compteur6 ← compteur6 + 1
    Fin Si
Fin Répéter

fréquence ← compteur6 / 1000
Afficher fréquence

Ce programme simule $1\,000$ lancers de dé et calcule la fréquence d'apparition du $6$ . On s'attend à obtenir environ $\dfrac{1}{6} \approx 0{,}167$ (stabilisation des fréquences, chapitre 9).

6. Correspondance pseudo-code ↔ Scratch

Au brevet, les exercices peuvent utiliser du pseudo-code ou des blocs Scratch. Il faut savoir passer de l'un à l'autre.

Pseudo-code	Scratch (bloc)
$x \leftarrow 5$	« mettre $x$ à $5$ »
$x \leftarrow x + 1$	« ajouter $1$ à $x$ »
Si [condition] Alors ... Sinon ...	« si <condition> alors ... sinon ... »
Répéter $n$ fois	« répéter ( $n$ ) fois »
Tant que [condition] Faire	« répéter jusqu'à <NON condition> » ⚠️
Afficher $x$	« dire $x$ »
Demander → $x$	« demander [...] et attendre », $x$ = « réponse »
nombre aléatoire entre $a$ et $b$	« nombre aléatoire entre ( $a$ ) et ( $b$ ) »

⚠️ Point crucial : « Tant que $x < 10$ » en pseudo-code = « Répéter jusqu'à $x \geqslant 10$ » en Scratch. La condition est inversée !

📌 À retenir

Variable = boîte mémoire. L'affectation $\leftarrow$ n'est pas une équation : $a \leftarrow a + 1$ prend l'ancienne valeur et ajoute $1$ .
Conditions composées : ET (les deux vraies), OU (au moins une vraie), NON (inverse).
Boucle « Tant que » : on répète tant que la condition est vraie. Attention à la boucle infinie !
Structure d'un programme : initialisation → traitement → résultat.
Trace d'exécution : suivre pas à pas l'évolution des variables dans un tableau.
Scratch ↔ pseudo-code : le « Répéter jusqu'à » de Scratch inverse la condition du « Tant que ».
Lien avec les maths : un programme de calcul s'écrit en expression algébrique (calcul littéral), une simulation de dé estime une probabilité (stabilisation des fréquences).

Révise ce chapitre avec KlarIA

Tuteur qui t'explique pas à pas, quiz pour t'entraîner, flashcards pour mémoriser. Gratuit.

Créer mon compte gratuitement→

Besoin d'aide ?

Pose ta question gratuitement→