$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 [Figure : 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 7

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

]]> 11

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

]]> 14

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

]]> 10

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

]]> Algorithmique et programmation par blocs — Q02 : Ce que dit le lutin avant un changement [Figure : 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 0

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

]]> 8

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

]]> 5

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

]]> 13

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

]]> Algorithmique et programmation par blocs — Q03 : Tentative d'échange de deux variables [Figure : 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 = 3 et b = 3

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

]]> 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 = 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 = 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 boucle

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

]]> Une entrée

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

]]> Une condition

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

]]> Une sortie

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

]]> Algorithmique et programmation par blocs — Q05 : Expression calculée par un script [Figure : 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 + 3)²

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

]]> x + 3x

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

]]> x² + 3

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

]]> x(x + 3)

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

]]> Algorithmique et programmation par blocs — Q06 : Résultat d'un script pour un nombre donné [Figure : 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 19

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

]]> 49

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

]]> 28

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

]]> 16

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

]]> Algorithmique et programmation par blocs — Q07 : Score après plusieurs ajouts [Figure : 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.

]]> 3

]]> Le bloc « ajouter » n'efface pas la valeur précédente : les trois ajouts se cumulent, 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.

]]> 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 à 5 »

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

]]> « dire (x + 5) »

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

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

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

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

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

]]> Algorithmique et programmation par blocs — Q10 : Deux variables qui s'échangent des valeurs [Figure : 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 4

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

]]> 10

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

]]> 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.

]]> Algorithmique et programmation par blocs — Q11 : Figure tracée par une boucle [Figure : 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 segment de 200 pas

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

]]> 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é.

]]> Algorithmique et programmation par blocs — Q12 : Polygone régulier tracé par une boucle [Figure : 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 360/n degrés.

]]> 1.0 0.0 0 true true abc 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 × 120° = 360° : le lutin revient au départ et la figure se referme.

]]> 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 à 3 côtés

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

]]> Algorithmique et programmation par blocs — Q13 : Angle à tourner pour un triangle [Figure : 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 360/n degrés.

]]> 1.0 0.0 0 true true abc 180

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

]]> 90

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

]]> 120

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

]]> 60

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

]]> Algorithmique et programmation par blocs — Q14 : Ajouts répétés dans une boucle [Figure : 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 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.

]]> 12

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

]]> Algorithmique et programmation par blocs — Q15 : Doublements répétés [Figure : 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ⁿ : la boucle calcule une puissance.

]]> 1.0 0.0 0 true true abc 7

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

]]> 6

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

]]> 8

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

]]> 16

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

]]> Algorithmique et programmation par blocs — Q16 : Somme calculée par une boucle [Figure : 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 15

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

]]> 20

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

]]> 10

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

]]> 6

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

]]> Algorithmique et programmation par blocs — Q17 : Nombre de doublements avant de dépasser 100 [Figure : 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 [Figure : 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 7

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

]]> 12

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

]]> 4

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

]]> 3

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

]]> 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 À 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.

]]> À faire attendre le programme pendant 10 secondes

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

]]> À 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.

]]> À 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 programme ne contient aucune variable

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

]]> 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 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 veut exécuter les instructions une seule fois

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

]]> Algorithmique et programmation par blocs — Q21 : Message choisi par une condition [Figure : 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, 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.

]]> grand

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

]]> Algorithmique et programmation par blocs — Q22 : Calcul qui dépend d'une condition [Figure : 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 4

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

]]> 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.

]]> Algorithmique et programmation par blocs — Q23 : Condition avec le mot et [Figure : 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 [Figure : 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.

]]> 10

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

]]> 1

]]> 1 < 3 : la première 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 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.

]]> 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.

]]> Algorithmique et programmation par blocs — Q26 : Ce que calcule un test de comparaison [Figure : 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.

]]> Toujours la valeur de a

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

]]> 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.

]]> Algorithmique et programmation par blocs — Q27 : Une suite de calculs jusqu'à 1 [Figure : 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.

]]> 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.

]]> 7

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

]]> 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 ≥ et ≤.

]]> 1.0 0.0 0 true true abc (x ≥ 5) et (x ≤ 10)

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

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

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

]]> (x ≤ 5) et (x ≥ 10)

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

]]> (x ≥ 5) ou (x ≤ 10)

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

]]> Algorithmique et programmation par blocs — Q29 : Compter des multiples avec une boucle [Figure : 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 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.

]]> 6

]]> Bonne réponse : k prend les valeurs de 1 à 20, et c compte celles qui sont multiples de 3 : 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 Le bloc « sinon » s'exécute toujours, en dernier

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

]]> 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.

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

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

]]> 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.

]]>