\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{Conditions et boucles}
\subtitle{QCM}
\author{Première}
\date{\today}

\begin{document}

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

% Q1 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 1 \textemdash{} Syntaxe du if}
    Quelle est la syntaxe correcte d'une condition
simple en Python ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
if (x > 0)
    print("positif");
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
if x > 0 then
    print("positif")
end
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
if x > 0:
    print("positif")
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
if {x > 0} print("positif")
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q1 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 1 \textemdash{} Syntaxe du if}
    Quelle est la syntaxe correcte d'une condition
simple en Python ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
if (x > 0)
    print("positif");
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
if x > 0 then
    print("positif")
end
\end{lstlisting}

        \item[\alert{C.}]~\\
\begin{lstlisting}
if x > 0:
    print("positif")
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
if {x > 0} print("positif")
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q2 - Réponse en D
\begin{frame}[fragile]{Question 2 \textemdash{} elif}
    À quoi sert le mot-clé \texttt{elif} en Python ?\medskip
    \begin{itemize}
        \item[A.] C'est un alias pour \texttt{if}
        \item[B.] C'est un alias pour \texttt{else}
        \item[C.] Cela teste si une variable existe
        \item[\alert<2>{D.}] \alert<2>{C'est l'équivalent du \texttt{else if} (ou \texttt{else \{ if ... \}}) en C/Java.}
    \end{itemize}
\end{frame}

% Q3 - Réponse en B
\begin{frame}[fragile]{Question 3 \textemdash{} Opérateurs logiques}
    Comment écrit-on « x est positif \textbf{et} pair »
en Python ?\medskip
    \begin{itemize}
        \item[A.] \texttt{x > 0 \&\& x \% 2 == 0}
        \item[\alert<2>{B.}] \alert<2>{\texttt{x > 0 and x \% 2 == 0}}
        \item[C.] \texttt{x > 0 et x \% 2 == 0}
        \item[D.] \texttt{x > 0, x \% 2 == 0}
    \end{itemize}
\end{frame}

% Q4 - Réponse en C
\begin{frame}[fragile]{Question 4 \textemdash{} Boucle for range}
    Combien d'itérations effectue
\texttt{for i in range(5):} ?\medskip
    \begin{itemize}
        \item[A.] Une infinité
        \item[B.] 4
        \item[\alert<2>{C.}] \alert<2>{5}
        \item[D.] 6
    \end{itemize}
\end{frame}

% Q5 - Réponse en C
\begin{frame}[fragile]{Question 5 \textemdash{} range avec deux arguments}
    Que produit \texttt{list(range(2, 7))} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{[3, 4, 5, 6, 7]}
        \item[B.] \texttt{[2, 3, 4, 5, 6, 7]}
        \item[\alert<2>{C.}] \alert<2>{\texttt{[2, 3, 4, 5, 6]}}
        \item[D.] \texttt{[2, 7]}
    \end{itemize}
\end{frame}

% Q6 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 6 \textemdash{} Boucle while}
    Que fait la boucle suivante ?
\begin{lstlisting}
n = 10
while n > 0:
    print(n)
    n -= 1
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Affiche les nombres de 1 à 10 dans l'ordre
        \item[B.] Boucle infinie
        \item[C.] N'affiche rien
        \item[D.] Affiche les nombres de 10 à 1 (en décroissant)
    \end{itemize}
\end{frame}

% Q6 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 6 \textemdash{} Boucle while}
    Que fait la boucle suivante ?
\begin{lstlisting}
n = 10
while n > 0:
    print(n)
    n -= 1
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Affiche les nombres de 1 à 10 dans l'ordre
        \item[B.] Boucle infinie
        \item[C.] N'affiche rien
        \item[\alert{D.}] \alert{Affiche les nombres de 10 à 1 (en décroissant)}
    \end{itemize}
\end{frame}

% Q7 - Réponse en A
\begin{frame}[fragile]{Question 7 \textemdash{} break}
    Que fait l'instruction \texttt{break} dans une boucle ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Sort immédiatement de la boucle (la plus interne)}
        \item[B.] Met la boucle en pause
        \item[C.] Recommence la boucle au début
        \item[D.] Termine le programme entier
    \end{itemize}
\end{frame}

% Q8 - Réponse en C
\begin{frame}[fragile]{Question 8 \textemdash{} continue}
    Que fait l'instruction \texttt{continue} dans une
boucle ?\medskip
    \begin{itemize}
        \item[A.] Met la boucle en pause
        \item[B.] Continue indéfiniment
        \item[\alert<2>{C.}] \alert<2>{Saute le reste de l'itération courante et passe à la suivante}
        \item[D.] Sort de la boucle
    \end{itemize}
\end{frame}

% Q9 - Réponse en B
\begin{frame}[fragile]{Question 9 \textemdash{} Test de parité}
    Quelle expression vaut \texttt{True} si et seulement
si \texttt{n} est \textbf{pair} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{n // 2 == 0}
        \item[\alert<2>{B.}] \alert<2>{\texttt{n \% 2 == 0}}
        \item[C.] \texttt{n / 2 == 0}
        \item[D.] \texttt{n == 2}
    \end{itemize}
\end{frame}

% Q10 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Boucle simple}
    Que fait ce code ?
\begin{lstlisting}
total = 0
for i in range(1, 5):
    total += i
print(total)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Affiche \texttt{10} (= 1+2+3+4)
        \item[B.] Boucle infinie
        \item[C.] Affiche \texttt{4}
        \item[D.] Affiche \texttt{15} (= 1+2+3+4+5)
    \end{itemize}
\end{frame}

% Q10 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 10 \textemdash{} Boucle simple}
    Que fait ce code ?
\begin{lstlisting}
total = 0
for i in range(1, 5):
    total += i
print(total)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{Affiche \texttt{10} (= 1+2+3+4)}
        \item[B.] Boucle infinie
        \item[C.] Affiche \texttt{4}
        \item[D.] Affiche \texttt{15} (= 1+2+3+4+5)
    \end{itemize}
\end{frame}

% Q11 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Boucles imbriquées}
    Combien de fois \texttt{print(...)} est-il exécuté ?
\begin{lstlisting}
for i in range(3):
    for j in range(2):
        print(i, j)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] 5
        \item[B.] 3
        \item[C.] 9
        \item[D.] 6
    \end{itemize}
\end{frame}

% Q11 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Boucles imbriquées}
    Combien de fois \texttt{print(...)} est-il exécuté ?
\begin{lstlisting}
for i in range(3):
    for j in range(2):
        print(i, j)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] 5
        \item[B.] 3
        \item[C.] 9
        \item[\alert{D.}] \alert{6}
    \end{itemize}
\end{frame}

% Q12 - Réponse en D
\begin{frame}[fragile]{Question 12 \textemdash{} Évaluation paresseuse}
    Pourquoi \texttt{False and 1/0 == 0} ne lève-t-il pas
\texttt{ZeroDivisionError} en Python ?\medskip
    \begin{itemize}
        \item[A.] Parce qu'il faut un \texttt{try/except}
        \item[B.] Parce que la division par zéro est tolérée par Python
        \item[C.] Parce que les nombres entiers ne plantent jamais
        \item[\alert<2>{D.}] \alert<2>{Parce que \texttt{and} est paresseux : si le premier opérande est \texttt{False}, le second n'est pas évalué}
    \end{itemize}
\end{frame}

% Q13 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 13 \textemdash{} Trace avec break}
    Que produit ce code ?
\begin{lstlisting}
for i in range(10):
    if i == 3:
        break
    print(i)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] 0 1 2 3 4 5 6 7 8 9
        \item[B.] Aucune sortie
        \item[C.] 0 1 2
        \item[D.] 0 1 2 3
    \end{itemize}
\end{frame}

% Q13 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 13 \textemdash{} Trace avec break}
    Que produit ce code ?
\begin{lstlisting}
for i in range(10):
    if i == 3:
        break
    print(i)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] 0 1 2 3 4 5 6 7 8 9
        \item[B.] Aucune sortie
        \item[\alert{C.}] \alert{0 1 2}
        \item[D.] 0 1 2 3
    \end{itemize}
\end{frame}

% Q14 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 14 \textemdash{} Trace avec continue}
    Que produit ce code ?
\begin{lstlisting}
for i in range(5):
    if i % 2 == 0:
        continue
    print(i)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Boucle infinie
        \item[B.] 1 3 (les impairs)
        \item[C.] 0 1 2 3 4
        \item[D.] 0 2 4 (les pairs)
    \end{itemize}
\end{frame}

% Q14 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 14 \textemdash{} Trace avec continue}
    Que produit ce code ?
\begin{lstlisting}
for i in range(5):
    if i % 2 == 0:
        continue
    print(i)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Boucle infinie
        \item[\alert{B.}] \alert{1 3 (les impairs)}
        \item[C.] 0 1 2 3 4
        \item[D.] 0 2 4 (les pairs)
    \end{itemize}
\end{frame}

% Q15 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 15 \textemdash{} While et condition}
    Que fait ce code, supposant la saisie d'un
entier non nul ?
\begin{lstlisting}
n = int(input())
while n != 1:
    if n % 2 == 0:
        n = n // 2
    else:
        n = 3 * n + 1
    print(n)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Boucle infinie systématique
        \item[B.] Affiche la suite de Fibonacci
        \item[C.] Calcule la suite de Syracuse (ou Collatz) jusqu'à atteindre 1
        \item[D.] Lève une exception
    \end{itemize}
\end{frame}

% Q15 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 15 \textemdash{} While et condition}
    Que fait ce code, supposant la saisie d'un
entier non nul ?
\begin{lstlisting}
n = int(input())
while n != 1:
    if n % 2 == 0:
        n = n // 2
    else:
        n = 3 * n + 1
    print(n)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Boucle infinie systématique
        \item[B.] Affiche la suite de Fibonacci
        \item[\alert{C.}] \alert{Calcule la suite de Syracuse (ou Collatz) jusqu'à atteindre 1}
        \item[D.] Lève une exception
    \end{itemize}
\end{frame}

% Q16 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 16 \textemdash{} Bug d'imbrication}
    \begin{lstlisting}
x = 5
if x > 0:
    if x > 10:
        print("grand")
    else:
        print("moyen")
else:
    print("négatif ou nul")
\end{lstlisting}
Qu'affiche le code ?\medskip
    \begin{itemize}
        \item[A.] Rien
        \item[B.] \texttt{négatif ou nul}
        \item[C.] \texttt{moyen}
        \item[D.] \texttt{grand}
    \end{itemize}
\end{frame}

% Q16 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 16 \textemdash{} Bug d'imbrication}
    \begin{lstlisting}
x = 5
if x > 0:
    if x > 10:
        print("grand")
    else:
        print("moyen")
else:
    print("négatif ou nul")
\end{lstlisting}
Qu'affiche le code ?\medskip
    \begin{itemize}
        \item[A.] Rien
        \item[B.] \texttt{négatif ou nul}
        \item[\alert{C.}] \alert{\texttt{moyen}}
        \item[D.] \texttt{grand}
    \end{itemize}
\end{frame}

% Q17 - Réponse en B
\begin{frame}[fragile]{Question 17 \textemdash{} Chaînage}
    L'expression \texttt{0 < x < 100} en Python est
équivalente à :\medskip
    \begin{itemize}
        \item[A.] \texttt{0 < x or x < 100}
        \item[\alert<2>{B.}] \alert<2>{\texttt{0 < x and x < 100}}
        \item[C.] Une erreur de syntaxe
        \item[D.] \texttt{(0 < x) < 100}
    \end{itemize}
\end{frame}

% Q18 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 18 \textemdash{} Parcours de liste}
    Quelle boucle permet d'afficher les éléments
d'une liste ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
while i in liste:
    print(i)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
for x in liste:
    print(x)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
for i in range(len(liste)):
    print(liste[i])
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
do print(x) for x in liste
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q18 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 18 \textemdash{} Parcours de liste}
    Quelle boucle permet d'afficher les éléments
d'une liste ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
while i in liste:
    print(i)
\end{lstlisting}

        \item[\alert{B.}]~\\
\begin{lstlisting}
for x in liste:
    print(x)
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
for i in range(len(liste)):
    print(liste[i])
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
do print(x) for x in liste
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q19 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 19 \textemdash{} Compréhension de liste}
    Quelle est l'équivalent \textbf{pythonique} de :
\begin{lstlisting}
carres = []
for i in range(10):
    carres.append(i * i)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] \texttt{carres = [i * i for i in range(10)]}
        \item[B.] \texttt{carres = [10][i * i]}
        \item[C.] \texttt{carres = map(2, range(10))}
        \item[D.] \texttt{carres = range(10)  2}
    \end{itemize}
\end{frame}

% Q19 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 19 \textemdash{} Compréhension de liste}
    Quelle est l'équivalent \textbf{pythonique} de :
\begin{lstlisting}
carres = []
for i in range(10):
    carres.append(i * i)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{\texttt{carres = [i * i for i in range(10)]}}
        \item[B.] \texttt{carres = [10][i * i]}
        \item[C.] \texttt{carres = map(2, range(10))}
        \item[D.] \texttt{carres = range(10)  2}
    \end{itemize}
\end{frame}

% Q20 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 20 \textemdash{} Trace de while}
    Que vaut \texttt{n} à la fin de :
\begin{lstlisting}
n = 100
while n > 1:
    n = n // 2
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Une infinité
        \item[B.] 1
        \item[C.] 0
        \item[D.] 2
    \end{itemize}
\end{frame}

% Q20 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 20 \textemdash{} Trace de while}
    Que vaut \texttt{n} à la fin de :
\begin{lstlisting}
n = 100
while n > 1:
    n = n // 2
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Une infinité
        \item[\alert{B.}] \alert{1}
        \item[C.] 0
        \item[D.] 2
    \end{itemize}
\end{frame}

% Q21 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 21 \textemdash{} Boucle infinie}
    Pourquoi cette boucle est-elle infinie ?
\begin{lstlisting}
i = 0
while i < 10:
    print(i)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Parce que \texttt{print} ne renvoie rien
        \item[B.] Parce que \texttt{while} est toujours infini
        \item[C.] Parce que \texttt{i = 0} est faux
        \item[D.] Parce que \texttt{i} n'est jamais modifié à l'intérieur de la boucle
    \end{itemize}
\end{frame}

% Q21 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 21 \textemdash{} Boucle infinie}
    Pourquoi cette boucle est-elle infinie ?
\begin{lstlisting}
i = 0
while i < 10:
    print(i)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Parce que \texttt{print} ne renvoie rien
        \item[B.] Parce que \texttt{while} est toujours infini
        \item[C.] Parce que \texttt{i = 0} est faux
        \item[\alert{D.}] \alert{Parce que \texttt{i} n'est jamais modifié à l'intérieur de la boucle}
    \end{itemize}
\end{frame}

% Q22 - Réponse en B
\begin{frame}[fragile]{Question 22 \textemdash{} enumerate}
    À quoi sert \texttt{enumerate} en Python ?\medskip
    \begin{itemize}
        \item[A.] À compter les éléments d'une liste
        \item[\alert<2>{B.}] \alert<2>{À itérer en récupérant à la fois l'indice et la valeur de chaque élément}
        \item[C.] À renvoyer une chaîne
        \item[D.] À trier la liste
    \end{itemize}
\end{frame}

% Q23 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Modifier en parcourant}
    Pourquoi ce code est-il \textbf{buggué} ?
\begin{lstlisting}
liste = [1, 2, 3, 4, 5]
for x in liste:
    if x > 2:
        liste.remove(x)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Parce que \texttt{5 > 2} est faux
        \item[B.] Parce que modifier la liste pendant qu'on l'itère provoque des éléments sautés ou des comportements imprévisibles
        \item[C.] Parce que \texttt{remove} n'existe pas
        \item[D.] Parce que la boucle ne s'exécute jamais
    \end{itemize}
\end{frame}

% Q23 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Modifier en parcourant}
    Pourquoi ce code est-il \textbf{buggué} ?
\begin{lstlisting}
liste = [1, 2, 3, 4, 5]
for x in liste:
    if x > 2:
        liste.remove(x)
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Parce que \texttt{5 > 2} est faux
        \item[\alert{B.}] \alert{Parce que modifier la liste pendant qu'on l'itère provoque des éléments sautés ou des comportements imprévisibles}
        \item[C.] Parce que \texttt{remove} n'existe pas
        \item[D.] Parce que la boucle ne s'exécute jamais
    \end{itemize}
\end{frame}

% Q24 - Réponse en A
\begin{frame}[fragile]{Question 24 \textemdash{} for / else}
    Python autorise une clause \texttt{else} après un
\texttt{for}. Quand est-elle exécutée ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Si la boucle se termine normalement (sans \texttt{break})}
        \item[B.] Toujours, comme un finally
        \item[C.] Si la boucle est interrompue par \texttt{break}
        \item[D.] Jamais en Python
    \end{itemize}
\end{frame}

% Q25 - Réponse en A
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations suivantes, laquelle est
\textbf{fausse} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{break} et \texttt{continue} ont le même effet}
        \item[B.] La boucle \texttt{for} sur un \texttt{range} fini termine toujours sans intervention
        \item[C.] Les opérateurs logiques \texttt{and}, \texttt{or}, \texttt{not} permettent de combiner des conditions
        \item[D.] La boucle \texttt{while} peut être infinie si la condition ne devient jamais fausse
    \end{itemize}
\end{frame}

% Q26 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Boucle de saisie validée}
    On veut que l'utilisateur saisisse un entier
strictement positif et redemander tant que la
réponse n'est pas correcte. Quel code convient le
mieux ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
for i in range(10):
    n = int(input("n ? "))
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
while True:
    n = int(input("n ? "))
    if n > 0:
        break
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
n = -1
while n > 0:
    n = int(input("n ? "))
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
n = int(input("n ? "))
if n <= 0:
    n = int(input("n ? "))
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q26 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Boucle de saisie validée}
    On veut que l'utilisateur saisisse un entier
strictement positif et redemander tant que la
réponse n'est pas correcte. Quel code convient le
mieux ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
for i in range(10):
    n = int(input("n ? "))
\end{lstlisting}

        \item[\alert{B.}]~\\
\begin{lstlisting}
while True:
    n = int(input("n ? "))
    if n > 0:
        break
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
n = -1
while n > 0:
    n = int(input("n ? "))
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
n = int(input("n ? "))
if n <= 0:
    n = int(input("n ? "))
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q27 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} if/elif vs plusieurs if}
    Considérons les deux extraits suivants. En quoi
diffèrent-ils ?

\begin{lstlisting}
# Extrait A
if x > 0:
    y = 1
elif x > 10:
    y = 2

# Extrait B
if x > 0:
    y = 1
if x > 10:
    y = 2
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Ils produisent toujours le même résultat
        \item[B.] L'extrait A teste les conditions de manière exclusive ; l'extrait B les évalue indépendamment, ce qui peut écraser la valeur de y
        \item[C.] L'extrait A produit une erreur car \texttt{elif} ne fonctionne pas seul
        \item[D.] L'extrait B est plus rapide que l'extrait A
    \end{itemize}
\end{frame}

% Q27 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} if/elif vs plusieurs if}
    Considérons les deux extraits suivants. En quoi
diffèrent-ils ?

\begin{lstlisting}
# Extrait A
if x > 0:
    y = 1
elif x > 10:
    y = 2

# Extrait B
if x > 0:
    y = 1
if x > 10:
    y = 2
\end{lstlisting}\medskip
    \begin{itemize}
        \item[A.] Ils produisent toujours le même résultat
        \item[\alert{B.}] \alert{L'extrait A teste les conditions de manière exclusive ; l'extrait B les évalue indépendamment, ce qui peut écraser la valeur de y}
        \item[C.] L'extrait A produit une erreur car \texttt{elif} ne fonctionne pas seul
        \item[D.] L'extrait B est plus rapide que l'extrait A
    \end{itemize}
\end{frame}

% Q28 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} Parcours parallèle de deux listes}
    Quelle est la façon la plus pythonique de parcourir
en parallèle deux listes \texttt{noms} et \texttt{notes} de même
longueur, pour afficher chaque nom suivi de sa
note ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
print(noms + notes)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
for i in range(len(noms)):
    print(noms[i], notes[i])
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
for nom in noms:
    for note in notes:
        print(nom, note)
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
for nom, note in zip(noms, notes):
    print(nom, note)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q28 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} Parcours parallèle de deux listes}
    Quelle est la façon la plus pythonique de parcourir
en parallèle deux listes \texttt{noms} et \texttt{notes} de même
longueur, pour afficher chaque nom suivi de sa
note ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
print(noms + notes)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
for i in range(len(noms)):
    print(noms[i], notes[i])
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
for nom in noms:
    for note in notes:
        print(nom, note)
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
for nom, note in zip(noms, notes):
    print(nom, note)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q29 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 29 \textemdash{} Calcul d'une racine entière}
    On exécute le code suivant :

\begin{lstlisting}
n = 30
r = 0
while r * r <= n:
    r = r + 1
\end{lstlisting}

Quelle est la valeur de \texttt{r} à la sortie de la boucle ?\medskip
    \begin{itemize}
        \item[A.] $7$
        \item[B.] $6$
        \item[C.] $30$
        \item[D.] $5$
    \end{itemize}
\end{frame}

% Q29 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 29 \textemdash{} Calcul d'une racine entière}
    On exécute le code suivant :

\begin{lstlisting}
n = 30
r = 0
while r * r <= n:
    r = r + 1
\end{lstlisting}

Quelle est la valeur de \texttt{r} à la sortie de la boucle ?\medskip
    \begin{itemize}
        \item[A.] $7$
        \item[\alert{B.}] \alert{$6$}
        \item[C.] $30$
        \item[D.] $5$
    \end{itemize}
\end{frame}

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

\end{document}
