\thumb

\begin{qcm}{Vérification de connaissances}{5} % titre , temps

Pour chacune des questions suivantes, plusieurs propositions de réponses sont faites dont une seule est correcte. Laquelle ?

\begin{questions}
\item On souhaite insérer dans une structure de données les différentes\linebreak hauteurs d'un arbre au fil des années sans y insérer les années. La structure de données la plus adaptée en Python est:\vspace*{-3mm}

\begin{multicols}{2}
\choix une liste;

\choix un dictionnaire;

\choix une pile;

\choix une file.
\end{multicols}

\item\resetchoix Dans une administration, on souhaite insérer dans une structure de\linebreak données les doléances reçues afin de les traiter selon leur ordre\linebreak d'arrivée. On aura alors plutôt intérêt à les enregistrer dans:\vspace*{-3mm}

\begin{multicols}{2}
\choix une liste;

\choix un dictionnaire;

\choix une pile;

\choix une file.
\end{multicols}

\item\resetchoix Dans une association, on souhaite enregistrer une liste d'informations pour chaque adhérent : taille, poids, etc. La meilleure structure de\linebreak données pour cela est:\vspace*{-3mm}

\begin{multicols}{2}
\choix une liste;

\choix un dictionnaire;

\choix une pile;

\choix une file.
\end{multicols}

\item\resetchoix Pour un logiciel, on doit enregistrer la liste des actions dans une structure de données de sorte à voir la dernière action en priorité. On enregistrera donc les actions dans:\vspace*{-3mm}

\begin{multicols}{2}
\choix une liste;

\choix un dictionnaire;

\choix une pile;

\choix une file.
\end{multicols}
\end{questions}
\end{qcm}

\begin{corrige}
\begin{questions}
\item Réponse \choix[a]. Quand on observe l'évolution d'une quantité numérique, ce n'est en général pas pour sortir le premier ou le dernier élément en premier, donc pile et file sont à exclure. 

De plus, il n'y a pas d'association donc un dictionnaire est impossible. Seule la liste convient pour ce genre de problème.

\item Réponse \choix[d]. On enregistre les doléances selon le principe : \og première arrivée, première traitée \fg{} (\og first in, first out \fg, donc FIFO) ce qui\linebreak correspond à une file.

\item Réponse \choix[b]. Il s'agit ici d'enregistrer des associations, c'est-à-dire des éléments qui sont rattachés à d'autres (adhérents $\to$ informations) donc le dictionnaire est le plus adapté. Ici, les clés seront les adhérents et les valeurs seront les informations.

\item Réponse \choix[c]. Il s'agit en effet d'enregistrer les actions selon le principe : \og dernière action faite, première action affichée \fg ( \og last in, first out \fg, donc LIFO), ce qui correspond à une pile.
\end{questions}

\begin{aretenir}
\begin{itemize}
\item Liste : succession de données accessibles sans contrainte.
\item Pile (LIFO) : on imagine une pile de pièces où la dernière mise est la première à pouvoir être prise.
\item \textbf{F}ile (\textbf{F}IFO) : on peut penser aux files d'attente, où la première personne arrivée est la première à être servie.
\end{itemize}
\end{aretenir}
\end{corrige}




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

\begin{exo}{Fabricant de tee-shirts}{Lycée polyvalent Émile Zola, Aix-en-Provence}{1}{5} 
Un fabricant décide de créer des tee-shirts dont la taille peut-être  : XS, S, M, L, XL, XXL. À chaque taille son prix; il adopte le principe suivant : 8 \euro pour la taille XS et il ajoute 2 \euro en passant à la taille supérieure, jusqu'au XXL.

\begin{questions}
\item Implémenter en Python ces informations dans la structure de données la mieux adaptée.

\item Ce même fabricant décide de changer sa façon de fixer le prix de revente des tee-shirts. Ceux dont la taille est XS sont toujours à 8 \euro, mais cette fois-ci, pour passer d'une taille à la suivante, il ajoute au prix de la taille inférieure la moitié de sa racine carrée.

Par exemple, pour obtenir le prix des tailles S, il fait : 
\[
8 + \sqrt{8}\div2\approx9,41.
\]

Proposer un programme Python qui automatise ces calculs et les\linebreak enregistre dans une structure de données adaptée.
\end{questions}
\end{exo}

\begin{corrige}
Comme toujours, quand il s'agit d'associer deux entités (ici, taille et prix), on utilisera un dictionnaire.
\begin{questions}
\item On implémente le dictionnaire ainsi :

\Par\enlargethispage*{3em}

{\ttfamily
prix = \{ 

\qquad 'XS': 8, 'S': 10, 'M': 12, 'L': 14, 'XL': 16,

\qquad 'XXL': 18 

\}
}

\item Dans cette question, il faut imaginer un programme qui effectue les\linebreak calculs au fur et à mesure. On peut donc par exemple stocker les tailles dans une liste, puis créer le dictionnaire élément par élément à partir de cette liste comme dans la proposition page suivante.

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

\Par

Ce qui donne :

{\ttfamily

\{ 'XS': 8, 'S': 9.41, 'M': 10.94, 'L': 12.59,

\quad 'XL': 14.36, 'XXL': 16.25 \} }

\Par

\begin{Remarque}
la racine carrée d'un nombre $x$ peut s'écrire \texttt{x ** 0.5} car $\sqrt{x} = x^{1/2}$. %On peut aussi fait appel au module \texttt{math} et à sa fonction \texttt{sqrt}, mais pour si peu, ce n'est pas nécessaire.
\end{Remarque}
\end{questions}
\end{corrige}


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

\begin{exo}{Séparation opérations / nombres}{Lycée Camille Jullian, Bordeaux}{1}{5} 
On considère une chaîne de caractères représentant une expression arithmétique \texttt{E} contenant des chiffres et les opérations élémentaires (+, -, *, et /).


\'Ecrire une fonction Python \texttt{separe(E)} qui renvoie deux listes : la\linebreak première, nommée \textbf{\texttt{nombres}}, contenant les chiffres de \texttt{E} et la seconde,\linebreak nommée \textbf{\texttt{operations}}, contenant les opérations de \texttt{E}.

Par exemple, si \texttt{E} est la chaîne '3 + 5 * 7 - 2' alors \texttt{nombres = [3,5,7,2]} et \texttt{operations = ['+','*','-']}.
\end{exo}

\begin{corrige}
Il suffit ici de parcourir l'expression \texttt{E} est d'effectuer des tests pour savoir si le caractère rencontré est un nombre (avec la méthode \texttt{isdigit} par exemple), une opération, ou autre chose (en l'occurrence, une espace).

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



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

\begin{exo}{Nombre de parenthèses}{Lycée François Mauriac, Bordeaux}{1}{10} 
On considère une expression arithmétique qui peut contenir des parenthèses.
\begin{questions}
\item Écrire un algorithme permettant de vérifier qu’il y a autant de parenthèses ouvrantes que de parenthèses fermantes.

\item Implémenter en Python une fonction \texttt{controle(E)} qui renvoie \og True \fg{} si l’expression \texttt{E} comporte autant de parenthèses ouvrantes que fermantes, et « False » sinon.
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item Il s'agit ici de compter le nombre de parenthèses ouvrantes et fermantes. Rien de bien compliqué.

\begin{algorithme}{}
E est une expression arithmétique
f $\leftarrow$ 0 (nombre de parenthèses fermantes)
o $\leftarrow$ 0 (nombre de parenthèses ouvrantes)
Pour chaque élément i de E:
\quad Si i = "(":
\qquad o $\leftarrow$ o + 1
\quad Sinon:
\qquad Si i = ")":
\qquad\quad f $\leftarrow$ f + 1
\quad Fin du Si
\quad Si f = o:
\qquad Renvoyer True
\quad Sinon:
\qquad Renvoyer False
\end{algorithme}

\item Une implémentation possible est alors:

\begin{listing}{}{01-controleparentheses.py}
\end{listing}
\end{questions}
\end{corrige}

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


\begin{exo}{Bon parenthésage ?}{Lycée Sophie Germain, Paris}{1}{10} 
Une expression (algébrique ou arithmétique) est correctement parenthésée si d'une part, le nombre de parenthèses (et crochets) ouvrant.e.s et fermant.e.s est le même et si d'autre part les correspondances ne se croisent pas.

Par exemple, l'expression \og $\big[ 3 + (5 -7] * 3 \big)$ \fg{} n'est pas correctement\linebreak parenthésée car la parenthèse fermante ne peut pas venir après le crochet fermant.

\begin{questions}
\item \'Ecrire un algorithme qui s'aide d'une pile pour contrôler le bon\linebreak parenthésage d'une expression.

\item \'Ecrire en Python une fonction \texttt{is}\_\texttt{goodpar(E)} qui renvoie \og True \fg{} si l'expression \texttt{E} est correctement parenthésée, et \og False \fg{} dans le cas contraire.
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item Il s'agit ici d'empiler les crochets et parenthèses ouvrant.e.s et de dépiler quand on rencontre son équivalent fermant.

\Par

\begin{algorithme}{}
P est une pile vide
E est une expression

Pour chaque élément e de E:
\quad Si e = "(" ou e = "[":
\qquad e est empilé
\Break
\quad Si e = ")":
\qquad Si la tête de P est "(":
\qquad\quad On dépile "("
\qquad Sinon:
\qquad\quad Renvoyer False
\qquad Fin du Si (tête de P)
\quad Fin du Si e = ")"
\quad Si e = "]":
\qquad Si la tête de P est "]":
\qquad\quad On dépile "["
\qquad Sinon:
\qquad\quad Renvoyer False
\qquad Fin du Si (tête de P)
\quad Fin du Si e = "]"
Si P est vide:
\quad Renvoyer True
\end{algorithme}

\Par

\item Une implémentation de cet algorithme en Python est:

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

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

\begin{exo}{Implémentation d'une file}{Lycée Turgot, Paris}{1}{15} 
Le module \texttt{collections}, avec \texttt{deque}, permet d'implémenter une file. Ainsi, les instructions :

\Par

{\ttfamily
\pychevrons f = deque()

\pychevrons f.appendleft(1)

\pychevrons f.appendleft(2)

\pychevrons print(f)
}

\Par

enfile la valeur \og 1 \fg{} puis la valeur \og 2 \fg, et affiche : \og \texttt{deque([2,1]} \fg, qui représente la file.

\Par

\'Ecrire une fonction \texttt{enfile(liste,tuple)} qui admet pour arguments une liste \texttt{liste} (qui nous sert de file) et un tuple regroupant les éléments à enfiler dans l'ordre que l'on veut.

Par exemple,

\Par

{\ttfamily

\pychevrons f = []

\pychevrons f = enfile( f , (1,2) )

\pychevrons f = enfile( f , 3)
}

\Par

retourne la liste \texttt{[3,2,1]} (on a enfilé \og 1 \fg, puis \og 2 \fg, et enfin \og 3 \fg).
\end{exo}

\begin{corrige}
Une implémentation possible est celle proposée page suivante.

Ainsi, on aura par exemple:

{\ttfamily

\pychevrons f = [2,1] \textit{\# On initialise la file comme une liste}

\pychevrons f = enfile(f,(3,4)) \textit{\# On enfile 3, puis 4}
}

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

\end{corrige}


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

\begin{exo}{D'une liste à un dictionnaire}{Lycée François Villon, Les Mureaux}{1}{15} 
\'Ecrire en Python une fonction \texttt{list}\_\texttt{to}\_\texttt{dico(liste)} qui admet en\linebreak argument une liste de la forme \texttt{[clé1,valeur1,clé2,valeur2,...]} et qui retourne le dictionnaire correspondant de la forme:
\begin{center}
\texttt{\{ clé 1 : valeur 1, clé 2 : valeur 2, ... \}}.
\end{center}
\end{exo}

\begin{corrige}
Il s'agit ici de parcourir la liste donnée en argument en sautant un élément sur deux afin de mettre l'élément sauté en valeur.

Une fonction possible est alors la suivante:

\begin{listing}{}{01-ListeADico.py}
\end{listing}

Ce qui donne par exemple:

\Par

\hrulefill

{\ttfamily

\pychevrons L = [ 'France' , 'Paris' , 

... 'Angleterre' , 'Londres' ,

... 'Espagne' , 'Madrid' , 

... 'Allemagne' , 'Berlin' ]


\pychevrons print( liste\_to\_dico(L) )

\{'France': 'Paris', 

'Angleterre': 'Londres', 

'Espagne': 'Madrid', 

'Allemagne': 'Berlin'\}
}

\hrulefill
\end{corrige}


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

\begin{exo}{Chiffrement}{Lycée Sainte-Anne, Brest}{2}{15} 
La fonction \texttt{ord(<caractère>)} renvoie le point de code Unicode du\linebreak caractère spécifié. Par exemple, \og \texttt{ord('f')} \fg{} renvoie la valeur 102.

La fonction inverse est \texttt{chr(<entier>)}. Par exemple, \og \texttt{chr(102)} \fg{} renvoie \og f \fg.

Pour calculer $a$ modulo $n$, on utilise la syntaxe \og a \% n \fg.

Pour chiffrer un mot $M$, on décide de procéder ainsi: pour chaque\linebreak caractère $c$ de $M$,

\begin{itemize}
\item on calcule $3 \times \text{ord}(c) - 61$ modulo 91, puis on ajoute 33. Le résultat est noté $r$;

\item on trouve ensuite le caractère correspondant à $r$ avec \texttt{chr(r)} : on note ce caractère $c_1$.

\item si $r$ est pair, on calcule $2 \times \text{ord}(c) - 31$ modulo 91 puis on ajoute 33, et on trouve le caractère correspondant à ce résultat, noté $c_2$. Dans ce cas, le caractère $c$ est chiffré en $c_1c_2$;

\item si $r$ est impair, on calcule $2 \times \text{ord}(c) - 32$ modulo 91 puis on ajoute 33, que l'on transforme en son caractère $c_2$, puis on calcule $3 \times \text{ord}(c) - 60$ modulo 91 puis on ajoute 33, que l'on transforme en son caractère $c_3$. Le caractère $c$ est alors chiffré en $c_1c_2c_3$.
\end{itemize}

Par exemple, pour chiffrer \og P \fg{} :

\begin{itemize}
\item \texttt{ord('P') = 80}, donc on calcule :
\[
3 \times 80 - 61 \mod 89 = 179 \mod 91 = 88,
\]
puis on ajoute 33:
\[
r = 88+33 = 121,
\]
qui est impair et qui correspond à \texttt{chr(121)} = \og y \fg. Donc $c_1$ correspond au caractère: \og y \fg;

\item $r$ est impair donc on calcule:
\[
2\times 80-32\mod 91 = 37,
\]
puis on ajoute 33:
\[
37+33=70,
\]
qui correspond à $c_2 = \text{chr}(70) = $ \og F \fg{} ;

\item ensuite, on calcule:
\[
3\times80-60\mod 91=89
\]
puis on ajoute 33:
\[
89+33=122
\]
qui correspond à $c_3 = \text{chr}(122) = $ \og z \fg;

\item \og P \fg{} est donc chiffré en \og yFz \fg.
\end{itemize}

Afin d'optimiser le temps de cryptage, on souhaite implémenter une structure de données nous permettant d'obtenir le cryptage de tous les caractères dont le point de code Unicode est compris entre 32 et 122 compris.

\begin{questions}
\item Implémenter la structure de données adéquate.
\item Chiffrer le message : \og informatique \fg.
\end{questions}
\end{exo}

\begin{corrige}
\begin{questions}
\item 
\begin{methode}
On peut ici créer un dictionnaire où les clés seront les caractères dont le point de code Unicode est compris entre 32 et 122 et où les valeurs\linebreak seront les résultats des chiffrements.
\end{methode}

On obtient une implémentation comme celle-ci:

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

\Par

Ici, \texttt{crypt} est un dictionnaire auquel on pourra faire appel lors de tout chiffrement.

\item On peut utiliser le programme suivant:

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

\Par

On obtient alors le résultat suivant :

\begin{center}
\includegraphics{020_02-exo-chiffrement}
\end{center}
\end{questions}
\newpage
\end{corrige}


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

\begin{exo}{Labyrinthe}{Lycée Camille Claudel, Blois}{2}{15} 
\index{Labyrinthe}
Une manière d'implémenter un labyrinthe rectangulaire est de découper le rectangle en cases, puis de définir pour chaque case s'il y a un mur en haut, en bas, à gauche et à droite avec des booléens.

\Par

\begin{figure}
\begin{center}
\includegraphics{012_02-exo-labyrinthe}
\figcaption{Labyrinthe à implémenter en Python}
\end{center}
\end{figure}

\Par

Utiliser une structure de données adaptée afin d'implémenter ce labyrinthe selon cette façon de concevoir les choses.

On ne demande pas d'implémenter tout le labyrinthe, mais d'expliquer\linebreak comment on ferait, en donnant l'exemple de la première case (en haut à gauche).
\end{exo}


\begin{corrige}
\begin{methode}
On peut représenter la grille par une matrice \texttt{L}, où \texttt{L[i][j]} représente la case de la $(i+1)$-ième ligne en partant du haut (par exemple) et \mbox{$(j+1)$-ième} colonne en partant de la gauche (par exemple).

Ensuite, la valeur de chaque cellule est un dictionnaire dont les clés seront par exemple quatre booléens \texttt{top}, \texttt{bottom}, \texttt{left} et \texttt{right} représentant la présence ou l'absence de murs respectivement  en haut, en bas, à gauche et à droite. 
\end{methode}

On aura ainsi :

\Par

{\ttfamily
M[0][0] = \{  'top' : True , 'bottom' : False , 

\hspace*{2cm} 'left' : False , 'right' : True \}
}

\Par

Cette implémentation a le mérite d'être claire, mais peu pratique car assez longue à faire. Ainsi, pour alléger, on peut opter pour une liste de booléens dans chaque cellule, en convenant de garder le même ordre (mais l'ordre peut différer selon la logique de la personne qui programme). On aura alors :

\Par

{\ttfamily

M[0][0] = [ True , False , False , True]
}

\Par

ce qui est bien plus simple et rapide à écrire, mais cette redondance introduit un risque de discordance des informations, souvent à l'origine de bugs dans la pratique.
\Par\enlargethispage*{3em}
\textit{Remarque}: nous verrons plus tard qu'il existe d'autres façons, peut-être plus pratiques, de représenter un labyrinthe, notamment à l'aide d'une \textit{classe} (voir le chapitre sur la Programmation Orientée Objet).
\end{corrige}

%%%%%%%%%%%%%%%%%%% NEW 2025

\begin{exo}{Dictionnaire et recettes}{Lycée Henri Alain-Fournier, Bourges}{2}{15}

Vous souhaitez créer une petite application pour gérer une collection de recettes de cuisine. Chaque recette a un nom, une liste d'ingrédients, et des instructions de préparation. Vous devez permettre aux utilisateurs d'ajouter de nouvelles recettes, de rechercher une recette par son nom, et d'afficher les détails d'une recette.

Votre objectif est d'utiliser un dictionnaire pour stocker les recettes et implémentez les fonctions nécessaires pour manipuler cette collection.

\newpage

\textit{Instructions:}

\begin{questions}
    \item Créez un dictionnaire appelé \texttt{recettes} où chaque clé est le nom de la recette et chaque valeur est un autre dictionnaire contenant les informations suivantes :
    \begin{itemize}
        \item \texttt{ingredients} : Une liste des ingrédients nécessaires.
        \item \texttt{instructions} : Une chaîne de caractères décrivant les étapes de préparation.
    \end{itemize}
    \item Implémentez les fonctions suivantes :
    \begin{itemize}
        \item \texttt{ajouter\_recette(recettes, nom, ingredients, instructions)} : Ajoute une nouvelle recette au dictionnaire.
        \item \texttt{rechercher\_recette(recettes, nom)} : Recherche une recette par son nom et retourne ses détails.
        \item \texttt{afficher\_recettes(recettes)} : Affiche les noms de toutes les recettes disponibles.
    \end{itemize}
    \item Testez votre application en ajoutant quelques recettes, en recherchant une recette spécifique, et en affichant la liste des recettes.
\end{questions}
\end{exo}

\begin{corrige}
\enlargethispage*{5em}
Voici un programme répondant aux instructions:

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

\begin{listing}{}{01-recettes-print-1.py}\end{listing}

\newpage

\begin{listing}{}{01-recettes-print-2.py}\end{listing}

\textit{En scannant le QR Code, vous aurez un exemple d'utilisation en plus du programme ci-dessus.}

\end{corrige}

%%%%%%%%%%%%%%%%%%% NEW 2025

\begin{exo}{Gestion d'une bibliothèque}{Lycée François Mauriac, Bordeaux}{2}{20}
\index{dictionnaire}\index{bibliothèque}

Vous devez concevoir un système de gestion pour une bibliothèque. La bibliothèque possède plusieurs livres, et chaque livre a des informations associées telles que le titre, l'auteur, l'année de publication, et le nombre de copies disponibles. Vous devez permettre aux utilisateurs d'ajouter des livres, d'emprunter des livres, de rendre des livres, et de vérifier la disponibilité des livres.

\Par

Votre objectif est d'implémenter un système de gestion de bibliothèque en utilisant des dictionnaires imbriqués pour stocker les informations sur les livres et les opérations associées.

\textit{Instructions:}

\begin{questions}
    \item Créez un dictionnaire principal appelé \texttt{bibliotheque} où chaque clé est un identifiant unique pour un livre (par exemple, un ISBN ou un numéro d'identification).
    
    \item Chaque valeur dans le dictionnaire principal doit être un autre dictionnaire contenant les informations suivantes pour chaque livre :
    \begin{itemize}
        \item \texttt{titre} : Le titre du livre.
        \item \texttt{auteur} : L'auteur du livre.
        \item \texttt{annee} : L'année de publication du livre.
        \item \texttt{copies\_disponibles} : Le nombre de copies disponibles pour l'emprunt.
    \end{itemize}
    
    \item Implémentez les fonctions suivantes :
    \begin{itemize}
        \item \texttt{ajouter\_livre(bibliotheque, identifiant, titre, auteur, annee, copies)} : Ajoute un nouveau livre à la bibliothèque.
        \item \texttt{emprunter\_livre(bibliotheque, identifiant)} : Emprunte un livre si des copies sont disponibles.
        \item \texttt{rendre\_livre(bibliotheque, identifiant)} : Rend un livre emprunté, augmentant ainsi le nombre de copies disponibles.
        \item \texttt{verifier\_disponibilite(bibliotheque, identifiant)} : Vérifie combien de copies d'un livre sont disponibles.
    \end{itemize}
    
    \item Testez votre système en ajoutant plusieurs livres, en empruntant et en rendant des livres, et en vérifiant la disponibilité.
\end{questions}

\end{exo}

\begin{corrige}
Voici un programme répondant aux instructions données (vous aurez en plus un exemple d'utilisation en scannant le QR Code):

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

\begin{listing}{}{01-bibliotheque-1.py} \end{listing}

\newpage

\begin{listing}{}{01-bibliotheque-2.py} \end{listing}
\end{corrige}


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

\begin{exo}{Expressions postfixées}{Lycée Henri Alain-Fournier, Bourges}{3}{20} 
\index{Postfixées (expressions)}
On ne considère dans cet exercice que les expressions numériques contenant les quatre opérations élémentaires (addition, soustraction, multiplication et\linebreak division).

La notation postfixée consiste à mettre les opérations arithmétiques après leurs deux arguments. Ainsi, l'opération $a \bigstar b$, où $\bigstar \in \{ + ; - ; \times ; \div \}$, a pour notation postfixée : $a b \bigstar$.

1\ier{} exemple : l'expression 3 * ((4 + 5) + 6) peut s'écrire \og 3 4 5 + 6 + * \fg (mais aussi : \og 4 5 + 6 + 3 * \fg{} ou encore \og 3 6 4 5 + + * \fg). 

2\ieme{} exemple : (4 + (5 + 6)) * 3 peut s'écrire \og 4 5 6 + + 3 * \fg.

\begin{questions}
\item \'Ecrire un algorithme utilisant une pile pour effectuer une opération en notation postfixée.

\item Implémenter l'algorithme en Python en définissant une fonction\linebreak \texttt{calcul(E)}, où \texttt{E} est l'expression en notation postfixée dans laquelle chaque nombre ou symbole est séparé par une espace.
\end{questions}
\end{exo}


\begin{corrige}
\begin{questions}
\item Un algorithme possible est le suivant :

\begin{algorithme}{}
P est une pile 
E est une expression en notation postfixée

Pour chaque élément e de E:
\quad Si e est un nombre:
\qquad Empiler e dans P
\quad Sinon:
\qquad Dépiler les deux premières valeurs v1 et v2 de P
\qquad Effectuer l'opération e sur v1 et v2
\qquad Empiler le résultat dans P
\quad Fin du Si
\end{algorithme}

\item Une implémentation possible de cette fonction est celle présentée page suivante.
\begin{itemize}
\item On parcourt la liste créée à partir de l’expression E de gauche à droite : \texttt{E.split()}.

\item Si on rencontre un nombre, on l’ajoute à la file.

\item Sinon, on retire les deux derniers nombres de la file, on applique l’opérateur, et on ajoute le résultat à la file.

\item À la fin de l’expression, le résultat final sera le seul élément restant dans la file.
\end{itemize}

\qrset{height=1.1cm,version=5}\rput(-1,-0.7){
\psframebox{\qrcode{https://idl-live.prepamath.fr/ILTNSI/01-postfixeest.py}}}
\vspace*{-10pt}
\begin{listing}{}{01-postfixees.py}
\end{listing}
\index{Python!del}
\index{Python!str}
\index{Python!split}


\end{questions}
\end{corrige}


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



\thumb
\AfficheCorrige
