\documentclass[a4paper,11pt]{article}

\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
\usepackage[francais,bloc,completemulti]{automultiplechoice}
\usepackage[french]{babel}
\usepackage{amsmath, amssymb}

\title{Programmation fonctionnelle}
\date{Numérique et sciences informatiques}

\begin{document}

\noindent\textbf{Programmation fonctionnelle} \hfill \textit{Numérique et sciences informatiques}\\[0.4em]
Nom~: \dotfill\ Prénom~: \dotfill

\bigskip

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q01}
    Quelle est l'idée centrale du \textbf{paradigme fonctionnel} ?
    \begin{choices}
    \correctchoice{Programmer en composant des fonctions, en évitant les modifications d'état (effets de bord)}
    \wrongchoice{Programmer uniquement avec des boucles \texttt{for}}
    \wrongchoice{Programmer en suivant l'ordre exact des instructions ligne par ligne}
    \wrongchoice{Programmer en utilisant uniquement des objets et des classes}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q02}
    Qu'est-ce qu'une \textbf{fonction pure} ?
    \begin{choices}
    \correctchoice{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.)}
    \wrongchoice{Une fonction qui modifie ses arguments}
    \wrongchoice{Une fonction écrite uniquement en Python}
    \wrongchoice{Une fonction qui ne contient aucun bug}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q03}
    Que signifie qu'une donnée est \textbf{immuable} ?
    \begin{choices}
    \wrongchoice{Elle est stockée sur le disque dur}
    \wrongchoice{Elle est protégée par un mot de passe}
    \correctchoice{Elle ne peut pas être modifiée après sa création}
    \wrongchoice{Elle ne peut pas être lue}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q04}
    Que signifie « les fonctions sont des objets de première
classe » dans un langage ?
    \begin{choices}
    \wrongchoice{Elles sont les plus rapides du programme}
    \correctchoice{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}
    \wrongchoice{Elles sont écrites en majuscules}
    \wrongchoice{Elles sont les premières instructions du programme}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q05}
    En Python, qu'est-ce qu'une \textbf{expression lambda} ?
    \begin{choices}
    \wrongchoice{Une variable globale}
    \correctchoice{Une fonction anonyme définie en une seule ligne}
    \wrongchoice{Un type de boucle}
    \wrongchoice{Une instruction de débogage}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q06}
    Que fait la fonction \texttt{map(f, L)} en Python ?
    \begin{choices}
    \wrongchoice{Elle filtre la liste selon un critère}
    \wrongchoice{Elle réduit la liste à une seule valeur}
    \correctchoice{Elle applique la fonction \texttt{f} à chaque élément de \texttt{L} et renvoie un itérateur des résultats}
    \wrongchoice{Elle modifie la liste \texttt{L} en y appliquant \texttt{f} directement}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q07}
    Que fait \texttt{filter(p, L)} en Python ?
    \begin{choices}
    \wrongchoice{Elle compte le nombre d'éléments dans \texttt{L}}
    \correctchoice{Elle conserve uniquement les éléments de \texttt{L} pour lesquels \texttt{p(element)} est vrai}
    \wrongchoice{Elle modifie chaque élément de \texttt{L}}
    \wrongchoice{Elle renvoie une liste vide}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q08}
    Quel est le rôle de \texttt{reduce(f, L)} (du module \texttt{functools}) ?
    \begin{choices}
    \wrongchoice{Trier la liste}
    \correctchoice{Combiner les éléments de \texttt{L} deux par deux à l'aide de \texttt{f} jusqu'à obtenir une seule valeur}
    \wrongchoice{Faire une boucle}
    \wrongchoice{Réduire la taille d'une liste en supprimant les doublons}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q09}
    Que signifie « composer deux fonctions $f$ et $g$ » ?
    \begin{choices}
    \wrongchoice{Les exécuter en parallèle}
    \correctchoice{Créer une nouvelle fonction qui applique d'abord $g$, puis $f$ au résultat (notée $f \circ g$)}
    \wrongchoice{Les écrire dans le même fichier}
    \wrongchoice{Les fusionner en une seule grosse fonction}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q10}
    Pourquoi la \textbf{récursivité} est-elle privilégiée à la
boucle dans le paradigme fonctionnel ?
    \begin{choices}
    \wrongchoice{Parce qu'elle est plus rapide}
    \correctchoice{Parce qu'une boucle nécessite la modification d'une variable de compteur, ce qui contredit l'idéal d'immutabilité}
    \wrongchoice{Parce que les boucles n'existent pas en Python}
    \wrongchoice{Parce que c'est la mode}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q11}
    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}
    \begin{choices}
    \wrongchoice{\texttt{f1} et \texttt{f4}}
    \wrongchoice{\texttt{f1} et \texttt{f2}}
    \correctchoice{\texttt{f1} uniquement}
    \wrongchoice{Toutes}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q12}
    Que renvoie l'expression Python suivante ?

\begin{lstlisting}
list(map(lambda x: x ** 2, [1, 2, 3, 4]))
\end{lstlisting}
    \begin{choices}
    \correctchoice{\texttt{[1, 4, 9, 16]}}
    \wrongchoice{\texttt{[1, 2, 3, 4]}}
    \wrongchoice{\texttt{[1, 16]}}
    \wrongchoice{\texttt{[2, 4, 6, 8]}}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q13}
    Que renvoie cette expression ?

\begin{lstlisting}
list(filter(lambda x: x % 2 == 0, range(10)))
\end{lstlisting}
    \begin{choices}
    \wrongchoice{\texttt{[]}}
    \wrongchoice{\texttt{[1, 3, 5, 7, 9]}}
    \wrongchoice{\texttt{[0, 1, 2, ..., 9]}}
    \correctchoice{\texttt{[0, 2, 4, 6, 8]}}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q14}
    Quelle est la \textbf{compréhension de liste} Python équivalente
à \texttt{list(map(lambda x: x * 2, filter(lambda x: x > 0, L)))} ?
    \begin{choices}
    \wrongchoice{\texttt{[x > 0 * 2 for x in L]}}
    \wrongchoice{\texttt{[x for x in L * 2]}}
    \wrongchoice{\texttt{[L if x > 0 for x in L]}}
    \correctchoice{\texttt{[x * 2 for x in L if x > 0]}}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q15}
    Quelle est la définition d'une \textbf{fonction d'ordre
supérieur} ?
    \begin{choices}
    \wrongchoice{Une fonction définie au niveau global}
    \wrongchoice{Une fonction qui appelle d'autres fonctions}
    \correctchoice{Une fonction qui prend une fonction en argument et/ou en retourne une}
    \wrongchoice{Une fonction très complexe}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q16}
    Pourquoi la mémoïsation est-elle particulièrement adaptée
aux fonctions pures ?
    \begin{choices}
    \correctchoice{Une fonction pure renvoie toujours la même valeur pour les mêmes arguments, donc le cache est toujours fiable}
    \wrongchoice{La mémoïsation modifie la fonction}
    \wrongchoice{Les fonctions pures sont plus rapides}
    \wrongchoice{Les fonctions pures n'ont pas besoin de mémoire}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q17}
    Que calcule cette expression ?

\begin{lstlisting}
from functools import reduce
reduce(lambda a, b: a * b, [1, 2, 3, 4, 5])
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Le maximum ($5$)}
    \wrongchoice{La somme des éléments ($15$)}
    \wrongchoice{La longueur ($5$)}
    \correctchoice{Le produit des éléments ($120$)}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q18}
    Que désigne la \textbf{transparence référentielle} d'une
expression ?
    \begin{choices}
    \wrongchoice{L'expression contient des commentaires}
    \wrongchoice{L'expression est écrite en blanc sur fond noir}
    \correctchoice{L'expression peut être remplacée par sa valeur sans changer le comportement du programme}
    \wrongchoice{L'expression renvoie une référence vers un objet}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q19}
    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}
    \begin{choices}
    \wrongchoice{\texttt{L.sum() if L > 0}}
    \correctchoice{\texttt{sum(x  2 for x in L if x > 0)}}
    \wrongchoice{\texttt{reduce(L)}}
    \wrongchoice{\texttt{for x in L: total += x  2}}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q20}
    Quelle est l'écriture \textbf{récursive pure} de la fonction
qui calcule la somme des éléments d'une liste ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
def somme(L):
    return sum(L)
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def somme(L):
    total = 0
    for x in L: total += x
    return total
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
def somme(L):
    if L == []:
        return 0
    return L[0] + somme(L[1:])
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
def somme(L):
    return reduce(lambda a, b: a + b, L)
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q21}
    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 ?
    \begin{choices}
    \wrongchoice{Aucun, ce n'est pas un vrai programme}
    \correctchoice{Deux : impératif (la boucle \texttt{for}) et fonctionnel (le tri par lambda)}
    \wrongchoice{Trois : impératif, fonctionnel et objet}
    \wrongchoice{Un seul, l'impératif}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q22}
    On veut calculer la somme des carrés des entiers
d'une liste \texttt{nombres}. Quel code suit le \textbf{style
fonctionnel} ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
total = 0
for n in nombres:
    total = total + n * n
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
class Sommateur:
    def __init__(self):
        self.total = 0
    def ajouter(self, n):
        self.total += n * n
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
total = nombres
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
total = sum(n * n for n in nombres)
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q23}
    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 ?
    \begin{choices}
    \correctchoice{Une approche fonctionnelle avec une compréhension de liste ou un \texttt{map} sur une lambda}
    \wrongchoice{Un paradigme logique type Prolog}
    \wrongchoice{Une approche objet avec une classe \texttt{Remiseur} et une méthode \texttt{appliquer}}
    \wrongchoice{Aucun paradigme : il faut tout écrire à la main, avec des \texttt{goto}}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q24}
    Pourquoi la programmation fonctionnelle est-elle
particulièrement adaptée au calcul \textbf{parallèle} ?
    \begin{choices}
    \wrongchoice{Elle utilise plus de cœurs du processeur}
    \wrongchoice{Elle utilise moins de mémoire}
    \wrongchoice{Elle est plus simple à apprendre}
    \correctchoice{L'absence d'effets de bord et l'immutabilité éliminent les conflits d'accès aux données partagées}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q25}
    Parmi les affirmations suivantes, laquelle est \textbf{vraie} ?
    \begin{choices}
    \wrongchoice{La programmation fonctionnelle remplace définitivement l'orientée objet}
    \wrongchoice{La programmation fonctionnelle ne fonctionne que sur les ordinateurs récents}
    \wrongchoice{La programmation fonctionnelle interdit l'utilisation des classes}
    \correctchoice{La programmation fonctionnelle et l'orientée objet sont des paradigmes complémentaires, chacun adapté à certaines situations}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q26}
    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 ?
    \begin{choices}
    \correctchoice{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
}
    \wrongchoice{Lève une erreur car \texttt{n} est une variable locale à
\texttt{faire\_compteur}
}
    \wrongchoice{Affiche \texttt{1 1 1} car \texttt{n} est réinitialisé à chaque
appel
}
    \wrongchoice{Affiche \texttt{0 0 0} car \texttt{n} ne peut pas être modifié
dans une fonction interne
}
    \end{choices}
  \end{question}
}

\element{terminaleprogrammationfonctionnelle}{
  \begin{question}{q27}
    Les décorateurs Python (\texttt{@nom}) sont une application
directe d'un concept fondamental de la programmation
fonctionnelle. Lequel ?
    \begin{choices}
    \wrongchoice{La compréhension de liste
}
    \wrongchoice{Le filtrage par motif (\textit{pattern matching})
}
    \wrongchoice{La récursivité
}
    \correctchoice{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{choices}
  \end{question}
}


\onecopy{1}{
  \shufflegroup{terminaleprogrammationfonctionnelle}
  \insertgroup{terminaleprogrammationfonctionnelle}
}

\end{document}
