\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{Programmation fonctionnelle}
\subtitle{QCM}
\author{Terminale}
\date{\today}

\begin{document}

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

% Q1 - Réponse en A
\begin{frame}[fragile]{Question 1 \textemdash{} Paradigme fonctionnel}
    Quelle est l'idée centrale du \textbf{paradigme fonctionnel} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Programmer en composant des fonctions, en évitant les modifications d'état (effets de bord)}
        \item[B.] Programmer uniquement avec des boucles \texttt{for}
        \item[C.] Programmer en suivant l'ordre exact des instructions ligne par ligne
        \item[D.] Programmer en utilisant uniquement des objets et des classes
    \end{itemize}
\end{frame}

% Q2 - Réponse en A
\begin{frame}[fragile]{Question 2 \textemdash{} Fonction pure}
    Qu'est-ce qu'une \textbf{fonction pure} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Une fonction qui, pour les mêmes arguments, retourne toujours le même résultat et n'a aucun effet de bord (modification de variable globale, écriture dans un fichier, etc.)}
        \item[B.] Une fonction qui modifie ses arguments
        \item[C.] Une fonction écrite uniquement en Python
        \item[D.] Une fonction qui ne contient aucun bug
    \end{itemize}
\end{frame}

% Q3 - Réponse en C
\begin{frame}[fragile]{Question 3 \textemdash{} Immutabilité}
    Que signifie qu'une donnée est \textbf{immuable} ?\medskip
    \begin{itemize}
        \item[A.] Elle est stockée sur le disque dur
        \item[B.] Elle est protégée par un mot de passe
        \item[\alert<2>{C.}] \alert<2>{Elle ne peut pas être modifiée après sa création}
        \item[D.] Elle ne peut pas être lue
    \end{itemize}
\end{frame}

% Q4 - Réponse en B
\begin{frame}[fragile]{Question 4 \textemdash{} Fonctions de première classe}
    Que signifie « les fonctions sont des objets de première
classe » dans un langage ?\medskip
    \begin{itemize}
        \item[A.] Elles sont les plus rapides du programme
        \item[\alert<2>{B.}] \alert<2>{Elles peuvent être passées en paramètre, retournées par d'autres fonctions, et stockées dans des variables, comme n'importe quelle autre valeur}
        \item[C.] Elles sont écrites en majuscules
        \item[D.] Elles sont les premières instructions du programme
    \end{itemize}
\end{frame}

% Q5 - Réponse en B
\begin{frame}[fragile]{Question 5 \textemdash{} Expression lambda}
    En Python, qu'est-ce qu'une \textbf{expression lambda} ?\medskip
    \begin{itemize}
        \item[A.] Une variable globale
        \item[\alert<2>{B.}] \alert<2>{Une fonction anonyme définie en une seule ligne}
        \item[C.] Un type de boucle
        \item[D.] Une instruction de débogage
    \end{itemize}
\end{frame}

% Q6 - Réponse en C
\begin{frame}[fragile]{Question 6 \textemdash{} Fonction map}
    Que fait la fonction \texttt{map(f, L)} en Python ?\medskip
    \begin{itemize}
        \item[A.] Elle filtre la liste selon un critère
        \item[B.] Elle réduit la liste à une seule valeur
        \item[\alert<2>{C.}] \alert<2>{Elle applique la fonction \texttt{f} à chaque élément de \texttt{L} et renvoie un itérateur des résultats}
        \item[D.] Elle modifie la liste \texttt{L} en y appliquant \texttt{f} directement
    \end{itemize}
\end{frame}

% Q7 - Réponse en B
\begin{frame}[fragile]{Question 7 \textemdash{} Fonction filter}
    Que fait \texttt{filter(p, L)} en Python ?\medskip
    \begin{itemize}
        \item[A.] Elle compte le nombre d'éléments dans \texttt{L}
        \item[\alert<2>{B.}] \alert<2>{Elle conserve uniquement les éléments de \texttt{L} pour lesquels \texttt{p(element)} est vrai}
        \item[C.] Elle modifie chaque élément de \texttt{L}
        \item[D.] Elle renvoie une liste vide
    \end{itemize}
\end{frame}

% Q8 - Réponse en B
\begin{frame}[fragile]{Question 8 \textemdash{} Fonction reduce}
    Quel est le rôle de \texttt{reduce(f, L)} (du module \texttt{functools}) ?\medskip
    \begin{itemize}
        \item[A.] Trier la liste
        \item[\alert<2>{B.}] \alert<2>{Combiner les éléments de \texttt{L} deux par deux à l'aide de \texttt{f} jusqu'à obtenir une seule valeur}
        \item[C.] Faire une boucle
        \item[D.] Réduire la taille d'une liste en supprimant les doublons
    \end{itemize}
\end{frame}

% Q9 - Réponse en B
\begin{frame}[fragile]{Question 9 \textemdash{} Composition de fonctions}
    Que signifie « composer deux fonctions $f$ et $g$ » ?\medskip
    \begin{itemize}
        \item[A.] Les exécuter en parallèle
        \item[\alert<2>{B.}] \alert<2>{Créer une nouvelle fonction qui applique d'abord $g$, puis $f$ au résultat (notée $f \circ g$)}
        \item[C.] Les écrire dans le même fichier
        \item[D.] Les fusionner en une seule grosse fonction
    \end{itemize}
\end{frame}

% Q10 - Réponse en B
\begin{frame}[fragile]{Question 10 \textemdash{} Récursivité en programmation fonctionnelle}
    Pourquoi la \textbf{récursivité} est-elle privilégiée à la
boucle dans le paradigme fonctionnel ?\medskip
    \begin{itemize}
        \item[A.] Parce qu'elle est plus rapide
        \item[\alert<2>{B.}] \alert<2>{Parce qu'une boucle nécessite la modification d'une variable de compteur, ce qui contredit l'idéal d'immutabilité}
        \item[C.] Parce que les boucles n'existent pas en Python
        \item[D.] Parce que c'est la mode
    \end{itemize}
\end{frame}

% Q11 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Identifier une fonction pure}
    Parmi les fonctions Python suivantes, laquelle est
\textbf{pure} ?

\begin{lstlisting}
def f1(x): return x + 1
def f2(x): print(x); return x
def f3(L, x): L.append(x); return L
def f4(): return random.random()
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] \texttt{f1} et \texttt{f4}
        \item[B.] \texttt{f1} et \texttt{f2}
        \item[C.] \texttt{f1} uniquement
        \item[D.] Toutes
    \end{itemize}
\end{frame}

% Q11 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Identifier une fonction pure}
    Parmi les fonctions Python suivantes, laquelle est
\textbf{pure} ?

\begin{lstlisting}
def f1(x): return x + 1
def f2(x): print(x); return x
def f3(L, x): L.append(x); return L
def f4(): return random.random()
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] \texttt{f1} et \texttt{f4}
        \item[B.] \texttt{f1} et \texttt{f2}
        \item[\alert{C.}] \alert{\texttt{f1} uniquement}
        \item[D.] Toutes
    \end{itemize}
\end{frame}

% Q12 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 12 \textemdash{} Lambda avec map}
    Que renvoie l'expression Python suivante ?

\begin{lstlisting}
list(map(lambda x: x ** 2, [1, 2, 3, 4]))
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] \texttt{[1, 4, 9, 16]}
        \item[B.] \texttt{[1, 2, 3, 4]}
        \item[C.] \texttt{[1, 16]}
        \item[D.] \texttt{[2, 4, 6, 8]}
    \end{itemize}
\end{frame}

% Q12 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 12 \textemdash{} Lambda avec map}
    Que renvoie l'expression Python suivante ?

\begin{lstlisting}
list(map(lambda x: x ** 2, [1, 2, 3, 4]))
\end{lstlisting}\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{\texttt{[1, 4, 9, 16]}}
        \item[B.] \texttt{[1, 2, 3, 4]}
        \item[C.] \texttt{[1, 16]}
        \item[D.] \texttt{[2, 4, 6, 8]}
    \end{itemize}
\end{frame}

% Q13 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 13 \textemdash{} Filter pour les nombres pairs}
    Que renvoie cette expression ?

\begin{lstlisting}
list(filter(lambda x: x % 2 == 0, range(10)))
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] \texttt{[]}
        \item[B.] \texttt{[1, 3, 5, 7, 9]}
        \item[C.] \texttt{[0, 1, 2, ..., 9]}
        \item[D.] \texttt{[0, 2, 4, 6, 8]}
    \end{itemize}
\end{frame}

% Q13 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 13 \textemdash{} Filter pour les nombres pairs}
    Que renvoie cette expression ?

\begin{lstlisting}
list(filter(lambda x: x % 2 == 0, range(10)))
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] \texttt{[]}
        \item[B.] \texttt{[1, 3, 5, 7, 9]}
        \item[C.] \texttt{[0, 1, 2, ..., 9]}
        \item[\alert{D.}] \alert{\texttt{[0, 2, 4, 6, 8]}}
    \end{itemize}
\end{frame}

% Q14 - Réponse en D
\begin{frame}[fragile]{Question 14 \textemdash{} Compréhension de liste}
    Quelle est la \textbf{compréhension de liste} Python équivalente
à \texttt{list(map(lambda x: x * 2, filter(lambda x: x > 0, L)))} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{[x > 0 * 2 for x in L]}
        \item[B.] \texttt{[x for x in L * 2]}
        \item[C.] \texttt{[L if x > 0 for x in L]}
        \item[\alert<2>{D.}] \alert<2>{\texttt{[x * 2 for x in L if x > 0]}}
    \end{itemize}
\end{frame}

% Q15 - Réponse en C
\begin{frame}[fragile]{Question 15 \textemdash{} Fonction d'ordre supérieur}
    Quelle est la définition d'une \textbf{fonction d'ordre
supérieur} ?\medskip
    \begin{itemize}
        \item[A.] Une fonction définie au niveau global
        \item[B.] Une fonction qui appelle d'autres fonctions
        \item[\alert<2>{C.}] \alert<2>{Une fonction qui prend une fonction en argument et/ou en retourne une}
        \item[D.] Une fonction très complexe
    \end{itemize}
\end{frame}

% Q16 - Réponse en A
\begin{frame}[fragile]{Question 16 \textemdash{} Mémoïsation et fonctions pures}
    Pourquoi la mémoïsation est-elle particulièrement adaptée
aux fonctions pures ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Une fonction pure renvoie toujours la même valeur pour les mêmes arguments, donc le cache est toujours fiable}
        \item[B.] La mémoïsation modifie la fonction
        \item[C.] Les fonctions pures sont plus rapides
        \item[D.] Les fonctions pures n'ont pas besoin de mémoire
    \end{itemize}
\end{frame}

% Q17 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 17 \textemdash{} Calcul avec reduce}
    Que calcule cette expression ?

\begin{lstlisting}
from functools import reduce
reduce(lambda a, b: a * b, [1, 2, 3, 4, 5])
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Le maximum ($5$)
        \item[B.] La somme des éléments ($15$)
        \item[C.] La longueur ($5$)
        \item[D.] Le produit des éléments ($120$)
    \end{itemize}
\end{frame}

% Q17 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 17 \textemdash{} Calcul avec reduce}
    Que calcule cette expression ?

\begin{lstlisting}
from functools import reduce
reduce(lambda a, b: a * b, [1, 2, 3, 4, 5])
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Le maximum ($5$)
        \item[B.] La somme des éléments ($15$)
        \item[C.] La longueur ($5$)
        \item[\alert{D.}] \alert{Le produit des éléments ($120$)}
    \end{itemize}
\end{frame}

% Q18 - Réponse en C
\begin{frame}[fragile]{Question 18 \textemdash{} Transparence référentielle}
    Que désigne la \textbf{transparence référentielle} d'une
expression ?\medskip
    \begin{itemize}
        \item[A.] L'expression contient des commentaires
        \item[B.] L'expression est écrite en blanc sur fond noir
        \item[\alert<2>{C.}] \alert<2>{L'expression peut être remplacée par sa valeur sans changer le comportement du programme}
        \item[D.] L'expression renvoie une référence vers un objet
    \end{itemize}
\end{frame}

% Q19 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 19 \textemdash{} Impératif vs fonctionnel}
    Quel est l'équivalent \textbf{fonctionnel} du code impératif
suivant ?

\begin{lstlisting}
total = 0
for x in L:
    if x > 0:
        total += x ** 2
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] \texttt{L.sum() if L > 0}
        \item[B.] \texttt{sum(x  2 for x in L if x > 0)}
        \item[C.] \texttt{reduce(L)}
        \item[D.] \texttt{for x in L: total += x  2}
    \end{itemize}
\end{frame}

% Q19 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 19 \textemdash{} Impératif vs fonctionnel}
    Quel est l'équivalent \textbf{fonctionnel} du code impératif
suivant ?

\begin{lstlisting}
total = 0
for x in L:
    if x > 0:
        total += x ** 2
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] \texttt{L.sum() if L > 0}
        \item[\alert{B.}] \alert{\texttt{sum(x  2 for x in L if x > 0)}}
        \item[C.] \texttt{reduce(L)}
        \item[D.] \texttt{for x in L: total += x  2}
    \end{itemize}
\end{frame}

% Q20 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 20 \textemdash{} Récursivité sans boucle}
    Quelle est l'écriture \textbf{récursive pure} de la fonction
qui calcule la somme des éléments d'une liste ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def somme(L):
    return sum(L)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def somme(L):
    total = 0
    for x in L: total += x
    return total
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def somme(L):
    if L == []:
        return 0
    return L[0] + somme(L[1:])
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def somme(L):
    return reduce(lambda a, b: a + b, L)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q20 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 20 \textemdash{} Récursivité sans boucle}
    Quelle est l'écriture \textbf{récursive pure} de la fonction
qui calcule la somme des éléments d'une liste ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def somme(L):
    return sum(L)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def somme(L):
    total = 0
    for x in L: total += x
    return total
\end{lstlisting}

        \item[\alert{C.}]~\\
\begin{lstlisting}
def somme(L):
    if L == []:
        return 0
    return L[0] + somme(L[1:])
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def somme(L):
    return reduce(lambda a, b: a + b, L)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q21 - Réponse en B
\begin{frame}[fragile]{Question 21 \textemdash{} Mélange de paradigmes}
    Un programme Python utilise une boucle \texttt{for} pour
parcourir une liste, puis appelle \texttt{sorted} avec une
fonction lambda comme critère. Combien de paradigmes
de programmation différents ce code combine-t-il ?\medskip
    \begin{itemize}
        \item[A.] Aucun, ce n'est pas un vrai programme
        \item[\alert<2>{B.}] \alert<2>{Deux : impératif (la boucle \texttt{for}) et fonctionnel (le tri par lambda)}
        \item[C.] Trois : impératif, fonctionnel et objet
        \item[D.] Un seul, l'impératif
    \end{itemize}
\end{frame}

% Q22 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 22 \textemdash{} Calculer la somme des carrés}
    On veut calculer la somme des carrés des entiers
d'une liste \texttt{nombres}. Quel code suit le \textbf{style
fonctionnel} ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
total = 0
for n in nombres:
    total = total + n * n
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
class Sommateur:
    def __init__(self):
        self.total = 0
    def ajouter(self, n):
        self.total += n * n
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
total = nombres
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
total = sum(n * n for n in nombres)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q22 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 22 \textemdash{} Calculer la somme des carrés}
    On veut calculer la somme des carrés des entiers
d'une liste \texttt{nombres}. Quel code suit le \textbf{style
fonctionnel} ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
total = 0
for n in nombres:
    total = total + n * n
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
class Sommateur:
    def __init__(self):
        self.total = 0
    def ajouter(self, n):
        self.total += n * n
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
total = nombres
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
total = sum(n * n for n in nombres)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q23 - Réponse en A
\begin{frame}[fragile]{Question 23 \textemdash{} Choisir un paradigme}
    Pour écrire un script court qui transforme une
liste de prix en y appliquant une remise de $10\%$,
quel \textbf{paradigme} est le plus naturel en Python ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Une approche fonctionnelle avec une compréhension de liste ou un \texttt{map} sur une lambda}
        \item[B.] Un paradigme logique type Prolog
        \item[C.] Une approche objet avec une classe \texttt{Remiseur} et une méthode \texttt{appliquer}
        \item[D.] Aucun paradigme : il faut tout écrire à la main, avec des \texttt{goto}
    \end{itemize}
\end{frame}

% Q24 - Réponse en D
\begin{frame}[fragile]{Question 24 \textemdash{} Programmation fonctionnelle et parallélisme}
    Pourquoi la programmation fonctionnelle est-elle
particulièrement adaptée au calcul \textbf{parallèle} ?\medskip
    \begin{itemize}
        \item[A.] Elle utilise plus de cœurs du processeur
        \item[B.] Elle utilise moins de mémoire
        \item[C.] Elle est plus simple à apprendre
        \item[\alert<2>{D.}] \alert<2>{L'absence d'effets de bord et l'immutabilité éliminent les conflits d'accès aux données partagées}
    \end{itemize}
\end{frame}

% Q25 - Réponse en D
\begin{frame}[fragile]{Question 25 \textemdash{} Comparaison des paradigmes}
    Parmi les affirmations suivantes, laquelle est \textbf{vraie} ?\medskip
    \begin{itemize}
        \item[A.] La programmation fonctionnelle remplace définitivement l'orientée objet
        \item[B.] La programmation fonctionnelle ne fonctionne que sur les ordinateurs récents
        \item[C.] La programmation fonctionnelle interdit l'utilisation des classes
        \item[\alert<2>{D.}] \alert<2>{La programmation fonctionnelle et l'orientée objet sont des paradigmes complémentaires, chacun adapté à certaines situations}
    \end{itemize}
\end{frame}

% Q26 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Fermeture (closure)}
    On considère le code Python suivant :
\begin{lstlisting}
def faire_compteur():
    n = 0
    def incrementer():
        nonlocal n
        n += 1
        return n
    return incrementer

c = faire_compteur()
print(c(), c(), c())
\end{lstlisting}
Que renvoie l'appel \texttt{print(c(), c(), c())} et de
quel concept s'agit-il ?\medskip
    \begin{itemize}
        \item[A.] Affiche \texttt{1 2 3}. C'est un exemple de fermeture
(closure) : la fonction interne \texttt{incrementer}
capture la variable \texttt{n} de la fonction englobante,
même après que celle-ci a terminé son exécution

        \item[B.] Lève une erreur car \texttt{n} est une variable locale à
\texttt{faire\_compteur}

        \item[C.] Affiche \texttt{1 1 1} car \texttt{n} est réinitialisé à chaque
appel

        \item[D.] Affiche \texttt{0 0 0} car \texttt{n} ne peut pas être modifié
dans une fonction interne

    \end{itemize}
\end{frame}

% Q26 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Fermeture (closure)}
    On considère le code Python suivant :
\begin{lstlisting}
def faire_compteur():
    n = 0
    def incrementer():
        nonlocal n
        n += 1
        return n
    return incrementer

c = faire_compteur()
print(c(), c(), c())
\end{lstlisting}
Que renvoie l'appel \texttt{print(c(), c(), c())} et de
quel concept s'agit-il ?\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{Affiche \texttt{1 2 3}. C'est un exemple de fermeture
(closure) : la fonction interne \texttt{incrementer}
capture la variable \texttt{n} de la fonction englobante,
même après que celle-ci a terminé son exécution
}
        \item[B.] Lève une erreur car \texttt{n} est une variable locale à
\texttt{faire\_compteur}

        \item[C.] Affiche \texttt{1 1 1} car \texttt{n} est réinitialisé à chaque
appel

        \item[D.] Affiche \texttt{0 0 0} car \texttt{n} ne peut pas être modifié
dans une fonction interne

    \end{itemize}
\end{frame}

% Q27 - Réponse en D
\begin{frame}[fragile]{Question 27 \textemdash{} Décorateur Python}
    Les décorateurs Python (\texttt{@nom}) sont une application
directe d'un concept fondamental de la programmation
fonctionnelle. Lequel ?\medskip
    \begin{itemize}
        \item[A.] La compréhension de liste

        \item[B.] Le filtrage par motif (\textit{pattern matching})

        \item[C.] La récursivité

        \item[\alert<2>{D.}] \alert<2>{Les fonctions d'ordre supérieur : un décorateur
est une fonction qui prend une fonction en
paramètre et renvoie une nouvelle fonction
(souvent enrichie d'un comportement
supplémentaire)
}
    \end{itemize}
\end{frame}

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

\end{document}
