\thumb


\begin{qcm}{Les types de variables}{5} % titre , temps
Pour chacune des questions suivantes, plusieurs propositions sont faites mais une seule est correcte. Laquelle ?

\begin{questions}
\item La réponse à l'instruction \og \texttt{1 == 3} \fg{} est :

\choix{} une variable numérique;

\choix{} une chaîne de caractères;

\choix{} un booléen.

\item On souhaite mettre le résultat de l'opération \og $9-3+(7-2)*4$ \fg{} dans une variable \texttt{result}. Le type de variable  le plus adapté de \texttt{result} est :\resetchoix

\choix{} la classe \texttt{str};

\choix{} la classe  \texttt{int};

\choix{} la classe \texttt{bool}.

\item Dans un programme Python, si \texttt{a = "8"} et et \texttt{b = 5}, que retourne ce programme en tapant : \og \texttt{a+b} \fg{} ?\resetchoix

\choix{} '13';

\choix{} 13;

\choix{} False;

\choix{} TypeError: must be str, not int.

\item Clément a \numprint{100} \euro dans sa tirelire. Chaque semaine, il dépense 10\% de ce qu'il y a dans sa tirelire. Il souhaite savoir combien il possèdera après 10 semaines. 

La classe Python de la variable représentant la somme de Clément est :\resetchoix

\choix{} la classe \texttt{int};

\choix{} la classe \texttt{float};

\choix{} la classe \texttt{bool};

\choix{} la classe \texttt{str}.
\end{questions}
\end{qcm}

\begin{corrige}
\begin{questions}
\item Réponse \choix[c]. En effet, quand on tape l'instruction \og \texttt{1 == 3} \fg{} en Python, on cherche à savoir si \og 1 \fg{} est égal à \og 3 \fg{} ; la réponse ne peut être que \textit{True} ou \textit{False} : c'est donc un booléen. Ici, Python renvoie \textit{False} car \og 1 \fg{} n'est bien entendu pas égal à \og 3 \fg.

\item Réponse \choix[2]. En effet, $9-3+(7-2)*4=26$ et \og 26 \fg{} est un entier. Donc le type \texttt{int} est le plus adapté, même s'il est tout à fait possible de stocker ce résultat dans une chaîne de caractères en le convertissant à l'aide de la fonction \texttt{str}.

\item Réponse \choix[d]. En effet, \texttt{a} est du type \textit{chaîne de caractères} et \texttt{b} est du type \textit{entier}. Or, on ne peut pas faire d'opérations entre deux variables de types différents. Python affiche donc qu'il y a une erreur.

\begin{Remarque}
penser que Python renvoie \textit{False} laisse à supposer que l'opération est possible à faire et qu'elle est fausse. Cela n'a donc ici aucun sens.
\end{Remarque}

\item Réponse \choix[b]. Ici, il est nullement question de trouver le résultat mais il faut anticiper sur le type de résultat. On sait que si on retire à un nombre 10\% de ce nombre, on doit le multiplier par $\left(1-\frac{10}{100}\right)$, c'est-à-dire par 0,9. Il y a donc fort à parier que les résultats seront des nombres réels et non entiers. 

Par conséquent, la classe du résultat est \texttt{float}.
\end{questions}
\end{corrige}

%%%%%%%%%%% 2

\begin{vf}{Codage des nombres}{10} % titre , temps
Les propositions suivantes sont-elles vraies ou fausses ?


\begin{questions}
\item Le nombre $\base{1,25}{10}$ a un développement dyadique fini.
\item En Python, quand on tape \texttt{1.2+1.25}, le résultat affiché est \texttt{1.45}.
\item $\base{1,01}{2}$ représente le nombre $1,25$.
\item En Python, quand on tape \texttt{3*1/3}, il s'affiche \og \texttt{1.0} \fg.
\end{questions}
\end{vf}

\begin{corrige}
\begin{questions}
\item La proposition est \textit{Vraie}. En effet, $1,25=\dfrac{125}{100}=\dfrac{5}{4}$, et 4 est une\linebreak puissance de 2. Donc le $\dfrac{5}{4}$ est un nombre dyadique et par conséquent, son développement dyadique est fini.

\item La proposition est \textit{fausse}. En effet, $\base{1,2}{10}$ n'est pas dyadique car\linebreak $1,2=\dfrac{12}{10}=\dfrac{6}{5}$, et 5 n'est pas une puissance de 2. Par conséquent, le développement dyadique de 1,2 est tronqué avec Python, et le résultat affiché n'est qu'une valeur approximative.

\item La proposition est \textit{vraie}. En effet, $\base{1,01}{2}$ représente le résultat de\linebreak $1\times2^0+0\times2^{-1}+1\times2^{-2}$, c'est-à-dire $1+0,25$, soit $1,25$.

\newpage

\item La proposition est \textit{vraie}. $\dfrac{1}{3}=\base{0,010101\ldots}{2}$ (voir cours) donc $\dfrac{1}{3}+\dfrac{1}{3}$ sera codé par :
\[
\begin{array}{*8{c}}
 & 0 & , & 0 & 1 & 0 & 1 & \ldots\\
+& 0 & , & 0 & 1 & 0 & 1 & \ldots\\
\hline
 & 0 & , & 1  & 0 & 1 & 0 & \ldots
\end{array}
\]
et donc $\dfrac{2}{3}+\dfrac{1}{3}$ est codé par :
\[
\begin{array}{*8{c}}
 & 0 & , & 1 & 0 & 1 & 0 & \ldots\\
+& 0 & , & 0 & 1 & 0 & 1 & \ldots\\
\hline
 & 0 & , & 1 & 1 & 1 & 1 & \ldots
\end{array}
\]
On reconnaît ici le développement dyadique de 1 (voir page \pageref{dev-dyadique-de-1}).

C'est la raison pour laquelle le résultat affiché est bien \og \texttt{1.0} \fg.
\end{questions}
\end{corrige}

%%%%%%%%%%% 3

\begin{vf}{Connaissances générales}{5} 
Les propositions suivantes sont-elles vraies ou fausses ?

\begin{questions}
\item Si \texttt{mot = "informatique"} alors \texttt{mot[2]="n"}.

\item Si \texttt{chaine = "Un signe."}  alors \texttt{chaine[-3:] = "ne."}

\item Si  \texttt{rep = (8>4 or 1<2)}  alors \texttt{rep = True}.

\item Si \texttt{mot = "éléphant"} alors \texttt{mot.upper() = "ELEPHANT"}.
\end{questions}
\end{vf}

\begin{corrige}
\begin{questions}
\item Si \texttt{mot = "informatique"} alors \texttt{mot[2] = "n"}.

Réponse : \textit{faux}. En effet, il ne faut pas oublier que l'indexation se fait à partir de 0. Donc \texttt{mot[0] = "i"} et par suite, \texttt{mot[2] = "f"}.

\item Si \texttt{chaine = "Un signe."} alors \texttt{chaine[-3:] = "ne."}

Réponse : \textit{vrai}. En effet, \texttt{chaine[-3:]} désigne les trois derniers caractères de la chaîne \texttt{chaine}. 

\item Si \texttt{rep = 8>4 or 1<2}  alors \texttt{rep = True}.

Réponse : \textit{vrai}. En effet, \texttt{rep} est un booléen, et la présence de \og \texttt{or} \fg{}  stipule qu'il vaut \textit{True} si l'une des conditions au moins est vraie, ce qui est le cas car même si \og 8 > 4 \fg{} est faux, \og 1<2 \fg{} est vrai.

\item Si \texttt{mot = "éléphant"}  alors \texttt{mot.upper() = "ELEPHANT"}.

Réponse : \textit{faux}. La commande \texttt{upper} met certes en majuscules,\linebreak mais la majuscule de \og é \fg{} est \og \'E \fg{} ; il en résulte que\linebreak \texttt{mot.upper() = "\'EL\'EPHANT"}.
\end{questions}
\end{corrige}

%================ CODAGE DE NOMBRES	=========

\sectionnn{Codage de nombres}

%%% 4

\begin{exo}{Complément à 2}{\null}{1}{10} 
Donner le complément à 2 des nombres suivants avec une mémoire de 8 bits :
\begin{questions}
\item 100
\item 75
\item $-50$
\item $-89$
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item $100>0$ donc le complément à 2 de 100 est le binaire signé correspondant.
\[
100 = 64 + 32 + 4 = 2^6 + 2^5 + 2^2
\]
donc $\base{100}{10}=\base{01100100}{2}$ (le bit fort est 0 car 100 est positif).

\item $75=64+8+2+1=2^6+2^3+2^1+2^0$ donc $\base{75}{10}=\base{01001011}{2}$.

\newpage

\item $-50<0$ donc on suit les étapes suivantes :
\begin{itemize}
\item $50=32+16+2=2^5 + 2^4+2^1$ donc $\base{50}{10}=\base{00110010}{2}$.
\item On prend le complément à 1 : $\base{11001101}{2}$.
\item On prend le complément à 2 : $\base{11001110}{2}$.
\end{itemize}
Le complément à 2 de $\base{-50}{10}$ est $\base{11001110}{2}$.

\item 
\begin{itemize}
\item $89=64+16+8+1=2^6 + 2^4 + 2^3 + 2^0$ donc $\base{89}{10}=\base{01011001}{2}$.
\item On prend le complément à 1 : $\base{10100110}{2}$.
\item On prend le complément à 2 : $\base{10100111}{2}$.
\end{itemize}
Le complément à 2 de $\base{-89}{10}$ est donc $\base{10100111}{2}$.
\end{questions}
\end{corrige}

%%% 5

\begin{exo}{Somme de deux entiers}{\null}{1}{15} 
Pour chacune des questions suivantes, avec une mémoire de 8 bits,
\begin{itemize}
\item donner le complément à 2 des deux nombres $a$ et $b$;
\item calculer la somme des compléments à 2 de $a$ et $b$;
\item vérifier que le résultat trouvé est bien le complément à 2 de la somme de $a$ et $b$.
\end{itemize}
\begin{questions}
\item $a=35$ et $b=65$.
\item $a=-12$ et $b=45$.
\item $a=-84$ et $b=29$.
\item $a=-17$ et $b=-111$.
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item 
\begin{itemize}
\item $a=35=32+2+1$ donc le complément à 2 de $\base{35}{10}$ est $\base{00100011}{2}$.
\item $b=65=64+1$ donc le complément à 2 de $\base{65}{10}$ est $\base{01000001}{2}$.
\end{itemize}
\[
\begin{array}{*{11}{c}}
 & &0&0&1&0&0&0&1&1\\
+& &0&1&0&0&0&0&0&1\\
\hline
&& 0&1&1&0&0&1&0&0
\end{array}
\]
Ainsi, $\base{00100011}{2}+\base{01000001}{2}=\base{01100100}{2}$, qui correspond au nombre $2^6+2^5+2^2=64+32+4=100$, qui est bien la somme de 35 et 65.

\item 
\begin{itemize}
\item $a=-12$. $12=8+4$ donc $\base{12}{10}=\base{00001100}{2}$. 

Le complément à 1 est $\base{11110011}{2}$.

Le complément à 2 est alors $\base{11110100}{2}$.

\item $45=32+8+4+1$ donc $\base{45}{10}=\base{00101101}{2}$.
\end{itemize}
\[
\begin{array}{*{11}{c}}
 & &1&1&1&1&0&1&0&0\\
+& &0&0&1&0&1&1&0&1\\
\hline
&1&0&0&1&0&0&0&0&1
\end{array}
\]
On ne prend que les 8 derniers bits donc le complément à 2 de la somme est $\base{00100001}{2}$. Le bit fort étant 0, la somme est positive, et $\base{00100001}{2}$ représente donc $2^5+2^0=33$, qui est bien égal à $12+45$.

\item
\begin{itemize}
\item $84=64+16+4$ donc $\base{84}{10}=\base{01010100}{1}$.

Le complément à 1 est $\base{10101011}{2}$.

Le complément à 2 est : $\base{10101100}{2}$.

Le complément à 2 de $\base{-84}{10}$ est donc $\base{10101100}{2}$.

\item $29=16+8+4+1$ donc $\base{29}{10}=\base{00011101}{2}$.
\end{itemize}
\[
\begin{array}{*{11}{c}}
 & &1&0&1&0&1&1&0&0\\
+& &0&0&0&1&1&1&0&1\\
\hline
&&1&1&0&0&1&0&0&1
\end{array}
\]
Le complément à 2 de la somme est donc $\base{11001001}{2}$. Le bit fort étant 1, elle correspond à un nombre négatif en base 10.

$a+b=-84+29=-55$. Or, $55=32+16+4+2+1$ donc $\base{55}{10}=\base{00110111}{2}$.

Le complément à 1 est $\base{11001000}{2}$.

Le complément à 2 est alors $\base{11001001}{2}$, qui correspond bien à ce que nous avons trouvé précédemment.

\item
\begin{itemize}
\item $17=16+1$ donc $\base{17}{10}=\base{00010001}{2}$.

Le complément à 1 est $\base{11101110}{2}$.

Le complément à 2 est alors $\base{11101111}{2}$.

\item $111=64+32+8+4+2+1$ donc $\base{111}{10}=\base{01101111}{2}$.

Le complément à 1 est $\base{10010000}{2}$.

Le complément à 2 est alors $\base{10010001}{2}$.
\end{itemize}
\[
\begin{array}{*{11}{c}}
 & &1&1&1&0&1&1&1&1\\
+& &1&0&0&1&0&0&0&1\\
\hline
&1&1&0&0&0&0&0&0&0
\end{array}
\]
On ne retient que les 8 derniers bits : $\base{10000000}{2}$, qui correspond à $-128$ (voir page \pageref{complementmoins128}), qui est bien la somme de $-17$ et $-111$.
\end{questions}
\end{corrige}

%%% 6

\begin{exo}{Nombres dyadiques}{\null}{1}{10} 
Coder en binaire les nombres suivants :
\begin{questions}
\item $\dfrac{75}{16}$\\[-1pt]
\item $\dfrac{101}{8}$\\[-1pt]
\item $\dfrac{59}{4}$\\[-1pt]
\item $\dfrac{61}{2}$
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item $\begin{aligned}[t]
\dfrac{75}{16} & =\dfrac{64}{16}+\dfrac{8}{16}+\dfrac{2}{16}+\dfrac{1}{16}\\
& =4+\dfrac{1}{2}+\dfrac{1}{8}+\dfrac{1}{16}\\
&=1\times2^2 + 0\times2^1 + 0\times2^0 + 1\times2^{-1}+0\times2^{-2}+1\times2^{-3}+1\times2^{-4}.
\end{aligned}$

Donc $\dfrac{75}{16}=\base{100,1011}{2}$.

\item $\begin{aligned}[t]
\dfrac{101}{8}&=\dfrac{64}{8}+\dfrac{32}{8}+\dfrac{4}{8}+\dfrac{1}{8}\\
&=8+4+\dfrac{1}{2}+\dfrac{1}{8}.
\end{aligned}$

Donc $\dfrac{101}{8}=\base{1100,101}{2}$.

\item $\begin{aligned}[t]
\dfrac{59}{4}&=\dfrac{32}{4}+\dfrac{16}{4}+\dfrac{8}{4}+\dfrac{2}{4}+\dfrac{1}{4}\\
&=8+4+2+\dfrac{1}{2}+\dfrac{1}{4}
\end{aligned}$

Donc $\dfrac{59}{4}=\base{1110,11}{2}$.

\item $\dfrac{61}{2}=30+\dfrac{1}{2}=16+8+4+2+\dfrac{1}{2}$.

Donc $\dfrac{61}{2}=\base{11110,1}{2}$.
\end{questions}
\end{corrige}


%%% 2 étoiles

%%% 7

\begin{exo}{À partir du complément à 2}{\null}{2}{10} 
Trouver le nombre en base 10 dont le complément à 2 est :
\begin{questions}
\item $\base{11001011}{2}$ 
\item $\base{11010100}{2}$
\item $\base{10000010}{2}$
\item $\base{10101010}{2}$
\end{questions}
\end{exo}

\begin{corrige}
\begin{methode}
Pour retrouver le nombre en base 10 d'un complément à 2, on exécute la méthode de la page \pageref{complement-a-deux} à l'envers :
\begin{itemize}
\item on enlève 1 au binaire;
\item on prend le complément à 1 du résultat;
\item on retrouve le nombre en base 10 (sans le signe).
\end{itemize}
\end{methode}

\begin{questions}
\item $\base{11001011}{2}$.
\begin{itemize}
\item On enlève 1 : $\base{11001010}{2}$ ;
\item on prend le complément à 1 : $\base{00110101}{2}$;
\item on retrouve le nombre en base 10 : $32+16+4+1=53$.
\end{itemize}
Ainsi, $\base{11001011}{2}=\base{-53}{10}$.

\item $\base{11010100}{2}$.
\begin{itemize}
\item On enlève 1 : $\base{11010011}{2}$ ;
\item on prend le complément à 1 : $\base{00101100}{2}$;
\item on retrouve le nombre en base 10 : $4+8+32=44$.
\end{itemize}
Ainsi, $\base{11010100}{2}=\base{-44}{10}$.

\item $\base{10000010}{2}$.
\begin{itemize}
\item On enlève 1 : $\base{10000001}{2}$ ;
\item on prend le complément à 1 : $\base{01111110}{2}$;
\item on retrouve le nombre en base 10 : $2+4+8+16+32+64=126$.
\end{itemize}
Ainsi, $\base{10000010}{2}=\base{-126}{10}$.

\newpage
\item $\base{10101010}{2}$.
\begin{itemize}
\item On enlève 1 : $\base{10101001}{2}$ ;
\item on prend le complément à 1 : $\base{01010110}{2}$;
\item on retrouve le nombre en base 10 : $2+4+16+64=86$.
\end{itemize}
Ainsi, $\base{10101010}{2}=\base{-86}{10}$.
\end{questions}
\end{corrige}


%================ BOOLEENS ==================

\sectionnn{Booléens}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 1 étoile

%%% 8

\begin{exo}{La valeur des booléens}{\null}{1}{5} 
Dans chacun des cas suivants, donnez la valeur du booléen \texttt{rep}.

\begin{questions}
\item \begin{tabular}[t]{>{\ttfamily}l}
x = -3\\
rep = x**2 == -9
\end{tabular}


\item \begin{tabular}[t]{>{\ttfamily}l}
x, y, z = 3, 4, 5\\
rep = x**2 + y**2 == z**2
\end{tabular}

\item \begin{tabular}[t]{>{\ttfamily}l}
a, b = 3, -7\\
rep = a**3 > 50 and b**2 < 50
\end{tabular}

\item \begin{tabular}[t]{>{\ttfamily}l}
a, b = 3, -7\\
rep = (a**3 > 50 and b**2 < 50) or\\ 
\hspace*{50mm}			  (a**2 < 10 and b**2 >10)
\end{tabular}
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item \texttt{rep = False}. En effet, $x=-3$ et donc $x^2=9$. Or, \og \texttt{x**2} \fg{} représente $x^2$ et \og \texttt{x**2 == -9} \fg{} teste si $x^2$ est égal à $-9$, ce qui n'est pas le cas ici. Donc la réponse est \textit{False}.

\item \texttt{rep = True}. En effet, $x=3$, $y=4$ et $z=5$ donc $x^2+y^2=3^2+4^2$, soit $x^2+y^2=25$ et $z^2=5^5=25$.

Le test \og \texttt{x**2 + y**2 == z**2} \fg{}  est donc validé : la réponse est \textit{True}.

\begin{Remarque}
on reconnaît ici la réciproque du théorème de Pythagore.
\end{Remarque}

\item \texttt{rep = False}. En effet, $a=3$ et $b=-7$ donc $a^3=27$ et $b^2=49$.

On teste alors si les deux conditions \texttt{a**3>50} et \texttt{b**2<50} sont vraies, ce qui n'est pas le cas car l'une d'elles est fausse. La réponse renvoyée est donc \textit{False}.

\item \texttt{rep = True}. En effet, nous retrouvons les mêmes valeurs de $a$ et $b$ que dans la question précédente et la première partie du test est la même : \og \texttt{(a**3 > 50 and b**2 < 50)} \fg{} est donc faux. Mais la seconde partie du test : \og \texttt{(a**2 < 10 and b**2 >10)} \fg{} est vraie car $a^2=9$ (qui est bien inférieur à 10) et $b^2=49$ (qui est bien supérieur à 10).

La présence de \texttt{or} signifie que l'on teste si l'une au moins des deux propositions est vraie, ce qui est le cas, donc la réponse est \textit{True}.
\end{questions}
\end{corrige}


%%% 9

\begin{exo}{Booléens et chaînes de caractères}{\null}{1}{5} 
\begin{questions}
\item Qu'affiche le programme suivant ?

\Par

\begin{tabularx}{\linewidth}{@{\hspace*{5mm}}>{\ttfamily}X}
phrase1 = "il est actuellement midi."\\
phrase2 = "il est temps d'aller manger."\\
"il" in (phrase1 and phrase2)
\end{tabularx}

\item Qu'affiche le programme suivant ?

\Par

\begin{tabularx}{\linewidth}{@{\hspace*{5mm}}>{\ttfamily}X}
phrase1 = "il est actuellement midi."\\
phrase2 = "il est temps d'aller manger."\\
"est" in (phrase1 and phrase2) and "na" in (phrase1 or phrase2)
\end{tabularx}
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}\enlargethispage*{\baselineskip}
\item L'instruction \og \texttt{"il" in (phrase1 and phrase2)} \fg{} teste si la chaîne de caractères \og il \fg{} est présente dans les deux phrases, ce qui est le cas.

Donc le programme affiche : \og True \fg.

\item L'instruction \og \texttt{"est" in (phrase1 and phrase2) and "na" in\\ (phrase1 or phrase2)} \fg{} teste si la chaine de caractères \og est \fg{} est présente dans les deux phrases (ce qui est le cas) et si la chaîne de caractères \og na \fg{} est présente dans l'une des deux phrases (ce qui n'est pas le cas). Nous avons donc comme réponses : \textit{True} ET \textit{False}. 

Le programme affiche donc : \og False \fg.
\end{questions}
\end{corrige}

%%%%%% 2 étoiles

%%% 10

\begin{exo}{Opérations sur des booléens}{\null}{2}{5} 
Compléter le tableau suivant :

\Par

\begin{tabular}{|C|C|*4{Zc|}}
\hline
\tabulartitle
a & b & not(a) and b & not(a) or b & not(a) and not(b)& not(a) or not(b)\\
\hline
0 & 0 & & & & \\
\hline
0 & 1 & & & & \\
\hline
1 & 0 & & & & \\
\hline
1 & 1 & & & & \\
\hline
\end{tabular}
\end{exo}

\begin{corrige}
Le tableau complété est le suivant :

\Par

\begin{tabular}{|C|C|*4{Zc|}}
\hline
\tabulartitle
a & b & not(a) and b & not(a) or b & not(a) and not(b)& not(a) or not(b)\\
\hline
0 & 0 & 0 & 1 & 1 & 1 \\
\hline
0 & 1 & 1 & 1 & 0 & 1 \\
\hline
1 & 0 & 0 & 0 & 0 & 1 \\
\hline
1 & 1 & 0 & 1 & 0 & 0 \\
\hline
\end{tabular}
\end{corrige}

%%% 11

\begin{exo}{Encore des opérations}{\null}{2}{10} 
\begin{questions}
\item Compléter le tableau suivant :
\begin{center}
\begin{tabular}{|C|C|Zc|}
\tabulartitle\hline
a & b & (a or b) and (a and b)\\
\hline
0 & 0 & \\
\hline
0 & 1 & \\
\hline
1 & 0 & \\
\hline
1 & 1 &  \\
\hline
\end{tabular}
\end{center}

\Par

Comment peut-on alors simplifier la règle \og (a or b) and (a and b) \fg{} ?

\item Compléter le tableau suivant :
\begin{center}
\begin{tabular}{|C|C|Zc|}
\tabulartitle\hline
a & b & (a or b) or (a and b)\\
\hline
0 & 0 & \\
\hline
0 & 1 & \\
\hline
1 & 0 & \\
\hline
1 & 1 &  \\
\hline
\end{tabular}
\end{center}

\Par

Comment peut-on alors simplifier la règle \og (a or b) or (a and b) \fg{} ?
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item \raisebox{-0.4\totalheight}{\begin{tabular}{|C|C|Zc|}
\tabulartitle\hline
a & b & (a or b) and (a and b)\\
\hline
0 & 0 & 0\\
\hline
0 & 1 & 0\\
\hline
1 & 0 &0 \\
\hline
1 & 1 &1 \\
\hline
\end{tabular}}

\Par

On s'aperçoit alors que la règle \og (a or b) and (a and b) \fg{} est identique à l'opérateur \og and \fg.

\item  \raisebox{-0.4\totalheight}{\begin{tabular}{|C|C|Zc|}
\tabulartitle\hline
a & b & (a or b) or (a and b)\\
\hline
0 & 0 & 0\\
\hline
0 & 1 & 1\\
\hline
1 & 0 & 1\\
\hline
1 & 1 & 1 \\
\hline
\end{tabular}}

\Par

On s'aperçoit alors que la règle \og (a or b) or (a and b) \fg{} est identique à l'opérateur \og or \fg.
\end{questions}
\end{corrige}

%%% 12

\begin{exo}{La loi \og Delta \fg}{\null}{2}{10} 
Soient \texttt{a} et \texttt{b} deux booléens. On définit la loi \texttt{Delta} telle que :
\begin{center}
\texttt{a Delta b = (a or b) and not(a and b)}
\end{center}
\begin{questions}
\item Compléter la table de la loi Delta suivante :
\begin{center}
\begin{tabular}{|C|Zc|Zc|}
\tabulartitle\hline
Delta & 0 & 1 \\
\hline
0 &  & \\
\hline
0 &  & \\
\hline
\end{tabular}
\end{center}

\item Que se cache-t-il derrière la loi Delta ?
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item 
\begin{minipage}[t]{3.5cm}
La table de la loi Delta est la suivante :

\Par

\begin{center}
\begin{tabular}{|C|Zc|Zc|}
\tabulartitle\hline
Delta & 0 & 1 \\
\hline
0 & 0 & 1\\
\hline
0 & 1 & 0\\
\hline
\end{tabular}
\end{center}
\end{minipage}
\hfill
\begin{minipage}[t]{\dimexpr\linewidth-4.4cm}
Explications :
\begin{itemize}
\item 0 Delta 0 = (0 or 0) and not(0 and 0)\\
\phantom{0 Delta 0 }= 0 and not(0) = 0 and 1 = 0.
\item 0 Delta 1 = (0 or 1) and not(0 and 1)\\
\phantom{0 Delta 1 }= 1 and not(0) = 1 and 1 = 1.
\item 1 Delta 0 = (1 or 0) and not(1 and 0)\\
\phantom{1 Delta 0 } = 1 and not(0) = 1 and 1 = 1.
\item 1 Delta 1 = (1 or 1) and not(1 and 1)\\
\phantom{1 Delta 1 } = 1 and not(1) = 1 and 0 = 0.
\end{itemize}
\end{minipage}

\item On constate que la table de la loi Delta est celle de l'opérateur xor. Donc derrière la loi Delta se cache en définitive l'opérateur xor.

\end{questions}
\end{corrige}

%%% 13

\begin{exo}{La fonction \og Delta \fg}{\null}{2}{15} 
On considère le programme suivant :
\begin{listing}{}{02-13.py}\end{listing}

\begin{questions}
\item Qu'affiche-t-il ?
\item Trouver une valeur de \texttt{x} pour qu'il affiche \og True \fg.
\item Que se passe-t-il quand x = \og A \fg{} si on définit la fonction \og Delta \fg{} de la manière suivante :

\Par

\begin{tabularx}{\linewidth}{@{\hspace*{5mm}}>{\ttfamily}X}
def delta(A,B,x):\\
\qquad return (x in A or B) and not(x in A and B)
\end{tabularx}
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item Dans la fonction \og Delta \fg, le test \og \texttt{x in (A or B)} \fg{} renvoie \textit{True} car le caractère \og K \fg{} apparaît dans l'une des chaînes \texttt{A} ou \texttt{B}.

Le test \og \texttt{x in (A and B)} \fg{} renvoie \textit{True} car \og K \fg{} apparaît dans les deux chaînes, donc \texttt{not(x in (A and B))} vaut \textit{False}.

Ainsi, le test \og \texttt{(x in (A or B)) and not(x in (A and B))} \fg{} est équivalent au test \og True and False \fg{} et renvoie donc la valeur \textit{False}.

\Par

Le programme affiche donc : \og False \fg.

\item Nous l'avons vu à la question précédente, \og K \fg{} apparaît dans les deux chaînes; ceci nous pousse à prendre un caractère qui n'apparaît que dans l'une d'elle. Prenons par exemple : \og A \fg. Alors :
\begin{itemize}
\item \og \texttt{x in (A or B)} \fg{} renvoie \textit{True};
\item \og \texttt{x in (A and B)} \fg{} renvoie \textit{False} donc \og \texttt{not(x in (A and B))} \fg{} renvoie \textit{True};
\item \og \texttt{(x in (A and B)) and not(x in (A and B))} \fg{} est équivalent au test \og True and True \fg{} et renvoie \textit{True}.
\end{itemize}

\item Dans cette nouvelle définition, on a enlevé les parenthèses aux deux \og \texttt{(A or/and B)} \fg; il n'y a donc plus de priorité aux opérateurs logiques \texttt{or} et \texttt{and}. 

Pour \texttt{x = 'A'}, le test \og \texttt{x in A or B} \fg{} n'a pas de sens car on fait avant tout le test \og \texttt{x in A} \fg{} (qui renvoie \textit{True}) et on effectue le test \og True or B \fg, qui n'est pas un test sur booléens. Python renvoie à cela : \og \texttt{'OKLM'} \fg, et ce n'est pas ce que nous attendions (on n'attendait pas grand-chose d'ailleurs...).

\Par

Ainsi, enlever les parenthèses est une erreur.
\end{questions}
\end{corrige}

\vfil\hfil\textit{Suite des exercices page suivante...}

\newpage

\sectionnn{Chaînes de caractères}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 1 étoile

%%% 14

\begin{exo}{Remplacer une lettre}{\null}{1}{5} 
On souhaite écrire un programme Python remplaçant la lettre \og e \fg{} par la lettre \og A \fg{} dans une chaîne de caractère \texttt{A}, sans utiliser la fonction \texttt{replace}.

Compléter l'algorithme suivant afin d'obtenir un tel programme.
\begin{listing}{}{02-14-01.py}
\end{listing}
\end{exo}


\begin{corrige}
\begin{listing}{}{02-14-02.py}\nathanliveProgWithoutText\end{listing}

\Par

Explications :

\begin{itemize}
\item Nous devons parcourir la chaîne \texttt{A}; la variable \texttt{i} représente ici l'index des caractères de la chaîne. Il faut donc que \texttt{i} prennent autant de valeurs qu'il y a de caractères dans \texttt{A}, donc \texttt{len(A)} valeurs.

\item On souhaite construire la chaîne \texttt{B} comme étant identique à la chaîne \texttt{A} sauf quand le caractère est \og e \fg, auquel cas on le remplace par \og a \fg. Il faut donc faire le test \og si le caractère d'index \texttt{i} est 'e' \fg, ce qui se traduit par \og \texttt{if A[i] == 'e'} \fg.
\end{itemize}
\end{corrige}

%%%% 15

\begin{exo}{Modification}{\null}{1}{5} 
On considère le programme suivant :
\begin{listing}{}{02-15.py}\end{listing}

\Par


Compléter le tableau d'exécution suivant :

\begin{center}
\begin{tabular}{|L|*3{Zc|}}
\hline
Valeurs de \texttt{i} & \ldots & \ldots & \ldots \\
\hline
Valeurs de \texttt{B} & \ldots & \ldots & \ldots\\
\hline
\end{tabular}
\end{center}

En déduire ce qu'affiche ce programme.
\end{exo}

\begin{corrige}
\texttt{len(A)} correspond au nombre de caractères dans la variable \texttt{A}, donc représente ici le nombre 19.

L'instruction \og \texttt{for i in range(len(A))} \fg{} signifie que la variable \texttt{i} prend 19 valeurs en partant de 0.

De plus, le test \og \texttt{if i\%2 == 0} \fg{} signifie : \og  si \texttt{i} est pair \fg{} car \texttt{i\%2} représente le reste de la division euclidienne de \texttt{i} par 2, et si ce reste est égal à 0, alors cela signifie que \texttt{i} est pair.

Le tableau d'exécution du programme commence ainsi :

\begin{center}
\begin{tabular}{|L|*6{Zc|}}
\hline
Valeurs de \texttt{i} & 0 & 1 & 2 & 3 & 4 & \ldots\\
\hline
Valeurs de \texttt{B} & H & H* & H*a & H*a* & H*a*t & \ldots \\
\hline
\end{tabular}
\end{center}
\enlargethispage*{3em}

Le programme remplace donc toutes les lettres dont l'index est impair par une astérisque.

Il affiche donc : \hfil \texttt{H*a*t*n*i*o*o*m*n*s}
\end{corrige}

%%% 16
\newpage
\begin{exo}{Manipulation}{\null}{1}{10} 
On considère le programme suivant :
\begin{listing}{}{02-16.py}\end{listing}

\Par

Compléter le tableau d'exécution suivant :

\begin{center}
\begin{tabular}{|L|*3{Zc|}}
\hline
Valeurs de \texttt{i} & \ldots & \ldots & \ldots \\
\hline
Valeurs de \texttt{A[i]} & \ldots & \ldots & \ldots\\
\hline
Valeurs de \texttt{B} & \ldots & \ldots & \ldots\\
\hline
\end{tabular}
\end{center}

En déduire ce qu'affiche ce programme.
\end{exo}

\begin{corrige}
En premier lieu, on remarque que l'incrémentation de la fonction \texttt{range} n'est pas conventionnelle : n'oublions pas que \texttt{for i in range(10)} (par exemple) signifie que \texttt{i} varie de 0 à  9 (prenant ainsi 10 valeurs), mais \texttt{for i in range(a,b,k)} signifie que \texttt{i} prend des valeurs allant de \texttt{a} à \texttt{b} avec un pas égal à \texttt{k} (c'est-à-dire de $k$ en $k$).

\Par

Ici, \texttt{len(A)-1} est égal à $7-1=6$ (donc les valeurs de \texttt{i} vont partir de 6 et vont aller jusqu'à $-1+1$ c'est-à-dire 0, avec un pas de $-1$); \texttt{i} va donc prendre les valeurs : 6, 5, 4, 3, 2, 1 et 0. D'où :

\begin{center}
\begin{tabular}{|L|*7{Zc|}}
\hline
Valeurs de \texttt{i} & 6 & 5 & 4 & 3 & 2 & 1 & 0 \\
\hline
Valeurs de \texttt{A[i]} & e & g & o & l & r & o & H \\
\hline
Valeurs de \texttt{B} & e  &eg  & ego  & egol  & egolr & egolro & egolroH    \\
\hline
\end{tabular}
\end{center}

Le programme affiche donc : \og egolroH \fg, c'est-à-dire le mot \og Horloge \fg{} à l'envers.
\end{corrige}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 2 étoiles

%%%% 17

\begin{exo}{Les initiales}{\null}{2}{10} 
Créer un programme Python qui :
\begin{itemize}
\item demande à l'utilisateur son nom et son prénom, séparés par un espace;
\item affiche : \og Votre prénom est : \fg{} suivi du prénom;
\item affiche : \og Votre nom est : \fg{} suivi du nom;
\item affiche : \og Vos initiales sont : \fg{} suivi des initiales du nom et du prénom en majuscules.
\end{itemize}

\textit{Aide :} vous pourrez recourir à un booléen pour détecter la présence de\linebreak l'espace.
\end{exo}

\begin{corrige}
\begin{listing}{}{02-17.py}\nathanliveProgWithoutText\end{listing}
\end{corrige}


%%% 18

\begin{exo}{Que fait ce programme ?}{\null}{2}{10} 
On considère le programme Python suivant :\enlargethispage*{2em}
\begin{listing}{}{02-18-01.py}\end{listing}
\begin{questions}
\item Quel est le type des variables \texttt{debut}, \texttt{lettre} et \texttt{fin} ?
\item Qu'affiche ce programme ?
\item Modifier ce programme afin que l'on puisse entrer n'importe quelle phrase et que l'on puisse choisir le caractère désigné par la variable \texttt{lettre}.
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item Les trois premières lignes sont des affectations : la variable \texttt{debut} prend la valeur d'une phrase (c'est donc une chaîne de caractères), la variable \texttt{lettre} prend la valeur \og r \fg{}  (c'est donc aussi une chaîne de caractères), et la variable \texttt{fin} est vide, mais est déclarée comme une chaîne de caractères puisque des guillemets sont présents dans son affectation.

\Par

Les variables \texttt{debut}, \texttt{lettre} et \texttt{fin} sont donc des chaînes de caractères.

\item Analysons la boucle du programme :
\begin{itemize}
\item \og \texttt{for i in debut:} \fg{} signifie que l'on parcourt la chaîne de caractères désignée par la variable \texttt{debut};

\item \og \texttt{if i != lettre:  fin += i} \fg{} signifie que si la lettre sur laquelle on est est différente de celle stockée dans la variable \texttt{lettre} (donc ici, \og r \fg) alors on concatène ce caractère à ce qui était stocké précédemment dans la variable \texttt{fin}.

Cette boucle a donc pour mission de construire une chaîne de caractères \texttt{fin} sur la base de la chaîne de caractères stockée dans \texttt{debut} en évitant tous les caractères \og r \fg.
\end{itemize}
\enlargethispage*{\baselineskip}

Ainsi, le programme affiche la phrase stockée dans \texttt{debut} en enlevant les \og r \fg, ce qui donne :
\begin{center}
\texttt{C'est un tou de vedue où chante une ivièe.}
\end{center}

\item Si on souhaite choisir la phrase de début et le caractère à enlever, on utilise la fonction \texttt{input} :

\begin{listing}{}{02-18-02.py}\end{listing}
\end{questions}
\end{corrige}

%%%%%%%%%%%%%%%%%%%%%%% 3 étoiles

%%% 19

\begin{exo}{Donner le rang d'un caractère}{\null}{3}{10} 
\enlargethispage*{0pt}
On souhaite créer un programme donnant tous les indexes d'un caractère donné dans une chaîne. On souhaite de plus afficher le message : \og rang pair \fg{}  dans le cas où l'index est pair.

Pour cela, on utilise le programme suivant :
\begin{listing}{}{02-19-01.py}\end{listing}

\begin{questions}
\item À quoi sert le booléen \texttt{presence} ?
\item Expliquer la syntaxe de la ligne : 
\begin{center}
\texttt{print("Le caractère",lettre,"est trouvé à l'index",str(i)+".")}.
\end{center}
\item Expliquer pourquoi le programme suivant ne convient pas :
\begin{listing}{}{02-19-02.py}\end{listing}
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item La valeur du booléen \texttt{presence} est par défaut égale à \textit{False}. Elle change dans la boucle si la condition \og \texttt{phrase[i] == lettre} \fg{} est vraie, c'est-à-dire si la lettre rencontrée est le caractère que l'on a entré au clavier.

Ainsi, \texttt{presence} vaut \textit{True} si on rencontre au moins une fois dans la variable \texttt{phrase} le caractère entré au clavier. Si le caractère n'est pas dans \texttt{phrase} alors il n'y a aucun affichage dans la boucle. Dans ce cas, l'utilisateur ne voit donc rien à l'écran et peut se poser des questions quant à l'exécution du programme. Il faut donc afficher que le caractère n'a pas été trouvé dans ce cas précis; c'est le but de la dernière partie du programme.

\item Le fait d'écrire dans la fonction \texttt{print} \og \texttt{"Le caractère",lettre} \fg{} affiche à l'écran le texte suivi de la valeur de la variable \texttt{lettre}, les deux étant séparés par un espace : la virgule permet de mettre un espace automatiquement.

Le fait de ne pas utiliser la virgule avant le point final signifie que l'on ne veut pas insérer un espace entre l'index de la lettre et ce point. C'est pourquoi on utilise la concaténation (avec le \og + \fg). 

Or, la concaténation suppose que les deux variables concaténées sont du même type, d'où la présence de \texttt{str(i)} pour convertir l'index (qui est une variable numérique) en chaîne de caractères.

\item Dans ce programme, la variable \texttt{i} est du type \textit{chaîne de caractères}; la boucle parcourt la variable \texttt{phrase} et dès que le caractère sur lequel on est correspond à la lettre cherchée, on affiche la réponse. Mais ici, \texttt{phrase.index(i)} correspond à l'index de la première occurrence trouvée de la variable \texttt{i} dans la variable \texttt{phrase}, donc  \texttt{phrase.index(i)} est une constante.
Ce programme affiche donc toujours le même index.

Par exemple, si on entre comme phrase :
\begin{center}
\ttfamily
Bonjour. Je m'appelle Kévin.
\end{center}

et si on recherche le caractère \og n \fg, ce dernier programme affiche :\enlargethispage*{3em}

\begin{center}
\ttfamily
Le caractère n est trouvé à l'index 2.

Le caractère n est trouvé à l'index 2.
\end{center}
\end{questions}
\end{corrige}

%================= PROGRAMMATION ET FONCTIONS

\sectionnn{Programmation et fonctions}

%%%%% 1 étoile

%%% 20

\begin{exo}{Dans la tirelire de Clément}{\null}{1}{5} 
Clément a \numprint{100} \euro dans sa tirelire. Chaque semaine, il dépense 10\% de ce qu'il y a dans sa tirelire. Il souhaite savoir combien il possèdera après 10 semaines. 

Compléter le programme suivant afin qu'il affiche le résultat souhaité.
\begin{listing}{}{02-20-01.py}\end{listing}
\end{exo}

\begin{corrige}
\begin{listing}{}{02-20-02.py}\end{listing}

\Par

Explications : 

\begin{itemize}
\item la première ligne doit affecter à la variable \texttt{somme} la somme que possède Clément au début, donc 100 \euro;
\item la boucle doit s'exécuter 10 fois car nous souhaitons savoir la somme qu'il reste à Clément après 10 semaines; on utilise donc \og \texttt{range(10)} \fg;

\item le calcul de \texttt{somme} dans la boucle repose sur le fait que, quand on enlève 10\% à \texttt{somme}, il reste 90\% de \texttt{somme}. 

\og \texttt{somme *= 0.9} \fg{} signifie que l'on multiplie par 0,9 le nombre stocké dans la variable \texttt{somme}. C'est bien ce que l'on veut.
\end{itemize}
\end{corrige}

%%% 21

\begin{exo}{Somme des premiers entiers}{\null}{1}{5} 
On souhaite créer une fonction Python qui affiche le résultat de l'opération :
\[1+2+3+4+5+6+\cdots + n \]
où $n$ est l'argument de la fonction.

Compléter l'algorithme suivant afin de satisfaire cette requête.

\begin{listing}{}{02-21-01.py}\end{listing}
\end{exo}

\begin{corrige}
\begin{listing}{}{02-21-02.py}\nathanliveProgWithoutText\end{listing}

\Par%\enlargethispage*{\baselineskip}

Explications :

\begin{itemize}
\item on part de $s=0$ car la première somme possible est pour le premier entier naturel $n$ possible, à savoir 0, et dans ce cas, la somme vaut 0;

\item on doit parcourir l'ensemble $\{0;1;2;3;\cdots;n\}$, c'est-à-dire $n+1$ valeurs, d'où l'instruction \og \texttt{range(n+1)} \fg;

\item dans la boucle, afin de calculer la somme, on doit ajouter à la valeur de \texttt{s} déjà stockée celle de \texttt{i}, d'où l'instruction \og \texttt{s += i} \fg{} (que l'on peut aussi écrire : \texttt{s = s + i}).
\end{itemize}
\end{corrige}

%%%%%%%%%%%%%%%%%%%%%%%%%% 2 étoiles

%%% 22

\begin{exo}{Le programme mystère}{\null}{2}{10} 

On donne page suivante un programme Python fort mystérieux.

\Par

Quel est son rôle ?

\newpage

\begin{listing}{}{02-22.py}\end{listing}
\end{exo}

\begin{corrige}
\begin{itemize}
\item L'instruction \og \texttt{for i in range(len(phrase)):} \fg{} nous informe que l'on souhaite parcourir la chaîne de caractères \texttt{phrase}.

\item L'instruction \og \texttt{presence = False} \fg{} définit un booléen qui est faux par défaut lorsque l'on entame chaque étape de la boucle.

\item L'instruction \og \texttt{for j in (range(len(lettres))):} \fg{} nous informe que l'on parcourt la chaîne de caractères \texttt{lettres}.

\item L'instruction \texttt{if phrase[i] == lettres[j]} est un test pour savoir si le caractère sur lequel on est pour la chaîne \texttt{phrase} est identique au caractère sur lequel on est pour la chaîne \texttt{lettres}. Si tel est le cas, le booléen \texttt{presence} vaut \textit{True}.

\item Une fois que l'on a parcouru la chaîne \texttt{lettres}, si le booléen \texttt{presence} vaut \textit{False} (c'est-à-dire si aucun caractère de \texttt{lettres} n'a été trouvé dans \texttt{phrase}) alors on concatène à \texttt{lettres} le caractère de \texttt{phrase} sur lequel on est, précédé d'un point-virgule, si l'index ne vaut pas 0; si l'index vaut 0, alors on concatène à \texttt{lettres} directement le caractère de \texttt{phrase} sur lequel on est.
\end{itemize}

À la vue de ceci, ce programme a pour objectif de lister tous les caractères utilisés dans la variable \texttt{phrase} une et une seule fois, et d'afficher tous ces caractères séparés par des points-virgule.
\end{corrige}

%%%%%%%%%%%%%%%%%%%%%%%%%%%% 3 étoiles

%%% 23

\begin{exo}{Le jeu du \og plus \fg{} ou \og moins \fg}{\null}{3}{15} 
\label{video:plusoumoins}
\nathanliveVideo

Le jeu du \og plus \fg{} ou \og moins \fg{} consiste à deviner un nombre en faisant de multiples propositions de nombres, auxquelles une personne répond par \og plus \fg{} si le nombre à deviner est plus grand que la proposition, et par \og moins \fg{} si le nombre à deviner est moins grand.

Nous souhaitons créer un programme Python qui :

\begin{itemize}
\item choisit au hasard un nombre entier entre 1 et 100 (compris);
\item demande un nombre autant de fois que nécessaire jusqu'à trouver le nombre choisi au hasard;
\item affiche \og plus \fg{} quand le nombre à trouver est supérieur à la proposition faite;
\item affiche \og moins \fg{} quand le nombre à trouver est inférieur à la proposition faite;
\item compte le nombre de propositions faites et l'affiche à la fin.
\end{itemize}

Pour cela, il faudra faire appel au module \texttt{random} qui permet de choisir un nombre entier entre deux nombres $a$ et $b$ comme ceci :

\Par

\begin{tabularx}{\linewidth}{@{\hspace{5mm}}>{\ttfamily}X}
import random\\
nombre = random.randint(a,b)
\end{tabularx}

\Par

Il nous faut aussi utiliser une boucle \texttt{while}.

\Par

Proposer un tel programme.
\end{exo}

\begin{corrige}
%%%\enlargethispage*{3em}
\begin{listing}{}{02-23.py}
%%%\nathanliveProgWithoutText
\end{listing}

\rput(-0.4,7.9){\nathanliveProgWithoutText}

\newpage

Explications :

\begin{itemize}
\item on commence par choisir un nombre au hasard entre 1 et 100 avec l'instruction \texttt{nombre = random.randint(1,100)};

\item on initialise les variables \texttt{n} (représentant le nombre entré au clavier) et \texttt{count} (représentant le nombre de propositions faites) à 0;

\item tant que le nombre proposé est différent du nombre choisi aléatoirement (\texttt{while n != nombre}), on exécute les instructions qui suivent;

\item on incrémente le compteur \texttt{count} (on lui ajoute 1 à chaque fois) et on demande d'entrer un nombre;

\item si le nombre proposé est égal au nombre choisi aléatoirement alors on a gagné. Si le nombre de coup(s) est égal à 1, alors on définit la terminaison du mot \og coup \fg{} par une chaîne vide, sinon cette terminaison est un \og s \fg. On affiche alors la phrase finale en incluant le nombre de coup(s);

\item si le nombre proposé n'est pas le nombre choisi aléatoirement alors il est soit plus petit (\texttt{nombre > n}) -- auquel cas on affiche \og Plus ! \fg{} -- soit plus grand (\texttt{nombre < n}) et dans ce cas, on affiche \og Moins ! \fg{} 
\end{itemize}
\end{corrige}

\thumb
\AfficheCorrige
