\documentclass[10pt,aspectratio=169]{beamer}

% --- Thème ---
\usetheme[language=french]{Celestia}

% Avec [allowframebreaks] sur les frames de questions, Beamer ajoute
% par défaut « (1) », « (2) », « (3) »... sur chaque sous-slide. On
% supprime entièrement cette annotation : un template vide pour
% « frametitle continuation ». L'enseignant identifie visuellement la
% continuation par le contenu de la slide. (Les variantes [from second]
% et [roman] interagissent mal avec un titre contenant \textemdash{}
% sous Celestia : elles déclenchent une erreur « Missing $ inserted ».)
\setbeamertemplate{frametitle continuation}{}

\subject{Numérique et sciences informatiques}
\title{Arbres binaires de recherche}
\subtitle{QCM}
\author{Terminale}
\date{\today}

\begin{document}

\begin{frame}
    \titlepage
\end{frame}

% Q1 - Réponse en C
\begin{frame}[fragile]{Question 1 \textemdash{} Propriété fondamentale}
    Quelle est la \textbf{propriété fondamentale} d'un
arbre binaire de recherche ?\medskip
    \begin{itemize}
        \item[A.] Toutes les feuilles se trouvent au même niveau
        \item[B.] Chaque nœud possède exactement deux enfants
        \item[\alert<2>{C.}] \alert<2>{Pour chaque nœud, toutes les valeurs du sous-arbre gauche sont strictement inférieures à la valeur du nœud, et toutes celles du sous-arbre droit lui sont strictement supérieures}
        \item[D.] La racine contient la plus grande valeur de l'arbre
    \end{itemize}
\end{frame}

% Q2 - Réponse en D
\begin{frame}[fragile]{Question 2 \textemdash{} Complexité de la recherche}
    Dans un arbre binaire de recherche \textbf{équilibré}
contenant $n$ éléments, quelle est la complexité
de la recherche d'une valeur ?\medskip
    \begin{itemize}
        \item[A.] $O(n^2)$
        \item[B.] $O(1)$
        \item[C.] $O(n)$
        \item[\alert<2>{D.}] \alert<2>{$O(\log n)$}
    \end{itemize}
\end{frame}

% Q3 - Réponse en D
\begin{frame}[fragile]{Question 3 \textemdash{} Cas pire}
    Quelle est la complexité de la recherche dans
un arbre binaire de recherche dans le \textbf{pire
cas}, sans contrainte d'équilibrage ?\medskip
    \begin{itemize}
        \item[A.] $O(\sqrt{n})$
        \item[B.] $O(\log n)$ dans tous les cas
        \item[C.] $O(n^2)$
        \item[\alert<2>{D.}] \alert<2>{$O(n)$, lorsque l'arbre a dégénéré en peigne et que chaque nœud n'a qu'un enfant}
    \end{itemize}
\end{frame}

% Q4 - Réponse en B
\begin{frame}[fragile]{Question 4 \textemdash{} Parcours infixe}
    Que donne un parcours \textbf{infixe} sur un arbre
binaire de recherche ?\medskip
    \begin{itemize}
        \item[A.] Les valeurs dans un ordre aléatoire
        \item[\alert<2>{B.}] \alert<2>{Les valeurs dans l'ordre croissant}
        \item[C.] Les valeurs dans l'ordre décroissant
        \item[D.] Aucune valeur particulière n'est visitée
    \end{itemize}
\end{frame}

% Q5 - Réponse en A
\begin{frame}[fragile]{Question 5 \textemdash{} Insertion}
    Pour insérer une valeur $v$ dans un arbre
binaire de recherche, on procède de la manière
suivante :\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{On descend dans l'arbre en comparant la valeur avec chaque nœud rencontré, puis on l'insère comme nouvelle feuille à la place vide trouvée}
        \item[B.] On trie les valeurs, puis on la place
        \item[C.] On la place toujours à la racine
        \item[D.] On la place dans la première feuille rencontrée, sans comparaison
    \end{itemize}
\end{frame}

% Q6 - Réponse en B
\begin{frame}[fragile]{Question 6 \textemdash{} Suppression}
    La \textbf{suppression} d'un nœud dans un arbre
binaire de recherche est plus délicate que
l'insertion. Pourquoi ?\medskip
    \begin{itemize}
        \item[A.] Parce qu'il faut détruire l'arbre puis le reconstruire entièrement
        \item[\alert<2>{B.}] \alert<2>{Parce que selon que le nœud à supprimer a $0$, $1$ ou $2$ enfants, le traitement est différent, et le cas à deux enfants demande de remplacer le nœud par son successeur (ou son prédécesseur)}
        \item[C.] Parce qu'il faut entièrement re-trier l'arbre après chaque suppression
        \item[D.] Parce qu'il est impossible de supprimer un nœud dans un arbre binaire de recherche
    \end{itemize}
\end{frame}

% Q7 - Réponse en C
\begin{frame}[fragile]{Question 7 \textemdash{} Comparaison avec un tableau trié}
    Quel est l'\textbf{avantage} d'un arbre binaire de
recherche équilibré par rapport à un tableau
trié ?\medskip
    \begin{itemize}
        \item[A.] La recherche y est plus rapide
        \item[B.] Aucune différence n'existe entre les deux structures
        \item[\alert<2>{C.}] \alert<2>{L'insertion et la suppression y sont en $O(\log n)$, alors qu'elles coûtent $O(n)$ dans un tableau trié, à cause du décalage des éléments}
        \item[D.] Il consomme moins de mémoire qu'un tableau
    \end{itemize}
\end{frame}

% Q8 - Réponse en A
\begin{frame}[fragile]{Question 8 \textemdash{} Construire l'arbre}
    On insère successivement les valeurs $5$, $3$,
$7$, $1$, $4$ dans un arbre binaire de
recherche initialement vide. Que devient la
racine ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{$5$}
        \item[B.] $7$
        \item[C.] $1$
        \item[D.] $4$
    \end{itemize}
\end{frame}

% Q9 - Réponse en A
\begin{frame}[fragile]{Question 9 \textemdash{} Cas d'usage}
    Lequel des cas suivants est un usage typique
d'un arbre binaire de recherche ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Maintenir dynamiquement un ensemble trié de valeurs avec des ajouts, des suppressions et des recherches fréquentes}
        \item[B.] Compter le nombre de mots dans un texte
        \item[C.] Afficher une image
        \item[D.] Calculer la somme des éléments d'une liste
    \end{itemize}
\end{frame}

% Q10 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Recherche récursive}
    Quelle fonction Python recherche correctement
la valeur \texttt{v} dans un arbre binaire de
recherche ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def chercher(n, v):
    if n is None: return False
    if v == n.valeur: return True
    if v < n.valeur:
        return chercher(n.gauche, v)
    return chercher(n.droit, v)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def chercher(n, v):
    return v == n.valeur
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def chercher(n, v):
    return True
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def chercher(n, v):
    if n is None: return False
    if n.valeur == v: return True
    return chercher(n.gauche, v) or chercher(n.droit, v)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q10 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Recherche récursive}
    Quelle fonction Python recherche correctement
la valeur \texttt{v} dans un arbre binaire de
recherche ?\medskip
    \begin{itemize}
        \item[\alert{A.}]~\\
\begin{lstlisting}
def chercher(n, v):
    if n is None: return False
    if v == n.valeur: return True
    if v < n.valeur:
        return chercher(n.gauche, v)
    return chercher(n.droit, v)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def chercher(n, v):
    return v == n.valeur
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def chercher(n, v):
    return True
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def chercher(n, v):
    if n is None: return False
    if n.valeur == v: return True
    return chercher(n.gauche, v) or chercher(n.droit, v)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q11 - Réponse en A
\begin{frame}[fragile]{Question 11 \textemdash{} Arbres AVL}
    Un arbre AVL est un arbre binaire de
recherche auto-équilibré. Quelle contrainte
maintient-il pour rester équilibré ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Pour chaque nœud, les hauteurs des sous-arbres gauche et droit ne diffèrent jamais de plus de $1$}
        \item[B.] Tous les chemins de la racine aux feuilles ont la même longueur
        \item[C.] Tous les sous-arbres doivent avoir la même taille
        \item[D.] La racine doit toujours être la valeur médiane des valeurs présentes
    \end{itemize}
\end{frame}

% Q12 - Réponse en D
\begin{frame}[fragile]{Question 12 \textemdash{} Arbres rouge-noir}
    Les arbres rouge-noir sont une autre famille
d'arbres binaires de recherche
auto-équilibrés. Quelle est leur particularité
par rapport aux arbres AVL ?\medskip
    \begin{itemize}
        \item[A.] Ils n'autorisent que les insertions, et pas les suppressions
        \item[B.] Ils sont parfaitement équilibrés
        \item[C.] Ils utilisent un tri par tas en interne
        \item[\alert<2>{D.}] \alert<2>{Ils tolèrent un déséquilibre légèrement supérieur (la hauteur reste majorée par $2 \log n$), en échange d'opérations d'équilibrage moins fréquentes}
    \end{itemize}
\end{frame}

% Q13 - Réponse en D
\begin{frame}[fragile]{Question 13 \textemdash{} Insertion dans le pire cas}
    Dans un arbre binaire de recherche \textbf{non
équilibré}, quelle séquence d'insertions
conduit au pire cas (forme dégénérée) ?\medskip
    \begin{itemize}
        \item[A.] Insérer les valeurs en commençant par la médiane
        \item[B.] Insérer une seule valeur
        \item[C.] Insérer les valeurs dans un ordre aléatoire
        \item[\alert<2>{D.}] \alert<2>{Insérer les valeurs déjà triées, par ordre croissant ou décroissant}
    \end{itemize}
\end{frame}

% Q14 - Réponse en D
\begin{frame}[fragile]{Question 14 \textemdash{} Application du parcours infixe}
    Comment obtenir efficacement les valeurs
\textbf{triées} d'un arbre binaire de recherche ?\medskip
    \begin{itemize}
        \item[A.] Trier les valeurs à chaque opération
        \item[B.] Ne renvoyer que les feuilles de l'arbre
        \item[C.] Effectuer un parcours préfixe
        \item[\alert<2>{D.}] \alert<2>{Effectuer un parcours infixe, qui visite naturellement les valeurs en ordre croissant}
    \end{itemize}
\end{frame}

% Q15 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 15 \textemdash{} Code d'insertion récursive}
    Quelle fonction Python insère correctement la
valeur \texttt{v} dans un arbre binaire de
recherche, en renvoyant la nouvelle racine ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def inserer(n, v):
    if n is None: return Noeud(v)
    if v < n.valeur:
        n.gauche = inserer(n.gauche, v)
    else:
        n.droit = inserer(n.droit, v)
    return n
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def inserer(n, v):
    return Noeud(v)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def inserer(n, v):
    n.valeur = v
    return n
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def inserer(n, v):
    n.gauche = Noeud(v)
    return n
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q15 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 15 \textemdash{} Code d'insertion récursive}
    Quelle fonction Python insère correctement la
valeur \texttt{v} dans un arbre binaire de
recherche, en renvoyant la nouvelle racine ?\medskip
    \begin{itemize}
        \item[\alert{A.}]~\\
\begin{lstlisting}
def inserer(n, v):
    if n is None: return Noeud(v)
    if v < n.valeur:
        n.gauche = inserer(n.gauche, v)
    else:
        n.droit = inserer(n.droit, v)
    return n
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def inserer(n, v):
    return Noeud(v)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def inserer(n, v):
    n.valeur = v
    return n
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def inserer(n, v):
    n.gauche = Noeud(v)
    return n
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q16 - Réponse en C
\begin{frame}[fragile]{Question 16 \textemdash{} Construire un arbre équilibré}
    Pour construire un arbre binaire de recherche
équilibré à partir d'un tableau trié, quelle
stratégie est la plus simple ?\medskip
    \begin{itemize}
        \item[A.] Insérer les éléments dans un ordre aléatoire
        \item[B.] Insérer les éléments dans l'ordre du tableau
        \item[\alert<2>{C.}] \alert<2>{Prendre l'élément du milieu comme racine, puis construire récursivement le sous-arbre gauche à partir de la moitié inférieure et le sous-arbre droit à partir de la moitié supérieure}
        \item[D.] Insérer les éléments du dernier au premier
    \end{itemize}
\end{frame}

% Q17 - Réponse en C
\begin{frame}[fragile]{Question 17 \textemdash{} Échec de la recherche}
    Lorsque la recherche d'une valeur \textbf{absente}
se termine dans un arbre binaire de recherche,
à quel endroit s'arrête-t-on ?\medskip
    \begin{itemize}
        \item[A.] À la racine de l'arbre
        \item[B.] La fonction lève une exception
        \item[\alert<2>{C.}] \alert<2>{À un sous-arbre vide (\texttt{None}), preuve que la valeur n'est pas présente dans l'arbre}
        \item[D.] À une feuille, peu importe sa valeur
    \end{itemize}
\end{frame}

% Q18 - Réponse en C
\begin{frame}[fragile]{Question 18 \textemdash{} Vérifier la propriété d'ordre}
    Pour vérifier qu'un arbre binaire respecte la
propriété d'arbre binaire de recherche, il
\textbf{ne suffit pas} de vérifier localement à
chaque nœud que :\medskip
    \begin{itemize}
        \item[A.] Les feuilles se trouvent toutes au même niveau
        \item[B.] La hauteur des sous-arbres est équilibrée
        \item[\alert<2>{C.}] \alert<2>{L'enfant gauche est plus petit et l'enfant droit est plus grand. Il faut aussi vérifier que toutes les valeurs du sous-arbre gauche sont inférieures (et symétriquement pour le sous-arbre droit)}
        \item[D.] La valeur du nœud est la moyenne de celles de ses enfants
    \end{itemize}
\end{frame}

% Q19 - Réponse en A
\begin{frame}[fragile]{Question 19 \textemdash{} Comparaison avec une table de hachage}
    Comparé à une \textbf{table de hachage}, quel est
l'\textbf{avantage} d'un arbre binaire de
recherche ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Il maintient les éléments dans l'ordre, ce qui permet de répondre à des requêtes par intervalle ou de retrouver le voisin le plus proche}
        \item[B.] Il consomme moins de mémoire
        \item[C.] Il est plus simple à implémenter
        \item[D.] La recherche y est plus rapide
    \end{itemize}
\end{frame}

% Q20 - Réponse en B
\begin{frame}[fragile]{Question 20 \textemdash{} Lecture d'un arbre}
    On insère successivement les valeurs $5$,
$2$, $8$, $1$, $3$ dans un arbre binaire de
recherche initialement vide. Quel est le
résultat de son parcours infixe ?\medskip
    \begin{itemize}
        \item[A.] $8, 5, 3, 2, 1$ (ordre décroissant)
        \item[\alert<2>{B.}] \alert<2>{$1, 2, 3, 5, 8$ (ordre croissant)}
        \item[C.] $5, 2, 1, 3, 8$ (parcours préfixe)
        \item[D.] $5, 2, 8, 1, 3$ (ordre d'insertion)
    \end{itemize}
\end{frame}

% Q21 - Réponse en D
\begin{frame}[fragile]{Question 21 \textemdash{} Suppression d'un nœud à deux enfants}
    Pour supprimer un nœud à \textbf{deux enfants} dans
un arbre binaire de recherche, par quoi le
remplace-t-on ?\medskip
    \begin{itemize}
        \item[A.] Par le sous-arbre gauche complet
        \item[B.] Par la racine de l'arbre
        \item[C.] Par une feuille choisie au hasard
        \item[\alert<2>{D.}] \alert<2>{Par son successeur infixe (le plus petit nœud du sous-arbre droit) ou par son prédécesseur infixe (le plus grand du sous-arbre gauche)}
    \end{itemize}
\end{frame}

% Q22 - Réponse en C
\begin{frame}[fragile]{Question 22 \textemdash{} Hauteur attendue}
    Pour un arbre binaire de recherche construit
en insérant $n$ valeurs \textbf{dans un ordre
aléatoire}, quelle est la hauteur attendue ?\medskip
    \begin{itemize}
        \item[A.] $\Theta(\sqrt{n})$
        \item[B.] $\Theta(n)$
        \item[\alert<2>{C.}] \alert<2>{$\Theta(\log n)$}
        \item[D.] $\Theta(1)$
    \end{itemize}
\end{frame}

% Q23 - Réponse en B
\begin{frame}[fragile]{Question 23 \textemdash{} Tri par arbre binaire de recherche}
    Le tri par arbre binaire de recherche, qui
consiste à insérer $n$ valeurs dans un arbre
puis à effectuer un parcours infixe, a une
complexité de :\medskip
    \begin{itemize}
        \item[A.] $O(n!)$
        \item[\alert<2>{B.}] \alert<2>{$O(n \log n)$ en moyenne (avec un ordre aléatoire), mais $O(n^2)$ dans le pire cas (ordre déjà trié)}
        \item[C.] $O(n)$
        \item[D.] $O(2^n)$
    \end{itemize}
\end{frame}

% Q24 - Réponse en D
\begin{frame}[fragile]{Question 24 \textemdash{} Successeur d'un nœud}
    Étant donné un nœud $n$ dans un arbre binaire
de recherche, comment trouver son
\textbf{successeur infixe}, c'est-à-dire la valeur
immédiatement supérieure ?\medskip
    \begin{itemize}
        \item[A.] La racine de l'arbre est toujours le successeur
        \item[B.] En descendant toujours à gauche
        \item[C.] Le successeur est choisi au hasard parmi les autres nœuds
        \item[\alert<2>{D.}] \alert<2>{Si le nœud $n$ a un sous-arbre droit, son successeur est le nœud le plus à gauche de ce sous-arbre. Sinon, c'est le premier ancêtre dont $n$ se trouve dans le sous-arbre gauche}
    \end{itemize}
\end{frame}

% Q25 - Réponse en A
\begin{frame}[fragile]{Question 25 \textemdash{} Quand utiliser un arbre binaire de recherche ?}
    Lequel des cas suivants justifie l'usage
d'un arbre binaire de recherche
auto-équilibré plutôt qu'une autre structure
?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Implémenter un dictionnaire dont les clés sont triées dynamiquement, avec des recherches par intervalle fréquentes}
        \item[B.] Calculer la somme des éléments d'une grande liste
        \item[C.] Stocker une liste fixe de noms à afficher
        \item[D.] Trier $1\,000$ entiers une seule fois
    \end{itemize}
\end{frame}

% Q26 - Réponse en D
\begin{frame}[fragile]{Question 26 \textemdash{} Trace d'insertions successives}
    On part d'un arbre binaire de recherche
vide. On y insère successivement les valeurs
$10, 5, 15, 3, 7, 12$. À quoi ressemble la
structure obtenue ?\medskip
    \begin{itemize}
        \item[A.] Tous les nœuds sont des feuilles d'une
racine vide

        \item[B.] Tous les nœuds sur une branche droite,
formant un peigne

        \item[C.] Racine $5$ ; tous les autres nœuds
répartis selon leur valeur

        \item[\alert<2>{D.}] \alert<2>{Racine $10$ ; sous-arbre gauche : $5$ avec
$3$ à gauche et $7$ à droite ; sous-arbre
droit : $15$ avec $12$ à gauche
}
    \end{itemize}
\end{frame}

% Q27 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Code de vérification de la propriété}
    Quelle fonction Python vérifie correctement
qu'un arbre binaire respecte la propriété
d'arbre binaire de recherche (en utilisant
des bornes minimum et maximum) ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def est_abr(n):
    if n is None:
        return True
    if n.gauche and n.gauche.valeur >= n.valeur:
        return False
    if n.droit and n.droit.valeur <= n.valeur:
        return False
    return est_abr(n.gauche) and est_abr(n.droit)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def est_abr(n):
    return n is None
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def est_abr(n, mini=float('-inf'), maxi=float('inf')):
    if n is None:
        return True
    if not (mini < n.valeur < maxi):
        return False
    return est_abr(n.gauche, mini, n.valeur) and est_abr(n.droit, n.valeur, maxi)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def est_abr(n):
    if n is None:
        return True
    return parcours_infixe(n) == sorted(parcours_infixe(n))
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q27 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Code de vérification de la propriété}
    Quelle fonction Python vérifie correctement
qu'un arbre binaire respecte la propriété
d'arbre binaire de recherche (en utilisant
des bornes minimum et maximum) ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def est_abr(n):
    if n is None:
        return True
    if n.gauche and n.gauche.valeur >= n.valeur:
        return False
    if n.droit and n.droit.valeur <= n.valeur:
        return False
    return est_abr(n.gauche) and est_abr(n.droit)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def est_abr(n):
    return n is None
\end{lstlisting}

        \item[\alert{C.}]~\\
\begin{lstlisting}
def est_abr(n, mini=float('-inf'), maxi=float('inf')):
    if n is None:
        return True
    if not (mini < n.valeur < maxi):
        return False
    return est_abr(n.gauche, mini, n.valeur) and est_abr(n.droit, n.valeur, maxi)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def est_abr(n):
    if n is None:
        return True
    return parcours_infixe(n) == sorted(parcours_infixe(n))
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q28 - Réponse en C
\begin{frame}[fragile]{Question 28 \textemdash{} Minimum et maximum dans un ABR}
    Comment trouver respectivement le \textbf{minimum}
et le \textbf{maximum} d'un arbre binaire de
recherche non vide ?\medskip
    \begin{itemize}
        \item[A.] Le minimum est toujours la racine, le
maximum est toujours une feuille

        \item[B.] On parcourt tout l'arbre et on retient les
valeurs minimale et maximale au fur et à
mesure

        \item[\alert<2>{C.}] \alert<2>{Le minimum se trouve en descendant toujours
à gauche depuis la racine ; le maximum
en descendant toujours à droite. Les
deux opérations sont en $O(h)$ où $h$ est
la hauteur
}
        \item[D.] Le minimum et le maximum sont les deux
enfants de la racine

    \end{itemize}
\end{frame}

\begin{frame}[standout]{}
    Fin de l'évaluation
\end{frame}

\end{document}
