\thumb

\begin{qcm}{Vérification de connaissances}{10}
\label{04-qcm1}
Pour chacune des questions suivantes, plusieurs propositions de réponses sont faites dont une seule est correcte. Laquelle ?

\begin{questions}
\item On définit la classe \texttt{identite} de la manière suivante :

\begin{listing}{}{04-qcm-q1.py}\end{listing}

\Par

Si on tape :

\Par

{\ttfamily
\pychevrons hugo = identite('Hugo' , 'Dupont' , 1999)\\
\pychevrons print( hugo.age(2020) )
}

\Par

que s'affiche-t-il ?

\Par

\begin{tabularx}{\linewidth}{@{}XXXX@{}}
\choix 'Hugo' & 
\choix 'Dupont' &
\choix 1999 &
\choix 21
\end{tabularx}

\item On définit la classe \texttt{voiture} de la manière suivante :

\begin{listing}{}{04-qcm-q2.py}\end{listing}

\Par

Si on tape :

\Par

{\ttfamily
\pychevrons F430 = voiture('Ferrari' , 'Rouge' , 43)\\
\pychevrons print(F430.nc())
}

\Par

que s'affiche-t-il ?\resetchoix

\Par

\begin{tabularx}{\linewidth}{@{}XX@{}}
\choix 'Ferrari Rouge'
&
\choix Une erreur
\end{tabularx}

\newpage

\item Qu'affiche le programme suivant ?\resetchoix

\begin{listing}{}{04-qcm-q3.py}\end{listing}

\Par

\begin{tabularx}{\linewidth}{@{}XXX@{}}
\choix Une erreur
&
\choix True
&
\choix False
\end{tabularx}

\end{questions}
\end{qcm}

\begin{corrige}
\begin{questions}
\item Réponse \choix[d]. En effet, la méthode calcule la différence entre la valeur de l'argument \texttt{a} et la valeur de \texttt{self.an}, qui correspond à l'année (sans doute de naissance) de Hugo. Il s'agit donc ici de $2020-1999=21$.

\item Réponse \choix[b]. En effet, dans la déclaration de la méthode \texttt{nc}, les\linebreak variables \texttt{nom} et \texttt{couleur} ne sont pas définies. Il aurait fallu écrire\linebreak \texttt{self.nom + self.couleur} pour que cela soit correct.

Rappelons que la déclaration d'une méthode peut faire appel:

\begin{itemize}
\item à des variables locales (qui doivent être initialisées avant utilisation et qui sont \og détruites \fg{} à la fin de la méthode);

\item à des attributs de l'objet lui-même qui  \og appartiennent \fg{} à l'objet, qui sont partagés entre toutes les méthodes, et qui subsistent en mémoire jusqu'à ce que l'objet lui-même soit détruit. Dans ce cas, il faut y faire référence en utilisant le paramètre \texttt{self}, qui est le premier argument de toute méthode.
\end{itemize}

\item Réponse \choix[b]. Ici, tout est correctement défini. Ainsi, la méthode\linebreak \texttt{is}\verb+_+\texttt{square} regarde si $a^2+b^2$ est bien égal à $c^2$, ce qui est le cas pour notre exemple. \og True \fg{}  est donc affiché.
\end{questions}
\end{corrige}


%%%%%%%%%%%%%%%

\begin{vf}{Vérification des connaissances}{10} % titre , temps
\label{04-vf2}
Les affirmations suivantes sont-elles vraies ou fausses ? Justifier la réponse.

\begin{questions}
\item \textit{La programmation dynamique.}
\begin{questions}
\item La mémoïsation est une forme itérative.

\item La programmation dynamique consiste à résoudre des problèmes, de celui qui a la taille la plus petite vers celui qui a la taille la plus grande.

\item Un problème d'optimisation où la variable peut être réelle peut être résolu en utilisant la programmation dynamique.

\item Le problème du rendu de monnaie est un problème classique qui ne peut être résolu que par programmation dynamique.
\end{questions}

\item \textit{La Programmation Orientée Objet (POO).}

\begin{questions}
\item Les variables d'une classe sont appelées des \textit{méthodes}.

\item Dans une classe, la définition d'une méthode \verb+_+\verb+_+\texttt{init}\verb+_+\verb+_+ n'est pas obligatoire.
\end{questions}
\end{questions}
\end{vf}

\begin{corrige}
\begin{questions}
\item \textit{La programmation dynamique.}

\begin{questions}
\item \textit{Faux}. La mémoïsation, ou Top Down, est une forme récursive.

\item \textit{Faux}. La technique décrite dans la question est celle du Bottom Up. La programmation dynamique, quant à elle, consiste à découper un problème en plusieurs sous-problèmes de tailles inférieures et en utilisant l'une des techniques Bottom Up ou Top Down pour les résoudre.

\item \textit{Faux}. La programmation dynamique ne sert que lorsque la variable est entière.

\item \textit{Faux}. Nous avons vu dans le cours qu'il existait d'autres façons que la programmation dynamique pour résoudre le problème du rendu de monnaie, comme l'approche gloutonne ou diviser pour régner. Cependant, la programmation dynamique a pour objectif d'optimiser le code. C'est donc cette technique qui est préférable aux autres car elle nécessite moins d'opérations de calcul et de traitement que les autres.
\end{questions}

\item \textit{La Programmation Orientée Objet (POO).}

\begin{questions}
\item \textit{Faux}. Une \textit{méthode} est une \textit{fonction} d'une classe. Les \textit{attributs} sont les variables de la classe.

\item \textit{Vrai}. On peut tout à fait définir une classe sans la méthode \verb+_+\verb+_+\texttt{init}\verb+_+\verb+_+. En voici un exemple :
\begin{listing}{}{04-vf.py}\end{listing}
\Par
qui renvoie \og 50 \fg.

Le constructeur \_\_\texttt{init}\_\_ est rendu obligatoire dès lors qu'un paramètre est passé lors de l'appel de la classe (par exemple,\linebreak \texttt{d = toto(7)}) ou qu'il est nécessaire d'initialiser certains attributs dès la création de l'objet.
\end{questions}

\end{questions}
\end{corrige}

\newpage

\sectionnn{Classes}


%%%%%%%%%%%%%%%%

\begin{exo}{La classe \og Piece \fg}{Lycée Camille Jullian, Bordeaux}{1}{5} 
\label{exo:04-piece}
Voici un programme en Python :

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-classe-piece.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-classe-piece.py}\end{listing}

\Par

Expliquez en détail ce qu'il permet d'afficher.
\end{exo}

\begin{corrige}
La classe \texttt{Piece} est composée de deux méthodes.

\begin{itemize}
\item La méthode \texttt{alea} retourne simplement un nombre aléatoire de l'ensemble $\{0;1\}$.

\item La méthode \texttt{moyenne}, qui admet un attribut \texttt{n}, commence par définir une liste vide nommée \texttt{tirage}. Ensuite, une boucle itérative est créée, pour 100 itérations. Au cours de chacune d'elles, on insère dans la liste \texttt{tirage} le retour de la méthode \texttt{alea} (on insère donc \og 0 \fg{} ou \og 1 \fg{} $n$ fois).

Une fois la boucle finie, on retourne la valeur de \og \texttt{sum(tirage) / n} \fg, c'est-à-dire la somme des nombres contenus dans la liste \texttt{tirage} divisée par $n$ : il s'agit ici du calcul du nombre moyen de \og 1 \fg{} obtenus lors des $n$ choix aléatoires.
\end{itemize}

Ainsi, dans ce contexte, si on décide d'associer \og Pile \fg{} à \og 1 \fg{} lors du\linebreak lancer d'une pièce, le programme calcule le nombre moyen de \og Pile \fg{} sur 100 lancers.
\end{corrige}


%%%%%%%%%%%%%%%

\begin{exo}{\'Ecrire une classe}{Lycée Sophie Germain, Paris}{1}{10} 
\textit{Pour chacune des questions suivantes, un constructeur initialisant les\linebreak mesures devra être présent dans chacune des classes.}
\enlargethispage*{3em}
\begin{questions}
\item \'Ecrire une classe nommée \texttt{Carre} admettant la mesure des côtés d'un carré en attribut, avec deux méthodes:
\begin{itemize}
\item une méthode \texttt{perimetre} permettant de retourner le périmètre du carré;
\item une méthode \texttt{aire} permettant de retourner son aire.
\end{itemize}


\item \'Ecrire une classe \texttt{Triangle} représentant un triangle et admettant la mesure des trois côtés comme attributs, avec deux méthodes :
\begin{itemize}
\item une méthode \texttt{aire} renvoyant l'aire du triangle à l'aide de la formule de Héron : 
\[
\mathcal{A}=\sqrt{p(p-a)(p-b)(p-c)},
\]
où $a$, $b$ et $c$ sont les longueurs des trois côtés et où $p=\dfrac{a+b+c}{2}$;
\item une méthode \texttt{rect} qui renvoie \texttt{True} si le triangle est rectangle, et \texttt{False} sinon.
\end{itemize}

\item Définir alors un carré de côté 5, puis afficher son aire et son périmètre. Définir ensuite un triangle de côtés 5.4, 9 et 7.2 pour afficher son aire et regarder s'il est rectangle.
\end{questions}
\end{exo}

\begin{corrige}
\enlargethispage*{5em}
\begin{questions}
\item ~\par\vspace*{-25pt}
\qrset{height=1.1cm,version=5}\rput(-1,-1.3){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-ecrire-classe-q1.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-ecrire-classe-q1.py}\end{listing}

\newpage

\item  Une classe possible est la suivante:

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-ecrire-classe-q2.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-ecrire-classe-q2.py}\end{listing}

\item Définissons dans une console le carré et le triangle demandés.

\Par

\hrulefill

{\ttfamily
\pychevrons C = Carre(5)\\
\pychevrons C.aire() , C.perimetre()\\
(25, 20)\\
\pychevrons T = Triangle(5.4 , 9 , 7.2)\\
\pychevrons (T.aire() , T.rect())\\
(19.44000000000001, True)
}

\hrulefill

\Par

On voit ainsi que le triangle défini est rectangle et que son aire vaut $19,44$.


\begin{Remarque}
on pourrait améliorer légèrement l'affichage dans le cas où le triangle est rectangle.
\end{Remarque}

\Par


En effet, dans ce cas précis, pour \mbox{calculer} l'aire du triangle, on peut utiliser la formule $\dfrac{b \times h}{2}$, où $b$ et $h$ sont respectivement une base du triangle et la hauteur relative à cette base.

Ainsi, dans la méthode \texttt{aire}, on pourrait écrire le code page ci-contre.

\begin{aretenir}
Quel que soit le contexte d'un programme, il ne faut pas s'éloigner de ses règles. Si le programme concerne des mathématiques alors il faut utiliser les propriétés mathématiques pour optimiser le code.
\end{aretenir}

\newpage

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-ecrire-classe-q3.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-ecrire-classe-q3.py}\end{listing}
\end{questions}
\end{corrige}


%%%%%%%%%%%%%%%%

\begin{exo}{Devinette et remplissage}{Lycée François Villon, Les Mureaux}{1}{10} 
On considère la classe \texttt{mystere} définie de la manière suivante:

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-devinette-classe.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-devinette-classe.py}\end{listing}

\begin{questions}
\item Que fait le programme suivant ?
\begin{listing}{}{04-devinette-q1.py}\end{listing}

\item Ajoutez à cette classe une méthode  \texttt{ecc} qui crée et renvoie  une liste dont les éléments sont les cumuls de ceux de l'attribut \texttt{Liste} de la classe.

Par exemple, si \texttt{Liste = [1,2,4,5]}, \texttt{ecc} doit retourner: 
\begin{center}
\texttt{[1, 3 ,7, 12]}.
\end{center}
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item \texttt{L.Liste} est \textit{a priori} une liste (d'après la ligne : \texttt{self.Liste = [ ]}).

Ainsi, l'affichage sera une liste. Regardons maintenant de plus près la définition de la fonction \texttt{add}:

\begin{itemize}
\item avant tout, si l'argument \texttt{x} est supérieur ou égal au dernier élément de la liste ou si la liste est vide, on ajoute la valeur de \texttt{x} à la liste;

\item sinon, si \texttt{x} contient une valeur strictement plus petite que le premier élément de la liste, on place la valeur de \texttt{x} en tête de la liste;

\item dans les autres cas, on parcourt la liste et on teste si la valeur contenue dans \texttt{x} est comprise entre deux valeurs de la liste. Si tel est le cas, on insère cette valeur entre les deux autres valeurs.
\end{itemize}

On peut alors dire que la fonction \texttt{add} ajoute la valeur de l'argument tout en faisant en sorte que la liste soit rangée dans l'ordre croissant.

\Par

Ainsi, le programme proposé affichera :
\Par
\begin{center}
\texttt{[7, 10, 50, 78, 89]}
\end{center}

\newpage

\item Voici une proposition pour la méthode \texttt{ecc}:

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-devinette.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-devinette-q2.py}\end{listing}

\Par

Ici, on commence par créer une liste \texttt{E} dont le seul élément est le\linebreak premier de la liste \texttt{self.Liste}, puis on parcourt \texttt{self.Liste} à\linebreak partir du deuxième élément : pour chaque nombre d'index \texttt{i}, on lui ajoute \texttt{E[i-1]} et on stocke le résultat à la fin de la liste \texttt{E}, donc dans \texttt{E[i]}.

La boucle terminée, on retourne \texttt{E}, qui est la liste de tous les cumuls.

\begin{Remarque}
en statistiques, on appelle ces nombres les \textit{effectifs cumulés croissants}.
\end{Remarque}
\end{questions}
\end{corrige}

%%% NEW 2025

\begin{exo}{Une classe \og Livre \fg}{Lycée François Mauriac, Bordeaux}{1}{10}
On définit une classe \texttt{Livre} de la manière suivante:

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-livre.py}}}
\vspace*{-10pt}

\begin{listing}{}{04-livre.py}\end{listing}

\begin{questions}
\item Dans le programme ci-dessus,
\begin{questions}
\item Combien a-t-on défini d'instances ? Quelles sont-elles ?
\item Combien la classe \texttt{Livre} a-t-elle d'attributs? Citez-les.
\item Combien la classe \texttt{Livre} a-t-elle de méthodes? Citez-les en précisant leur rôle.
\end{questions}

\item Qu'affiche le programme?
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item 
\begin{questions}
\item Dans le programme, il y a trois instances:
\begin{verbatim}
livre1 = Livre("1984", "George Orwell")
livre2 = Livre("La Ferme des animaux", 
		"George Orwell")
livre3 = Livre("Le théorème du Perroquet",
		"Denis Guedj")
\end{verbatim}

\item La classe \texttt{Livre} a deux attributs : \texttt{titre} et \texttt{auteur}.

\item  La classe \texttt{Livre} a deux méthodes : 
\begin{itemize}
\item \texttt{afficher\_infos(self)} : une méthode qui affiche les informations du livre sous la forme \og Titre : [titre], Auteur : [auteur] \fg;
\item \texttt{meme\_auteur(self, autre\_livre)} : une méthode qui prend un autre objet de type \texttt{Livre} en paramètre et retourne \texttt{True} si les deux livres ont le même auteur, sinon \texttt{False}.
\end{itemize}
\end{questions}

\item Le programme affiche \og False \fg{} car \texttt{livre1} et \texttt{livre3} n'ont pas le même auteur.
\end{questions}
\newpage
\end{corrige}

%%% NEW 2025

\begin{exo}{Compte bancaire}{Lycée Richelieu, Versailles}{1}{20}
\enlargethispage*{3em}
On souhaite implémenter une classe \texttt{Compte\_bancaire} telle que les instances de \texttt{Compte\_bancaire} possèdent un seul
attribut \texttt{solde} (pouvant être positif ou négatif) ainsi que les méthodes suivantes :
\begin{itemize}
\item une méthode \texttt{transferer} pour transférer un montant X positif vers une instance B de \texttt{Compte\_bancaire} ;
\item une méthode \texttt{prelever} pour prélever un montant X positif depuis une instance B de \texttt{Compte\_bancaire} ;
\item une méthode \texttt{etat\_solde} pour renvoyer \og Positif \fg, \og Négatif \fg{} ou \og Nul \fg{} lorsqu’on lui demande l’état du compte.
\end{itemize}
Dans ce qui suit, on considère que le code sera écrit et indenté à l’intérieur d’un bloc commençant par \texttt{class Compte\_bancaire}.

\begin{questions}
\item Écrire la méthode \texttt{\_\_init\_\_} en précisant si nécessaire le ou les arguments à utiliser.
\item Écrire la méthode \texttt{etat\_solde} en précisant si nécessaire le ou les arguments à utiliser.
\item Soit A une variable recevant une instance de \texttt{Compte\_bancaire} :\linebreak \texttt{A = Compte\_bancaire(1000)}.

Prévoir le résultat de l’instruction suivante : \texttt{A.etat\_solde()}.
\item 
\begin{questions}
\item Écrire la méthode \texttt{transferer}.
\item Écrire la méthode \texttt{prelever}.
\item Écrire les instructions permettant de modéliser toutes les
étapes de la situation suivante :
\begin{itemize}
\item un compte bancaire A contient \numprint{1000} \euro;
\item un autre compte bancaire B contient \numprint{5000} \euro;
\item le compte bancaire B prélève \numprint{1100} \euro le compte A ;
\item le solde du compte A est affiché (avec un \texttt{print}).
\end{itemize}
\end{questions}
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item Le constructeur de la classe peut être le suivant:

\begin{listing}{}{04-compte-init.py}\end{listing}

\item La méthode \texttt{etat\_solde} peut être définie comme suit:

\begin{listing}{}{04-compte-etat.py}\end{listing}

\item Le résultat est le suivant:

\hrulefill

\bgroup
\ttfamily

\pychevrons A = Compte\_bancaire(1000)

\pychevrons A.etat\_solde()

"Positif"
\egroup

\hrulefill

\item
\begin{questions}
\item La méthode \texttt{transférer} peut être définie ainsi:\vspace*{-3mm}

\begin{listing}{}{04-compte-transferer.py}\end{listing}

\Par\Par

\item La méthode \texttt{prelever} peut être définie ainsi:\vspace*{-3mm}

\begin{listing}{}{04-compte-prelever.py}\end{listing}

\Par\Par

\item La suite d'instructions peut être la suivante:\vspace*{-3mm}\enlargethispage*{\baselineskip}

\hrulefill

\bgroup
\ttfamily
A = Compte\_bancaire(1000)


B = Compte\_bancaire(5000)

B.prelever(1100, A)

print(A.solde)
\egroup

\hrulefill
\end{questions}
\end{questions}

\end{corrige}


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


%%%%%%%%%%% 

\begin{exo}{La classe \og Temps \fg}{Lycée Sainte-Clotilde, Strasbourg}{2}{25} 
\index{Classe!Temps}
En Python, écrire une classe \texttt{Temps} qui permet de définir un horaire au format $\rm hh:mm:ss$ et qui admet les méthodes suivantes:
\begin{itemize}
\item \texttt{affiche}, qui affiche l'horaire au format \og 12 h 37 min 45 s \fg;

\item \texttt{add}, qui ajoute deux horaires de la classe \texttt{Temps};

\item \texttt{sub}, qui calcule la différence entre deux horaires de la classe \texttt{Temps}.
\end{itemize}
\end{exo}

\begin{corrige}
Une définition possible de la classe \texttt{Temps} est la suivante:\vspace*{-3mm}

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-classe-temps.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-classe-temps.py}\end{listing}

\Par

Avec cette définition, voici ce que l'on peut obtenir:

\hrulefill\\
\texttt{\pychevrons t1, t2 = Temps(8,45,37), Temps(15,31,18)}\\
\texttt{\pychevrons (t1+t2).affiche(), (t1-t2).affiche()}\\
\texttt{'24 h 16 min 55 s' , '6 h 45 min 41 s'}

\hrulefill


\end{corrige}



%%%%%%%%%%%%%%%%%

\begin{exo}{Classes \og Mot \fg et \og Phrase \fg}{Lycée Raoul Follereau, Nevers}{2}{30} 
On donne page ci-contre la classe \texttt{Mot}.
\begin{questions}
\item Indiquer ce que fait la fonction \texttt{fctA()} définie par :
\begin{listing}{}{04-classe-mot-q1.py}\end{listing}
\end{questions}

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-classe-mot.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-classe-mot.py}\end{listing}

\begin{questions}
\setcounter{enumi}{1}
\item Indiquer ce que fait la fonction \texttt{fctB()} définie par :
\begin{listing}{}{04-classe-mot-q2.py}\end{listing}
\end{questions}



On souhaite écrire une classe \texttt{Phrase}. Toutes les questions suivantes porteront sur cette classe.

\begin{questions}
\setcounter{enumi}{2}
\item \'Ecrire un constructeur qui définit une liste \texttt{self.mots} remplie de tous les mots de la phrase passée en paramètre, chacun des mots devant être de classe \texttt{Mot}.

\item \'Ecrire deux méthodes \texttt{doReverse} et \texttt{value} telles que la fonction \texttt{fctC()} suivante :
\begin{listing}{}{04-classe-mot-q4.py}\end{listing}
\Par
affiche : 
\begin{center}
\og mortels sont hommes les Tous \fg
\end{center}

\item \'Ecrire une méthode \texttt{doShuffle} afin que la fonction suivante:
\begin{listing}{}{04-classe-mot-q5.py}\end{listing}
\Par
affiche les mots de la phrase \og Tous les hommes sont mortels \fg{} dans un ordre aléatoire.

\item On définit la méthode \texttt{motAt} de la manière suivante:
\begin{listing}{}{04-classe-mot-q6a.py}\end{listing}
\Par
Que fait la fonction \texttt{fctE()} suivante ?
\begin{listing}{}{04-classe-mot-q6b.py}\end{listing}

\item On définit la méthode \texttt{insert} de la manière suivante:
\begin{listing}{}{04-classe-mot-q7a.py}\end{listing}
\Par
Que fait la fonction \texttt{fctF()} suivante ?
\begin{listing}{}{04-classe-mot-q7b.py}\end{listing}

\item On définit la méthode \texttt{remove} de la manière suivante:
\begin{listing}{}{04-classe-mot-q8a.py}\end{listing}
\Par
Que fait la fonction \texttt{fctG()} suivante ?
\begin{listing}{}{04-classe-mot-q8b.py}\end{listing}
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item L'instruction \og \texttt{m = Mot("Socrate")} \fg{} définit dans un premier temps un objet \texttt{Mot} comme étant la chaîne de caractères \og Socrate \fg. 

Ensuite, \og \texttt{m.doReverse()} \fg{} fait appel à la méthode \texttt{doReverse} de la classe \texttt{Mot} qui, comme son nom l'indique, transforme la chaîne de caractères en inversant les lettres. 

Enfin, \og \texttt{print(m.value())} \fg{} affiche ce qui est contenu dans \texttt{self.m} de la classe \texttt{Mot}, donc affiche ici : \og etarcoS \fg{} (le mot écrit à l'envers).

\item Comme dans la fonction précédente, on commence par définir un\linebreak objet de classe \og Mot \fg, puis on fait appel à la méthode \texttt{doShuffle} qui retourne une anagramme du mot.

La fonction \texttt{fctB()} affiche donc une anagramme de \og Socrate \fg.

\item Un constructeur possible est le suivant :

\begin{listing}{}{04-classe-phrase-constr.py}\end{listing}

\Par

On commence par définir une liste \texttt{L} composée de tous les mots de la phrase passée en paramètre avec la méthode \texttt{split} : à ce stade, les mots se sont que des chaînes de caractères. Or, nous souhaitons que chaque mot soit de classe \texttt{Mot}. On parcourt alors cette liste et, à partir de chaque item, on définit un objet de classe \texttt{Mot} que l'on insère dans une liste \texttt{self.mots} (\og self \fg{} est indispensable pour lier cette nouvelle liste à l'objet de classe \texttt{Phrase} ainsi défini).

\item Une proposition de méthodes est la suivante:
\begin{listing}{}{04-classe-phrase-doreverse.py}\end{listing}
\Par
Dans la méthode \texttt{doReverse}, nous n'avons fait qu'inverser l'ordre des items de la liste \texttt{self.mots} avec l'opération \texttt{[::-1]}, et dans la\linebreak méthode \texttt{value}, nous avons initialisé une chaîne de caractères \texttt{result} comme étant vide, puis parcouru chaque item de la liste \texttt{self.mots} pour concaténer à \texttt{result} la chaîne de caractères correspondant à l'item (\texttt{m.value()}) en y ajoutant un espace afin qu'au final, \texttt{result}\linebreak représente la phrase.

\newpage

\item Ici, nous pouvons utiliser à nouveau la fonction \texttt{shuffle} du module \texttt{random}, ce qui donne:
\begin{listing}{}{04-classe-phrase-doshuffle.py}\end{listing}

\item Dans la fonction \texttt{fctE()}, on commence par définir une phrase, puis un mot \texttt{m} comme étant l'objet \texttt{Mot} en position 3 dans la phrase définie. Ici, il s'agit donc de \og sont \fg{} (attention : le premier mot est à la position 0, comme dans toute liste). Ensuite, on applique la méthode \texttt{doReverse} de la classe \texttt{Mot} au mot ainsi trouvé, ce qui a pour effet de mettre ses lettres dans le sens inverse.

On affiche ensuite la phrase ainsi obtenue, ce qui donne :

\Par

\begin{center}
Tous les hommes tnos mortels
\end{center}

\item Dans la fonction \texttt{fctE()}, on commence par définir une phrase, puis on fait appel à la méthode \texttt{insert} qui insère le mot \og ne \fg{} dans la phrase en position 3, c'est-à-dire après le 3\ieme{} mot de la phrase. On fait de même en position 5, c'est-à-dire après le 5\ieme{} mot : on y insère le mot \og pas \fg. Et enfin, on affiche la phrase ainsi obtenue, ce qui donne:

\Par

\begin{center}
Tous les hommes ne sont pas mortels
\end{center}

\item On commence par prendre le mot en position 4 dans la phrase, donc \og 
mortels \fg. On mélange ensuite les lettres dans ce mot en faisant appel à la méthode \texttt{doShuffle} de la classe \texttt{Mot}. Ensuite, on fait appel à la méthode \texttt{remove} de la classe \texttt{Phrase} en passant en paramètre le nombre 2 : on supprime alors le mot \og hommes \fg. Enfin, on insère en position 2 le contenu de la variable \texttt{m}, c'est-à-dire l'anagramme de \og mortels \fg{} obtenu précédemment. On affiche alors le résultat, ce qui donne par exemple:

\Par

\begin{center}
Tous les elmsort sont elmsort
\end{center}
\vspace*{-4mm}
\begin{Remarque}
le dernier mot n'est plus \og mortels \fg; en effet, nous avons définit \texttt{m} comme l'objet en position 4 dans l'objet \texttt{p}. Dès lors que l'on écrit \texttt{m.doShuffle}, cet objet est modifié dans l'objet \texttt{p}. Ainsi, à ce stade, l'objet \og mortels \fg{} n'existe plus mais il est remplacé par une anagramme de la chaîne de caractères qu'il représente.
\end{Remarque}

\Par

\qrset{height=1.1cm,version=5}\rput(-1,0){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-classes-mot-phrase.py}}}
\vspace*{-10pt}
\textit{Télécharger le programme complet à l'aide du QR code.}
\end{questions}
\newpage
\end{corrige}


%%% NEW 2025

\begin{exo}{Personnage d'un jeu vidéo}{Lycée André Theuriet, Civray}{3}{30} 
Vous êtes en train de développer un jeu vidéo et vous avez besoin de créer une classe pour représenter les personnages du jeu. Chaque personnage a un nom, un niveau, et des points de vie. Vous devez pouvoir créer des personnages, les faire gagner de l'expérience, et vérifier leur état de santé.

\textit{Instructions}:

\begin{questions}
    \item Créez une classe \texttt{Personnage} avec les attributs suivants :
        \begin{itemize}
            \item \texttt{nom} : une chaîne de caractères représentant le nom du personnage.
            \item \texttt{niveau} : un entier représentant le niveau du personnage.
            \item \texttt{points\_de\_vie} : un entier représentant les points de vie du personnage.
        \end{itemize}
        
        Ajoutez un constructeur \texttt{\_\_init\_\_} pour initialiser ces attributs.

    \item Implémentez les méthodes suivantes.
    \begin{questions}
        \item \texttt{gagner\_experience(self, experience)} : une méthode qui\linebreak prend un nombre d'expérience en paramètre et augmente le niveau du personnage en fonction de l'expérience gagnée. Supposons que chaque tranche de 100 points d'expérience augmente le niveau de 1.
        \item \texttt{est\_vivant(self)} : une méthode qui retourne \texttt{True} si le personnage a des points de vie supérieurs à 0, sinon \texttt{False}.
        \item \texttt{afficher\_etat(self)} : une méthode qui affiche les informations du personnage sous la forme \og Nom : [nom], Niveau : [niveau], Points de vie : [points\_de\_vie] \fg.
    \end{questions}

\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item La classe \texttt{Personnage} peut être définie avec son constructeur de la\linebreak manière suivante:

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-personnage-jeu-video.py}}}
\vspace*{-10pt}

\begin{listing}{}{04-personnage-init.py}\end{listing}

\item 
\begin{questions}
\item \begin{listing}{}{04-personnage-gagner.py}\end{listing}

\item \begin{listing}{}{04-personnage-vivant.py}\end{listing}

\item \begin{listing}{}{04-personnage-etat.py}\end{listing}
\end{questions}

\end{questions}
\end{corrige}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\newpage

\sectionnn{Programmation dynamique}

%%% NEW 2025

\begin{exo}{Découpe d'une chaîne}{Lycée Sainte-Anne, Brest}{1}{15}
Complétez le programme suivant:

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-decoupe-chaine-enonce.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-decoupe-chaine-enonce.py}\end{listing}

\Par

Le but de ce programme est de proposer une liste de plusieurs \og découpes \fg{} d'une chaîne de caractère selon un dictionnaire de mots fourni.

\Par


\hrulefill
\bgroup
\ttfamily

\pychevrons dictionnaire = \{

"chat", "chapeau", "au", "lait", "laitue", "eau", "tue", "lai"

\}

\pychevrons chaine = "chapeaulaitueau"

\pychevrons decoupes = decouper\_chaine(chaine, dictionnaire)

\pychevrons print("Découpes possibles :", decoupes)

Découpes possibles : 

[['chapeau', 'lai', 'tue', 'au'], 

['chapeau', 'laitue', 'au']]

\egroup
\hrulefill
\end{exo}

\begin{corrige}
\enlargethispage*{5em}
Voici le programme dument complété:

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-decoupe-chaine-complet.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-decoupe-chaine-complet-print.py}\end{listing}
\end{corrige}


%%%%%%%%%%%%%%%%%%

\begin{exo}{Modélisation d'une suite numérique}{Lycée François Mauriac, Bordeaux}{2}{20} 
On considère la suite numérique $(u_n)$ définie par ses deux premiers termes $u_0=1$, $u_1=2$ et par la relation de récurrence suivante:
\[
\forall\; n\in\N,\quad u_{n+2}=\dfrac{u_n}{u_{n+1}}.
\]
\'Ecrire un programme Python permettant de calculer $u_n$ pour un entier $n$ donné en utilisant la programmation dynamique (version Bottom Up et Top Down).
\end{exo}

\begin{corrige}
Une version Bottom Up du programme dynamique est la suivante :

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://https://idl-live.prepamath.fr/ILTNSI/04-modelisation-suiteBU.py}}}
\vspace*{-10pt}
\begin{listing}{Bottom Up}{04-modelisation-suiteBU.py}\end{listing}

\Par

Une version optimisée (en espace mémoire) est la suivante:

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-modelisation-suiteBUopt.py}}}
\vspace*{-10pt}
\begin{listing}{Bottom Up (optimisée en espace mémoire)}{04-modelisation-suiteBUopt.py}\end{listing}

\Par\enlargethispage*{\baselineskip}

Une version Top Down est la suivante :


\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-modelisation-suiteTD.py}}}
\vspace*{-10pt}
\begin{listing}{Top Down}{04-modelisation-suiteTD.py}\end{listing}

Une manière plus simple peut aussi être envisagée :

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-modelisation-suiteTDsimp.py}}}
\vspace*{-10pt}
\begin{listing}{Top Down}{04-modelisation-suiteTDsimp.py}\end{listing}
\end{corrige}

%%%%%%%%%%%%%%%%%%

\begin{exo}{Somme dans une suite numérique}{Lycée polyvalent Émile Zola, Aix-en-Provence}{3}{30} 
On définit une suite $(u_n)$ par son premier terme $u_0=1$ et par la relation de récurrence:
\[
\forall n\in\N,\quad u_{n+1}=\dfrac{1}{n+1}\sum_{k=0}^n (k+1) u_k.
\]
\begin{questions}
\item Calculer $u_1$, $u_2$ et $u_3$.
\item Proposer deux programmes permettant de calculer $u_n$ pour tout entier naturel $n$ en utilisant le paradigme de la programmation dynamique\linebreak (version Bottom Up et Top Down).
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item Bien que mathématique, et non informatique, cette question permet de comprendre le mode de génération des termes de la suite définie.
\begin{itemize}
\item $\displaystyle u_1 = u_{0+1}=\dfrac{1}{0+1}\sum_{k=0}^0 (k+1)u_k = u_0 = 1$;

\item $\displaystyle u_2 = u_{1+1} = \dfrac{1}{1+1}\sum_{k=0}^1 (k+1) u_k = \dfrac{1}{2}( 1u_0 + 2u_1 ) =  \dfrac{3}{2}$;

\item $\displaystyle\begin{aligned}[t]
u_3 & = u_{2+1}\\
&  = \dfrac{1}{2+1}\displaystyle\sum_{k=0}^2 (k+1) u_k \\
& = \dfrac{1}{3}( 1u_0 + 2u_1 + 3u_2 ) \\
& =  \dfrac{1}{3} \times \left(3+\dfrac{9}{2}\right) = \dfrac{5}{2}.
\end{aligned}$
\end{itemize}

\item La difficulté de ce genre de calcul réside dans la sommation. Il faut\linebreak penser à la stocker au même titre que les termes de la suite.

\enlargethispage*{5em}
\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-somme-suite.py}}}
\vspace*{-10pt}
\begin{listing}{Bottom Up}{04-somme-suite.py}\end{listing}

\newpage

L'idée ici est donc de stocker non pas un terme mais un couple constitué du terme $u_k$ et de la somme $u_0+2u_1+\cdots+(k+1)u_k$ pour pouvoir calculer par la suite $u_{k+1}$.

\Par

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-somme-suiteTD.py}}}
\vspace*{-10pt}
\begin{listing}{Top Down}{04-somme-suiteTD.py}\end{listing}
\end{questions}
\end{corrige}


%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

\begin{exo}{Le retour du problème du sac à dos}{Lycée Jean-Joseph Fourier, Auxerre}{3}{30} 
\label{exo:04-sacados}
\index{Sac à dos (problème du)}
Nous avons vu dans l'exercice \ref{exo:sac-a-dos-1} page \pageref{exo:sac-a-dos-1} ce en quoi consiste le problème du sac à dos. Nous en avons d'ailleurs donné une solution récursive de type \og diviser pour régner \fg.

\begin{questions}
\item Proposer une approche dynamique de type Bottom Up et Top Down de ce problème qui affiche uniquement la valeur maximale des objets.

Vérifier les programmes avec l'exemple où le poids maximal est $P = 10$ et où la collection d'objets est $E = \{ (5,7) ; (3,1) ; (3,4) ; (3,2) \}$.

\item Compléter l'approche Bottom Up (par exemple) afin d'afficher la\linebreak combinaison des objets retenus.

\item Que dire de la complexité de l'approche Bottom Up par rapport à celle de l'approche récursive initiale ?
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item Rappelons avant tout la fonction récursive initiale du problème : 

\begin{listing}{}{04-sac-a-dos-recur.py}\end{listing}

\begin{itemize}
\item \textit{Approche dynamique de type \og Top Down \fg}.

\Par

Pour améliorer cette fonction récursive, il nous faut mémoriser les\linebreak solutions aux sous-problèmes (mémoïsation). Nous allons donc\linebreak stocker les valeurs de \texttt{V[i][p]}, avec $0 \leqslant i \leqslant n$ et $0 \leqslant p \leqslant P$, où $P$ est le poids maximal autorisé, dans une liste nommée par exemple \texttt{temp}.

La solution est très proche de l'initiale.

\newpage


\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-sac-a-dosTD.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-sac-a-dosTD.py}\end{listing}

\Par\Par

Ce qui donne pour notre exemple:

\hrulefill
{\ttfamily

\pychevrons E, P = [ (5,7) , (3,1) , (3,4) , (3,2) ] , 10

\pychevrons initSac(E,P)

11
}

\hrulefill

\Par 

Cela signifie que la valeur maximale des objets que l'on peut mettre dans le sac est égale à 11 ($7 + 4$, avec un poids de $5+3=8$).

\item \textit{Approche dynamique de type \og Bottom Up \fg}.
\Par

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-sac-a-dos-dyn.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-sac-a-dos-dyn.py}\end{listing}

\Par

Avec cette approche, il n'y a plus de récursivité mais une itération.

On garde à peu près la même structure pour la fonction \texttt{sac}.

\Par

On obtient bien entendu le même résultat, à savoir \og 11 \fg.
\end{itemize}

\newpage

\item Comme nous pouvons le voir ici, ces solutions n'affichent que la valeur optimale. Le problème du sac à dos étant d'obtenir la combinaison des objets retenus, il nous faut compléter ces solutions.

Si on complète l'approche Bottom up, cela donne le programme suivant:\enlargethispage*{\baselineskip}

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-sac-a-dos-bottomup.py}}}
\vspace*{-10pt}
\begin{listing}{}{04-sac-a-dos-bottomup.py} \end{listing}

\Par

Ici, on ajoute une liste \texttt{garde} qui stocke le numéro des objets que l'on met dans le sac.


\item Dans l'approche récursive initiale, la complexité est en $O\big(2^n\big)$. En effet, deux appels récursifs sont fait pour $n$ objets.

\Par


Dans l'approche Bottom Up, elle est en $O(n \times P)$ car il y a deux boucles imbriquées portant sur $n$ et $P$, et qu'il y a le même nombre d'opérations élémentaires dans chacune d'elles.

\begin{attention}
Il ne faut pas conclure que la complexité est linéaire par rapport à $P$. En effet, la variable \texttt{P} est de taille $\log_2(P)$ et on peut alors écrire que le poids maximal est $P = 2^{\log_2(\texttt{P})}$. La complexité du programme dynamique est alors exponentielle par rapport à la taille de \texttt{P}. 

Cependant, elle reste meilleure que celle du programme initial.
\end{attention}
\end{questions}
\end{corrige}


%%% NEW 2025

\newpage

\begin{exo}{La civilisation Maya}{Extrait du Bac 2024, Métropole, septembre}{3}{45}
\textit{Cet exercice porte sur les bases de numération, la structure de données PILE
et la POO.}

\Par

La civilisation Maya est une ancienne civilisation de Mésoamérique principalement
connue pour ses avancées dans les domaines de l’écriture, de l’art, de
l’architecture, de l’agriculture, des mathématiques et de l’astronomie.

La numération Maya est une numération positionnelle de base 20 (dite vigésimale)
utilisant trois symboles pour former les « chiffres » :
\begin{itemize}
\item une coquille pour le zéro \includegraphics[height=1em]{106_maya-0},
\item un point pour l’unité \includegraphics[height=1em]{106_maya-point},
\item un trait pour la valeur 5 \includegraphics[height=1em]{106_maya-trait}.
\end{itemize}
Les « chiffres » sont les suivants. Ils utilisent une numération additive :
\begin{figure}

\Par

\begin{center}
\includegraphics{106_maya-1}
\figcaption{Table des « chiffres » et valeurs correspondantes\\
(source : Wikipédia)}
\end{center}
\end{figure}

\newpage

Dans une version simplifiée de ce système, l’écriture d’un nombre se fait par
empilement de « chiffres ». Chaque étage correspond à un chiffre de poids 20
fois supérieur au poids du chiffre de l’étage inférieur.

Ainsi la valeur du chiffre de l’étage le plus bas est multipliée par $20^0$ soit 1,
du second étage par $20^1$, du troisième étage par $20^2$, et ainsi de suite.

\begin{Exemple}
la représentation Maya de l’entier 407 est la suivante.
\begin{center}
\includegraphics{107_maya-2}
\end{center}
\end{Exemple}

\begin{questions}
\item Compléter le tableau donné en annexe à rendre avec la copie.
\item Justifier que l’écriture Maya de l’entier \numprint{3435} est :
\begin{figure}
\begin{center}
\includegraphics{107_maya-3}
\end{center}
\figcaption{Écriture Maya de l’entier \numprint{3435}}
\end{figure}
\end{questions}

On modélise l’écriture d’un entier dans sa représentation Maya par une pile
formée de listes. Chacune de ces listes est composée de trois entiers et modélise
le « chiffre » d’un étage :
\begin{itemize}
\item le premier entier vaut 0 ou 1 suivant s’il y a ou non une coquille ;
\item le deuxième représente le nombre de points ;
\item le troisième représente le nombre de traits.
\end{itemize}

Ainsi, la modélisation Maya de l’entier \numprint{3435} est :
\begin{center}
\ttfamily [[0, 0, 3], [0, 1, 2], [0, 3, 1]]
\end{center}
et celle de l’entier 407 est :
\begin{center}
\ttfamily [[0, 2, 1], [1, 0, 0], [0, 1, 0]].
\end{center}

Le sommet de la pile se situe en fin de liste. On dispose de la classe suivante :

\begin{listing}{}{04-class-Maya.py}\end{listing}

\begin{questions}
\setcounter{enumi}{2}
\item Écrire une suite d’instructions permettant de créer une instance, nommée
$M$, de la classe Maya qui modélise le nombre entier \numprint{3435}.
\item Écrire la méthode \texttt{nbEtages} de la classe \texttt{Maya}. Celle-ci renvoie le nombre de « chiffres » utilisés pour écrire le nombre correspondant en écriture Maya.
\end{questions}

\subsectionnn{De l’écriture Maya à l’écriture décimale}

\begin{questions}
\setcounter{enumi}{4}
\item Écrire une fonction \texttt{valeurChiffre} ayant pour paramètre une liste \texttt{L}. Celle-ci renvoie la valeur de l’entier associé à la liste \texttt{L = [c,p,t]} où \texttt{c} (de valeur 0 ou 1) indique la présence d’une coquille, \texttt{p} est le nombre de points et \texttt{t} le nombre de traits composant un « chiffre » Maya.

\begin{Exemple}
\begin{verbatim}
>>> valeurChiffre([0, 2, 3])
>>> 17
>>> valeurChiffre([1, 0, 0])
>>> 0
\end{verbatim}
\end{Exemple}

\item Recopier et compléter les lignes 2, 4, 5 et 7 de la méthode \texttt{MayaToDec}
suivante de la classe \texttt{Maya}. Cette méthode renvoie la valeur de l’entier
associé à l’objet \texttt{Maya}. On pourra utiliser les méthodes \texttt{estVide}, \texttt{nbEtages} et \texttt{retirer}.

\begin{listing}[style=numeros]{}{04-class-Maya-MayaToDec.py}\end{listing}
\end{questions}

\subsectionnn{De l’écriture décimale vers sa modélisation Maya}

On considère que la fonction \texttt{DecToVige} est déjà écrite. Celle-ci prend en
paramètre un entier $n$ et renvoie la décomposition en base 20 de celui-ci sous
la forme d’une liste $[a_0,a_1,\ldots,a_p]$ telle que :
\[
n = a_0 \times 20^0 + a_1 \times 20^1 + a_2 \times 20^2 + \cdots + a_p \times 20^p.
\]

\begin{Exemple}
\begin{verbatim}
>>> DecToVige(3435)
[15, 11, 8]
>>> DecToVige(407)
[7, 0, 1]
\end{verbatim}
\end{Exemple}

\begin{questions}
\setcounter{enumi}{6}
\item Écrire la fonction \texttt{decompChiffre} qui prend en paramètre un entier $n$
compris entre 0 et 19 et renvoie la liste \texttt{[c, p, t]} où \texttt{c} vaut 0 ou 1 et indique la présence ou non d’une coquille, \texttt{p} est le nombre de points et \texttt{t} le nombre de traits composant le \og chiffre \fg{} Maya correspondant.

\begin{Exemple}
\begin{verbatim}
>>> decompChiffre(17)
[0, 2, 3]
>>> decompChiffre(0)
[1, 0, 0]
\end{verbatim}
\end{Exemple}

\item Écrire la fonction \texttt{DecToMaya} qui prend en paramètre un entier $n$ et renvoie la modélisationMaya d’un objet \texttt{M} de la classe \texttt{Maya} correspondant.

\begin{Exemple}
\begin{verbatim}
>>> DecToMaya(3435).nombre
[[0, 0, 3], [0, 1, 2], [0, 3, 1]]
>>> DecToMaya(407).nombre
[[0, 2, 1], [1, 0, 0], [0, 1, 0]]
\end{verbatim}
\end{Exemple}
\end{questions}

\subsectionnn{Opérations sur les nombres en modélisation Maya}

On souhaite additionner des nombres directement à partir de leur modélisation
Maya.

\begin{questions}
\setcounter{enumi}{8}
\item Écrire la méthode \texttt{multiplie} de la classe \texttt{Maya} qui renvoie le résultat de la multiplication par 20 d’un nombre en modélisation Maya.

\begin{Exemple}
\begin{verbatim}
>>> M = Maya()
>>> M.ajouter([0, 0, 3])
>>> M.ajouter([0, 1, 2])
>>> M.multiplie().nombre
[[1, 0, 0], [0, 0, 3], [0, 1, 2]]
\end{verbatim}
\end{Exemple}
\end{questions}

On donne la fonction \texttt{mystere} suivante :

\begin{listing}{}{04-class-Maya-mystere.py}\end{listing}

\begin{questions}
\setcounter{enumi}{9}
\item Donner les résultats renvoyés par les deux appels suivants :
\begin{itemize}
\item \texttt{mystere([0, 1, 1], [0, 3, 1], 0)}
\item \texttt{mystere([0, 1, 1], [0, 4, 2], 0)}
\end{itemize}

\item Écrire une méthode \texttt{somme} de la classe \texttt{Maya} permettant d’ajouter à l’instance courante un autre nombre \texttt{maya2} de même taille en modélisation Maya.
\end{questions}

\subsectionnn{ANNEXE À RENDRE AVEC LA COPIE}

\Par

\begin{tabular}{|>{\centering\arraybackslash}Z{m{11mm}}|Z{m{13mm}}|m{30mm}|m{28mm}|}
\tabulartitle\hline
\bfseries 
Étage 
& 
\begin{minipage}{13mm} 
\begin{center}
\bfseries
Écriture Maya
\end{center}
\end{minipage}
& 
\begin{minipage}{30mm} 
\begin{center}
\bfseries
Valeur du « chiffre »\\
de l’étage
\end{center}
\end{minipage}
&
\begin{minipage}{28mm}
\begin{center}
\bfseries
Valeur dans la\\
conversion
\end{center}
\end{minipage}
\\
\hline
3 & \includegraphics{111_maya-annexe-1} & $1 \times 5 + 3 \times 1 = 8$ & $8\times20^2=\numprint{3200}$\\
\hline
2 & \includegraphics{111_maya-annexe-2} & &\\
\hline
1 & \includegraphics{111_maya-annexe-3} &  & \\
\hline
\end{tabular}
\end{exo}

\begin{corrige}
\begin{questions}
\item Le tableau complété est le suivant:
\begin{center}
\begin{tabular}{|>{\centering\arraybackslash}Z{m{11mm}}|Z{m{13mm}}|m{30mm}|m{28mm}|}
\tabulartitle\hline
\bfseries 
Étage 
& 
\begin{minipage}{13mm} 
\begin{center}
\bfseries
Écriture Maya
\end{center}
\end{minipage}
& 
\begin{minipage}{30mm} 
\begin{center}
\bfseries
Valeur du « chiffre »\\
de l’étage
\end{center}
\end{minipage}
&
\begin{minipage}{28mm}
\begin{center}
\bfseries
Valeur dans la\\
conversion
\end{center}
\end{minipage}
\\
\hline
3 & \includegraphics{111_maya-annexe-1} & $1 \times 5 + 3 \times 1 = 8$ & $8\times20^2=\numprint{3200}$\\
\hline
2 & \includegraphics{111_maya-annexe-2} & $2 \times 5 + 1 \times 1 = 11$ & $11\times20^1=220$ \\
\hline
1 & \includegraphics{111_maya-annexe-3} & $3\times5=15$ & $15^20^0=15$ \\
\hline
\end{tabular}
\end{center}

\item En additionnant les nombres trouvés précédemment, on a :
\[
\numprint{3200} + 220 + 15 = \numprint{3435}.
\]

\item Les instructions pour créer une instance de la classe \texttt{Maya} modélisant le nombre \numprint{3435} sont :
\begin{verbatim}
M = Maya()
M.ajouter([0, 0, 3])
M.ajouter([0, 1, 2])
M.ajouter([0, 3, 1])
\end{verbatim}

\item La méthode \texttt{nbEtages} de la classe \texttt{Maya} est :

\begin{listing}{}{04-class-Maya-nbEtages.py}\end{listing}

\item La fonction \texttt{valeurChiffre} est :

\begin{listing}{}{04-class-Maya-ValeurChiffre.py}\end{listing}

\item La méthode \texttt{MayaToDec} complétée est :

\begin{listing}{}{04-class-Maya-ToDec.py}\end{listing}

\item La fonction \texttt{decompChiffre} est :

\begin{listing}{}{04-class-Maya-decompChiffre.py}\end{listing}

\item La fonction \texttt{DecToMaya} est :

\begin{listing}{}{04-class-Maya-DecToMaya.py}\end{listing}

\item La méthode \texttt{multiplie} de la classe \texttt{Maya} est :

\begin{listing}{}{04-class-Maya-multiplie.py}\end{listing}

\item Les résultats renvoyés par les appels de la fonction \texttt{mystere} sont :
\begin{itemize}
\item \texttt{mystere([0, 1, 1], [0, 3, 1], 0)} renvoie \texttt{([0, 4, 2], 0)}
\item \texttt{mystere([0, 1, 1], [0, 4, 2], 0)} renvoie \texttt{([1, 0, 0], 1)}
\end{itemize}
Cette fonction renvoie en effet la somme de deux « chiffres » Mayas.

\item La méthode \texttt{somme} de la classe \texttt{Maya} est :

\begin{listing}{}{04-class-Maya-somme.py}\end{listing}
\end{questions}

\Par
\Par

\qrset{height=1.1cm,version=5}\rput(-1,0.2){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/04-class-Maya-Complete.py}}}
\textit{Téléchargez la classe complète.}
\end{corrige}











\thumb
\AfficheCorrige
