\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{Recherche linéaire}
\subtitle{QCM}
\author{Première}
\date{\today}

\begin{document}

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

% Q1 - Réponse en B
\begin{frame}[fragile]{Question 1 \textemdash{} Recherche linéaire ou séquentielle}
    En quoi consiste la \textbf{recherche linéaire} (ou séquentielle) ?\medskip
    \begin{itemize}
        \item[A.] Sauter directement à la position centrale puis comparer
        \item[\alert<2>{B.}] \alert<2>{Parcourir la liste élément par élément et comparer chaque valeur à celle recherchée}
        \item[C.] Utiliser un dictionnaire pour aller directement à la valeur
        \item[D.] Trier la liste puis chercher le premier élément
    \end{itemize}
\end{frame}

% Q2 - Réponse en B
\begin{frame}[fragile]{Question 2 \textemdash{} Liste triée ou non ?}
    La recherche linéaire suppose-t-elle que la liste
soit \textbf{triée} ?\medskip
    \begin{itemize}
        \item[A.] Uniquement si la liste contient des nombres
        \item[\alert<2>{B.}] \alert<2>{Non, elle fonctionne sur n'importe quelle liste}
        \item[C.] Uniquement si la liste contient au moins 10 éléments
        \item[D.] Oui, sinon elle ne fonctionne pas
    \end{itemize}
\end{frame}

% Q3 - Réponse en C
\begin{frame}[fragile]{Question 3 \textemdash{} Pire cas}
    Quel est le \textbf{nombre maximal de comparaisons} dans
une recherche linéaire dans une liste de longueur n ?\medskip
    \begin{itemize}
        \item[A.] n²
        \item[B.] log(n)
        \item[\alert<2>{C.}] \alert<2>{n}
        \item[D.] n / 2
    \end{itemize}
\end{frame}

% Q4 - Réponse en D
\begin{frame}[fragile]{Question 4 \textemdash{} Quand arrête-t-on la boucle ?}
    Dans une recherche linéaire bien programmée, quand
arrête-t-on de parcourir la liste ?\medskip
    \begin{itemize}
        \item[A.] Au bout de log(n) comparaisons
        \item[B.] Dès que l'élément n'est pas trouvé
        \item[C.] Toujours après avoir parcouru toute la liste
        \item[\alert<2>{D.}] \alert<2>{Dès que l'élément cherché est trouvé, ou en arrivant à la fin de la liste}
    \end{itemize}
\end{frame}

% Q5 - Réponse en D
\begin{frame}[fragile]{Question 5 \textemdash{} Que renvoyer si absent ?}
    Si l'élément cherché n'est \textbf{pas dans la liste},
que peut-on raisonnablement renvoyer ?\medskip
    \begin{itemize}
        \item[A.] La dernière position de la liste (n - 1)
        \item[B.] La position 0 (par défaut)
        \item[C.] La longueur de la liste
        \item[\alert<2>{D.}] \alert<2>{\texttt{None} ou \texttt{-1}, pour signaler l'absence}
    \end{itemize}
\end{frame}

% Q6 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 6 \textemdash{} Code Python typique}
    Quel code implémente correctement la recherche
linéaire et renvoie l'\textbf{indice} de la cible (ou
-1 si absente) ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def chercher(liste, cible):
    for i in range(len(liste)):
        if liste[i] == cible:
            return i
        return -1
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def chercher(liste, cible):
    for x in liste:
        if x == cible:
            return x
    return -1
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def chercher(liste, cible):
    for i in range(len(liste)):
        if liste[i] == cible:
            return i
    return -1
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def chercher(liste, cible):
    while True:
        if liste[0] == cible:
            return 0
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q6 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 6 \textemdash{} Code Python typique}
    Quel code implémente correctement la recherche
linéaire et renvoie l'\textbf{indice} de la cible (ou
-1 si absente) ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def chercher(liste, cible):
    for i in range(len(liste)):
        if liste[i] == cible:
            return i
        return -1
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def chercher(liste, cible):
    for x in liste:
        if x == cible:
            return x
    return -1
\end{lstlisting}

        \item[\alert{C.}]~\\
\begin{lstlisting}
def chercher(liste, cible):
    for i in range(len(liste)):
        if liste[i] == cible:
            return i
    return -1
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def chercher(liste, cible):
    while True:
        if liste[0] == cible:
            return 0
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q7 - Réponse en C
\begin{frame}[fragile]{Question 7 \textemdash{} Opérateur \texttt{in}}
    L'expression Python \texttt{42 in liste} réalise
implicitement quelle opération ?\medskip
    \begin{itemize}
        \item[A.] Un tri
        \item[B.] Une recherche dichotomique (rapide)
        \item[\alert<2>{C.}] \alert<2>{Une recherche linéaire de gauche à droite, qui s'arrête dès qu'une correspondance est trouvée}
        \item[D.] Une vérification de type
    \end{itemize}
\end{frame}

% Q8 - Réponse en C
\begin{frame}[fragile]{Question 8 \textemdash{} Liste vide}
    Que doit renvoyer une recherche linéaire (qui
renvoie l'indice ou -1) sur une \textbf{liste vide} ?\medskip
    \begin{itemize}
        \item[A.] Une exception
        \item[B.] \texttt{None}
        \item[\alert<2>{C.}] \alert<2>{-1 (élément absent)}
        \item[D.] 0
    \end{itemize}
\end{frame}

% Q9 - Réponse en D
\begin{frame}[fragile]{Question 9 \textemdash{} Recherche de minimum}
    Trouver le \textbf{minimum} d'une liste est aussi un
cas de recherche linéaire. Quelle est sa
complexité ?\medskip
    \begin{itemize}
        \item[A.] O(n²) : double boucle nécessaire
        \item[B.] O(1) : on prend juste le premier élément
        \item[C.] O(log n) : recherche dichotomique
        \item[\alert<2>{D.}] \alert<2>{O(n) : on doit comparer tous les éléments}
    \end{itemize}
\end{frame}

% Q10 - Réponse en D
\begin{frame}[fragile]{Question 10 \textemdash{} Trace simple}
    On cherche \texttt{cible = 7} dans \texttt{liste = [3, 5, 7, 2, 7]}.
Combien de comparaisons effectue une recherche
linéaire \textbf{avec arrêt précoce} ?\medskip
    \begin{itemize}
        \item[A.] 5
        \item[B.] 1
        \item[C.] 2
        \item[\alert<2>{D.}] \alert<2>{3}
    \end{itemize}
\end{frame}

% Q11 - Réponse en A
\begin{frame}[fragile]{Question 11 \textemdash{} Meilleur cas}
    Quelle est la complexité dans le \textbf{meilleur cas}
de la recherche linéaire ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{O(1)}
        \item[B.] O(n²)
        \item[C.] O(log n)
        \item[D.] O(n)
    \end{itemize}
\end{frame}

% Q12 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 12 \textemdash{} Variante booléenne}
    On veut juste savoir si l'élément est présent ou
non (sans avoir besoin de l'indice). Quelle
version est la plus pythonique ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def present(liste, cible):
    return liste.index(cible)
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def present(liste, cible):
    return cible in liste
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def present(liste, cible):
    for x in liste:
        if x == cible:
            return True
    return False
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def present(liste, cible):
    return cible == liste
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q12 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 12 \textemdash{} Variante booléenne}
    On veut juste savoir si l'élément est présent ou
non (sans avoir besoin de l'indice). Quelle
version est la plus pythonique ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def present(liste, cible):
    return liste.index(cible)
\end{lstlisting}

        \item[\alert{B.}]~\\
\begin{lstlisting}
def present(liste, cible):
    return cible in liste
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def present(liste, cible):
    for x in liste:
        if x == cible:
            return True
    return False
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def present(liste, cible):
    return cible == liste
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q13 - Réponse en B
\begin{frame}[fragile]{Question 13 \textemdash{} Toutes les occurrences}
    Pour trouver \textbf{toutes} les positions où la cible
apparaît dans la liste, quelle adaptation de la
recherche linéaire utilise-t-on ?\medskip
    \begin{itemize}
        \item[A.] On trie la liste avant de chercher
        \item[\alert<2>{B.}] \alert<2>{On parcourt toute la liste et on enregistre tous les indices où l'élément correspond}
        \item[C.] On utilise une recherche dichotomique
        \item[D.] On s'arrête à la première occurrence et on l'enregistre
    \end{itemize}
\end{frame}

% Q14 - Réponse en A
\begin{frame}[fragile]{Question 14 \textemdash{} Linéaire vs dichotomique}
    Pour rechercher un élément dans une \textbf{liste triée}
de 1 000 000 d'éléments, combien de comparaisons
au pire avec chacune des deux méthodes ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Linéaire : 1 000 000 ; dichotomique : ~ 20}
        \item[B.] Linéaire : 1 000 000 ; dichotomique : 1 000
        \item[C.] Linéaire : 1 000 ; dichotomique : 1 000 000
        \item[D.] Les deux sont identiques
    \end{itemize}
\end{frame}

% Q15 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 15 \textemdash{} Bug d'initialisation}
    Un élève écrit
\begin{lstlisting}
def chercher(liste, cible):
    for i in range(len(liste)):
        if liste[i] == cible:
            trouve = True
        else:
            trouve = False
    return trouve
\end{lstlisting}
Quel est le bug ?\medskip
    \begin{itemize}
        \item[A.] \texttt{return} doit être à l'intérieur de la boucle
        \item[B.] À chaque itération, \texttt{trouve} est réinitialisé. Seul le résultat de la dernière comparaison est renvoyé.
        \item[C.] La fonction est trop lente
        \item[D.] La variable \texttt{trouve} n'est pas définie hors de la boucle
    \end{itemize}
\end{frame}

% Q15 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 15 \textemdash{} Bug d'initialisation}
    Un élève écrit
\begin{lstlisting}
def chercher(liste, cible):
    for i in range(len(liste)):
        if liste[i] == cible:
            trouve = True
        else:
            trouve = False
    return trouve
\end{lstlisting}
Quel est le bug ?\medskip
    \begin{itemize}
        \item[A.] \texttt{return} doit être à l'intérieur de la boucle
        \item[\alert{B.}] \alert{À chaque itération, \texttt{trouve} est réinitialisé. Seul le résultat de la dernière comparaison est renvoyé.}
        \item[C.] La fonction est trop lente
        \item[D.] La variable \texttt{trouve} n'est pas définie hors de la boucle
    \end{itemize}
\end{frame}

% Q16 - Réponse en B
\begin{frame}[fragile]{Question 16 \textemdash{} While ou for ?}
    Quelle est la différence pratique entre une
recherche linéaire écrite avec \texttt{for} et avec
\texttt{while} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{while} ne fonctionne pas sur les listes
        \item[\alert<2>{B.}] \alert<2>{\texttt{for} est plus lisible quand on parcourt tous les indices ; \texttt{while} est plus naturel pour combiner deux conditions d'arrêt (par exemple \texttt{i < n and not trouve})}
        \item[C.] \texttt{for} est plus rapide
        \item[D.] Les deux sont strictement équivalents en Python
    \end{itemize}
\end{frame}

% Q17 - Réponse en A
\begin{frame}[fragile]{Question 17 \textemdash{} Recherche dans un dictionnaire}
    Pourquoi la recherche d'une \textbf{clé} dans un
dictionnaire Python est-elle en O(1) (alors que
\texttt{in liste} est en O(n)) ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Parce que les dictionnaires utilisent une table de hachage : la position d'une clé est calculée directement par une fonction de hachage}
        \item[B.] Parce que les dictionnaires sont triés
        \item[C.] Parce qu'ils contiennent moins de données
        \item[D.] Parce que Python est un langage rapide
    \end{itemize}
\end{frame}

% Q18 - Réponse en C
\begin{frame}[fragile]{Question 18 \textemdash{} Optimisation par fréquence}
    Si l'on sait qu'un élément est \textbf{plus souvent
cherché} que les autres, comment optimiser une
série de recherches linéaires successives ?\medskip
    \begin{itemize}
        \item[A.] Trier la liste par ordre croissant
        \item[B.] Doubler la taille de la liste
        \item[\alert<2>{C.}] \alert<2>{Placer les éléments les plus fréquents au début de la liste}
        \item[D.] Convertir la liste en chaîne
    \end{itemize}
\end{frame}

% Q19 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 19 \textemdash{} Recherche dans liste de tuples}
    Soit
\texttt{eleves = [("Alice", 17), ("Bob", 16), ("Eve", 18)]}.
Comment trouver l'âge d'Alice ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
eleves["Alice"]
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
for nom, age in eleves:
    if nom == "Alice":
        return age
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
eleves.index(("Alice"))
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
eleves.find("Alice")
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q19 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 19 \textemdash{} Recherche dans liste de tuples}
    Soit
\texttt{eleves = [("Alice", 17), ("Bob", 16), ("Eve", 18)]}.
Comment trouver l'âge d'Alice ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
eleves["Alice"]
\end{lstlisting}

        \item[\alert{B.}]~\\
\begin{lstlisting}
for nom, age in eleves:
    if nom == "Alice":
        return age
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
eleves.index(("Alice"))
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
eleves.find("Alice")
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q20 - Réponse en D
\begin{frame}[fragile]{Question 20 \textemdash{} Sur une chaîne}
    L'expression \texttt{"a" in "abracadabra"} :\medskip
    \begin{itemize}
        \item[A.] Lève une exception
        \item[B.] Renvoie \texttt{False}
        \item[C.] Renvoie le nombre d'occurrences
        \item[\alert<2>{D.}] \alert<2>{Renvoie \texttt{True}}
    \end{itemize}
\end{frame}

% Q21 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 21 \textemdash{} Bug : oubli du \texttt{break}}
    \begin{lstlisting}
def trouver(liste, cible):
    indice = -1
    for i in range(len(liste)):
        if liste[i] == cible:
            indice = i
    return indice
\end{lstlisting}
Quel est le comportement de cette fonction si la
cible apparaît plusieurs fois ?\medskip
    \begin{itemize}
        \item[A.] Elle renvoie -1
        \item[B.] Elle renvoie l'indice de la dernière occurrence
        \item[C.] Elle entre dans une boucle infinie
        \item[D.] Elle renvoie l'indice de la première occurrence
    \end{itemize}
\end{frame}

% Q21 - Réponse en B
\begin{frame}[fragile,allowframebreaks]{Question 21 \textemdash{} Bug : oubli du \texttt{break}}
    \begin{lstlisting}
def trouver(liste, cible):
    indice = -1
    for i in range(len(liste)):
        if liste[i] == cible:
            indice = i
    return indice
\end{lstlisting}
Quel est le comportement de cette fonction si la
cible apparaît plusieurs fois ?\medskip
    \begin{itemize}
        \item[A.] Elle renvoie -1
        \item[\alert{B.}] \alert{Elle renvoie l'indice de la dernière occurrence}
        \item[C.] Elle entre dans une boucle infinie
        \item[D.] Elle renvoie l'indice de la première occurrence
    \end{itemize}
\end{frame}

% Q22 - Réponse en A
\begin{frame}[fragile]{Question 22 \textemdash{} Choisir le bon algorithme}
    Pour rechercher un élément dans une liste de
100 éléments, \textbf{non triée}, qu'on ne consultera
qu'une seule fois, quelle stratégie est la plus
efficace \textbf{globalement} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Recherche linéaire directement}
        \item[B.] Convertir en dictionnaire
        \item[C.] Faire la recherche en parallèle sur 4 cœurs
        \item[D.] Trier puis dichotomie
    \end{itemize}
\end{frame}

% Q23 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Boucle while à bug}
    \begin{lstlisting}
def chercher(liste, cible):
    i = 0
    while liste[i] != cible:
        i += 1
    return i
\end{lstlisting}
Quel problème pose ce code ?\medskip
    \begin{itemize}
        \item[A.] Aucun, le code est correct
        \item[B.] La fonction ne renvoie jamais rien
        \item[C.] Si l'élément est absent, la boucle dépasse la fin de la liste et lève \texttt{IndexError}
        \item[D.] Le code modifie la liste
    \end{itemize}
\end{frame}

% Q23 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Boucle while à bug}
    \begin{lstlisting}
def chercher(liste, cible):
    i = 0
    while liste[i] != cible:
        i += 1
    return i
\end{lstlisting}
Quel problème pose ce code ?\medskip
    \begin{itemize}
        \item[A.] Aucun, le code est correct
        \item[B.] La fonction ne renvoie jamais rien
        \item[\alert{C.}] \alert{Si l'élément est absent, la boucle dépasse la fin de la liste et lève \texttt{IndexError}}
        \item[D.] Le code modifie la liste
    \end{itemize}
\end{frame}

% Q24 - Réponse en B
\begin{frame}[fragile]{Question 24 \textemdash{} Comparer en pratique}
    Sur ma machine, une recherche linéaire dans une
liste de 1 million d'éléments prend ~ 30 ms. Que
prendra une recherche dans une liste de 1
milliard d'éléments (si la mémoire le permet) ?\medskip
    \begin{itemize}
        \item[A.] Environ 60 ms (juste deux fois plus)
        \item[\alert<2>{B.}] \alert<2>{Environ 30 secondes (1000 fois plus, car n est multiplié par 1000)}
        \item[C.] Environ 30 secondes au carré
        \item[D.] Toujours environ 30 ms (constante)
    \end{itemize}
\end{frame}

% Q25 - Réponse en D
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations suivantes sur la recherche
linéaire, laquelle est \textbf{fausse} ?\medskip
    \begin{itemize}
        \item[A.] En Python, l'opérateur \texttt{in} sur une liste fait une recherche linéaire
        \item[B.] Elle fonctionne sur des listes triées comme non triées
        \item[C.] Sa complexité au pire est O(n)
        \item[\alert<2>{D.}] \alert<2>{Elle est toujours plus rapide que la dichotomique}
    \end{itemize}
\end{frame}

% Q26 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Compter les occurrences}
    On veut \textbf{compter} combien de fois la cible
apparaît dans la liste (et non simplement la
trouver). Quelle adaptation de la recherche
linéaire faut-il faire ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def compter(liste, cible):
    for x in liste:
        if x == cible:
            return 1
    return 0
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def compter(liste, cible):
    return len(liste) if cible in liste else 0
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def compter(liste, cible):
    n = 0
    for x in liste:
        if x == cible:
            n += 1
    return n
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def compter(liste, cible):
    return liste.index(cible)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q26 - Réponse en C
\begin{frame}[fragile,allowframebreaks]{Question 26 \textemdash{} Compter les occurrences}
    On veut \textbf{compter} combien de fois la cible
apparaît dans la liste (et non simplement la
trouver). Quelle adaptation de la recherche
linéaire faut-il faire ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def compter(liste, cible):
    for x in liste:
        if x == cible:
            return 1
    return 0
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def compter(liste, cible):
    return len(liste) if cible in liste else 0
\end{lstlisting}

        \item[\alert{C.}]~\\
\begin{lstlisting}
def compter(liste, cible):
    n = 0
    for x in liste:
        if x == cible:
            n += 1
    return n
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def compter(liste, cible):
    return liste.index(cible)
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q27 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Recherche par condition}
    On cherche le \textbf{premier} élément d'une liste de
nombres qui soit \textbf{strictement supérieur} à
\texttt{100} (et son indice). Quel code applique
correctement la recherche linéaire à ce cas ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def premier_grand(liste):
    liste.sort()
    return liste[-1]
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def premier_grand(liste):
    return max(liste) > 100
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def premier_grand(liste):
    for x in liste:
        if x > 100:
            return x
        return None
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def premier_grand(liste):
    for i, x in enumerate(liste):
        if x > 100:
            return (i, x)
    return None
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q27 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Recherche par condition}
    On cherche le \textbf{premier} élément d'une liste de
nombres qui soit \textbf{strictement supérieur} à
\texttt{100} (et son indice). Quel code applique
correctement la recherche linéaire à ce cas ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def premier_grand(liste):
    liste.sort()
    return liste[-1]
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def premier_grand(liste):
    return max(liste) > 100
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def premier_grand(liste):
    for x in liste:
        if x > 100:
            return x
        return None
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
def premier_grand(liste):
    for i, x in enumerate(liste):
        if x > 100:
            return (i, x)
    return None
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q28 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} Recherche dans un tableau à deux dimensions}
    On dispose d'une matrice carrée représentée par
une liste de listes (par exemple
\texttt{m = [[3, 7, 1], [8, 2, 5], [4, 9, 6]]}). On
cherche le couple \texttt{(ligne, colonne)} de la
première occurrence de la valeur \texttt{5}. Quel code
est correct ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def chercher(m, cible):
    if cible in m:
        return m.index(cible)
    return None
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def chercher(m, cible):
    for ligne in m:
        for x in ligne:
            if x == cible:
                return x
    return None
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def chercher(m, cible):
    for i in range(len(m)):
        if m[i] == cible:
            return i
    return None
\end{lstlisting}

        \item[D.]~\\
\begin{lstlisting}
def chercher(m, cible):
    for i in range(len(m)):
        for j in range(len(m[i])):
            if m[i][j] == cible:
                return (i, j)
    return None
\end{lstlisting}

    \end{itemize}
\end{frame}

% Q28 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 28 \textemdash{} Recherche dans un tableau à deux dimensions}
    On dispose d'une matrice carrée représentée par
une liste de listes (par exemple
\texttt{m = [[3, 7, 1], [8, 2, 5], [4, 9, 6]]}). On
cherche le couple \texttt{(ligne, colonne)} de la
première occurrence de la valeur \texttt{5}. Quel code
est correct ?\medskip
    \begin{itemize}
        \item[A.]~\\
\begin{lstlisting}
def chercher(m, cible):
    if cible in m:
        return m.index(cible)
    return None
\end{lstlisting}

        \item[B.]~\\
\begin{lstlisting}
def chercher(m, cible):
    for ligne in m:
        for x in ligne:
            if x == cible:
                return x
    return None
\end{lstlisting}

        \item[C.]~\\
\begin{lstlisting}
def chercher(m, cible):
    for i in range(len(m)):
        if m[i] == cible:
            return i
    return None
\end{lstlisting}

        \item[\alert{D.}]~\\
\begin{lstlisting}
def chercher(m, cible):
    for i in range(len(m)):
        for j in range(len(m[i])):
            if m[i][j] == cible:
                return (i, j)
    return None
\end{lstlisting}

    \end{itemize}
\end{frame}

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

\end{document}
