À quoi sert un bloc personnalisé ?

À découper un programme en sous-problèmes : on définit une fois un bloc (par exemple « carré (côté) ») et on l'appelle autant de fois que nécessaire, éventuellement avec des valeurs différentes. Le script principal devient plus court et plus lisible.

Comment simuler une expérience aléatoire dans Scratch ?

Avec le bloc « nombre aléatoire entre (1) et (6) » que l'on range dans une variable, à l'intérieur d'une boucle « Répéter n fois ». Un bloc « si … alors » compte les résultats intéressants dans un compteur ; la fréquence obtenue (compteur ÷ n) se rapproche de la probabilité quand n est grand.

Algorithmique et programmation Scratch

Définitions

Définition 1 — algorithme et programme. Un algorithme est une méthode composée d’étapes précises et sans ambiguïté qui permet d’aboutir à un résultat déterminé : chaque étape peut être exécutée mécaniquement. Un programme est la traduction d’un algorithme dans un langage compréhensible par la machine ; dans Scratch, on empile des blocs colorés qui s’exécutent de haut en bas. Exemple : préparer un chocolat chaud — 1. verser 25 cL de lait ; 2. chauffer 2 minutes ; 3. ajouter 2 carrés de chocolat, remuer ; 4. si le chocolat est fondu alors servir, sinon continuer à remuer. On y retrouve des données en entrée, des instructions ordonnées et un test.

Définition 2 — variable et affectation. Une variable est une case mémoire à laquelle on donne un nom : on peut y stocker un nombre ou un texte, puis lire ou modifier son contenu au fil du programme. L’affectation range une valeur dans la variable.

Bloc Scratch	Effet	Écriture mathématique
`mettre [x] à (10)`	place la valeur 10 dans $x$	$x \leftarrow 10$
`ajouter (4) à [x]`	augmente $x$ de 4	$x \leftarrow x + 4$
`demander [...] et attendre`	attend une saisie, rangée dans `réponse`	saisie clavier

Exemple : après mettre [x] à (10) puis ajouter (4) à [x], la variable $x$ contient $14$ .

Définition 3 — les deux boucles. La boucle « Répéter $n$ fois » exécute un groupe d’instructions exactement $n$ fois (boucle bornée). La boucle « Répéter jusqu’à (condition) » recommence tant que la condition est fausse et s’arrête dès qu’elle devient vraie (boucle conditionnelle) : on ne sait pas d’avance combien de tours seront faits. Exemple : « Répéter (4) fois : avancer de (80) ; tourner de (90)° » fait exactement 4 tours ; « Répéter jusqu’à (k × k > 200) : ajouter (1) à [k] » s’arrête dès que $k^2$ dépasse 200.

Définition 4 — instruction conditionnelle. Le bloc « Si … alors » exécute des instructions seulement quand le test est vérifié ; sinon, le programme saute à la suite. Le bloc « Si … alors … sinon » propose deux chemins : un si le test réussit, un autre s’il échoue. Exemple : « Si (score ≥ 10) alors dire « Admis » sinon dire « Recalé » ».

Définition 5 — événement et scripts en parallèle. Un script commence toujours par un bloc événement (en jaune dans Scratch) qui indique quand il démarre. Plusieurs scripts peuvent partir du même événement : ils s’exécutent alors en parallèle, en même temps.

Bloc	Déclenchement
`quand le drapeau vert est cliqué`	au lancement du programme
`quand la touche [espace] est pressée`	quand l’utilisateur appuie sur la touche
`quand ce lutin est cliqué`	quand on clique sur le lutin

Exemple : le lutin A avance en boucle, le lutin B surveille en permanence « touche le lutin A ? » et dit « touché ! » dès le contact — les deux scripts, lancés par le même drapeau vert, tournent en même temps : c’est ainsi qu’on programme un jeu.

Définition 6 — bloc personnalisé. Un bloc personnalisé (catégorie « Mes blocs ») regroupe une suite d’instructions sous un nom choisi, éventuellement avec un paramètre. On le définit une fois, on l’appelle autant de fois qu’on veut : c’est la façon de découper un problème en sous-problèmes et de structurer un programme. Exemple : « définir carré (côté) : Répéter (4) fois : avancer de (côté) ; tourner de (90)° » ; ensuite carré (30) puis carré (60) tracent deux carrés de tailles différentes.

Propriétés

Propriété 1 — « mettre à » remplace, « ajouter à » conserve. mettre [x] à (…) remplace tout ce que $x$ contenait : l’ancienne valeur disparaît. ajouter (k) à [x] conserve la valeur existante et lui ajoute $k$ (qui peut être négatif). Exemple résolu, trace d’exécution : mettre [a] à (3) → $a = 3$ ; mettre [a] à (a + 7) → $a = 10$ ; ajouter (-2) à [a] → $a = 8$ .

Propriété 2 — arrêt d’une boucle « répéter jusqu’à ». La boucle « Répéter jusqu’à (condition) » teste la condition avant chaque tour : elle tourne tant que le test est faux et s’interrompt dès qu’il devient vrai. Les instructions placées après la boucle s’exécutent alors avec les valeurs finales des variables. Exemple : « mettre [k] à (1) ; Répéter jusqu’à (k × k > 200) : ajouter (1) à [k] ; dire (k × k) » affiche $225$ , le premier carré parfait strictement supérieur à 200 ( $14^2 = 196$ ne suffit pas, $15^2 = 225$ convient).

Propriété 3 — modulo et divisibilité. Le modulo $a \text{ mod } b$ est le reste de la division entière de $a$ par $b$ . Si $a \text{ mod } b = 0$ , alors $a$ est divisible par $b$ . En particulier, $n \text{ mod } 2 = 0$ signifie que $n$ est pair.

Opération	Résultat	Pourquoi ?
$17 \text{ mod } 5$	$2$	$17 = 3 \times 5 + 2$
$24 \text{ mod } 6$	$0$	$24$ se divise exactement par $6$
$11 \text{ mod } 4$	$3$	$11 = 2 \times 4 + 3$

Propriété 4 — angle de rotation d’un polygone régulier. Pour tracer un polygone régulier à $n$ côtés, le lutin tourne à chaque sommet de

$\text{angle de rotation} = \frac{360°}{n}$

C’est l’angle extérieur (celui dont tourne le lutin), pas l’angle intérieur de la figure ; la somme des rotations fait un tour complet.

Figure	$n$	Angle de rotation
Triangle équilatéral	3	$120°$
Carré	4	$90°$
Pentagone régulier	5	$72°$
Hexagone régulier	6	$60°$
Octogone régulier	8	$45°$

Propriété 5 — conditions composées. Les tests peuvent être combinés avec et, ou, non :

Bloc	Vrai lorsque…
`(x > 10) et (x modulo 2 = 0)`	les deux tests sont vrais : $x$ dépasse 10 et $x$ est pair
`(x < 0) ou (x > 100)`	au moins un des deux tests est vrai
`non (x = 5)`	le test est faux : $x \neq 5$

Exemple : pour $x = 14$ , (x > 10) et (x modulo 2 = 0) est vrai ; pour $x = 15$ , c’est faux (15 est impair).

Propriété 6 — fréquence et probabilité dans une simulation. Le bloc nombre aléatoire entre (a) et (b) renvoie un entier au hasard entre $a$ et $b$ inclus, toutes les valeurs étant équiprobables. Quand on répète un grand nombre de tirages, la fréquence d’un résultat se stabilise vers sa probabilité : le compteur est proche du nombre attendu, sans lui être exactement égal. Exemple : sur 600 tirages de « nombre aléatoire entre (1) et (6) », on attend environ $600 \times \frac{1}{6} = 100$ fois le 6.

Méthodes

Méthode 1 — suivre un script pas à pas.

Noter la valeur de chaque variable au départ.
Exécuter les instructions une par une, dans l’ordre, en mettant à jour les valeurs (trace d’exécution).
Pour une boucle, faire un tableau tour par tour : valeur au début du tour, affichage éventuel, valeur à la fin.

Exemple résolu : « mettre [t] à (2) ; Répéter (4) fois : dire (t) ; mettre [t] à (t × 3) » :

Tour	$t$ au début	Affiche	$t$ à la fin
1	2	2	6
2	6	6	18
3	18	18	54
4	54	54	162

Le dernier nombre dit est $54$ : la valeur $162$ est calculée au dernier tour mais jamais affichée, car « dire » précède la multiplication.

Méthode 2 — traduire un programme de calcul en expression littérale.

Appeler $x$ le nombre de départ (la « réponse »).
Suivre chaque bloc dans l’ordre en remplaçant par des expressions en $x$ .
Le dernier « dire » donne la formule ; vérifier avec une valeur numérique.

Exemple résolu : « mettre [r] à (réponse) → $r = x$ ; mettre [r] à (r + 4) → $r = x + 4$ ; mettre [r] à (r × 2) → $r = 2(x + 4) = 2x + 8$ ». Vérification pour $x = 3$ : le programme donne $(3 + 4) \times 2 = 14$ et la formule $2 \times 3 + 8 = 14$ . Autre exemple : « r × r » puis « ajouter (−4) » puis « ajouter (réponse) » donne $x^2 - 4 + x$ , et pour $x = 5$ : $25 + 5 - 4 = 26$ .

Méthode 3 — prévoir l’arrêt d’une boucle « répéter jusqu’à ».

Écrire la liste des valeurs successives de la variable, tour après tour.
Tester la condition avant chaque tour : tant qu’elle est fausse, on continue (Propriété 2).
La première valeur qui rend la condition vraie est la valeur finale.

Exemple résolu : « mettre [n] à (1) ; Répéter jusqu’à (n > 100) : mettre [n] à (n × 2) ; dire (n) » : $1, 2, 4, 8, 16, 32, 64, 128$ — on double tant que $n \leq 100$ , et $128 > 100$ arrête la boucle : le lutin dit $128$ .

Méthode 4 — tracer une figure avec le stylo.

Mettre le stylo en position d’écriture (il trace le chemin du lutin).
Pour un polygone régulier à $n$ côtés : « Répéter ( $n$ ) fois : avancer de (longueur du côté) ; tourner de ( $\frac{360°}{n}$ ) degrés » (Propriété 4).
Pour lire un script de tracé : compter les répétitions (nombre de côtés) et l’angle (type de polygone).

Exemple résolu : carré de côté 80 : « Répéter (4) fois : avancer de (80) ; tourner de (90)° ». Hexagone régulier de côté 60 : « Répéter (6) fois : avancer de (60) ; tourner de (60)° ». Inversement, « Répéter (5) fois : avancer de (50) ; tourner de (72)° » trace un pentagone régulier car $72° = \frac{360°}{5}$ .

Méthode 5 — définir et utiliser un bloc personnalisé.

Définir le bloc une fois (avec un paramètre si besoin) : il regroupe les instructions d’un sous-problème.
L’appeler dans le script principal, autant de fois que nécessaire.
Pour compter les exécutions d’une instruction : (répétitions dans le bloc) × (nombre d’appels).

Exemple résolu : « définir motif : carré (40) ; relever le stylo ; avancer de (50) ; stylo en position d’écriture », puis script principal « Répéter (3) fois : motif » : on obtient une frise de 3 carrés espacés, et l’instruction « avancer de (40) » (dans carré) est exécutée $3 \times 4 = 12$ fois.

Méthode 6 — simuler une expérience aléatoire.

Ranger nombre aléatoire entre (1) et (6) dans une variable, à l’intérieur d’une boucle « Répéter $n$ fois ».
Compter les succès avec « si … alors ajouter (1) à [compteur] ».
La fréquence $\frac{\text{compteur}}{n}$ se rapproche de la probabilité quand $n$ est grand (Propriété 6).

Exemple résolu : compter les 6 sur 600 lancers : « mettre [compteur] à (0) ; Répéter (600) fois : mettre [dé] à (nombre aléatoire entre (1) et (6)) ; si (dé = 6) alors ajouter (1) à [compteur] ; dire (compteur / 600) » : le lutin affiche une fréquence proche de $\frac{1}{6} \approx 0{,}167$ (compteur proche de 100). Même principe pour une pièce avec « nombre aléatoire entre (0) et (1) ».

Méthode 7 — analyser un script conditionnel (exercice type brevet).

Évaluer le test avec la valeur d’entrée (souvent un modulo, Propriété 3).
N’exécuter que la branche correspondante du « si … alors … sinon » (Définition 4).
Pour la question inverse (« quel nombre entrer pour afficher … ? ») : résoudre l’équation de la branche visée, puis vérifier que l’entrée passe bien par cette branche.

Exemple résolu : « si (n modulo 5 = 0) alors mettre [n] à (n / 5) sinon mettre [n] à (n × 3 − 2) ; dire (n) ». Pour $n = 20$ : $20 \text{ mod } 5 = 0$ , le programme affiche $20 \div 5 = 4$ . Pour $n = 8$ : $8 \text{ mod } 5 = 3 \neq 0$ , branche « sinon » : $8 \times 3 - 2 = 22$ . Pour afficher $7$ via la première branche : $\frac{n}{5} = 7$ donne $n = 35$ , et $35 \text{ mod } 5 = 0$ : cohérent.

Récapitulatif des blocs essentiels

Bloc Scratch	Signification
`mettre [v] à (…)`	Affectation : $v \leftarrow \text{valeur}$
`ajouter (k) à [v]`	Incrémentation : $v \leftarrow v + k$
`dire (…)`	Affichage du résultat
`Répéter (n) fois`	Boucle bornée : $n$ passages
`Répéter jusqu'à (…)`	Boucle conditionnelle : s’arrête quand le test devient vrai
`Si (…) alors … sinon`	Branchement selon un test
`… modulo …`	Reste de la division entière
`(…) et (…)`, `(…) ou (…)`	Conditions composées
`quand le drapeau vert est cliqué`	Événement qui lance le script
`définir [nom]`	Bloc personnalisé (sous-programme)
`nombre aléatoire entre (a) et (b)`	Simulation d’une expérience aléatoire

Pièges classiques

« Mettre à » n’est pas « ajouter à » : le premier écrase la valeur, le second la conserve et l’augmente (Propriété 1).
« Dire » affiche la valeur du moment : dans une boucle, une valeur calculée après le dernier « dire » n’est jamais affichée (Méthode 1).
Angle extérieur, pas intérieur : pour un polygone régulier, le lutin tourne de $\frac{360°}{n}$ , qui n’est pas l’angle intérieur de la figure (Propriété 4) — pour le triangle équilatéral, on tourne de $120°$ , pas de $60°$ .
« Répéter jusqu’à » s’arrête quand le test devient vrai, pas quand il est faux (Propriété 2) : toujours dérouler les valeurs tour par tour.