$course$/QCM de maths/Automatismes du collège/Algorithmique et programmation par blocs Séquences d'instructions, variables, boucles et conditions dans un
langage de programmation par blocs, programmes de calcul.

]]> Algorithmique et programmation par blocs — Q01 : Valeur d'une variable après trois instructions Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre x à 3 ; ajouter 4 à x ; mettre x à (x * 2) ; dire x.

Quelle valeur le lutin dit-il à la fin de ce script ?

]]> Les blocs s'exécutent l'un après l'autre, de haut en bas ; chaque instruction part de la valeur que la variable a reçue juste avant.

]]> 1.0 0.0 0 true true abc $14$

]]> Bonne réponse : $x$ vaut $3$, puis $3 + 4 = 7$, puis $7 \times 2 = 14$.

]]> $11$

]]> Seul $4$ a été doublé. Les instructions s'exécutent dans l'ordre : on double la valeur $7$ obtenue à la deuxième ligne.

]]> $10$

]]> Le doublement a été fait avant l'ajout. L'ordre des blocs compte : on ajoute d'abord, puis on double.

]]> $7$

]]> La dernière instruction de calcul a été oubliée : $x$ est encore multiplié par $2$.

]]> Algorithmique et programmation par blocs — Q02 : Ce que dit le lutin avant un changement Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre x à 5 ; dire x ; mettre x à 8.

Quelle valeur le lutin dit-il ?

]]> Une variable ne contient qu'une valeur à la fois ; un affichage montre la valeur au moment précis où il s'exécute.

]]> 1.0 0.0 0 true true abc $5$

]]> Bonne réponse : au moment du bloc « dire x », $x$ vaut encore $5$ ; la troisième ligne vient après.

]]> $8$

]]> La valeur $8$ n'est donnée à $x$ qu'après le bloc « dire x » : le lutin a déjà dit $5$.

]]> $13$

]]> Le bloc « mettre » remplace la valeur de $x$, il ne l'ajoute pas ; et le lutin parle avant ce remplacement.

]]> $0$

]]> $x$ a reçu la valeur $5$ à la première ligne : c'est elle que le lutin dit.

]]> Algorithmique et programmation par blocs — Q03 : Tentative d'échange de deux variables Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre a à 3 ; mettre b à 7 ; mettre a à b ; mettre b à a.

Que valent $a$ et $b$ à la fin de ce script ?

]]> Pour échanger deux variables, il faut une troisième variable qui garde l'ancienne valeur de $a$ avant de l'écraser.

]]> 1.0 0.0 0 true true abc $a = 7$ et $b = 7$

]]> Bonne réponse : la troisième ligne donne à $a$ la valeur $7$ ; la quatrième recopie cette nouvelle valeur dans $b$.

]]> $a = 7$ et $b = 3$

]]> L'échange échoue : quand on exécute « mettre b à a », $a$ vaut déjà $7$. L'ancienne valeur $3$ est perdue.

]]> $a = 3$ et $b = 3$

]]> La troisième ligne s'exécute en premier : $a$ reçoit la valeur de $b$, soit $7$.

]]> $a = 3$ et $b = 7$

]]> Les deux dernières lignes modifient les variables : $a$ reçoit $7$, puis $b$ reçoit cette même valeur.

]]> Algorithmique et programmation par blocs — Q04 : Rôle du bloc demander Dans un script, que représente le bloc « demander Quel est ton âge ? et attendre » ?

]]> Les entrées sont les données fournies au programme (« demander »), les sorties sont les résultats qu'il produit (« dire »).

]]> 1.0 0.0 0 true true abc Une entrée

]]> Bonne réponse : le programme reçoit une donnée tapée par l'utilisateur, stockée dans « réponse ».

]]> Une sortie

]]> Une sortie est une information que le programme affiche, comme avec le bloc « dire ».

]]> Une boucle

]]> Une boucle répète des instructions ; ce bloc attend une seule réponse.

]]> Une condition

]]> Une condition choisit entre deux suites d'instructions ; ce bloc récupère une donnée.

]]> Algorithmique et programmation par blocs — Q05 : Expression calculée par un script Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; demander Choisis un nombre. et attendre ; mettre x à réponse ; mettre y à (x + 3) ; mettre y à (y * x) ; dire y.

Le nombre choisi est noté $x$. Quelle expression le lutin dit-il ?

]]> Chaque bloc « mettre » remplace la valeur de la variable : on écrit l'expression étape par étape, en gardant les parenthèses.

]]> 1.0 0.0 0 true true abc $x(x + 3)$

]]> Bonne réponse : $y$ vaut d'abord $x + 3$, puis ce résultat est multiplié par $x$.

]]> $x + 3x$

]]> Les parenthèses ont été oubliées : c'est toute la somme $x + 3$ qui est multipliée par $x$.

]]> $(x + 3)^2$

]]> $y$ est multiplié par $x$, pas par lui-même : on obtient $x(x + 3)$.

]]> $x^2 + 3$

]]> Le nombre $3$ est ajouté avant la multiplication, il est donc lui aussi multiplié par $x$ : $x(x + 3)$.

]]> Algorithmique et programmation par blocs — Q06 : Résultat d'un script pour un nombre donné Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; demander Choisis un nombre. et attendre ; mettre x à réponse ; mettre y à (x + 3) ; mettre y à (y * x) ; dire y.

L'utilisateur répond $4$. Quelle valeur le lutin dit-il ?

]]> Avec $x = 4$, on suit les lignes une à une : $y$ prend la valeur $7$, puis $28$.

]]> 1.0 0.0 0 true true abc $28$

]]> Bonne réponse : $y = 4 + 3 = 7$, puis $y = 7 \times 4 = 28$.

]]> $16$

]]> La multiplication a été appliquée à $3$ seulement. C'est $y$, qui vaut $7$, qui est multiplié par $4$.

]]> $49$

]]> $y$ a été multiplié par lui-même. Le script multiplie $y$ par $x$, qui vaut $4$.

]]> $19$

]]> L'ajout de $3$ a été fait après la multiplication. Dans le script, il vient avant.

]]> Algorithmique et programmation par blocs — Q07 : Score après plusieurs ajouts Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre score à 0 ; ajouter 3 à score ; ajouter -1 à score ; ajouter 3 à score.

Quelle est la valeur de score à la fin de ce script ?

]]> Le bloc « ajouter … à score » augmente la valeur de score ; avec un nombre négatif, il la diminue.

]]> 1.0 0.0 0 true true abc $5$

]]> Bonne réponse : $0 + 3 - 1 + 3 = 5$.

]]> $7$

]]> Ajouter $-1$, c'est retirer $1$ : on calcule $0 + 3 - 1 + 3 = 5$.

]]> $2$

]]> Le dernier ajout de $3$ a été oublié : le score vaut $5$.

]]> $3$

]]> Le bloc « ajouter » n'efface pas la valeur précédente : les trois ajouts se cumulent, $5$.

]]> Algorithmique et programmation par blocs — Q08 : Sens du bloc mettre Que fait le bloc « mettre x à 0 » ?

]]> « mettre … à » affecte une valeur à une variable ; « ajouter … à » modifie la valeur existante.

]]> 1.0 0.0 0 true true abc Il donne à la variable $x$ la valeur $0$

]]> Bonne réponse : l'ancienne valeur de $x$ est remplacée par $0$.

]]> Il ajoute $0$ à la valeur de la variable $x$

]]> C'est le rôle du bloc « ajouter 0 à x », qui ne changerait rien. « mettre » remplace la valeur.

]]> Il compare la valeur de la variable $x$ à $0$

]]> Une comparaison est une condition, écrite dans un bloc hexagonal comme « x = 0 ».

]]> Il affiche la valeur $0$ à côté de $x$

]]> Un affichage se fait avec « dire ». « mettre » change la valeur de la variable sans rien afficher.

]]> Algorithmique et programmation par blocs — Q09 : Deux écritures équivalentes Quel bloc a le même effet que « ajouter 5 à x » ?

]]> « ajouter 5 à x » est un raccourci pour « mettre x à (x + 5) ».

]]> 1.0 0.0 0 true true abc « mettre x à (x + 5) »

]]> Bonne réponse : la nouvelle valeur de $x$ est l'ancienne augmentée de $5$.

]]> « mettre x à 5 »

]]> Ce bloc remplace la valeur de $x$ par $5$, quelle qu'elle soit : l'ancienne valeur est perdue.

]]> « mettre x à (5 + 5) »

]]> $x$ vaudrait $10$, quelle que soit sa valeur de départ.

]]> « dire (x + 5) »

]]> Ce bloc affiche $x + 5$ sans modifier $x$.

]]> Algorithmique et programmation par blocs — Q10 : Deux variables qui s'échangent des valeurs Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre a à 7 ; mettre b à 3 ; mettre a à (a + b) ; mettre b à (a - b) ; dire b.

Quelle valeur le lutin dit-il ?

]]> On suit les valeurs de chaque variable ligne après ligne, sans oublier qu'une affectation modifie la valeur utilisée ensuite.

]]> 1.0 0.0 0 true true abc $7$

]]> Bonne réponse : $a$ devient $7 + 3 = 10$, puis $b = 10 - 3 = 7$.

]]> $3$

]]> $b$ a été modifié par la quatrième ligne : il vaut $a - b = 10 - 3 = 7$.

]]> $10$

]]> C'est la valeur de $a$ après la troisième ligne. Le lutin dit $b$, qui vaut $10 - 3 = 7$.

]]> $4$

]]> La troisième ligne a été oubliée : au moment de calculer $a - b$, $a$ vaut déjà $10$.

]]> Algorithmique et programmation par blocs — Q11 : Figure tracée par une boucle Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; répéter 4 fois [ avancer de 50 pas ; tourner de 90 degrés ].

Le stylo du lutin est en position d'écriture. Quelle figure trace-t-il ?

]]> Après $4$ virages de $90°$, le lutin a fait un tour complet de $360°$ et revient à son point de départ.

]]> 1.0 0.0 0 true true abc Un carré de côté $50$ pas

]]> Bonne réponse : quatre côtés égaux et quatre virages de $90°$, soit un tour complet.

]]> Un triangle équilatéral de côté $50$ pas

]]> Un triangle n'a que trois côtés ; la boucle en trace quatre.

]]> Un rectangle qui n'est pas un carré

]]> Les quatre côtés tracés ont la même longueur, $50$ pas : c'est un carré.

]]> Un segment de $200$ pas

]]> Le lutin tourne de $90°$ après chaque côté : il ne trace pas une ligne droite.

]]> Algorithmique et programmation par blocs — Q12 : Polygone régulier tracé par une boucle Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; répéter 3 fois [ avancer de 60 pas ; tourner de 120 degrés ].

Le lutin, stylo baissé, exécute ce script. Quelle figure obtient-on ?

]]> Pour un polygone régulier à $n$ côtés, le lutin tourne $n$ fois de $\dfrac{360}{n}$ degrés.

]]> 1.0 0.0 0 true true abc Un polygone régulier à $3$ côtés

]]> Bonne réponse : $3$ côtés égaux et $3$ virages de $120°$, soit $3 \times 120° = 360°$, un tour complet.

]]> Un polygone régulier à $120$ côtés

]]> $120$ est l'angle de chaque virage en degrés, pas un nombre de côtés : la boucle trace $3$ côtés.

]]> Un polygone régulier à $4$ côtés

]]> La boucle s'exécute $3$ fois et trace un côté à chaque passage : $3$ côtés.

]]> Une ligne brisée qui ne se referme pas

]]> Les virages totalisent $3 \times 120° = 360°$ : le lutin revient au départ et la figure se referme.

]]> Algorithmique et programmation par blocs — Q13 : Angle à tourner pour un triangle Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; répéter 3 fois [ avancer de 80 pas ; tourner de ? degrés ].

On veut que le lutin trace un triangle équilatéral. Quel nombre faut-il écrire à la place de « ? » ?

]]> L'angle dont tourne le lutin est l'angle extérieur du polygone ; pour un polygone régulier à $n$ côtés, il vaut $\dfrac{360}{n}$ degrés.

]]> 1.0 0.0 0 true true abc $120$

]]> Bonne réponse : le lutin doit faire un tour complet en trois virages, $360 \div 3 = 120$.

]]> $60$

]]> $60°$ est l'angle intérieur du triangle. Le lutin tourne de l'angle extérieur, $180° - 60° = 120°$.

]]> $90$

]]> Trois virages de $90°$ ne font que trois quarts de tour : la figure ne se referme pas.

]]> $180$

]]> Avec un demi-tour, le lutin revient sur ses pas : il ne trace qu'un segment.

]]> Algorithmique et programmation par blocs — Q14 : Ajouts répétés dans une boucle Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre x à 0 ; répéter 4 fois [ ajouter 3 à x ] ; dire x.

Quelle valeur le lutin dit-il ?

]]> Une boucle « répéter n fois » exécute son contenu exactement $n$ fois ; des ajouts répétés reviennent à une multiplication.

]]> 1.0 0.0 0 true true abc $12$

]]> Bonne réponse : $3$ est ajouté $4$ fois, donc $x = 4 \times 3 = 12$.

]]> $7$

]]> Le nombre de répétitions ne s'ajoute pas : la boucle ajoute $3$ à chaque passage, soit $12$ au total.

]]> $3$

]]> L'ajout n'a été compté qu'une fois ; il est répété $4$ fois.

]]> $9$

]]> Un passage a été oublié : la boucle s'exécute exactement $4$ fois, d'où $12$.

]]> Algorithmique et programmation par blocs — Q15 : Doublements répétés Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre x à 1 ; répéter 3 fois [ mettre x à (x * 2) ] ; dire x.

Quelle valeur le lutin dit-il ?

]]> Multiplier $n$ fois par $2$ à partir de $1$ donne $2^n$ : la boucle calcule une puissance.

]]> 1.0 0.0 0 true true abc $8$

]]> Bonne réponse : $x$ est doublé $3$ fois à partir de $1$, donc $x = 2^3 = 8$.

]]> $6$

]]> Doubler $3$ fois n'est pas multiplier par $3$ : on obtient $2^3 = 8$.

]]> $16$

]]> Un doublement de trop : la boucle s'exécute $3$ fois, pas $4$.

]]> $7$

]]> On a ajouté $2$ à chaque passage au lieu de multiplier par $2$. On trouve $2^3 = 8$.

]]> Algorithmique et programmation par blocs — Q16 : Somme calculée par une boucle Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre s à 0 ; mettre i à 1 ; répéter 4 fois [ ajouter i à s ; ajouter 1 à i ] ; dire s.

Quelle valeur le lutin dit-il ?

]]> $i$ sert de compteur : il vaut $1$ au premier passage, $2$ au deuxième, et ainsi de suite jusqu'à $4$.

]]> 1.0 0.0 0 true true abc $10$

]]> Bonne réponse : la boucle ajoute successivement $1$, $2$, …, $4$, soit $10$.

]]> $20$

]]> C'est le double de la somme. On calcule $1 + 2 + \ldots + 4 = 10$.

]]> $6$

]]> La somme s'arrête trop tôt, à $3$ : au dernier passage, $i$ vaut $4$ et il est ajouté.

]]> $15$

]]> La somme va trop loin, jusqu'à $5$ : la boucle ne s'exécute que $4$ fois.

]]> Algorithmique et programmation par blocs — Q17 : Nombre de doublements avant de dépasser 100 Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre x à 7 ; mettre c à 0 ; répéter jusqu'à ce que x > 100 [ mettre x à (x * 2) ; ajouter 1 à c ] ; dire c.

Quelle valeur le lutin dit-il ?

]]> Une boucle « répéter jusqu'à ce que » teste la condition avant chaque passage et s'arrête dès qu'elle est vraie.

]]> 1.0 0.0 0 true true abc $4$

]]> Bonne réponse : $x$ est doublé $4$ fois avant de dépasser $100$, pour atteindre $112$.

]]> $3$

]]> Le dernier passage manque : après $3$ doublements, $x$ vaut $56$, ce qui ne dépasse pas encore $100$.

]]> $5$

]]> La boucle s'arrête dès que $x$ dépasse $100$, après $4$ doublements ; il n'y a pas de passage supplémentaire.

]]> $112$

]]> C'est la valeur finale de $x$. Le lutin dit $c$, le nombre de passages dans la boucle : $4$.

]]> Algorithmique et programmation par blocs — Q18 : Deux boucles imbriquées Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre n à 0 ; répéter 3 fois [ répéter 4 fois [ ajouter 1 à n ] ] ; dire n.

Quelle valeur le lutin dit-il ?

]]> Une boucle placée à l'intérieur d'une autre est exécutée entièrement à chaque passage de la boucle extérieure.

]]> 1.0 0.0 0 true true abc $12$

]]> Bonne réponse : la boucle intérieure ajoute $4$ à chaque passage de la boucle extérieure, qui en fait $3$, soit $12$.

]]> $7$

]]> Les boucles sont imbriquées, pas placées l'une après l'autre : les nombres de passages se multiplient.

]]> $3$

]]> La boucle intérieure ajoute $1$ à $n$ à chacun de ses passages : $4$ fois par tour de la boucle extérieure.

]]> $4$

]]> La boucle intérieure est relancée à chacun des $3$ passages de la boucle extérieure : on obtient $12$.

]]> Algorithmique et programmation par blocs — Q19 : Rôle d'une boucle répéter À quoi sert une boucle « répéter 10 fois » ?

]]> Une boucle « répéter n fois » est une boucle inconditionnelle : on connaît à l'avance le nombre de répétitions.

]]> 1.0 0.0 0 true true abc À exécuter $10$ fois de suite les blocs qu'elle contient

]]> Bonne réponse : la boucle évite d'écrire dix fois les mêmes instructions.

]]> À faire attendre le programme pendant $10$ secondes

]]> Pour attendre, on utilise le bloc « attendre 10 secondes ». La boucle répète des instructions.

]]> À n'exécuter les blocs que si une condition est vraie

]]> C'est le rôle d'un bloc « si … alors ». La boucle répète sans condition.

]]> À donner la valeur $10$ à une variable du programme

]]> C'est le rôle du bloc « mettre … à 10 ». La boucle répète des instructions.

]]> Algorithmique et programmation par blocs — Q20 : Choisir le bon type de boucle Dans quel cas utilise-t-on « répéter jusqu'à ce que » plutôt que « répéter n fois » ?

]]> « Répéter n fois » : nombre de passages connu d'avance. « Répéter jusqu'à ce que » : arrêt quand une condition devient vraie.

]]> 1.0 0.0 0 true true abc Quand le nombre de répétitions n'est pas connu d'avance

]]> Bonne réponse : la boucle s'arrête quand une condition devient vraie, après un nombre de passages qui dépend des valeurs.

]]> Quand on connaît exactement le nombre de répétitions

]]> Dans ce cas, « répéter n fois » suffit et se lit plus simplement.

]]> Quand on veut exécuter les instructions une seule fois

]]> Une instruction exécutée une seule fois n'a besoin d'aucune boucle.

]]> Quand le programme ne contient aucune variable

]]> La condition d'arrêt porte souvent sur une variable : c'est l'inverse.

]]> Algorithmique et programmation par blocs — Q21 : Message choisi par une condition Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre x à 7 ; si x > 10 alors [ dire grand ] sinon [ dire petit ].

Quel message le lutin dit-il ?

]]> Le bloc « si … alors … sinon » teste la condition une fois, puis exécute exactement l'un des deux blocs.

]]> 1.0 0.0 0 true true abc petit

]]> Bonne réponse : $7 > 10$ est faux, donc seul le bloc « sinon » s'exécute.

]]> grand

]]> Le bloc « alors » ne s'exécute que si la condition est vraie ; or $7$ n'est pas supérieur à $10$.

]]> grand, puis petit

]]> Un seul des deux blocs s'exécute : « alors » si la condition est vraie, « sinon » si elle est fausse.

]]> rien

]]> Avec un bloc « sinon », le lutin dit toujours quelque chose : ici « petit », car la condition est fausse.

]]> Algorithmique et programmation par blocs — Q22 : Calcul qui dépend d'une condition Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre x à 4 ; si x < 6 alors [ mettre y à (x * 2) ] sinon [ mettre y à (x + 10) ] ; dire y.

Quelle valeur le lutin dit-il ?

]]> Attention aux inégalités strictes : « x < 6 » est faux lorsque $x$ vaut exactement $6$.

]]> 1.0 0.0 0 true true abc $8$

]]> Bonne réponse : on compare $4$ à $6$ (inégalité stricte), puis on applique le seul calcul du bloc choisi.

]]> $14$

]]> C'est le calcul de l'autre bloc. La condition « x < 6 » décide du bloc : avec $x = 4$, on obtient $8$.

]]> $18$

]]> Les deux calculs ont été enchaînés. Un seul des deux blocs s'exécute : $8$.

]]> $4$

]]> $y$ reçoit une valeur dans chacun des deux blocs ; le lutin dit $y$, pas $x$ : $8$.

]]> Algorithmique et programmation par blocs — Q23 : Condition avec le mot et Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; si (x > 5) et (x < 9) alors [ dire Gagné ].

Pour quelle valeur de $x$ le lutin dit-il « Gagné » ?

]]> Une condition « A et B » n'est vraie que si A et B sont vraies toutes les deux.

]]> 1.0 0.0 0 true true abc $7$

]]> Bonne réponse : $7 > 5$ et $7 < 9$ ; les deux conditions sont vraies.

]]> $5$

]]> Les inégalités sont strictes : pour $x = 5$, l'une des deux conditions est fausse, donc « et » donne faux.

]]> $2$

]]> $2$ n'est pas supérieur à $5$ : la première condition est fausse, donc « et » donne faux.

]]> $12$

]]> $12$ n'est pas inférieur à $9$ : la seconde condition est fausse, donc « et » donne faux.

]]> Algorithmique et programmation par blocs — Q24 : Condition avec le mot ou Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; si (x < 3) ou (x > 8) alors [ dire Hors zone ].

Pour quelle valeur de $x$ le lutin ne dit-il rien ?

]]> Une condition « A ou B » est vraie dès que l'une des deux est vraie ; elle n'est fausse que si A et B sont fausses toutes les deux.

]]> 1.0 0.0 0 true true abc $5$

]]> Bonne réponse : $5$ n'est ni inférieur à $3$ ni supérieur à $8$ ; les deux conditions sont fausses.

]]> $1$

]]> $1 < 3$ : la première condition est vraie, cela suffit pour que « ou » donne vrai, et le lutin parle.

]]> $10$

]]> $10 > 8$ : la seconde condition est vraie, cela suffit pour que « ou » donne vrai, et le lutin parle.

]]> $13$

]]> $13 > 8$ : la seconde condition est vraie, cela suffit pour que « ou » donne vrai, et le lutin parle.

]]> Algorithmique et programmation par blocs — Q25 : Tester la parité Dans un script, quand la condition « (n modulo 2) = 0 » est-elle vraie ?

]]> « a modulo b » donne le reste de la division euclidienne de $a$ par $b$ : il permet de tester la divisibilité.

]]> 1.0 0.0 0 true true abc Quand $n$ est pair

]]> Bonne réponse : « n modulo 2 » est le reste de la division de $n$ par $2$, nul exactement pour les nombres pairs.

]]> Quand $n$ est impair

]]> Pour un nombre impair, le reste de la division par $2$ vaut $1$, pas $0$.

]]> Quand $n$ est nul

]]> $0$ rend la condition vraie, mais il n'est pas le seul : $2$, $4$, $6$… aussi.

]]> Quand $n$ est un multiple de $3$

]]> $3$ est un multiple de $3$, mais $3$ modulo $2$ vaut $1$. Le test porte sur la division par $2$.

]]> Algorithmique et programmation par blocs — Q26 : Ce que calcule un test de comparaison Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; si a > b alors [ mettre m à a ] sinon [ mettre m à b ].

Que contient la variable m à la fin de ce script, pour des nombres a et b quelconques ?

]]> Ce script classique calcule le maximum de deux nombres. En inversant le test, on obtiendrait le minimum.

]]> 1.0 0.0 0 true true abc Le plus grand des deux nombres

]]> Bonne réponse : si $a$ dépasse $b$, $m$ reçoit $a$ ; sinon, il reçoit $b$, qui est alors le plus grand ou égal à $a$.

]]> Le plus petit des deux nombres

]]> Quand $a > b$, $m$ reçoit $a$, le plus grand : le script garde le maximum.

]]> La somme des deux nombres

]]> Aucun bloc n'additionne $a$ et $b$ : $m$ reçoit l'un des deux.

]]> Toujours la valeur de a

]]> Quand $a$ n'est pas supérieur à $b$, c'est $b$ que $m$ reçoit.

]]> Algorithmique et programmation par blocs — Q27 : Une suite de calculs jusqu'à 1 Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre x à 6 ; mettre c à 0 ; répéter jusqu'à ce que x = 1 [ si (x modulo 2) = 0 alors [ mettre x à (x / 2) ] sinon [ mettre x à (3 * x + 1) ] ; ajouter 1 à c ] ; dire c.

Quelle valeur le lutin dit-il ?

]]> On dresse un tableau des valeurs successives de $x$ et de $c$ ; la boucle s'arrête dès que $x$ vaut $1$.

]]> 1.0 0.0 0 true true abc $8$

]]> Bonne réponse : en notant chaque valeur de $x$ jusqu'à $1$, on compte $8$ passages dans la boucle.

]]> $7$

]]> Un passage a été oublié : le dernier calcul, qui donne $x = 1$, compte aussi.

]]> $9$

]]> La valeur de départ a été comptée comme un passage. Seuls les calculs comptent : $8$.

]]> $16$

]]> C'est la plus grande valeur prise par $x$. Le lutin dit $c$, le nombre de passages : $8$.

]]> Algorithmique et programmation par blocs — Q28 : Traduire un encadrement Quelle condition traduit « $x$ est compris entre $5$ et $10$, bornes incluses » ?

]]> « Compris entre a et b » se traduit par deux conditions reliées par « et » ; « bornes incluses » impose $\geq$ et $\leq$.

]]> 1.0 0.0 0 true true abc $(x \geq 5)$ et $(x \leq 10)$

]]> Bonne réponse : $x$ doit être au moins égal à $5$ et au plus égal à $10$.

]]> $(x \geq 5)$ ou $(x \leq 10)$

]]> Avec « ou », tout nombre convient : $20 \geq 5$ suffit à rendre la condition vraie.

]]> $(x > 5)$ et $(x < 10)$

]]> Les inégalités strictes excluent les bornes $5$ et $10$, qui doivent être incluses.

]]> $(x \leq 5)$ et $(x \geq 10)$

]]> Aucun nombre n'est à la fois inférieur à $5$ et supérieur à $10$ : la condition est toujours fausse.

]]> Algorithmique et programmation par blocs — Q29 : Compter des multiples avec une boucle Script Scratch, de haut en bas : quand le drapeau vert est cliqué ; mettre k à 1 ; mettre c à 0 ; répéter 20 fois [ si (k modulo 3) = 0 alors [ ajouter 1 à c ] ; ajouter 1 à k ] ; dire c.

Quelle valeur le lutin dit-il ?

]]> Le reste de $k$ par $3$ est nul exactement quand $k$ est un multiple de $3$ ; le script compte ces multiples.

]]> 1.0 0.0 0 true true abc $6$

]]> Bonne réponse : $k$ prend les valeurs de $1$ à $20$, et $c$ compte celles qui sont multiples de $3$ : $6$.

]]> $7$

]]> Le nombre $0$ n'est jamais testé, car $k$ commence à $1$ : il y a $6$ multiples de $3$ entre $1$ et $20$.

]]> $14$

]]> C'est le nombre de valeurs qui ne sont pas des multiples de $3$. Le compteur augmente quand le reste est nul : $6$.

]]> $3$

]]> $c$ ne vaut pas $3$ : il augmente d'une unité à chaque multiple de $3$ rencontré, soit $6$ fois.

]]> Algorithmique et programmation par blocs — Q30 : Fonctionnement d'un bloc si-sinon Comment s'exécute un bloc « si … alors … sinon … » ?

]]> Une instruction conditionnelle permet au programme de choisir entre deux suites d'instructions.

]]> 1.0 0.0 0 true true abc Un seul des deux blocs s'exécute, selon la condition

]]> Bonne réponse : « alors » si la condition est vraie, « sinon » si elle est fausse.

]]> Les deux blocs s'exécutent, l'un après l'autre

]]> Un seul bloc s'exécute : la condition sert justement à choisir lequel.

]]> Le bloc « alors » se répète tant que la condition est vraie

]]> Répéter est le rôle d'une boucle. Le bloc « si » ne teste la condition qu'une fois.

]]> Le bloc « sinon » s'exécute toujours, en dernier

]]> Le bloc « sinon » ne s'exécute que si la condition est fausse.

]]>