\begin{exercise}[subtitle={QCM}, step={2}, origin={Annales}, topics={Tuples et listes}, tags={tuple, liste}]
    \begin{enumerate}
        \item Quel est le type de l'expression \texttt{f(4)} si la fonction \texttt{f} est définie par

            \begin{center}
                \begin{minipage}{0.9\linewidth}
                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_f.py}
                \end{minipage}
            \end{center}


            \begin{tasks}(4)
                \task un entier
                \task un flottant
                \task une liste
                \task un tuple
            \end{tasks}

        \item On dispose d'une liste définie par \mintinline{python}{L = [15, 17, 12, 23]}.

            Quelle est la valeur de L après l'instruction \mintinline{python}{L[2] = 25}

            \begin{tasks}(2)
                \task \mintinline{python}{[15, 25, 12, 23]}
                \task \mintinline{python}{[15, 17, 25, 12, 23]}
                \task \mintinline{python}{[15, 25, 25, 23]}
                \task \mintinline{python}{[15, 17, 12, 25, 23]}
            \end{tasks}

        \item Après l'affectation suivante :

                \mintinline{python}{alphabet = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',] }

            quelle est l'expression qui permet d'accéder à la lettre E?

            \begin{tasks}(2)
                \task \mintinline{python}{alphabet.E}
                \task \mintinline{python}{alphabet['E']}
                \task \mintinline{python}{alphabet[4]}
                \task \mintinline{python}{alphabet[5]}
            \end{tasks}

        \item On considère le script suivant:

            \begin{center}
                \begin{minipage}{0.9\linewidth}
                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_t.py}
                \end{minipage}
            \end{center}

            Quelle est la valeur de t à la fin de son exécution?

            \begin{tasks}(4)
                \task \mintinline{python}{[2, 13, 9, 2]}
                \task \mintinline{python}{[2, 8, 14, 2]}
                \task \mintinline{python}{[2, 13, 14, 2]}
                \task \mintinline{python}{[2, 13, 9, 2]}
            \end{tasks}


        \item On considère la fonction suivante:

            \begin{center}
                \begin{minipage}{0.9\linewidth}
                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_somme.py}
                \end{minipage}
            \end{center}

            Par quelle instruction faut-il remplacer les points de suspension pour que l'appel

            \mintinline{python}{somme([10, 11, 12, 13, 14])} renvoie 60?

            \begin{tasks}(2)
                \task \mintinline{python}{s = tab[i]}
                \task \mintinline{python}{s = s + tab[i]}
                \task \mintinline{python}{tab[i] = tab[i] + s}
                \task \mintinline{python}{s = s + i}
            \end{tasks}

        \item On exécute le script suivant:

            \begin{center}
                \begin{minipage}{0.9\linewidth}
                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_double.py}
                \end{minipage}
            \end{center}

            Quelle est la valeur de m à la fin de son exécution?

            \begin{tasks}(1)
                \task \mintinline{python}{[ [0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8] ] }
                \task \mintinline{python}{[ [0, 0, 0], [0, 1, 2], [0, 2, 4], [0, 3, 6], [0, 4, 8] ] }
                \task \mintinline{python}{[ [1, 1, 1], [2, 4, 6], [3, 6, 9], [4, 8, 12], [5, 10, 15] ] }
                \task \mintinline{python}{[ [1, 1, 1, 1, 1], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8, 12, 16, 20], [5, 10, 15, 20, 25] ]}
            \end{tasks}

        \item L est une liste d'entiers. On définit la fonction suivante

            \begin{center}
                \begin{minipage}{0.9\linewidth}
                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_filtre.py}
                \end{minipage}
            \end{center}

            Que calcule cette fonction?
            \begin{tasks}(1)
                \task le maximum de la liste L passée en argument
                \task le minimum de la liste L passée en argument
                \task le premier terme de la liste L passée en argument
                \task le dernier terme de la liste L passée en argument
            \end{tasks}

        \item Quelle est la valeur de la variable r à la fin de l'exécution du script suivant?

            \begin{center}
                \begin{minipage}{0.9\linewidth}
                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_tuple.py}
                \end{minipage}
            \end{center}

            \begin{tasks}(4)
                \task -9
                \task 2
                \task 3
                \task 6
            \end{tasks}


        \item On définit : \mintinline{python}{[10,9,8,7,6,5,4,3,2,1]}

            Quelle est la valeur de \mintinline{python}{L[L[3]]}

            \begin{tasks}(4)
                \task 3
                \task 4
                \task 7
                \task 8
            \end{tasks}

        \item On considère la liste de listes suivantes

            \begin{center}
                \begin{minipage}{0.9\linewidth}
                    \inputminted[bgcolor=base3]{python}{./scripts/QCM_tictactoe.py}
                \end{minipage}
            \end{center}

            Quelle instruction permet d'obtenir une diagonale de "X"?

            \begin{tasks}(2)
                \task \mintinline{python}{tictactoe[3] = "X"}
                \task \mintinline{python}{tictactoe[4] = "X"}
                \task \mintinline{python}{tictactoe[1][1] = "X"}
                \task \mintinline{python}{tictactoe[2][2] = "X"}
            \end{tasks}

        \item On définit ainsi une liste M

            \begin{center}
                \mintinline{python}{M = [['A','B','C','D'], ['E','F','G','H'], ['I','J','K','L']] }
            \end{center}
            Quelle expression vaut la chaîne de caractères 'H'?

            \begin{tasks}(4)
                \task \mintinline{python}{M[1][3]}
                \task \mintinline{python}{M[3][1]}
                \task \mintinline{python}{M(7)}
                \task \mintinline{python}{M(8)}
            \end{tasks}



    \end{enumerate}
\end{exercise}

\begin{exercise}[subtitle={Suite de Fibonacci}, step={3}, origin={Annales}, topics={Tuples et listes}, tags={tuple, liste}]
    En mathématiques, la suite de Fibonacci est une suite d'entiers dans laquelle chaque terme est la somme des deux termes qui le précèdent.

    Voici les premiers termes de la suite

    \begin{center}
        1, 2, 3, 5, 8, 13, 21 ...
    \end{center}

    Écrire une fonction \texttt{Fibonacci} qui prend en argument un nombre $n$ et qui retourne la liste des $n$ premiers nombres de la suite de Fibonacci.
\end{exercise}

\begin{exercise}[subtitle={Suite de Syracuse}, step={3}, origin={Annales}, topics={Tuples et listes}, tags={tuple, liste}]
    Une suite de Syracuse est une suite d'entiers naturels définie de la manière suivante : on part d'un nombre entier strictement positif ; s’il est pair, on le divise par 2 ; s’il est impair, on le multiplie par 3 et l'on ajoute 1. En répétant l’opération, on obtient une suite d'entiers strictement positifs dont chacun ne dépend que de son prédécesseur.

    Par exemple, à partir de 14, on construit la suite des nombres :
    \begin{center}
        14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2...
    \end{center}
    C'est la suite de Syracuse du nombre 14.

    Après que le nombre 1 a été atteint, la suite des valeurs 1, 4, 2, 1, 4, 2… se répète indéfiniment en un cycle de longueur 3, appelé cycle trivial. On s'arrêtera donc au premier 1 rencontré.

    \begin{enumerate}
        \item Écrire une fonction \texttt{syracuse} qui prend en argument le nombre de départ puis qui renvoie la liste des termes de la suite de Syracuse associée à ce nombre. On s'arrêtera au premier 1 rencontré.
        \item
            \begin{enumerate}
                \item Écrire une fonction \texttt{temps\_de\_vol} qui prend en argument la liste des termes de la liste et qui renvoie le nombre de termes avant d'arriver à 1.
                \item Lister les temps de vol de tous les nombres de 2 à 50.
            \end{enumerate}
        \item
            \begin{enumerate}
                \item Écrire une fonction \texttt{altitude\_de\_vol} qui prend en argument la liste des termes de la liste et qui renvoie la plus haute valeur.
                \item Lister les altitudes de vol de tous les nombres de 2 à 50.
            \end{enumerate}
        \item
            \begin{enumerate}
                \item Écrire une fonction \texttt{temps\_en\_altitude} qui prend en argument la liste des termes de la liste et qui renvoie le nombre de terme plus haut que le premier terme de la liste.
                \item Lister les temps en altitude de tous les nombres entre 2 et 50.
            \end{enumerate}
    \end{enumerate}
\end{exercise}
