\documentclass[a4paper,11pt]{article}

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

\title{Conditions et boucles}
\date{Numérique et sciences informatiques}

\begin{document}

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

\bigskip

\element{premiereconditionsboucles}{
  \begin{question}{q01}
    Quelle est la syntaxe correcte d'une condition
simple en Python ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
if (x > 0)
    print("positif");
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
if x > 0 then
    print("positif")
end
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
if x > 0:
    print("positif")
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
if {x > 0} print("positif")
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q02}
    À quoi sert le mot-clé \texttt{elif} en Python ?
    \begin{choices}
    \wrongchoice{C'est un alias pour \texttt{if}}
    \wrongchoice{C'est un alias pour \texttt{else}}
    \wrongchoice{Cela teste si une variable existe}
    \correctchoice{C'est l'équivalent du \texttt{else if} (ou \texttt{else \{ if ... \}}) en C/Java.}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q03}
    Comment écrit-on « x est positif \textbf{et} pair »
en Python ?
    \begin{choices}
    \wrongchoice{\texttt{x > 0 \&\& x \% 2 == 0}}
    \correctchoice{\texttt{x > 0 and x \% 2 == 0}}
    \wrongchoice{\texttt{x > 0 et x \% 2 == 0}}
    \wrongchoice{\texttt{x > 0, x \% 2 == 0}}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q04}
    Combien d'itérations effectue
\texttt{for i in range(5):} ?
    \begin{choices}
    \wrongchoice{Une infinité}
    \wrongchoice{4}
    \correctchoice{5}
    \wrongchoice{6}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q05}
    Que produit \texttt{list(range(2, 7))} ?
    \begin{choices}
    \wrongchoice{\texttt{[3, 4, 5, 6, 7]}}
    \wrongchoice{\texttt{[2, 3, 4, 5, 6, 7]}}
    \correctchoice{\texttt{[2, 3, 4, 5, 6]}}
    \wrongchoice{\texttt{[2, 7]}}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q06}
    Que fait la boucle suivante ?
\begin{lstlisting}
n = 10
while n > 0:
    print(n)
    n -= 1
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Affiche les nombres de 1 à 10 dans l'ordre}
    \wrongchoice{Boucle infinie}
    \wrongchoice{N'affiche rien}
    \correctchoice{Affiche les nombres de 10 à 1 (en décroissant)}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q07}
    Que fait l'instruction \texttt{break} dans une boucle ?
    \begin{choices}
    \correctchoice{Sort immédiatement de la boucle (la plus interne)}
    \wrongchoice{Met la boucle en pause}
    \wrongchoice{Recommence la boucle au début}
    \wrongchoice{Termine le programme entier}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q08}
    Que fait l'instruction \texttt{continue} dans une
boucle ?
    \begin{choices}
    \wrongchoice{Met la boucle en pause}
    \wrongchoice{Continue indéfiniment}
    \correctchoice{Saute le reste de l'itération courante et passe à la suivante}
    \wrongchoice{Sort de la boucle}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q09}
    Quelle expression vaut \texttt{True} si et seulement
si \texttt{n} est \textbf{pair} ?
    \begin{choices}
    \wrongchoice{\texttt{n // 2 == 0}}
    \correctchoice{\texttt{n \% 2 == 0}}
    \wrongchoice{\texttt{n / 2 == 0}}
    \wrongchoice{\texttt{n == 2}}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q10}
    Que fait ce code ?
\begin{lstlisting}
total = 0
for i in range(1, 5):
    total += i
print(total)
\end{lstlisting}
    \begin{choices}
    \correctchoice{Affiche \texttt{10} (= 1+2+3+4)}
    \wrongchoice{Boucle infinie}
    \wrongchoice{Affiche \texttt{4}}
    \wrongchoice{Affiche \texttt{15} (= 1+2+3+4+5)}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q11}
    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}
    \begin{choices}
    \wrongchoice{5}
    \wrongchoice{3}
    \wrongchoice{9}
    \correctchoice{6}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q12}
    Pourquoi \texttt{False and 1/0 == 0} ne lève-t-il pas
\texttt{ZeroDivisionError} en Python ?
    \begin{choices}
    \wrongchoice{Parce qu'il faut un \texttt{try/except}}
    \wrongchoice{Parce que la division par zéro est tolérée par Python}
    \wrongchoice{Parce que les nombres entiers ne plantent jamais}
    \correctchoice{Parce que \texttt{and} est paresseux : si le premier opérande est \texttt{False}, le second n'est pas évalué}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q13}
    Que produit ce code ?
\begin{lstlisting}
for i in range(10):
    if i == 3:
        break
    print(i)
\end{lstlisting}
    \begin{choices}
    \wrongchoice{0 1 2 3 4 5 6 7 8 9}
    \wrongchoice{Aucune sortie}
    \correctchoice{0 1 2}
    \wrongchoice{0 1 2 3}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q14}
    Que produit ce code ?
\begin{lstlisting}
for i in range(5):
    if i % 2 == 0:
        continue
    print(i)
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Boucle infinie}
    \correctchoice{1 3 (les impairs)}
    \wrongchoice{0 1 2 3 4}
    \wrongchoice{0 2 4 (les pairs)}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q15}
    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}
    \begin{choices}
    \wrongchoice{Boucle infinie systématique}
    \wrongchoice{Affiche la suite de Fibonacci}
    \correctchoice{Calcule la suite de Syracuse (ou Collatz) jusqu'à atteindre 1}
    \wrongchoice{Lève une exception}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q16}
    \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 ?
    \begin{choices}
    \wrongchoice{Rien}
    \wrongchoice{\texttt{négatif ou nul}}
    \correctchoice{\texttt{moyen}}
    \wrongchoice{\texttt{grand}}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q17}
    L'expression \texttt{0 < x < 100} en Python est
équivalente à :
    \begin{choices}
    \wrongchoice{\texttt{0 < x or x < 100}}
    \correctchoice{\texttt{0 < x and x < 100}}
    \wrongchoice{Une erreur de syntaxe}
    \wrongchoice{\texttt{(0 < x) < 100}}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q18}
    Quelle boucle permet d'afficher les éléments
d'une liste ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
while i in liste:
    print(i)
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
for x in liste:
    print(x)
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
for i in range(len(liste)):
    print(liste[i])
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
do print(x) for x in liste
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q19}
    Quelle est l'équivalent \textbf{pythonique} de :
\begin{lstlisting}
carres = []
for i in range(10):
    carres.append(i * i)
\end{lstlisting}
    \begin{choices}
    \correctchoice{\texttt{carres = [i * i for i in range(10)]}}
    \wrongchoice{\texttt{carres = [10][i * i]}}
    \wrongchoice{\texttt{carres = map(2, range(10))}}
    \wrongchoice{\texttt{carres = range(10)  2}}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q20}
    Que vaut \texttt{n} à la fin de :
\begin{lstlisting}
n = 100
while n > 1:
    n = n // 2
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Une infinité}
    \correctchoice{1}
    \wrongchoice{0}
    \wrongchoice{2}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q21}
    Pourquoi cette boucle est-elle infinie ?
\begin{lstlisting}
i = 0
while i < 10:
    print(i)
\end{lstlisting}
    \begin{choices}
    \wrongchoice{Parce que \texttt{print} ne renvoie rien}
    \wrongchoice{Parce que \texttt{while} est toujours infini}
    \wrongchoice{Parce que \texttt{i = 0} est faux}
    \correctchoice{Parce que \texttt{i} n'est jamais modifié à l'intérieur de la boucle}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q22}
    À quoi sert \texttt{enumerate} en Python ?
    \begin{choices}
    \wrongchoice{À compter les éléments d'une liste}
    \correctchoice{À itérer en récupérant à la fois l'indice et la valeur de chaque élément}
    \wrongchoice{À renvoyer une chaîne}
    \wrongchoice{À trier la liste}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q23}
    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}
    \begin{choices}
    \wrongchoice{Parce que \texttt{5 > 2} est faux}
    \correctchoice{Parce que modifier la liste pendant qu'on l'itère provoque des éléments sautés ou des comportements imprévisibles}
    \wrongchoice{Parce que \texttt{remove} n'existe pas}
    \wrongchoice{Parce que la boucle ne s'exécute jamais}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q24}
    Python autorise une clause \texttt{else} après un
\texttt{for}. Quand est-elle exécutée ?
    \begin{choices}
    \correctchoice{Si la boucle se termine normalement (sans \texttt{break})}
    \wrongchoice{Toujours, comme un finally}
    \wrongchoice{Si la boucle est interrompue par \texttt{break}}
    \wrongchoice{Jamais en Python}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q25}
    Parmi les affirmations suivantes, laquelle est
\textbf{fausse} ?
    \begin{choices}
    \correctchoice{\texttt{break} et \texttt{continue} ont le même effet}
    \wrongchoice{La boucle \texttt{for} sur un \texttt{range} fini termine toujours sans intervention}
    \wrongchoice{Les opérateurs logiques \texttt{and}, \texttt{or}, \texttt{not} permettent de combiner des conditions}
    \wrongchoice{La boucle \texttt{while} peut être infinie si la condition ne devient jamais fausse}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q26}
    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 ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
for i in range(10):
    n = int(input("n ? "))
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
while True:
    n = int(input("n ? "))
    if n > 0:
        break
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
n = -1
while n > 0:
    n = int(input("n ? "))
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
n = int(input("n ? "))
if n <= 0:
    n = int(input("n ? "))
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q27}
    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}
    \begin{choices}
    \wrongchoice{Ils produisent toujours le même résultat}
    \correctchoice{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}
    \wrongchoice{L'extrait A produit une erreur car \texttt{elif} ne fonctionne pas seul}
    \wrongchoice{L'extrait B est plus rapide que l'extrait A}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q28}
    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 ?
    \begin{choices}
    \wrongchoice{\begin{lstlisting}
print(noms + notes)
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
for i in range(len(noms)):
    print(noms[i], notes[i])
\end{lstlisting}
}
    \wrongchoice{\begin{lstlisting}
for nom in noms:
    for note in notes:
        print(nom, note)
\end{lstlisting}
}
    \correctchoice{\begin{lstlisting}
for nom, note in zip(noms, notes):
    print(nom, note)
\end{lstlisting}
}
    \end{choices}
  \end{question}
}

\element{premiereconditionsboucles}{
  \begin{question}{q29}
    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 ?
    \begin{choices}
    \wrongchoice{$7$}
    \correctchoice{$6$}
    \wrongchoice{$30$}
    \wrongchoice{$5$}
    \end{choices}
  \end{question}
}


\onecopy{1}{
  \shufflegroup{premiereconditionsboucles}
  \insertgroup{premiereconditionsboucles}
}

\end{document}
