\setcounter{chapter}{12}
\chapter{Tableurs et programmation~Scratch}

\section{Tableur}

\subsection{Utilisation pour les statistiques}
\label{sec:tabstats}

\begin{exointro}{Collège Jeanne d'Arc, Clermont-Ferrand}
\qrset{height=1.1cm,version=5}\rput(-1.2,0.2){\psframebox{\qrcode{https://media.prepamath.fr/IL3MCh13Tableur}}}
\rput(-0.7,-0.9){\PictoNathanLive[Video]}
\NathanLiveVideo[Vous pouvez retrouver la correction de cet exercice avec un tuto sur les tableurs en vidéo.]{Tutoriel sur le tableur}{https://media.prepamath.fr/IL3MCh13Tableur}
%\textit{\textbf{Vous pouvez retrouver la correction de cet exercice avec un tuto sur les tableurs en vidéo.}}
\Par
Dans une classe de troisième, on demande à chaque élève de 
donner le nombre de livres qu'il a emprunté à la bibliothèque du 
collège, puis on classe les élèves par nombre de livres empruntés. Le 
résultat est donné dans le tableau suivant.

\Par

\begin{center}
 \begin{tabular}{|L|c|c|c|c|c|c|c|} \hline
  Nb. de livres empruntés & 3 & 5 & 6 & 7 & 10 & 13 & 17 \\ 
\hline
Effectif & 1 & 3 & 3 & 5 & 4 & 7 & 2  \\ \hline
 \end{tabular}
\end{center}

\Par

Un élève a emprunté $3$ livres, $3$ élèves ont emprunté $5$ livres, 
etc.

\Par

\`A l'aide du tableur calculer :
\begin{questions}
 \item l'effectif total de la classe, sachant que tous les élèves ont 
emprunté au moins $3$ livres,
\item le nombre total de livres empruntés,
\item le nombre moyen de livres empruntés par élève.
\end{questions}
\vspace*{-5mm}
\end{exointro}


\subsubsection{Plage de données}
\label{sec:tabstats-deb}
\label{chap:algo-sec-plage}
\enlargethispage*{\baselineskip}

Un tableur est un programme informatique qui permet de traiter des 
informations sous forme de tableau. On l'utilise souvent en 
statistiques pour calculer la \emph{médiane}, la \emph{moyenne} ou 
l'\emph{étendue} d'une série statistique (ces notions ont été 
définies au chapitre \ref{chap:statistiques}). Microsoft Excel, OpenCalc, Google Sheets ou Lotus 1-2-3  sont des exemples de tableurs très répandus.

Pour résoudre notre exercice-type, nous allons tout d'abord entrer 
les valeurs du tableau dans le tableur : c'est la \emph{plage de 
données} qui va nous servir à faire des calculs.

\Par

\begin{center}
\includegraphics{326_13_02}
\end{center}

\subsubsection{Calculer une somme}

Une somme s'obtient à l'aide de la fonction : 

\Par

\begin{center}
\fbox{~$=$SOMME(\og 1\iere{} cellule \fg{} : \og dernière cellule \fg)\strut~}
\end{center}

\Par

Ainsi, pour calculer la somme des effectifs et afficher le résultat dans la cellule I2, on écrira dans cette cellule :

\Par

\begin{center}
\includegraphics{326_13_03}
\end{center}

Il y a donc ici 25 élèves car le tableur affiche \og 25 \fg{} dans la 
cellule I2.

\begin{aretenir}
Quelle que soit la formule que l'on décide d'écrire dans une cellule de tableur, il faut toujours qu'elle commence par le signe \og $=$ \fg.
\end{aretenir}

\subsubsection{Calculer une moyenne}
\label{sec:tabstats-fin}
%\enlargethispage*{4em}

%Quand on a un tableau avec des effectifs, la moyenne ne se calcule pas directement. Nous devons d'abord calculer des valeurs intermédiaires.

La fonction MOYENNE permet de calculer la moyenne d'un groupe de nombres. Son utilisation est similaire à celle de la fonction SOMME.

Ainsi, dans le tableau suivant contenant les notes d'un groupe de 4 élèves, on en obtient la moyenne en écrivant dans B5 la formule \og $=$MOYENNE(B1:B4) \fg.

{\vfil\hfil\textit{Voir illustration page ci-contre.}}

\newpage

\begin{center}
\includegraphics{327_13_052}
\end{center}

\Par

Le tableur affiche le résultat qui vaut 12,37.

Dans le cas de la question 3) de l'exercice-type, où l'on nous demande de calculer le nombre moyen de livres empruntés par élève, il faudra d'abord calculer le nombre total de livres empruntés par tous les élèves de la classe. 


\Par

La colonne B nous indique qu'il y a 1 élève qui possède 3 livres.

La colonne C nous indique qu'il y a 3 élèves qui possèdent 5 livres; le nombre total de livres pour cette colonne est donc : $3\times5=15$.

\Par

Nous allons faire de même pour toutes les colonnes en entrant d'abord 
dans la cellule B3 la formule : \og $=$B1*B2 \fg{} puis \textit{en l'étirant} jusqu'à la cellule H3.

%\begin{center}\includegraphics{327_13_04}\end{center}

%\begin{Remarque}on étire une formule en cliquant sur le petit carré noir dans le coin inférieur droit de la cellule B3 et en bougeant la souris jusqu'à la cellule H2 tout en restant appuyé sur le bouton de la souris. Une fois arrivé en H2, on relâche le bouton de la souris. À ce moment, le tableur effectue tous les calculs et les affiche.\end{Remarque}

%On calcule ensuite la somme de tous les résultats calculés : cela correspond au nombre total de livres possédés par les élèves de cette classe. 

\Par

\begin{center}
\includegraphics{327_13_04}
\end{center}

\Par

%D'après la formule de la moyenne, pour l'obtenir, il ne reste plus qu'à diviser cette somme par l'effectif total en entrant dans la cellule I4 la formule : \og $=$I3/I2 \fg.

On calcule ensuite la somme de tous ces résultats dans I3 en utilisant la formule \og $=$SOMME(B2:H2) \fg. On obtient ainsi le nombre total de livres empruntés par les élèves de la classe, qui vaut 236.

\Par

Pour obtenir la moyenne du nombre de livres empruntés par élève, il ne reste plus qu'à diviser cette valeur par l'effectif total en entrant dans I4 la formule : \og =I3/I2 \fg.

{\vfil\hfil\textit{Voir illustration page suivante.}}

\newpage

\begin{center}
\includegraphics{328_13_06}
\end{center}

La valeur recherchée est 9,44 livres par élève.

%\subsubsection{Formules directes}
%
%\raisebox{15mm}{\begin{minipage}[b]{5cm}
%On a aussi la possibilité de construire une plage de données 
%\textit{sans effectifs}, ce qui nous permet de calculer directement 
%la moyenne, la médiane et l'étendue :
%\end{minipage}}\hspace{1em}
%\includegraphics{13_09}
%
%\begin{itemize}
%\item la moyenne se calcule avec la formule : \og $=$MOYENNE(A1:E5) \fg{} 
%\item la médiane s'obtient avec la formule : \og $=$MEDIANE(A1:E5) \fg{} 
%\item l'étendue se calcule avec la formule : \og $\rm=MAX(A1:E5)-MIN(A1:E5)$ \fg{} 
%\end{itemize}
%
%L'avantage de cette méthode est que l'on peut insérer les différentes valeurs d'une plage de données dans n'importe quel ordre.

\subsubsection{Représentation graphique}

En sélectionnant la plage de données du tableau des effectifs du 
paragraphe \ref{chap:algo-sec-plage} (y compris la colonne A), et en 
cliquant sur l'icône \og Diagramme \fg{} (cet icône varie selon les 
tableurs, il faut entrer les paramètres suivants dans la section \og 
Plage de données \fg{} :

\begin{itemize}
\item on sélectionne \og Séries de données en lignes \fg{} 
\item on coche la case correspondant à \og Première ligne comme étiquette \fg{} 
\item on coche la case correspondant à \og Première colonne comme étiquette \fg{} 
\end{itemize}

on obtient le diagramme suivant :

\begin{center}
\includegraphics{328_13_10}
\end{center}


\begin{solintro}
\qrset{height=1.1cm,version=5}\rput(-1.2,0.6){\psframebox{\qrcode{https://media.prepamath.fr/IL3MCh13Tableur}}}
%\rput(-0.7,-0.7){\PictoNathanLive[Video]}
Voir \S\ref{sec:tabstats-deb} à \ref{sec:tabstats-fin}. \PictoNathanLive[Video]
\end{solintro}


\newpage

\subsection{Utilisation d'un tableur pour l'étude d'une fonction}
\label{sec:tabfonctions}

\begin{exointro}{Collège Clémence Isaure, Toulouse}
 On s'intéresse à la fonction $f(x) = -0,5x^2 + x + 1$.
 
 \`A l'aide d'un tableur :
 \begin{questions}
  \item Dresser un tableau de valeurs de $f$ pour les nombres compris 
entre $-2$ et $3$ avec un pas de $0,5$ (c'est-à-dire de $0,5$ en 
$0,5$).
\item Représenter graphiquement la fonction $f$.
 \end{questions}

\end{exointro}

\subsubsection{Tableau de valeurs}
\label{sec:tabfonctionstabval}

Nous souhaitons calculer l'image de tous les nombres compris entre $-2$ et 3 avec un pas de 0,5 (c'est-à-dire de 0,5 en 0,5).

On entre pour cela les valeurs de $x$ dans la ligne 1 : on peut entrer la valeur \og $-2$ \fg{} dans la cellule B1, puis entrer dans C1 la formule : \og $\rm=B1+0,5$ \fg{} et l'étirer jusqu'à L1.

Ensuite, on entre dans la cellule B2 la formule : \og $\rm=-0,5*B1$\verb+^+$\rm 2+B1+1$ \fg{} (qui signifie que l'on calcule $-0,5x^2+x+1$, B1 jouant le rôle de $x$). On étire alors cette formule jusqu'à L2.

\Par

\begin{center}
\includegraphics{329_13_11}
\end{center}

\subsubsection{Représentation graphique}
\label{sec:tabfonctionsRepGraph}

On sélectionne la plage de données allant de B1 jusqu'à L2, puis on 
clique sur l'icône \og Diagramme \fg. Il faut ici veiller à :

\begin{minipage}[b]{45mm}
\begin{itemize}
\item choisir comme type de diagramme : \og Ligne \fg{} 
\item paramétrer la plage de données en sélectionnant \og Série de données en lignes \fg{} et en cochant \og Première ligne comme étiquette \fg{} 
\end{itemize}

On obtient alors la représentation ci-contre.
\end{minipage}\hspace{1em}\includegraphics[scale=0.8]{329_13_12}

\begin{solintro}
 Voir § \ref{sec:tabfonctionstabval} et \ref{sec:tabfonctionsRepGraph}.
\end{solintro}

% \section{Programmation sur Scratch}
% \enlargethispage*{4em}
% % 
% \begin{exointro}{Collège Nina Simone, Lille}
% \begin{minipage}{0.25\linewidth}
% On donne\\ l'algorithme\\ ci-contre.
% 
% \Par
% 
% Expliquer ce\\ qu'il affiche en\\ imaginant par\\ exemple une\\ situation\\ concrète.
% 
% ~\par 
% \end{minipage}
% \hfill
% \begin{minipage}{0.74\linewidth}
% \begin{algorithme}
% Variable :
% \quad P est un nombre
% \quad i est un entier naturel
% Initialisation :
% \quad P prend la valeur 250
% Traitement :
% \quad Pour i allant de 1 à 5
% \quad\quad P prend la valeur P $\times$ (1+5/100)
% \quad Fin du Pour
% Sortie : 
% \quad Afficher P
% \end{algorithme}
% \end{minipage}
% \end{exointro}
% 
% 
% Lorsque l'on parle d'algorithme en mathématiques, c'est très souvent dans le but de faire ensuite un programme. Il faut donc utiliser une structure propre à ce type d'algorithme.
% 
% \subsection{Composition d'un algorithme}
% 
% Un algorithme est composé de quatre \og blocs \fg.
% 
% \begin{itemize}
% \item {\bfseries Déclaration des variables :}
% 
% C'est comme la liste des ingrédients dans une recette; déclarer les variables signifie donner la liste des variables qui vont être utilisées plus tard. Très souvent, ces variables sont des lettres (comme en algèbre), mais elles peuvent aussi être des mots pour être plus explicites, plus parlantes.
% 
% \item {\bfseries Initialisation des variables :}
% 
% C'est ici que l'on affecte une valeur à chaque variable.
% 
% \item {\bfseries Le traitement :}
% 
% C'est le c\oe ur de l'algorithme : c'est dans ce bloc que vont s'exécuter toutes les tâches à faire.
% 
% \item {\bfseries La sortie :}
% 
% C'est le bloc qui affiche le ou les résultats souhaités.
% \end{itemize}
% 
% \begin{Exemple}[programme de calcul]
% considérons le programme de calcul suivant.
% 
% \Par
% 
% % \begin{center}
% % \begin{tabular}{|Sl|}
% % \hline
% % Choisir un nombre $x$.\\
% % L'élever au carré.\\
% % Multiplier le résultat par 4.\\
% % Soustraire 25.\\
% % \hline
% % \end{tabular}
% % \end{center}
% 
% \Break
% 
% Nous avons vu dans le chapitre \ref{chap:developpements} ce genre de programme de calcul. Celui-ci donne à la fin : $4x^2-16$.
% 
% Un algorithme permettant d'afficher le résultat est :
% 
% \Par
% 
% \begin{algorithme}
% Variables :
% \qquad x est un nombre
% Initialisation :
% \qquad Demander à l'utilisateur la valeur de x
% Traitement :
% \qquad x prend la valeur 4x$^{\text{2}}-$16
% Sortie :
% \qquad Afficher x
% \end{algorithme}
% 
% \Par
% 
% Dans cet algorithme, on demande à l'utilisateur du programme de rentrer une valeur quelconque de $x$, puis on calcule $4x^2-16$; le résultat est ensuite stocké dans la variable $x$, que l'on affiche en sortie. Le fait de mettre le résultat dans $x$ permet de ne pas déclarer une autre variable.
% \end{Exemple}
% 
% \subsection{Les différentes variables}
% 
% Dans un algorithme, nous pouvons avoir plusieurs types de variables :
% 
% \begin{itemize}
% \item les variables représentant des nombres (entiers ou autres);
% \item les variables représentant des listes de nombres ou de caractères (dans le cas des caractères, on pourra déclarer une variable comme \emph{chaîne de caractères} plutôt que comme liste).
% \end{itemize}
% 
% Si L est une variable de type liste, on notera L[0] sa première valeur, L[1] sa deuxième valeur, L[2] sa troisième, etc.
% 
% \subsection{Les tests}
% \enlargethispage*{2em}
% \begin{defin}
% Un \emph{test} peut s'écrire sous la forme : \og Si ... Alors ... Sinon ... Fin du Si \fg{} ou sous la forme : \og Si ... Alors ... Fin du Si \fg.
% \end{defin}
% 
% \begin{Exemple} nous allons voir ici un algorithme qui nous dit si le nombre que nous entrons est plus grand ou plus petit qu'un nombre choisi préalablement au hasard.
% \end{Exemple}
% 
% \begin{algorithme}
% Variables :
% \qquad n est un entier naturel
% \qquad x est un entier naturel
% \qquad c est une chaîne de caractères
% Initialisation :
% \qquad n prend une valeur au hasard entre 1 et 100 compris
% \qquad Demander à l'utilisateur une valeur de x
% \Break
% Traitement :
% \qquad Si $\text{x} < \text{n}$ Alors
% \qquad\qquad c prend la valeur \og le nombre que vous avez entré est plus 
% \qquad\qquad petit que n. \fg
% \qquad Sinon
% \qquad\qquad Si $\text{x} > \text{n}$ Alors
% \qquad\qquad\qquad c prend la valeur \og le nombre que vous avez entré est 
% \qquad\qquad\qquad plus grand que n. \fg
% \qquad\qquad Sinon
% \qquad\qquad\qquad c prend la valeur \og le nombre que vous avez entrée est 
% \qquad\qquad\qquad égal à n. \fg
% \qquad\qquad Fin du Si
% \qquad Fin du Si
% Sortie :
% \qquad Afficher c
% \end{algorithme}
% 
% \Par
% 
% Notons que l'on peut mettre deux tests l'un dans l'autre comme ici : si $x<n$, il reste deux possibilités : $x>n$ ou $x=0$, d'où le deuxième test : 
% 
% \og Si $x>n$ alors ... Sinon (dans le cas où $x=n$) ... Fin du Si \fg{} 
% 
% \subsection{Les boucles}
% 
% Les \emph{boucles} servent à répéter une même instruction plusieurs fois.
% 
% Il existe deux types de boucles.
% 
% \subsubsection{La boucle \og Pour \fg}
% \enlargethispage*{2em}
% 
% On se sert de ce type de boucle quand on sait combien de fois l'instruction doit être répétée.
% 
% \begin{Exemple} nous souhaitons calculer la somme :
% \[
% S=0,5^0+0,5^1+0,5^2+0,5^3+\cdots+0,5^{30}.
% \]
% L'algorithme suivant permet de le faire :
% 
% \Par
% 
% \begin{algorithme}
% Variables :
% \qquad S est un nombre
% \qquad i est un nombre entier naturel
% Initialisation :
% \qquad S prend la valeur 0
% Traitement :
% \qquad Pour i allant de 0 à 30
% \qquad\qquad S prend la valeur S + 0,5$^\text{i}$
% \qquad Fin du Pour
% Sortie :
% \qquad Afficher S
% \end{algorithme}
% 
% \Break
% 
% Dans le traitement, voici ce qui se passe pas à pas :
% \begin{itemize}
% \item quand $i=0$, avant de faire le calcul, $\rm S=0$ donc S prend la valeur $0+0,5^0=1$;
% \item quand $i=1$, S vaut 1 et donc S prend la valeur $1+0,5^1=1,5$;
% \item quand $i=2$, S vaut 1,5 et donc S prend la valeur $1,5+0,5^2=1,75$;
% \item etc.
% \end{itemize}
% \end{Exemple}
% 
% \subsubsection{La boucle \og Tant que \fg}
% 
% On se sert de ce type de boucle quand on ne sait pas quand on doit s'arrêter : l'instant où la boucle doit s'arrêter dépend du ou des calculs faits à l'intérieur de cette même boucle.
% 
% \begin{Exemple} un nombre entier est choisi au hasard entre 1 et 100 compris. L'utilisateur doit le deviner en entrant plusieurs valeurs une à une en fonction de ce que l'algorithme lui répondra.
% 
% \Par
% 
% \begin{algorithme}
% Variables : 
% \qquad n est un nombre entier
% \qquad x est un nombre entier
% \qquad c est une chaîne de caractères
% Initialisation :
% \qquad n prend une valeur aléatoire entre 1 et 100 compris
% \qquad x prend la valeur 0
% Traitement :
% \qquad Tant que x $\neq$ n
% \qquad\qquad Demander à l'utilisateur d'entrer une valeur de x
% \qquad\qquad Si $\text{x}=\text{n}$ Alors
% \qquad\qquad\qquad c prend la valeur \og Gagné ! \fg
% \qquad\qquad Sinon
% \qquad\qquad\qquad Si $\text{x}<\text{n}$ Alors
% \qquad\qquad\qquad\qquad c prend la valeur \og n est plus grand... \fg
% \qquad\qquad\qquad Sinon
% \qquad\qquad\qquad\qquad c prend la valeur \og n est plus petit... \fg
% \qquad\qquad\qquad Fin du Si
% \qquad\qquad Fin du Si
% \qquad Fin du Tant que
% Sortie :
% \qquad Afficher c
% \end{algorithme}
% \label{chap:algotableur-algorithme}
% 
% \Par
% 
% Si l'utilisateur entre une valeur de $x$ plus grande que $n$, la phrase : \og $n$ est plus petit... \fg{} s'affichera et une autre valeur de $x$ lui sera demandée.
% 
% S'il entre une valeur de $x$ plus petite que $n$, la phrase : \og $n$ est plus grand... \fg{} s'affichera et une autre valeur de $x$ lui sera demandée.
% 
% Ceci tournera en boucle tant que $x$ ne sera pas égal à $n$.
% \end{Exemple}
% 
% \newpage
% 
% \begin{attention}
% Quand on utilise la boucle \og Tant que \fg, il est impératif de faire en sorte que la condition à remplir pour sortir de cette boucle soit réalisable, sinon la boucle sera infinie (ne s'arrêtera jamais).
% \end{attention}
% 
% \begin{solintro}
% L'algorithme contient une boucle \og Pour \fg{} qui s'exécute 5 fois dans laquelle il y a l'instruction  :
% 
% \begin{center}
% P prend la valeur P $\times$ (1+5/100)\;,
% \end{center}
% 
% ce qui signifie que P va être multiplié par 1,05 (car 1+5/100 est égal à\linebreak $1 + 0,05$) à chaque fois. 
% 
% 
% Multiplier par $1+\dfrac{t}{100}$ doit nous faire penser à une augmentation de $t$\;\% donc ici, P est augmenté de 5\;\% à chaque fois.
% 
% 
% La valeur affichée sera donc égale à $\text{P}\times1,05^5$ et cela correspondra à cinq augmentations successives de 5\;\%.
% 
% P est initialisée à 250; donc la valeur affichée sera : 
% \[
% 250\times1,05^5\approx319,07.
% \]
% \end{solintro}

\section{Programmation sous Scratch}


\begin{exointro}{Collège Henri Matisse, Nice}
\qrset{height=1.1cm,version=5}
\rput(-1.2,0.4){\psframebox{\qrcode{https://scratch.mit.edu/projects/491898505}}}
\textit{Vous pouvez retrouver ce programme en tapant:}
\begin{center}
\texttt{https://scratch.mit.edu/projects/491898505}
\end{center} 
\begin{multicols}{2}
% \begin{minipage}{\dimexpr\linewidth-55mm}

Que permet de calculer le\\ programme ci-contre ?

\Par

Qu'affiche-t-il si on entre \\ le nombre 250 ?

\medskip



\vfill\text{}

\columnbreak

\hspace{-2em}\begin{scratch}[scale=0.9]
 \blockinit{quand \greenflag est cliqué}
 \blocksensing{demander \ovalnum{entrer un nombre} et attendre}
 \blockvariable{mettre \selectmenu{a} \`a \ovalsensing{réponse}}
 \blockrepeat{répéter \ovalnum{5} fois}{ \blockvariable{mettre 
\selectmenu{a}%
\`a \ovaloperator{\ovalvariable{a}*\ovalnum{1.05}}}
}
\blocksound{dire \ovalvariable{a}}
 \end{scratch}
\end{multicols}
\vspace{-8mm}
\end{exointro}

%\begin{minipage}[t]{7cm}
%\NathanLiveProg[\normalfont\selectfont \textit{Pour accéder à ce 
%programme en ligne :}]{\'Evolutions 
%successives}{scratch.mit.edu/projects/491898505}
%\end{minipage}


\begin{defin}
Un \emph{algorithme} est une suite d'instructions dans le but 
d'exécuter une tâche.
\end{defin}

\begin{Exemples}
\begin{itemize}
\item Une recette de cuisine est un algorithme.
\item Un programme de calcul est un algorithme.
\end{itemize}
\end{Exemples}

\begin{anecdote}[étymologie]
Le mot \emph{algorithme} vient du mathématicien perse du 
\textsc{ix}\ieme{} 
siècle Al-Khwarizmi, dont le nom a été latinisé en \emph{Algoritmi}.
\end{anecdote}

% 
% \begin{defin}
% Un \emph{programme} est la traduction d'un algorithme dans un langage spécifique. Il peut se présenter sous forme \emph{linéaire} (une succession de commandes écrites) ou \emph{graphique} (forme plus intuitive).
% \end{defin}
% 
% En classe de Troisième, les programmes sont vus à travers le logiciel Scratch, donc sous forme graphique.
% 
% \newpage
% 
% \subsection{Introduction à Scratch}
% 
% Le logiciel Scratch peut être installé gratuitement chez vous, quel que soit le système d'exploitation installé sur votre ordinateur (Windows, Mac OS ou Linux). Il suffit d'aller sur la page https\kern-0.25em://scratch.mit.edu/scratch2download/, d'installer \emph{Adobe Air}, puis \emph{Scratch Offline Editor}.
% 
% \Par
% 
% Lors de la première utilisation, pour changer le langage par défaut (qui est d'origine en anglais), il faudra cliquer sur l'icône qui ressemble à une petite sphère, à droite de l'icône \og Scratch \fg.
% 
% \Par
% 
% Le principe général de Scratch est d'encastrer des blocs qui représentent des instructions dans la fenêtre de droite. Une fois l'assemblage terminé, on doit double-cliquer dessus pour lancer le programme.
% 
% \Par
% 
% Par défaut, un \og lutin \fg{} apparaît dans la fenêtre où l'on observe le résultat du programme lancé : c'est un personnage (un chat par défaut) qui exécute ce qu'on lui demande de faire. Mais on peut le cacher en cliquant sur l'icône en bas à gauche avec le bouton droit, et en sélectionnant \og cacher \fg.
% 
% \begin{center}
% \includegraphics{13_14}
% \end{center}

\newpage

\subsection{Les commandes de Scratch}
% \enlargethispage*{2em}


Les principales commandes sont regroupées par menus :
\begin{itemize}
\item \textcolor{scrmove}{Mouvement} : ce menu permet de déplacer et 
d'orienter les lutins ;
\item \textcolor{scrlook}{Apparence} : ce menu permet de changer 
l'apparence des lutins et d'afficher des résultats ;
\item \textcolor{scrsound}{Sons} : ce menu contient les bruitages ;
\item \textcolor{screvent}{\'Evènements} : ce menu permet de choisir 
l'évènement qui va déclencher le programme (un appui sur le drapeau 
vert ou sur une autre touche du clavier par exemple) ;
\item \textcolor{scrcontrol}{Contrôle} : ce menu contient toutes les 
boucles et les instructions conditionnelles (si\dots alors\dots) ;
\item \textcolor{scrsensing}{Capteurs} : ce menu permet à 
l'utilisateur de saisir des valeurs. Il contient également des tests 
que l'on pourra utiliser dans les boucles ou dans les instructions 
conditionnelles ;
\item \textcolor{scroperator}{Opérateurs} : ce menu contient les 
fonctions numériques classiques ainsi que des tests que l'on pourra 
utiliser dans les boucles ou dans les instructions conditionnelles ;
\item \textcolor{scrvariable}{Variables} : ce menu permet de définir 
et de gérer des variables ;
\item \textcolor{scrmoreblocks}{Mes blocs} : ce menu permet de créer 
des sous-programmes ;
\item \begin{tikzpicture}[scale=0.8,rotate=45,
rounded corners=.4pt,line width=.5pt,
x=5ex,y=5ex,radius=5ex,baseline=4.5,inner sep=0pt,
outer sep=0pt]
\draw[penline,fill={%
\ifboolKV[\scrname]{print}
{scr_linegray}
{penblue}%
}]
(0,0)--(22:0.1)..controls(0.13,0.04)and(0.13,-0.04)..(-22:0.1)[sharp 
corners]--cycle;
\draw[penline,fill=white,rounded corners=.2pt]
(22:0.1)--(22:0.2)[rounded 
corners=0.05pt]--(.56,.07492)..controls(.62,0.04)and(.62,
-0.04)..(.56,-.07492)[rounded 
corners=2pt]--(-22:.2)[rounded 
corners=0.05pt]--(-22:0.1)..controls(0.13,-0.04)and(0.13,
0.04)..(22:0.1);
\draw[penline,fill={%
\ifboolKV[\scrname]{print}
{scr_linegray}{penblue}%
},rounded corners=.2pt]
(.56,.07492)--(.88,.07492)..controls(.92,0.04)and(.92,-0.04)..(0.88,
-.07492)[sharp 
corners]--(.56,-.07492)..controls(.62,-0.04)and(.62,0.04)..cycle;
\draw[penline](.84,0.07492)..controls(.7,.24)and(.58,0.02)..(.5,0.16);
		\filldraw[penline](.535,.17) circle [radius=1pt];
	\end{tikzpicture}% 
	\textcolor{penblue}{Stylo} : ce menu permet de 
construire des 
figures. 
\end{itemize}

\subsubsection{Les boucles}

Les boucles servent à répéter une même instruction plusieurs fois. 
Sous Scratch, il existe deux types de boucles :
\begin{itemize}
 \item la boucle \og répéter \dots fois\fg{} lorsque l'on connaît le 
nombre de répétitions ;
\item la boucle \og répéter jusqu'à ce que \dots\fg{} qui repète 
l'instruction jusqu'à ce qu'un test soit validé.
\end{itemize}

\begin{multicols}{2}
 \begin{scratch}
  \blockrepeat{répéter \ovalnum{10} fois}{
  \blockspace
  }
 \end{scratch}

  \begin{scratch}
  \blockrepeat{répéter jusqu'à ce que \boolempty[1em]}{
  \blockspace
  }
 \end{scratch}
\end{multicols}

\begin{Exemple}
 le programme ci-dessous permet de construire un 
polygone régulier 
(côtés égaux et angles de même mesure) de côté mesurant 30 pas et 
dans lequel l'utilisateur saisit le nombre de côtés.
\end{Exemple}

\newpage

\textit{Vous pouvez retrouver ce programme en tapant:}
\begin{center}
\texttt{https://scratch.mit.edu/projects/491851965}
\end{center} 

\qrset{height=1.1cm,version=5}
\rput(-1,0){\psframebox{\qrcode{https://scratch.mit.edu/projects/491851965}}
}
\begin{scratch}[scale=0.9]
 \blockinit{quand \greenflag est cliqué}
\blocklook{cacher}
\blockpen{\textcolor{white}{effacer tout}}
\blocksensing{demander \ovalnum{Quel est le nombre de côtés ?} et 
attendre}
\blockvariable{mettre \selectmenu{nombre de côtés} à 
\ovalsensing{réponse}}
\blockpen{\textcolor{white}{stylo en position d'écriture}}
\blockrepeat{répéter \ovalvariable{nombre de côtés} fois}
{
\blockmove{avancer de \ovalnum{30} pas}
\blockmove{tourner \turnright\ de 
\ovaloperator{\ovalnum{360}/\ovalvariable{nombre de côtés}} degrés}
}
\end{scratch}

%\begin{minipage}[t]{7cm}
%\NathanLiveProg[\normalfont\selectfont \textit{Pour accéder à ce programme en ligne :}]{Polygones 
%réguliers}{scratch.mit.edu/projects/491851965}
%\end{minipage}


\textit{Remarques}
\begin{itemize}
  \item \ovalvariable{nombre de côtés} est une variable. Une 
\emph{variable} est une \og case mémoire\fg{} dans laquelle on stocke 
une information ou un nombre pour l'utiliser plus tard. On désigne une 
variable par un nom.
\item L'étiquette 
\fcolorbox{white}{scrlook}{\textcolor{white}{cacher}} permet de 
cacher le lutin afin de mieux voir le polygone une fois construit.
\item Le lutin doit tourner $n$ fois du même angle pour retrouver son 
orientation initiale. Il a fait ainsi un tour complet.

C'est donc 
qu'il a tourné à chaque fois de $\dfrac{360}{n}$ degrés.
\item Si l'on veut construire un polygone avec un grand nombre de 
côtés, il faut réduire la taille du côté afin que le lutin ne sorte 
pas du cadre.
 \end{itemize}


\subsubsection{Les instructions conditionnelles}

\enlargethispage*{4em}

\begin{minipage}{5cm}
Une instruction conditionnelle est de la forme :
\begin{itemize}
 \item Si \dots alors \dots ;
 \item Si \dots alors \ldots sinon \dots
\end{itemize}

Sous Scratch, ces instructions sont dans le menu 
\textcolor{scrcontrol}{Contrôle}.
\end{minipage}\hfill 
\raisebox{1cm}{\begin{scratch}[scale=0.9]
  \blockif{si \boolempty\ alors}{
 \blockspace
 }
\end{scratch}
\hspace{1em}\begin{scratch}[scale=0.9]
  \blockifelse{si \boolempty\ alors}{\blockspace}{\blockspace}
\end{scratch}}

\newpage

\textit{Exemple :}
 le programme ci-dessous, permet, en connaissant
les longueurs 
des trois côtés d'un triangle, de savoir si ce triangle est rectangle 
ou non (en utilisant la réciproque du théorème de Pythagore).
\Par
\textit{Vous pouvez retrouver ce programme en tapant:}
\begin{center}
\texttt{https://scratch.mit.edu/projects/491037447}
\end{center} 

\qrset{height=1.1cm,version=5}
\rput(-1,0){\psframebox{\qrcode{https://scratch.mit.edu/projects/491037447}
}}
\begin{scratch}[scale=0.9]
  \blockinit{quand \greenflag est cliqué}
  \blocksensing{demander \ovalnum{Quelle est la longueur du plus 
grand côté ?} et attendre}
\blockvariable{mettre \ovalvariable{Grand c\^ot\'e} \`a 
\ovalsensing{réponse}}
  \blocksensing{demander \ovalnum{Quelle est la longueur du 2ème 
côté ?} et attendre}
\blockvariable{mettre \ovalvariable{Côté2} à 
\ovalsensing{réponse}}
  \blocksensing{demander \ovalnum{Quelle est la longueur du 3ème 
côté ?} et attendre}
\blockvariable{mettre \ovalvariable{Côté3} à 
\ovalsensing{réponse}}
\blockifelse{si \booloperator{\ovaloperator{\ovalvariable{Grand côté} 
* \ovalvariable{Grand côté}}=\ovaloperator{\ovalvariable{Côté2} 
* \ovalvariable{Côté2}}+\ovaloperator{\ovalvariable{Côté3} 
* \ovalvariable{Côté3}}} alors}{\blocklook{dire \ovalnum{Le 
triangle est rectangle.}}}{\blocklook{dire \ovalnum{Le triangle n'est 
pas rectangle.}}}
\end{scratch}

%\begin{minipage}[t]{7cm}
%\NathanLiveProg[\normalfont\selectfont \textit{Pour accéder à ce 
%programme en ligne :}]{Réciproque du théorème de 
%Pythagore}{scratch.mit.edu/projects/491037447}
%\end{minipage}


\begin{solintro}
Le programme demande d'entrer un nombre qui est mis dans la 
variable \ovalvariable{a}. 

Ensuite, on répète 5 fois la même opération : on multiplie la variable 
\ovalvariable{a} par 1,05. C'est une augmentation de 5\;\%.

\begin{attention}
 $1,05$ s'écrit $1.05$ sous Scratch.
\end{attention}


Ainsi, le programme va afficher le résultat de 5 augmentations successives de 5\;\% sur le nombre que l'on entre au clavier.

\Par

Si on entre $250$ au début du programme, la valeur affichée sera :
\[250 \times 1,05^5 \approx 319,07.\]
\vspace*{-3em}
\end{solintro}
