Exercice 1 : exercices sur scratch
Lorsqu’on clique une seule fois sur le ballon, le script suivant est déclenché :
– La commande \[\] »quand ce lutin est cliqué »\[\] est activée.
– Cela déclenche \[\] »créer un clone de moi-même »\[\], créant ainsi un clone du ballon.
Pour le clone créé :
– La commande \[\] »quand je commence comme un clone »\[\] est activée.
– Le clone est déplacé à une position aléatoire le long de l’axe des \[x\], entre \[-240\] et \[240\], et à la position \[y=0\].
– Le clone attend ensuite \[4\] secondes avant de se supprimer lui-même grâce à la commande \[\] »supprimer ce clone »\[\].
Ainsi, en cliquant une seule fois sur le ballon, un clone du ballon apparaît à une position aléatoire sur l’axe des \[x\] dès que vous le cliquez, reste visible pendant \[4\] secondes, puis disparaît.
Lorsqu’on clique plusieurs fois rapidement sur le ballon :
– Chaque clic crée un nouveau clone du ballon.
– Chacun de ces clones est déplacé à une position aléatoire sur l’axe des \[x\] et reste visible pendant \[4\] secondes avant de se supprimer.
Par conséquent, plus vous cliquez rapidement sur le ballon, plus il y aura de clones créés simultanément. Ces clones seront chacun à une position aléatoire le long de l’axe des \[x\] et seront visibles pendant \[4\] secondes avant de disparaître.
En résumé:
1. \[\]Clique unique\[\] :
– Un clone du ballon apparaît à une position aléatoire sur l’axe des \[x\].
– Ce clone reste visible pendant \[4\] secondes avant de se supprimer.
2. \[\]Clique multiple rapide\[\] :
– Plusieurs clones du ballon apparaissent, chacun à une position aléatoire sur l’axe des \[x\].
– Chaque clone reste visible pendant \[4\] secondes avant de se supprimer.
Exercice 2 : associer le bon programme
Solution :
Le premier programme génère une spirale. Voici le détail des instructions :
– Aller à x: 0 y: 0
– Stylos en position d’écriture
– Effacer tout
– Répéter 100 fois :
– Avancer de (10 * i) pas (i étant le nombre de répétitions)
– Tourner (90 degrés)
Cela correspond à la sortie 1.
Le deuxième programme dessine un carré. Voici le détail des instructions :
– Aller à x: 0 y: 0
– Stylos en position d’écriture
– Effacer tout
– Répéter 4 fois :
– Avancer de 100 pas
– Tourner 90 degrés
Cela correspond à la sortie 3.
Le troisième programme dessine une figure composé de deux lignes avec un cercle à la fin. Voici le détail des instructions :
– Aller à x: 0 y: 0
– Stylos en position d’écriture
– Effacer tout
– Répéter 2 fois :
– Avancer de 100 pas
– Tourner 90 degrés
Cela correspond à la sortie 2.
En résumé :
Programme 1 – Sortie 1
Programme 2 – Sortie 3
Programme 3 – Sortie 2
Exercice 3 : détailler une liste
Le programme commence par supprimer tous les éléments de la liste appelée `maliste`. Ensuite, il demande à l’utilisateur de saisir un nombre, qu’il place dans la variable `réponse`. Dans cet exercice, nous supposons que l’utilisateur saisit \( 45 \).
La variable \( i \) est initialisée à \( 1 \). Le programme répète une boucle un nombre de fois égal à la valeur de la variable `réponse` (ici, \( 45 \) fois). À chaque itération, si \( i \) est un diviseur de \( 45 \) (c’est-à-dire si \( \frac{45}{i} \) est un nombre entier), alors \( i \) est ajouté à la liste `maliste`. Ensuite, \( i \) est incrémenté de \( 1 \).
Les diviseurs de \( 45 \) sont : \( 1, 3, 5, 9, 15, 45 \).
À la fin de l’exécution, la liste `maliste` contiendra donc ces diviseurs dans l’ordre croissant :
\[ \text{maliste} = [1, 3, 5, 9, 15, 45] \]
Exercice 4 : compléter un programme avec scratch
Pour compléter ce programme afin de pouvoir ajouter le nombre saisi à la liste seulement dans le cas où le nombre n’y figure pas encore, suivez ces étapes :
1. On initialise une variable `jaiTrouve` à 0 pour indiquer que le nombre n’a pas encore été trouvé dans la liste.
2. On demande ensuite à l’utilisateur d’entrer un nombre et on le stocke dans une variable.
3. On va ensuite vérifier si ce nombre figure déjà dans la liste. Pour cela, on va parcourir chaque élément de la liste et comparer avec le nombre saisi.
4. Si on trouve le nombre dans la liste, on met `jaiTrouve` à 1.
5. Après avoir vérifié tous les éléments de la liste, si `jaiTrouve` est toujours 0 (ce qui signifie que le nombre n’a pas été trouvé), on peut ajouter le nombre à la liste.
Le code complété serait alors :
« `latex
\texttt{quand [pressé v]}
mettre [jaiTrouve v] à [0]
demander [Donne moi un nombre] et attendre
mettre [nombre v] à (réponse)
répéter (longueur de [uneListe v]) fois
si <(élément (i v) de [uneListe v]) = (nombre)> alors
mettre [jaiTrouve v] à [1]
fin
si <(jaiTrouve) = [0]> alors
ajouter (nombre) à [uneListe v]
fin
« `
– La condition `si <(jaiTrouve) = [0]>` vérifie si le nombre a été trouvé dans la liste. Si `jaiTrouve` vaut 0, cela signifie que le nombre n’est pas dans la liste, et donc on peut l’ajouter.
Avec cette correction, le programme ajoute le nombre à la liste seulement s’il n’y figure pas déjà.
Exercice 5 : ajouter un code
Pour que le lutin Bear1 (ours) dise « bonjour » au chat lorsque ce dernier est près de lui, il faut ajouter des blocs de code aux deux lutins. Voici la correction sous forme de description des blocs Scratch nécessaires pour chaque lutin :
### Code pour le lutin chat :
Le code est correct et déplacera le chat vers la droite. Il n’est pas nécessaire d’ajouter d’autre code pour le chat.
### Code pour le lutin Bear1 (ours) :
Il faut ajouter un script qui détecte lorsque le chat est à proximité et lui fait dire « bonjour ».
1. \[\]Commencez par l’événement de démarrage :\[\]
« `plaintext
quand le drapeau vert est cliqué
« `
2. \[\]Ajoutez une boucle infinie pour constamment vérifier la condition :\[\]
« `plaintext
répéter indéfiniment
« `
3. \[\]Vérifiez la distance entre le lutin Bear1 et le chat :\[\]
« `plaintext
si <(distance à [chat v]) < [50]> alors
dire [bonjour] pendant [2] secondes
« `
### Code complet pour Bear1 (ours) :
Voici comment tout cela s’assemble visuellement dans Scratch :
« `plaintext
quand le drapeau vert est cliqué
répéter indéfiniment
si <(distance à [chat v]) < [50]> alors
dire [bonjour] pendant [2] secondes
fin
fin
« `
Ainsi, lorsque le chat s’approche à une distance de 50 unités de l’ours, l’ours dira « bonjour » pendant 2 secondes.
Exercice 6 : analyse d’un algorithme avec scratch
Lorsqu’on clique sur le lutin (le chat), voici les étapes du déroulement des événements :
1. Le lutin attend \(7\) secondes.
2. Ensuite, il envoie le message \(1\) à tous (y compris la fille).
Lorsqu’elle reçoit le message \(1\), la fille fait :
1. Elle dit « Bonjour ! » pendant \(2\) secondes.
2. Ensuite, elle envoie le message \(2\) à tous (y compris le lutin).
Lorsqu’il reçoit le message \(2\), le lutin fait :
1. Il attend \(7\) secondes.
2. Ensuite, il dit « Bonjour ! » pendant \(2\) secondes.
Calcul du temps total avant que le lutin (le chat) dise « Bonjour ! » :
\[ T = 7 \; \text{secondes (première attente)} + 2 \; \text{secondes (pour la fille)} + 7 \; \text{secondes (deuxième attente)} \]
\[ T = 16 \; \text{secondes} \]
Donc, le chat dira exactement « Bonjour ! » au bout de \(16\) secondes.
Exercice 7 : gagner un jeu
Pour déterminer s’il est possible de gagner à ce jeu en cliquant sur le lutin Ball, nous devons analyser le fonctionnement du script.
1. \[\]Initialisation:\[\]
Lorsque le drapeau vert est cliqué, le lutin est placé à la position \((0, 0)\).
2. \[\]Boucle indéfinie :\[\]
Le script entre ensuite dans une boucle qui s’exécute continuellement.
3. \[\]Condition de distance:\[\]
À chaque itération de la boucle, le script vérifie si la distance entre le lutin (qui est la boule) et le pointeur de souris est inférieure à 50 pixels.
4. \[\]Déplacement aléatoire :\[\]
Si la condition est vérifiée, le lutin est déplacé vers une nouvelle position avec un \( x \) aléatoire compris entre -200 et 200 et un \( y \) fixé à 0.
5. \[\]Lors du clic :\[\]
Si l’utilisateur clique sur le lutin, le message « Gagné ! » est affiché pendant 2 secondes.
### Analyse
Pour gagner à ce jeu, il faut cliquer sur le lutin. Cependant, le lutin se déplace chaque fois que le pointeur de souris est proche de lui (moins de 50 pixels). Voici les points essentiels :
– \[\]Détection de proximité :\[\]
\[
\text{distance} < 50
\]
– \[\]Déplacement :\[\]
\[
x = \text{nombre aléatoire entre } -200 \text{ et } 200
\]
\[
y = 0
\]
### Conclusion
Il est possible de gagner à ce jeu en cliquant sur le lutin. Le script ne vérifie pas la condition de distance lorsque le lutin est cliqué. Ainsi, si l’utilisateur parvient à cliquer sur le lutin avant qu’il ne se déplace (parce que la condition de distance est vérifiée après un court délai), le message « Gagné ! » sera affiché.
\[\]Pourquoi ?\[\] Parce que le lutin ne bouge qu’en fonction de la position du pointeur de la souris par rapport au lutin. Si l’utilisateur clique rapidement sur le lutin pendant que celui-ci est à une position fixe (avant qu’il ne rentre dans la boucle indéfinie ou durant une brève phase où la condition de distance ne l’a pas encore déplacé), il est tout à fait possible de gagner.
En résumé, il est possible de gagner à ce jeu malgré les déplacements du lutin, car le script permet l’interaction (clic) avant l’exécution du déplacement conditionnel.
Exercice 8 : que fait ce programme ?
Ce programme demande à l’utilisateur d’entrer deux valeurs successivement (12 puis 15) et les stocke dans les variables `valeur 1` et `valeur 2`. Ensuite, il essaie d’afficher le résultat de l’expression `\sqrt{\text{valeur 1}} + \text{valeur 1} – \text{valeur 2} – \text{valeur 2}`.
Dans notre cas, les valeurs entrées sont 12 et 15. Nous devons donc calculer l’expression suivante :
\[
\sqrt{12} + 12 – 15 – 15
\]
Calculons d’abord \(\sqrt{12}\):
\[
\sqrt{12} \approx 3.46
\]
Ensuite, substituons \(\sqrt{12}\) dans l’expression :
\[
3.46 + 12 – 15 – 15
\]
Calculons chaque opération :
\[
3.46 + 12 = 15.46
\]
Ensuite :
\[
15.46 – 15 = 0.46
\]
Enfin :
\[
0.46 – 15 = -14.54
\]
Donc, le programme devrait annoncer -14.54, et non pas NAN.
Le message NAN (Not a Number) apparaît souvent lorsqu’une opération mathématique produit un résultat indéfini ou impossible, souvent dû à des erreurs de division par zéro ou prise de racine carrée de nombres négatifs. Cependant, dans ce programme, il semble y avoir une erreur plutôt en ce qui concerne la syntaxe de l’expression finale au moment d’imprimer le résultat. Vérifions le bloc « dire ». Dans Scratch, les opérations doivent être bien définies pour éviter des erreurs dans l’affichage.
Pour améliorer le programme :
1. Assurer que l’expression mathématique est correcte et ne comporte pas de syntaxe incorrecte.
2. Vérifier que les valeurs saisies ne créent pas d’anomalies telles que des opérations interdites par les règles mathématiques standards.
3. Ajouter des vérifications supplémentaires pour s’assurer que les entrées sont valides avant de procéder aux calculs.
Réviser les cours et exercices de maths avec nos Q.C.M :
D'autres outils pour progresser en autonomie :
