{
  "chapter": {
    "id": "python-listes",
    "level": "snt",
    "theme": "Programmation",
    "title": "8. Listes",
    "description": "Créer une liste, lire et modifier un élément par son indice, qui\ncommence à 0 ; la longueur avec len ; ajouter avec append ; tester\nla présence avec in ; parcourir une liste avec for, par éléments ou\npar indices ; calculer une somme, un maximum, un effectif. En\ncoordination avec le programme de mathématiques de seconde.",
    "prerequisites": [],
    "references": []
  },
  "questions": [
    {
      "id": "q01",
      "difficulty": 1,
      "skills": [
        "indice",
        "acces"
      ],
      "title": "Lire un élément",
      "statement": "```python\nnotes = [12, 15, 9, 18]\nprint(notes[1])\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`15`",
          "correct": true,
          "feedback": "Bonne réponse : les indices commencent à 0. L'indice 1 désigne\nle deuxième élément, 15.\n"
        },
        {
          "text": "`12`",
          "correct": false,
          "feedback": "Erreur : 12 est à l'indice 0, le premier.\n"
        },
        {
          "text": "`1`",
          "correct": false,
          "feedback": "Erreur : `notes[1]` renvoie l'élément rangé à l'indice 1, pas\nl'indice lui-même.\n"
        },
        {
          "text": "`9`",
          "correct": false,
          "feedback": "Erreur : 9 est à l'indice 2.\n"
        }
      ],
      "explanation": "Une liste range ses éléments à des positions numérotées à partir de\n0. `notes[1]` est le deuxième élément, `notes[0]` le premier.",
      "variants": [
        {
          "statement": "```python\nnotes = [12, 15, 9, 18]\nprint(notes[1])\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`15`",
              "correct": true,
              "feedback": "Bonne réponse : les indices commencent à 0. L'indice 1 désigne\nle deuxième élément, 15.\n"
            },
            {
              "text": "`12`",
              "correct": false,
              "feedback": "Erreur : 12 est à l'indice 0, le premier.\n"
            },
            {
              "text": "`1`",
              "correct": false,
              "feedback": "Erreur : `notes[1]` renvoie l'élément rangé à l'indice 1, pas\nl'indice lui-même.\n"
            },
            {
              "text": "`9`",
              "correct": false,
              "feedback": "Erreur : 9 est à l'indice 2.\n"
            }
          ],
          "explanation": "Une liste range ses éléments à des positions numérotées à partir de\n0. `notes[1]` est le deuxième élément, `notes[0]` le premier."
        },
        {
          "statement": "```python\nnotes = [7, 4, 22, 13]\nprint(notes[1])\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`4`",
              "correct": true,
              "feedback": "Bonne réponse : les indices commencent à 0. L'indice 1 désigne\nle deuxième élément, 4.\n"
            },
            {
              "text": "`7`",
              "correct": false,
              "feedback": "Erreur : 7 est à l'indice 0, le premier.\n"
            },
            {
              "text": "`1`",
              "correct": false,
              "feedback": "Erreur : `notes[1]` renvoie l'élément rangé à l'indice 1, pas\nl'indice lui-même.\n"
            },
            {
              "text": "`22`",
              "correct": false,
              "feedback": "Erreur : 22 est à l'indice 2.\n"
            }
          ],
          "explanation": "Une liste range ses éléments à des positions numérotées à partir de\n0. `notes[1]` est le deuxième élément, `notes[0]` le premier."
        },
        {
          "statement": "```python\nnotes = [5, 30, 11, 8]\nprint(notes[2])\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`11`",
              "correct": true,
              "feedback": "Bonne réponse : les indices commencent à 0. L'indice 2 désigne\nle troisième élément, 11.\n"
            },
            {
              "text": "`5`",
              "correct": false,
              "feedback": "Erreur : 5 est à l'indice 0, le premier.\n"
            },
            {
              "text": "`2`",
              "correct": false,
              "feedback": "Erreur : `notes[2]` renvoie l'élément rangé à l'indice 2, pas\nl'indice lui-même.\n"
            },
            {
              "text": "`8`",
              "correct": false,
              "feedback": "Erreur : 8 est à l'indice 3.\n"
            }
          ],
          "explanation": "Une liste range ses éléments à des positions numérotées à partir de\n0. `notes[1]` est le deuxième élément, `notes[0]` le premier."
        }
      ]
    },
    {
      "id": "q02",
      "difficulty": 1,
      "skills": [
        "len",
        "liste"
      ],
      "title": "Le nombre d'éléments",
      "statement": "```python\nvilles = [\"Lyon\", \"Paris\", \"Nice\"]\nprint(len(villes))\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`3`",
          "correct": true,
          "feedback": "Bonne réponse : `len` compte les éléments de la liste, trois\nchaînes.\n"
        },
        {
          "text": "`2`",
          "correct": false,
          "feedback": "Erreur : 2 est le plus grand indice, mais il y a trois\néléments.\n"
        },
        {
          "text": "`4`",
          "correct": false,
          "feedback": "Erreur : la liste contient trois chaînes.\n"
        },
        {
          "text": "`14`",
          "correct": false,
          "feedback": "Erreur : `len` ne compte pas les caractères des chaînes, mais\nles éléments de la liste.\n"
        }
      ],
      "explanation": "`len` renvoie le nombre d'éléments d'une liste. Les indices valides\nvont de 0 à `len(liste) - 1`."
    },
    {
      "id": "q03",
      "difficulty": 1,
      "skills": [
        "append",
        "liste"
      ],
      "title": "Ajouter à la fin",
      "statement": "```python\npanier = [\"pain\"]\npanier.append(\"lait\")\nprint(panier)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`['pain', 'lait']`",
          "correct": true,
          "feedback": "Bonne réponse : `append` ajoute l'élément à la fin de la liste,\nqui est modifiée.\n"
        },
        {
          "text": "`['lait', 'pain']`",
          "correct": false,
          "feedback": "Erreur : `append` ajoute toujours à la fin, jamais au début.\n"
        },
        {
          "text": "`['pain']`",
          "correct": false,
          "feedback": "Erreur : `append` modifie bien la liste, sans qu'il soit\nnécessaire de réaffecter.\n"
        },
        {
          "text": "`pain lait`",
          "correct": false,
          "feedback": "Erreur : `print` affiche une liste entre crochets, avec ses\nchaînes entre apostrophes.\n"
        }
      ],
      "explanation": "`liste.append(x)` ajoute `x` à la fin de la liste. La liste est\nmodifiée sur place : il n'y a rien à réaffecter."
    },
    {
      "id": "q04",
      "difficulty": 2,
      "skills": [
        "indice",
        "index-error",
        "erreur"
      ],
      "title": "Un indice trop grand",
      "statement": "```python\nt = [4, 8, 15]\nprint(t[3])\n```\n\nQue se passe-t-il ?",
      "options": [
        {
          "text": "Une erreur, les indices de cette liste vont de 0 à 2",
          "correct": true,
          "feedback": "Bonne réponse : trois éléments occupent les indices 0, 1 et 2.\nL'indice 3 n'existe pas, d'où une erreur `IndexError`.\n"
        },
        {
          "text": "Python affiche 15, le dernier élément",
          "correct": false,
          "feedback": "Erreur : le dernier élément est à l'indice 2, pas 3.\n"
        },
        {
          "text": "Python affiche `None`, il n'y a rien à cet indice",
          "correct": false,
          "feedback": "Erreur : un indice hors de la liste provoque une erreur, pas\nune valeur vide.\n"
        },
        {
          "text": "Python affiche 0, valeur par défaut d'une case vide",
          "correct": false,
          "feedback": "Erreur : il n'y a pas de case vide, la liste s'arrête à\nl'indice 2.\n"
        }
      ],
      "explanation": "Le plus grand indice d'une liste est `len(liste) - 1`. Le dépasser\ndéclenche `IndexError: list index out of range`, une erreur très\ncourante."
    },
    {
      "id": "q05",
      "difficulty": 2,
      "skills": [
        "modification",
        "indice"
      ],
      "title": "Modifier un élément",
      "statement": "Un programme retouche la première composante d'un pixel.\n\n```python\npixel = [10, 20, 30]\npixel[0] = 255\nprint(pixel)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`[255, 20, 30]`",
          "correct": true,
          "feedback": "Bonne réponse : l'affectation `pixel[0] = 255` remplace\nl'élément d'indice 0.\n"
        },
        {
          "text": "`[10, 255, 30]`",
          "correct": false,
          "feedback": "Erreur : l'indice 0 désigne le premier élément.\n"
        },
        {
          "text": "`[255, 10, 20, 30]`",
          "correct": false,
          "feedback": "Erreur : l'affectation par indice remplace, elle n'insère pas.\n"
        },
        {
          "text": "Une erreur, une liste ne se modifie pas",
          "correct": false,
          "feedback": "Erreur : une liste est modifiable, élément par élément.\n"
        }
      ],
      "explanation": "`liste[i] = valeur` remplace l'élément d'indice `i`. La longueur de\nla liste ne change pas.",
      "variants": [
        {
          "statement": "Un programme retouche la première composante d'un pixel.\n\n```python\npixel = [10, 20, 30]\npixel[0] = 255\nprint(pixel)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[255, 20, 30]`",
              "correct": true,
              "feedback": "Bonne réponse : l'affectation `pixel[0] = 255` remplace\nl'élément d'indice 0.\n"
            },
            {
              "text": "`[10, 255, 30]`",
              "correct": false,
              "feedback": "Erreur : l'indice 0 désigne le premier élément.\n"
            },
            {
              "text": "`[255, 10, 20, 30]`",
              "correct": false,
              "feedback": "Erreur : l'affectation par indice remplace, elle n'insère pas.\n"
            },
            {
              "text": "Une erreur, une liste ne se modifie pas",
              "correct": false,
              "feedback": "Erreur : une liste est modifiable, élément par élément.\n"
            }
          ],
          "explanation": "`liste[i] = valeur` remplace l'élément d'indice `i`. La longueur de\nla liste ne change pas."
        },
        {
          "statement": "Un programme retouche la première composante d'un pixel.\n\n```python\npixel = [40, 50, 60]\npixel[0] = 0\nprint(pixel)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[0, 50, 60]`",
              "correct": true,
              "feedback": "Bonne réponse : l'affectation `pixel[0] = 0` remplace\nl'élément d'indice 0.\n"
            },
            {
              "text": "`[40, 0, 60]`",
              "correct": false,
              "feedback": "Erreur : l'indice 0 désigne le premier élément.\n"
            },
            {
              "text": "`[0, 40, 50, 60]`",
              "correct": false,
              "feedback": "Erreur : l'affectation par indice remplace, elle n'insère pas.\n"
            },
            {
              "text": "Une erreur, une liste ne se modifie pas",
              "correct": false,
              "feedback": "Erreur : une liste est modifiable, élément par élément.\n"
            }
          ],
          "explanation": "`liste[i] = valeur` remplace l'élément d'indice `i`. La longueur de\nla liste ne change pas."
        },
        {
          "statement": "Un programme retouche la première composante d'un pixel.\n\n```python\npixel = [1, 2, 3]\npixel[0] = 99\nprint(pixel)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[99, 2, 3]`",
              "correct": true,
              "feedback": "Bonne réponse : l'affectation `pixel[0] = 99` remplace\nl'élément d'indice 0.\n"
            },
            {
              "text": "`[1, 99, 3]`",
              "correct": false,
              "feedback": "Erreur : l'indice 0 désigne le premier élément.\n"
            },
            {
              "text": "`[99, 1, 2, 3]`",
              "correct": false,
              "feedback": "Erreur : l'affectation par indice remplace, elle n'insère pas.\n"
            },
            {
              "text": "Une erreur, une liste ne se modifie pas",
              "correct": false,
              "feedback": "Erreur : une liste est modifiable, élément par élément.\n"
            }
          ],
          "explanation": "`liste[i] = valeur` remplace l'élément d'indice `i`. La longueur de\nla liste ne change pas."
        }
      ]
    },
    {
      "id": "q06",
      "difficulty": 2,
      "skills": [
        "parcours",
        "liste",
        "for"
      ],
      "title": "Parcourir une liste",
      "statement": "```python\nfor v in [3, 5, 7]:\n    print(v * 2)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "6, 10 et 14",
          "correct": true,
          "feedback": "Bonne réponse : `v` prend successivement chaque élément, et son\ndouble est affiché.\n"
        },
        {
          "text": "3, 5 et 7",
          "correct": false,
          "feedback": "Erreur : chaque élément est multiplié par 2 avant l'affichage.\n"
        },
        {
          "text": "0, 2 et 4",
          "correct": false,
          "feedback": "Erreur : `v` reçoit les éléments de la liste, pas leurs\nindices.\n"
        },
        {
          "text": "6, 10, 14, 6, 10 et 14",
          "correct": false,
          "feedback": "Erreur : la liste est parcourue une seule fois, trois tours.\n"
        }
      ],
      "explanation": "`for v in liste` donne à `v` chaque élément à son tour, du premier au\ndernier. C'est la façon la plus simple de traiter tous les éléments."
    },
    {
      "id": "q07",
      "difficulty": 2,
      "skills": [
        "accumulateur",
        "len",
        "moyenne"
      ],
      "title": "Une moyenne",
      "statement": "```python\nreleves = [12, 15, 9, 18]\ntotal = 0\nfor r in releves:\n    total = total + r\nprint(total / len(releves))\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`13.5`",
          "correct": true,
          "feedback": "Bonne réponse : la somme vaut 54, divisée par 4 éléments.\n"
        },
        {
          "text": "`54.0`",
          "correct": false,
          "feedback": "Erreur : 54 est la somme, mais le programme la divise par la\nlongueur.\n"
        },
        {
          "text": "`13.0`",
          "correct": false,
          "feedback": "Erreur : la division `/` ne tronque pas, 54 divisé par 4 vaut\n13.5.\n"
        },
        {
          "text": "`18.0`",
          "correct": false,
          "feedback": "Erreur : 18 est le dernier élément, pas la moyenne.\n"
        }
      ],
      "explanation": "La moyenne combine un accumulateur pour la somme et `len` pour\nl'effectif. Le même schéma sert pour n'importe quelle liste de\nnombres.",
      "variants": [
        {
          "statement": "```python\nreleves = [12, 15, 9, 18]\ntotal = 0\nfor r in releves:\n    total = total + r\nprint(total / len(releves))\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`13.5`",
              "correct": true,
              "feedback": "Bonne réponse : la somme vaut 54, divisée par 4 éléments.\n"
            },
            {
              "text": "`54.0`",
              "correct": false,
              "feedback": "Erreur : 54 est la somme, mais le programme la divise par la\nlongueur.\n"
            },
            {
              "text": "`13.0`",
              "correct": false,
              "feedback": "Erreur : la division `/` ne tronque pas, 54 divisé par 4 vaut\n13.5.\n"
            },
            {
              "text": "`18.0`",
              "correct": false,
              "feedback": "Erreur : 18 est le dernier élément, pas la moyenne.\n"
            }
          ],
          "explanation": "La moyenne combine un accumulateur pour la somme et `len` pour\nl'effectif. Le même schéma sert pour n'importe quelle liste de\nnombres."
        },
        {
          "statement": "```python\nreleves = [10, 13]\ntotal = 0\nfor r in releves:\n    total = total + r\nprint(total / len(releves))\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`11.5`",
              "correct": true,
              "feedback": "Bonne réponse : la somme vaut 23, divisée par 2 éléments.\n"
            },
            {
              "text": "`23.0`",
              "correct": false,
              "feedback": "Erreur : 23 est la somme, mais le programme la divise par la\nlongueur.\n"
            },
            {
              "text": "`11.0`",
              "correct": false,
              "feedback": "Erreur : la division `/` ne tronque pas, 23 divisé par 2 vaut\n11.5.\n"
            },
            {
              "text": "`13.0`",
              "correct": false,
              "feedback": "Erreur : 13 est le dernier élément, pas la moyenne.\n"
            }
          ],
          "explanation": "La moyenne combine un accumulateur pour la somme et `len` pour\nl'effectif. Le même schéma sert pour n'importe quelle liste de\nnombres."
        },
        {
          "statement": "```python\nreleves = [20, 25, 15, 30, 11]\ntotal = 0\nfor r in releves:\n    total = total + r\nprint(total / len(releves))\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`20.2`",
              "correct": true,
              "feedback": "Bonne réponse : la somme vaut 101, divisée par 5 éléments.\n"
            },
            {
              "text": "`101.0`",
              "correct": false,
              "feedback": "Erreur : 101 est la somme, mais le programme la divise par la\nlongueur.\n"
            },
            {
              "text": "`20.0`",
              "correct": false,
              "feedback": "Erreur : la division `/` ne tronque pas, 101 divisé par 5 vaut\n20.2.\n"
            },
            {
              "text": "`11.0`",
              "correct": false,
              "feedback": "Erreur : 11 est le dernier élément, pas la moyenne.\n"
            }
          ],
          "explanation": "La moyenne combine un accumulateur pour la somme et `len` pour\nl'effectif. Le même schéma sert pour n'importe quelle liste de\nnombres."
        }
      ]
    },
    {
      "id": "q08",
      "difficulty": 2,
      "skills": [
        "in",
        "liste",
        "chaine"
      ],
      "title": "Tester la présence",
      "statement": "```python\ninscrits = [\"Ana\", \"Bob\", \"Chloé\"]\nprint(\"bob\" in inscrits)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`False`",
          "correct": true,
          "feedback": "Bonne réponse : `in` cherche un élément exactement égal, et\n`\"bob\"` diffère de `\"Bob\"` par sa majuscule.\n"
        },
        {
          "text": "`True`",
          "correct": false,
          "feedback": "Erreur : la comparaison des chaînes distingue majuscules et\nminuscules.\n"
        },
        {
          "text": "`1`",
          "correct": false,
          "feedback": "Erreur : `in` renvoie un booléen, pas une position.\n"
        },
        {
          "text": "Une erreur, `in` ne s'applique pas aux chaînes",
          "correct": false,
          "feedback": "Erreur : `in` teste si une valeur figure dans la liste, quel que\nsoit son type.\n"
        }
      ],
      "explanation": "`x in liste` vaut `True` si un élément de la liste est égal à `x`.\nL'égalité est exacte, majuscules comprises."
    },
    {
      "id": "q09",
      "difficulty": 3,
      "skills": [
        "maximum",
        "parcours"
      ],
      "title": "Chercher le maximum",
      "statement": "```python\ntemp = [18, 24, 21, 27, 19]\nmaxi = temp[0]\nfor t in temp:\n    if t > maxi:\n        maxi = t\nprint(maxi)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`27`",
          "correct": true,
          "feedback": "Bonne réponse : `maxi` part du premier élément et est remplacé à\nchaque valeur plus grande, 24 puis 27.\n"
        },
        {
          "text": "`18`",
          "correct": false,
          "feedback": "Erreur : 18 est la valeur de départ, dépassée par une valeur\nplus grande.\n"
        },
        {
          "text": "`19`",
          "correct": false,
          "feedback": "Erreur : 19 est le dernier élément, mais il ne dépasse pas 27.\n"
        },
        {
          "text": "`5`",
          "correct": false,
          "feedback": "Erreur : 5 est le nombre d'éléments, pas le maximum.\n"
        }
      ],
      "explanation": "Pour trouver le plus grand élément, on part du premier et on parcourt\nla liste en remplaçant le maximum courant dès qu'on trouve mieux.\nPartir du premier élément évite de choisir une valeur arbitraire.",
      "variants": [
        {
          "statement": "```python\ntemp = [18, 24, 21, 27, 19]\nmaxi = temp[0]\nfor t in temp:\n    if t > maxi:\n        maxi = t\nprint(maxi)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`27`",
              "correct": true,
              "feedback": "Bonne réponse : `maxi` part du premier élément et est remplacé à\nchaque valeur plus grande, 24 puis 27.\n"
            },
            {
              "text": "`18`",
              "correct": false,
              "feedback": "Erreur : 18 est la valeur de départ, dépassée par une valeur\nplus grande.\n"
            },
            {
              "text": "`19`",
              "correct": false,
              "feedback": "Erreur : 19 est le dernier élément, mais il ne dépasse pas 27.\n"
            },
            {
              "text": "`5`",
              "correct": false,
              "feedback": "Erreur : 5 est le nombre d'éléments, pas le maximum.\n"
            }
          ],
          "explanation": "Pour trouver le plus grand élément, on part du premier et on parcourt\nla liste en remplaçant le maximum courant dès qu'on trouve mieux.\nPartir du premier élément évite de choisir une valeur arbitraire."
        },
        {
          "statement": "```python\ntemp = [12, 9, 30, 25, 14]\nmaxi = temp[0]\nfor t in temp:\n    if t > maxi:\n        maxi = t\nprint(maxi)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`30`",
              "correct": true,
              "feedback": "Bonne réponse : `maxi` part du premier élément et est remplacé à\nchaque valeur plus grande, 30.\n"
            },
            {
              "text": "`12`",
              "correct": false,
              "feedback": "Erreur : 12 est la valeur de départ, dépassée par une valeur\nplus grande.\n"
            },
            {
              "text": "`14`",
              "correct": false,
              "feedback": "Erreur : 14 est le dernier élément, mais il ne dépasse pas 30.\n"
            },
            {
              "text": "`5`",
              "correct": false,
              "feedback": "Erreur : 5 est le nombre d'éléments, pas le maximum.\n"
            }
          ],
          "explanation": "Pour trouver le plus grand élément, on part du premier et on parcourt\nla liste en remplaçant le maximum courant dès qu'on trouve mieux.\nPartir du premier élément évite de choisir une valeur arbitraire."
        },
        {
          "statement": "```python\ntemp = [40, 42, 38, 45, 41]\nmaxi = temp[0]\nfor t in temp:\n    if t > maxi:\n        maxi = t\nprint(maxi)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`45`",
              "correct": true,
              "feedback": "Bonne réponse : `maxi` part du premier élément et est remplacé à\nchaque valeur plus grande, 42 puis 45.\n"
            },
            {
              "text": "`40`",
              "correct": false,
              "feedback": "Erreur : 40 est la valeur de départ, dépassée par une valeur\nplus grande.\n"
            },
            {
              "text": "`41`",
              "correct": false,
              "feedback": "Erreur : 41 est le dernier élément, mais il ne dépasse pas 45.\n"
            },
            {
              "text": "`5`",
              "correct": false,
              "feedback": "Erreur : 5 est le nombre d'éléments, pas le maximum.\n"
            }
          ],
          "explanation": "Pour trouver le plus grand élément, on part du premier et on parcourt\nla liste en remplaçant le maximum courant dès qu'on trouve mieux.\nPartir du premier élément évite de choisir une valeur arbitraire."
        }
      ]
    },
    {
      "id": "q10",
      "difficulty": 2,
      "skills": [
        "indice",
        "parcours",
        "range"
      ],
      "title": "Parcourir par indices",
      "statement": "```python\nmots = [\"a\", \"b\", \"c\"]\nfor i in range(len(mots)):\n    print(i, mots[i])\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`0 a`, `1 b` et `2 c`",
          "correct": true,
          "feedback": "Bonne réponse : `range(len(mots))` fournit les indices 0, 1 et\n2, et `mots[i]` l'élément correspondant.\n"
        },
        {
          "text": "`1 a`, `2 b` et `3 c`",
          "correct": false,
          "feedback": "Erreur : les indices commencent à 0.\n"
        },
        {
          "text": "`a`, `b` et `c`",
          "correct": false,
          "feedback": "Erreur : le programme affiche aussi l'indice, avant l'élément.\n"
        },
        {
          "text": "`0`, `1` et `2`",
          "correct": false,
          "feedback": "Erreur : chaque ligne contient l'indice et l'élément.\n"
        }
      ],
      "explanation": "Parcourir par indices avec `range(len(liste))` donne accès à la\nposition de chaque élément, ce qui est utile pour modifier la liste\nou comparer des voisins."
    },
    {
      "id": "q11",
      "difficulty": 3,
      "skills": [
        "append",
        "construction"
      ],
      "title": "Construire une liste dans une boucle",
      "statement": "```python\ncarres = []\nfor n in range(1, 5):\n    carres.append(n * n)\nprint(carres)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`[1, 4, 9, 16]`",
          "correct": true,
          "feedback": "Bonne réponse : on part d'une liste vide et on ajoute les carrés\nde 1, 2, 3 et 4.\n"
        },
        {
          "text": "`[0, 1, 4, 9]`",
          "correct": false,
          "feedback": "Erreur : `range(1, 5)` commence à 1, pas à 0.\n"
        },
        {
          "text": "`[1, 4, 9, 16, 25]`",
          "correct": false,
          "feedback": "Erreur : 5 est exclu par `range(1, 5)`.\n"
        },
        {
          "text": "`[16]`",
          "correct": false,
          "feedback": "Erreur : `append` ajoute sans effacer les éléments précédents.\n"
        }
      ],
      "explanation": "Une liste vide suivie d'un `append` à chaque tour est le schéma pour\nconstruire une liste. Elle s'allonge d'un élément par tour.",
      "variants": [
        {
          "statement": "```python\ncarres = []\nfor n in range(1, 5):\n    carres.append(n * n)\nprint(carres)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[1, 4, 9, 16]`",
              "correct": true,
              "feedback": "Bonne réponse : on part d'une liste vide et on ajoute les carrés\nde 1, 2, 3 et 4.\n"
            },
            {
              "text": "`[0, 1, 4, 9]`",
              "correct": false,
              "feedback": "Erreur : `range(1, 5)` commence à 1, pas à 0.\n"
            },
            {
              "text": "`[1, 4, 9, 16, 25]`",
              "correct": false,
              "feedback": "Erreur : 5 est exclu par `range(1, 5)`.\n"
            },
            {
              "text": "`[16]`",
              "correct": false,
              "feedback": "Erreur : `append` ajoute sans effacer les éléments précédents.\n"
            }
          ],
          "explanation": "Une liste vide suivie d'un `append` à chaque tour est le schéma pour\nconstruire une liste. Elle s'allonge d'un élément par tour."
        },
        {
          "statement": "```python\ncarres = []\nfor n in range(2, 6):\n    carres.append(n * n)\nprint(carres)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[4, 9, 16, 25]`",
              "correct": true,
              "feedback": "Bonne réponse : on part d'une liste vide et on ajoute les carrés\nde 2, 3, 4 et 5.\n"
            },
            {
              "text": "`[1, 4, 9, 16]`",
              "correct": false,
              "feedback": "Erreur : `range(2, 6)` commence à 2, pas à 1.\n"
            },
            {
              "text": "`[4, 9, 16, 25, 36]`",
              "correct": false,
              "feedback": "Erreur : 6 est exclu par `range(2, 6)`.\n"
            },
            {
              "text": "`[25]`",
              "correct": false,
              "feedback": "Erreur : `append` ajoute sans effacer les éléments précédents.\n"
            }
          ],
          "explanation": "Une liste vide suivie d'un `append` à chaque tour est le schéma pour\nconstruire une liste. Elle s'allonge d'un élément par tour."
        },
        {
          "statement": "```python\ncarres = []\nfor n in range(1, 7):\n    carres.append(n * n)\nprint(carres)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[1, 4, 9, 16, 25, 36]`",
              "correct": true,
              "feedback": "Bonne réponse : on part d'une liste vide et on ajoute les carrés\nde 1, 2, 3, 4, 5 et 6.\n"
            },
            {
              "text": "`[0, 1, 4, 9, 16, 25]`",
              "correct": false,
              "feedback": "Erreur : `range(1, 7)` commence à 1, pas à 0.\n"
            },
            {
              "text": "`[1, 4, 9, 16, 25, 36, 49]`",
              "correct": false,
              "feedback": "Erreur : 7 est exclu par `range(1, 7)`.\n"
            },
            {
              "text": "`[36]`",
              "correct": false,
              "feedback": "Erreur : `append` ajoute sans effacer les éléments précédents.\n"
            }
          ],
          "explanation": "Une liste vide suivie d'un `append` à chaque tour est le schéma pour\nconstruire une liste. Elle s'allonge d'un élément par tour."
        }
      ]
    },
    {
      "id": "q12",
      "difficulty": 2,
      "skills": [
        "compteur",
        "condition",
        "parcours"
      ],
      "title": "Compter au-dessus d'un seuil",
      "statement": "```python\nmesures = [31, 28, 35, 40, 22]\nn = 0\nfor m in mesures:\n    if m > 30:\n        n = n + 1\nprint(n)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`3`",
          "correct": true,
          "feedback": "Bonne réponse : 31, 35 et 40 dépassent 30.\n"
        },
        {
          "text": "`2`",
          "correct": false,
          "feedback": "Erreur : 31 est strictement supérieur à 30, il compte.\n"
        },
        {
          "text": "`4`",
          "correct": false,
          "feedback": "Erreur : 28 et 22 ne dépassent pas 30.\n"
        },
        {
          "text": "`106`",
          "correct": false,
          "feedback": "Erreur : 106 est la somme des valeurs retenues, mais le\nprogramme les compte, il ne les additionne pas.\n"
        }
      ],
      "explanation": "Le compteur conditionnel s'applique aux listes comme aux `range` :\non parcourt les éléments et on ajoute 1 quand le test est vrai.",
      "variants": [
        {
          "statement": "```python\nmesures = [31, 28, 35, 40, 22]\nn = 0\nfor m in mesures:\n    if m > 30:\n        n = n + 1\nprint(n)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`3`",
              "correct": true,
              "feedback": "Bonne réponse : 31, 35 et 40 dépassent 30.\n"
            },
            {
              "text": "`2`",
              "correct": false,
              "feedback": "Erreur : 31 est strictement supérieur à 30, il compte.\n"
            },
            {
              "text": "`4`",
              "correct": false,
              "feedback": "Erreur : 28 et 22 ne dépassent pas 30.\n"
            },
            {
              "text": "`106`",
              "correct": false,
              "feedback": "Erreur : 106 est la somme des valeurs retenues, mais le\nprogramme les compte, il ne les additionne pas.\n"
            }
          ],
          "explanation": "Le compteur conditionnel s'applique aux listes comme aux `range` :\non parcourt les éléments et on ajoute 1 quand le test est vrai."
        },
        {
          "statement": "```python\nmesures = [15, 22, 9, 18, 25]\nn = 0\nfor m in mesures:\n    if m > 20:\n        n = n + 1\nprint(n)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`2`",
              "correct": true,
              "feedback": "Bonne réponse : 22 et 25 dépassent 20.\n"
            },
            {
              "text": "`1`",
              "correct": false,
              "feedback": "Erreur : 22 est strictement supérieur à 20, il compte.\n"
            },
            {
              "text": "`3`",
              "correct": false,
              "feedback": "Erreur : 15, 9 et 18 ne dépassent pas 20.\n"
            },
            {
              "text": "`47`",
              "correct": false,
              "feedback": "Erreur : 47 est la somme des valeurs retenues, mais le\nprogramme les compte, il ne les additionne pas.\n"
            }
          ],
          "explanation": "Le compteur conditionnel s'applique aux listes comme aux `range` :\non parcourt les éléments et on ajoute 1 quand le test est vrai."
        },
        {
          "statement": "```python\nmesures = [50, 61, 48, 70, 65, 52, 58]\nn = 0\nfor m in mesures:\n    if m > 55:\n        n = n + 1\nprint(n)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`4`",
              "correct": true,
              "feedback": "Bonne réponse : 61, 70, 65 et 58 dépassent 55.\n"
            },
            {
              "text": "`3`",
              "correct": false,
              "feedback": "Erreur : 58 est strictement supérieur à 55, il compte.\n"
            },
            {
              "text": "`5`",
              "correct": false,
              "feedback": "Erreur : 50, 48 et 52 ne dépassent pas 55.\n"
            },
            {
              "text": "`254`",
              "correct": false,
              "feedback": "Erreur : 254 est la somme des valeurs retenues, mais le\nprogramme les compte, il ne les additionne pas.\n"
            }
          ],
          "explanation": "Le compteur conditionnel s'applique aux listes comme aux `range` :\non parcourt les éléments et on ajoute 1 quand le test est vrai."
        }
      ]
    },
    {
      "id": "q13",
      "difficulty": 1,
      "skills": [
        "indice",
        "len"
      ],
      "title": "Le dernier élément",
      "statement": "```python\nt = [7, 3, 9, 4]\nprint(t[len(t) - 1])\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`4`",
          "correct": true,
          "feedback": "Bonne réponse : `len(t)` vaut 4, donc `len(t) - 1` vaut 3,\nl'indice du dernier élément.\n"
        },
        {
          "text": "`9`",
          "correct": false,
          "feedback": "Erreur : 9 est à l'indice 2, l'avant-dernier.\n"
        },
        {
          "text": "`3`",
          "correct": false,
          "feedback": "Erreur : 3 est la valeur de l'indice calculé, pas l'élément qui\ns'y trouve.\n"
        },
        {
          "text": "Une erreur, l'indice 4 n'existe pas",
          "correct": false,
          "feedback": "Erreur : l'indice calculé est 3, pas 4, grâce au `- 1`.\n"
        }
      ],
      "explanation": "Le dernier élément est à l'indice `len(liste) - 1`, puisque la\nnumérotation commence à 0. C'est un calcul à connaître.",
      "variants": [
        {
          "statement": "```python\nt = [7, 3, 9, 4]\nprint(t[len(t) - 1])\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`4`",
              "correct": true,
              "feedback": "Bonne réponse : `len(t)` vaut 4, donc `len(t) - 1` vaut 3,\nl'indice du dernier élément.\n"
            },
            {
              "text": "`9`",
              "correct": false,
              "feedback": "Erreur : 9 est à l'indice 2, l'avant-dernier.\n"
            },
            {
              "text": "`3`",
              "correct": false,
              "feedback": "Erreur : 3 est la valeur de l'indice calculé, pas l'élément qui\ns'y trouve.\n"
            },
            {
              "text": "Une erreur, l'indice 4 n'existe pas",
              "correct": false,
              "feedback": "Erreur : l'indice calculé est 3, pas 4, grâce au `- 1`.\n"
            }
          ],
          "explanation": "Le dernier élément est à l'indice `len(liste) - 1`, puisque la\nnumérotation commence à 0. C'est un calcul à connaître."
        },
        {
          "statement": "```python\nt = [2, 8, 6, 1, 5]\nprint(t[len(t) - 1])\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`5`",
              "correct": true,
              "feedback": "Bonne réponse : `len(t)` vaut 5, donc `len(t) - 1` vaut 4,\nl'indice du dernier élément.\n"
            },
            {
              "text": "`1`",
              "correct": false,
              "feedback": "Erreur : 1 est à l'indice 3, l'avant-dernier.\n"
            },
            {
              "text": "`4`",
              "correct": false,
              "feedback": "Erreur : 4 est la valeur de l'indice calculé, pas l'élément qui\ns'y trouve.\n"
            },
            {
              "text": "Une erreur, l'indice 5 n'existe pas",
              "correct": false,
              "feedback": "Erreur : l'indice calculé est 4, pas 5, grâce au `- 1`.\n"
            }
          ],
          "explanation": "Le dernier élément est à l'indice `len(liste) - 1`, puisque la\nnumérotation commence à 0. C'est un calcul à connaître."
        },
        {
          "statement": "```python\nt = [10, 20, 30]\nprint(t[len(t) - 1])\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`30`",
              "correct": true,
              "feedback": "Bonne réponse : `len(t)` vaut 3, donc `len(t) - 1` vaut 2,\nl'indice du dernier élément.\n"
            },
            {
              "text": "`20`",
              "correct": false,
              "feedback": "Erreur : 20 est à l'indice 1, l'avant-dernier.\n"
            },
            {
              "text": "`2`",
              "correct": false,
              "feedback": "Erreur : 2 est la valeur de l'indice calculé, pas l'élément qui\ns'y trouve.\n"
            },
            {
              "text": "Une erreur, l'indice 3 n'existe pas",
              "correct": false,
              "feedback": "Erreur : l'indice calculé est 2, pas 3, grâce au `- 1`.\n"
            }
          ],
          "explanation": "Le dernier élément est à l'indice `len(liste) - 1`, puisque la\nnumérotation commence à 0. C'est un calcul à connaître."
        }
      ]
    },
    {
      "id": "q14",
      "difficulty": 2,
      "skills": [
        "liste",
        "types",
        "concatenation"
      ],
      "title": "Une liste de chaînes",
      "statement": "```python\ncodes = [\"12\", \"7\"]\nprint(codes[0] + codes[1])\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`127`",
          "correct": true,
          "feedback": "Bonne réponse : les éléments sont des chaînes, `+` les\nconcatène.\n"
        },
        {
          "text": "`19`",
          "correct": false,
          "feedback": "Erreur : 19 supposerait des entiers. Entre guillemets, ce sont\ndes chaînes.\n"
        },
        {
          "text": "`12 7`",
          "correct": false,
          "feedback": "Erreur : la concaténation n'insère pas d'espace.\n"
        },
        {
          "text": "Une erreur, on n'additionne pas des éléments de liste",
          "correct": false,
          "feedback": "Erreur : un élément de liste s'utilise comme n'importe quelle\nvaleur de son type.\n"
        }
      ],
      "explanation": "Une liste peut contenir des chaînes, des nombres ou des booléens.\nChaque élément garde son type, et les opérateurs se comportent en\nconséquence."
    },
    {
      "id": "q15",
      "difficulty": 3,
      "skills": [
        "parcours-indices",
        "modification"
      ],
      "title": "Modifier tous les éléments",
      "statement": "```python\nval = [1, 2, 3]\nfor i in range(len(val)):\n    val[i] = val[i] * 10\nprint(val)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`[10, 20, 30]`",
          "correct": true,
          "feedback": "Bonne réponse : à chaque tour, l'élément d'indice `i` est\nremplacé par son produit par 10.\n"
        },
        {
          "text": "`[1, 2, 3]`",
          "correct": false,
          "feedback": "Erreur : l'affectation `val[i] = ...` modifie bien la liste.\n"
        },
        {
          "text": "`[10, 10, 10]`",
          "correct": false,
          "feedback": "Erreur : chaque élément est multiplié par 10, ils restent\ndifférents.\n"
        },
        {
          "text": "`[0, 10, 20]`",
          "correct": false,
          "feedback": "Erreur : on multiplie les valeurs, pas les indices.\n"
        }
      ],
      "explanation": "Pour modifier les éléments d'une liste, on parcourt les indices et\non réaffecte `liste[i]`. C'est le rôle du parcours par indices.",
      "variants": [
        {
          "statement": "```python\nval = [1, 2, 3]\nfor i in range(len(val)):\n    val[i] = val[i] * 10\nprint(val)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[10, 20, 30]`",
              "correct": true,
              "feedback": "Bonne réponse : à chaque tour, l'élément d'indice `i` est\nremplacé par son produit par 10.\n"
            },
            {
              "text": "`[1, 2, 3]`",
              "correct": false,
              "feedback": "Erreur : l'affectation `val[i] = ...` modifie bien la liste.\n"
            },
            {
              "text": "`[10, 10, 10]`",
              "correct": false,
              "feedback": "Erreur : chaque élément est multiplié par 10, ils restent\ndifférents.\n"
            },
            {
              "text": "`[0, 10, 20]`",
              "correct": false,
              "feedback": "Erreur : on multiplie les valeurs, pas les indices.\n"
            }
          ],
          "explanation": "Pour modifier les éléments d'une liste, on parcourt les indices et\non réaffecte `liste[i]`. C'est le rôle du parcours par indices."
        },
        {
          "statement": "```python\nval = [2, 5, 7]\nfor i in range(len(val)):\n    val[i] = val[i] * 3\nprint(val)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[6, 15, 21]`",
              "correct": true,
              "feedback": "Bonne réponse : à chaque tour, l'élément d'indice `i` est\nremplacé par son produit par 3.\n"
            },
            {
              "text": "`[2, 5, 7]`",
              "correct": false,
              "feedback": "Erreur : l'affectation `val[i] = ...` modifie bien la liste.\n"
            },
            {
              "text": "`[3, 3, 3]`",
              "correct": false,
              "feedback": "Erreur : chaque élément est multiplié par 3, ils restent\ndifférents.\n"
            },
            {
              "text": "`[0, 3, 6]`",
              "correct": false,
              "feedback": "Erreur : on multiplie les valeurs, pas les indices.\n"
            }
          ],
          "explanation": "Pour modifier les éléments d'une liste, on parcourt les indices et\non réaffecte `liste[i]`. C'est le rôle du parcours par indices."
        },
        {
          "statement": "```python\nval = [4, 1, 6]\nfor i in range(len(val)):\n    val[i] = val[i] * 100\nprint(val)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[400, 100, 600]`",
              "correct": true,
              "feedback": "Bonne réponse : à chaque tour, l'élément d'indice `i` est\nremplacé par son produit par 100.\n"
            },
            {
              "text": "`[4, 1, 6]`",
              "correct": false,
              "feedback": "Erreur : l'affectation `val[i] = ...` modifie bien la liste.\n"
            },
            {
              "text": "`[100, 100, 100]`",
              "correct": false,
              "feedback": "Erreur : chaque élément est multiplié par 100, ils restent\ndifférents.\n"
            },
            {
              "text": "`[0, 100, 200]`",
              "correct": false,
              "feedback": "Erreur : on multiplie les valeurs, pas les indices.\n"
            }
          ],
          "explanation": "Pour modifier les éléments d'une liste, on parcourt les indices et\non réaffecte `liste[i]`. C'est le rôle du parcours par indices."
        }
      ]
    },
    {
      "id": "q16",
      "difficulty": 3,
      "skills": [
        "parcours",
        "modification",
        "trace"
      ],
      "title": "Un parcours qui ne modifie rien",
      "statement": "```python\nval = [1, 2, 3]\nfor v in val:\n    v = v * 10\nprint(val)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`[1, 2, 3]`",
          "correct": true,
          "feedback": "Bonne réponse : `v` reçoit une copie de chaque élément. La\nmodifier ne change pas la liste.\n"
        },
        {
          "text": "`[10, 20, 30]`",
          "correct": false,
          "feedback": "Erreur : pour modifier la liste, il faut réaffecter `val[i]`,\npas la variable de boucle.\n"
        },
        {
          "text": "`[30]`",
          "correct": false,
          "feedback": "Erreur : la liste n'est ni réduite ni modifiée.\n"
        },
        {
          "text": "Une erreur, `v` n'est pas modifiable",
          "correct": false,
          "feedback": "Erreur : `v` est une variable ordinaire, on peut la modifier,\nmais sans effet sur la liste.\n"
        }
      ],
      "explanation": "Dans `for v in val`, la variable `v` est une copie de l'élément.\nModifier `v` ne touche pas la liste ; il faut passer par les indices\npour la changer."
    },
    {
      "id": "q17",
      "difficulty": 2,
      "skills": [
        "append",
        "len",
        "indice"
      ],
      "title": "Longueur après ajouts",
      "statement": "```python\nl = [5, 6]\nl.append(7)\nl.append(8)\nprint(len(l), l[2])\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`4 7`",
          "correct": true,
          "feedback": "Bonne réponse : deux ajouts portent la longueur à 4, et\nl'élément d'indice 2 est 7.\n"
        },
        {
          "text": "`4 8`",
          "correct": false,
          "feedback": "Erreur : 8 est à l'indice 3, le dernier.\n"
        },
        {
          "text": "`2 7`",
          "correct": false,
          "feedback": "Erreur : `len` compte les éléments après les ajouts.\n"
        },
        {
          "text": "`3 7`",
          "correct": false,
          "feedback": "Erreur : deux `append` ajoutent deux éléments.\n"
        }
      ],
      "explanation": "Chaque `append` ajoute un élément à la fin et augmente la longueur de\n1. Le nouvel élément prend l'indice `len - 1`.",
      "variants": [
        {
          "statement": "```python\nl = [5, 6]\nl.append(7)\nl.append(8)\nprint(len(l), l[2])\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`4 7`",
              "correct": true,
              "feedback": "Bonne réponse : deux ajouts portent la longueur à 4, et\nl'élément d'indice 2 est 7.\n"
            },
            {
              "text": "`4 8`",
              "correct": false,
              "feedback": "Erreur : 8 est à l'indice 3, le dernier.\n"
            },
            {
              "text": "`2 7`",
              "correct": false,
              "feedback": "Erreur : `len` compte les éléments après les ajouts.\n"
            },
            {
              "text": "`3 7`",
              "correct": false,
              "feedback": "Erreur : deux `append` ajoutent deux éléments.\n"
            }
          ],
          "explanation": "Chaque `append` ajoute un élément à la fin et augmente la longueur de\n1. Le nouvel élément prend l'indice `len - 1`."
        },
        {
          "statement": "```python\nl = [1, 2, 3]\nl.append(9)\nl.append(4)\nprint(len(l), l[2])\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`5 3`",
              "correct": true,
              "feedback": "Bonne réponse : deux ajouts portent la longueur à 5, et\nl'élément d'indice 2 est 3.\n"
            },
            {
              "text": "`5 4`",
              "correct": false,
              "feedback": "Erreur : 4 est à l'indice 4, le dernier.\n"
            },
            {
              "text": "`3 3`",
              "correct": false,
              "feedback": "Erreur : `len` compte les éléments après les ajouts.\n"
            },
            {
              "text": "`4 3`",
              "correct": false,
              "feedback": "Erreur : deux `append` ajoutent deux éléments.\n"
            }
          ],
          "explanation": "Chaque `append` ajoute un élément à la fin et augmente la longueur de\n1. Le nouvel élément prend l'indice `len - 1`."
        },
        {
          "statement": "```python\nl = [10, 11, 12]\nl.append(20)\nl.append(30)\nprint(len(l), l[2])\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`5 12`",
              "correct": true,
              "feedback": "Bonne réponse : deux ajouts portent la longueur à 5, et\nl'élément d'indice 2 est 12.\n"
            },
            {
              "text": "`5 30`",
              "correct": false,
              "feedback": "Erreur : 30 est à l'indice 4, le dernier.\n"
            },
            {
              "text": "`3 12`",
              "correct": false,
              "feedback": "Erreur : `len` compte les éléments après les ajouts.\n"
            },
            {
              "text": "`4 12`",
              "correct": false,
              "feedback": "Erreur : deux `append` ajoutent deux éléments.\n"
            }
          ],
          "explanation": "Chaque `append` ajoute un élément à la fin et augmente la longueur de\n1. Le nouvel élément prend l'indice `len - 1`."
        }
      ]
    },
    {
      "id": "q18",
      "difficulty": 3,
      "skills": [
        "compteur",
        "chaine",
        "len"
      ],
      "title": "Dépouiller un sondage",
      "statement": "```python\nreponses = [\"oui\", \"non\", \"oui\", \"oui\"]\nc = 0\nfor r in reponses:\n    if r == \"oui\":\n        c = c + 1\nprint(c, len(reponses) - c)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`3 1`",
          "correct": true,
          "feedback": "Bonne réponse : 3 `oui`, et le reste, 4 moins 3, soit 1\n`non`.\n"
        },
        {
          "text": "`1 3`",
          "correct": false,
          "feedback": "Erreur : le compteur compte les `oui`, qui sont 3.\n"
        },
        {
          "text": "`3 4`",
          "correct": false,
          "feedback": "Erreur : le second nombre est `len(reponses) - c`, soit 1.\n"
        },
        {
          "text": "`4 3`",
          "correct": false,
          "feedback": "Erreur : `c` ne compte que les `oui`.\n"
        }
      ],
      "explanation": "Compter les éléments égaux à une valeur est un compteur\nconditionnel. Le complément s'obtient avec `len`, sans second\nparcours.",
      "variants": [
        {
          "statement": "```python\nreponses = [\"oui\", \"non\", \"oui\", \"oui\"]\nc = 0\nfor r in reponses:\n    if r == \"oui\":\n        c = c + 1\nprint(c, len(reponses) - c)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`3 1`",
              "correct": true,
              "feedback": "Bonne réponse : 3 `oui`, et le reste, 4 moins 3, soit 1\n`non`.\n"
            },
            {
              "text": "`1 3`",
              "correct": false,
              "feedback": "Erreur : le compteur compte les `oui`, qui sont 3.\n"
            },
            {
              "text": "`3 4`",
              "correct": false,
              "feedback": "Erreur : le second nombre est `len(reponses) - c`, soit 1.\n"
            },
            {
              "text": "`4 3`",
              "correct": false,
              "feedback": "Erreur : `c` ne compte que les `oui`.\n"
            }
          ],
          "explanation": "Compter les éléments égaux à une valeur est un compteur\nconditionnel. Le complément s'obtient avec `len`, sans second\nparcours."
        },
        {
          "statement": "```python\nreponses = [\"non\", \"oui\", \"non\", \"non\", \"oui\"]\nc = 0\nfor r in reponses:\n    if r == \"oui\":\n        c = c + 1\nprint(c, len(reponses) - c)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`2 3`",
              "correct": true,
              "feedback": "Bonne réponse : 2 `oui`, et le reste, 5 moins 2, soit 3\n`non`.\n"
            },
            {
              "text": "`3 2`",
              "correct": false,
              "feedback": "Erreur : le compteur compte les `oui`, qui sont 2.\n"
            },
            {
              "text": "`2 5`",
              "correct": false,
              "feedback": "Erreur : le second nombre est `len(reponses) - c`, soit 3.\n"
            },
            {
              "text": "`5 2`",
              "correct": false,
              "feedback": "Erreur : `c` ne compte que les `oui`.\n"
            }
          ],
          "explanation": "Compter les éléments égaux à une valeur est un compteur\nconditionnel. Le complément s'obtient avec `len`, sans second\nparcours."
        },
        {
          "statement": "```python\nreponses = [\"oui\", \"oui\", \"oui\", \"non\", \"oui\"]\nc = 0\nfor r in reponses:\n    if r == \"oui\":\n        c = c + 1\nprint(c, len(reponses) - c)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`4 1`",
              "correct": true,
              "feedback": "Bonne réponse : 4 `oui`, et le reste, 5 moins 4, soit 1\n`non`.\n"
            },
            {
              "text": "`1 4`",
              "correct": false,
              "feedback": "Erreur : le compteur compte les `oui`, qui sont 4.\n"
            },
            {
              "text": "`4 5`",
              "correct": false,
              "feedback": "Erreur : le second nombre est `len(reponses) - c`, soit 1.\n"
            },
            {
              "text": "`5 4`",
              "correct": false,
              "feedback": "Erreur : `c` ne compte que les `oui`.\n"
            }
          ],
          "explanation": "Compter les éléments égaux à une valeur est un compteur\nconditionnel. Le complément s'obtient avec `len`, sans second\nparcours."
        }
      ]
    },
    {
      "id": "q19",
      "difficulty": 2,
      "skills": [
        "liste",
        "len"
      ],
      "title": "Une liste vide",
      "statement": "```python\nl = []\nprint(len(l), l)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`0 []`",
          "correct": true,
          "feedback": "Bonne réponse : une liste vide a zéro élément et s'affiche\n`[]`.\n"
        },
        {
          "text": "Une erreur, une liste ne peut pas être vide",
          "correct": false,
          "feedback": "Erreur : la liste vide existe, c'est le point de départ habituel\navant des `append`.\n"
        },
        {
          "text": "`[] 0`",
          "correct": false,
          "feedback": "Erreur : `len(l)` est affiché en premier.\n"
        },
        {
          "text": "`None`",
          "correct": false,
          "feedback": "Erreur : `[]` est une liste, pas l'absence de valeur.\n"
        }
      ],
      "explanation": "`[]` est la liste vide : longueur 0, aucun indice valide. On la\nremplit ensuite avec `append`."
    },
    {
      "id": "q20",
      "difficulty": 3,
      "skills": [
        "echange",
        "indice"
      ],
      "title": "Échanger deux éléments",
      "statement": "```python\nt = [1, 2, 3]\ntmp = t[0]\nt[0] = t[2]\nt[2] = tmp\nprint(t)\n```\n\nQu'affiche ce programme ?",
      "options": [
        {
          "text": "`[3, 2, 1]`",
          "correct": true,
          "feedback": "Bonne réponse : `tmp` garde 1, le premier élément reçoit 3, et\nle dernier récupère 1.\n"
        },
        {
          "text": "`[1, 2, 3]`",
          "correct": false,
          "feedback": "Erreur : les deux affectations modifient bien les éléments.\n"
        },
        {
          "text": "`[3, 2, 3]`",
          "correct": false,
          "feedback": "Erreur : `t[2] = tmp` remet la valeur sauvegardée, 1, à la fin.\n"
        },
        {
          "text": "`[1, 2, 1]`",
          "correct": false,
          "feedback": "Erreur : `t[0] = t[2]` donne 3 au premier élément.\n"
        }
      ],
      "explanation": "L'échange de deux éléments suit le schéma de l'échange de deux\nvariables, avec une variable temporaire. C'est l'opération de base\ndes algorithmes de tri.",
      "variants": [
        {
          "statement": "```python\nt = [1, 2, 3]\ntmp = t[0]\nt[0] = t[2]\nt[2] = tmp\nprint(t)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[3, 2, 1]`",
              "correct": true,
              "feedback": "Bonne réponse : `tmp` garde 1, le premier élément reçoit 3, et\nle dernier récupère 1.\n"
            },
            {
              "text": "`[1, 2, 3]`",
              "correct": false,
              "feedback": "Erreur : les deux affectations modifient bien les éléments.\n"
            },
            {
              "text": "`[3, 2, 3]`",
              "correct": false,
              "feedback": "Erreur : `t[2] = tmp` remet la valeur sauvegardée, 1, à la fin.\n"
            },
            {
              "text": "`[1, 2, 1]`",
              "correct": false,
              "feedback": "Erreur : `t[0] = t[2]` donne 3 au premier élément.\n"
            }
          ],
          "explanation": "L'échange de deux éléments suit le schéma de l'échange de deux\nvariables, avec une variable temporaire. C'est l'opération de base\ndes algorithmes de tri."
        },
        {
          "statement": "```python\nt = [4, 5, 6]\ntmp = t[0]\nt[0] = t[2]\nt[2] = tmp\nprint(t)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[6, 5, 4]`",
              "correct": true,
              "feedback": "Bonne réponse : `tmp` garde 4, le premier élément reçoit 6, et\nle dernier récupère 4.\n"
            },
            {
              "text": "`[4, 5, 6]`",
              "correct": false,
              "feedback": "Erreur : les deux affectations modifient bien les éléments.\n"
            },
            {
              "text": "`[6, 5, 6]`",
              "correct": false,
              "feedback": "Erreur : `t[2] = tmp` remet la valeur sauvegardée, 4, à la fin.\n"
            },
            {
              "text": "`[4, 5, 4]`",
              "correct": false,
              "feedback": "Erreur : `t[0] = t[2]` donne 6 au premier élément.\n"
            }
          ],
          "explanation": "L'échange de deux éléments suit le schéma de l'échange de deux\nvariables, avec une variable temporaire. C'est l'opération de base\ndes algorithmes de tri."
        },
        {
          "statement": "```python\nt = [9, 8, 7]\ntmp = t[0]\nt[0] = t[2]\nt[2] = tmp\nprint(t)\n```\n\nQu'affiche ce programme ?",
          "options": [
            {
              "text": "`[7, 8, 9]`",
              "correct": true,
              "feedback": "Bonne réponse : `tmp` garde 9, le premier élément reçoit 7, et\nle dernier récupère 9.\n"
            },
            {
              "text": "`[9, 8, 7]`",
              "correct": false,
              "feedback": "Erreur : les deux affectations modifient bien les éléments.\n"
            },
            {
              "text": "`[7, 8, 7]`",
              "correct": false,
              "feedback": "Erreur : `t[2] = tmp` remet la valeur sauvegardée, 9, à la fin.\n"
            },
            {
              "text": "`[9, 8, 9]`",
              "correct": false,
              "feedback": "Erreur : `t[0] = t[2]` donne 7 au premier élément.\n"
            }
          ],
          "explanation": "L'échange de deux éléments suit le schéma de l'échange de deux\nvariables, avec une variable temporaire. C'est l'opération de base\ndes algorithmes de tri."
        }
      ]
    },
    {
      "id": "q21",
      "difficulty": 1,
      "skills": [
        "liste",
        "concatenation"
      ],
      "title": "Deux listes mises bout à bout",
      "statement": "Qu'affiche `print([1, 2] + [3])` ?",
      "options": [
        {
          "text": "`[1, 2, 3]`",
          "correct": true,
          "feedback": "Bonne réponse : `+` entre deux listes les met bout à bout, dans\nl'ordre, en une seule liste.\n"
        },
        {
          "text": "`[[1, 2], [3]]`",
          "correct": false,
          "feedback": "Erreur : `+` ne crée pas une liste de listes, il enchaîne les\néléments.\n"
        },
        {
          "text": "`[1, 2, 3, 3]`",
          "correct": false,
          "feedback": "Erreur : aucun élément n'est dupliqué ni additionné, les listes\nsont simplement enchaînées.\n"
        },
        {
          "text": "`6`",
          "correct": false,
          "feedback": "Erreur : `+` entre listes ne calcule pas la somme des éléments.\n"
        }
      ],
      "explanation": "Comme pour les chaînes, `+` concatène les listes : le résultat\ncontient les éléments de la première puis ceux de la seconde.",
      "variants": [
        {
          "statement": "Qu'affiche `print([1, 2] + [3])` ?",
          "options": [
            {
              "text": "`[1, 2, 3]`",
              "correct": true,
              "feedback": "Bonne réponse : `+` entre deux listes les met bout à bout, dans\nl'ordre, en une seule liste.\n"
            },
            {
              "text": "`[[1, 2], [3]]`",
              "correct": false,
              "feedback": "Erreur : `+` ne crée pas une liste de listes, il enchaîne les\néléments.\n"
            },
            {
              "text": "`[1, 2, 3, 3]`",
              "correct": false,
              "feedback": "Erreur : aucun élément n'est dupliqué ni additionné, les listes\nsont simplement enchaînées.\n"
            },
            {
              "text": "`6`",
              "correct": false,
              "feedback": "Erreur : `+` entre listes ne calcule pas la somme des éléments.\n"
            }
          ],
          "explanation": "Comme pour les chaînes, `+` concatène les listes : le résultat\ncontient les éléments de la première puis ceux de la seconde."
        },
        {
          "statement": "Qu'affiche `print([5] + [6, 7])` ?",
          "options": [
            {
              "text": "`[5, 6, 7]`",
              "correct": true,
              "feedback": "Bonne réponse : `+` entre deux listes les met bout à bout, dans\nl'ordre, en une seule liste.\n"
            },
            {
              "text": "`[[5], [6, 7]]`",
              "correct": false,
              "feedback": "Erreur : `+` ne crée pas une liste de listes, il enchaîne les\néléments.\n"
            },
            {
              "text": "`[5, 5, 6, 7]`",
              "correct": false,
              "feedback": "Erreur : aucun élément n'est dupliqué ni additionné, les listes\nsont simplement enchaînées.\n"
            },
            {
              "text": "`18`",
              "correct": false,
              "feedback": "Erreur : `+` entre listes ne calcule pas la somme des éléments.\n"
            }
          ],
          "explanation": "Comme pour les chaînes, `+` concatène les listes : le résultat\ncontient les éléments de la première puis ceux de la seconde."
        },
        {
          "statement": "Qu'affiche `print([10, 20] + [30, 40])` ?",
          "options": [
            {
              "text": "`[10, 20, 30, 40]`",
              "correct": true,
              "feedback": "Bonne réponse : `+` entre deux listes les met bout à bout, dans\nl'ordre, en une seule liste.\n"
            },
            {
              "text": "`[[10, 20], [30, 40]]`",
              "correct": false,
              "feedback": "Erreur : `+` ne crée pas une liste de listes, il enchaîne les\néléments.\n"
            },
            {
              "text": "`[40, 60]`",
              "correct": false,
              "feedback": "Erreur : aucun élément n'est dupliqué ni additionné, les listes\nsont simplement enchaînées.\n"
            },
            {
              "text": "`100`",
              "correct": false,
              "feedback": "Erreur : `+` entre listes ne calcule pas la somme des éléments.\n"
            }
          ],
          "explanation": "Comme pour les chaînes, `+` concatène les listes : le résultat\ncontient les éléments de la première puis ceux de la seconde."
        }
      ]
    },
    {
      "id": "q22",
      "difficulty": 1,
      "skills": [
        "liste",
        "sum"
      ],
      "title": "La somme d'une liste",
      "statement": "Qu'affiche `print(sum([4, 8, 5]))` ?",
      "options": [
        {
          "text": "`17`",
          "correct": true,
          "feedback": "Bonne réponse : `sum` additionne tous les éléments de la liste.\n"
        },
        {
          "text": "`3`",
          "correct": false,
          "feedback": "Erreur : 3 est le nombre d'éléments, donné par `len`.\n"
        },
        {
          "text": "`8`",
          "correct": false,
          "feedback": "Erreur : 8 est le plus grand élément, donné par `max`.\n"
        },
        {
          "text": "`5`",
          "correct": false,
          "feedback": "Erreur : 5 est le dernier élément, pas la somme.\n"
        }
      ],
      "explanation": "`sum`, `len`, `max` et `min` sont des fonctions prêtes à l'emploi\nsur les listes de nombres.",
      "variants": [
        {
          "statement": "Qu'affiche `print(sum([4, 8, 5]))` ?",
          "options": [
            {
              "text": "`17`",
              "correct": true,
              "feedback": "Bonne réponse : `sum` additionne tous les éléments de la liste.\n"
            },
            {
              "text": "`3`",
              "correct": false,
              "feedback": "Erreur : 3 est le nombre d'éléments, donné par `len`.\n"
            },
            {
              "text": "`8`",
              "correct": false,
              "feedback": "Erreur : 8 est le plus grand élément, donné par `max`.\n"
            },
            {
              "text": "`5`",
              "correct": false,
              "feedback": "Erreur : 5 est le dernier élément, pas la somme.\n"
            }
          ],
          "explanation": "`sum`, `len`, `max` et `min` sont des fonctions prêtes à l'emploi\nsur les listes de nombres."
        },
        {
          "statement": "Qu'affiche `print(sum([10, 20, 5, 1]))` ?",
          "options": [
            {
              "text": "`36`",
              "correct": true,
              "feedback": "Bonne réponse : `sum` additionne tous les éléments de la liste.\n"
            },
            {
              "text": "`4`",
              "correct": false,
              "feedback": "Erreur : 4 est le nombre d'éléments, donné par `len`.\n"
            },
            {
              "text": "`20`",
              "correct": false,
              "feedback": "Erreur : 20 est le plus grand élément, donné par `max`.\n"
            },
            {
              "text": "`1`",
              "correct": false,
              "feedback": "Erreur : 1 est le dernier élément, pas la somme.\n"
            }
          ],
          "explanation": "`sum`, `len`, `max` et `min` sont des fonctions prêtes à l'emploi\nsur les listes de nombres."
        },
        {
          "statement": "Qu'affiche `print(sum([9, 7]))` ?",
          "options": [
            {
              "text": "`16`",
              "correct": true,
              "feedback": "Bonne réponse : `sum` additionne tous les éléments de la liste.\n"
            },
            {
              "text": "`2`",
              "correct": false,
              "feedback": "Erreur : 2 est le nombre d'éléments, donné par `len`.\n"
            },
            {
              "text": "`9`",
              "correct": false,
              "feedback": "Erreur : 9 est le plus grand élément, donné par `max`.\n"
            },
            {
              "text": "`7`",
              "correct": false,
              "feedback": "Erreur : 7 est le dernier élément, pas la somme.\n"
            }
          ],
          "explanation": "`sum`, `len`, `max` et `min` sont des fonctions prêtes à l'emploi\nsur les listes de nombres."
        }
      ]
    },
    {
      "id": "q23",
      "difficulty": 1,
      "skills": [
        "liste",
        "creation",
        "repetition"
      ],
      "title": "Une liste remplie de zéros",
      "statement": "Qu'affiche `print([0] * 3)` ?",
      "options": [
        {
          "text": "`[0, 0, 0]`",
          "correct": true,
          "feedback": "Bonne réponse : multiplier une liste par un entier la répète.\n`[0] * 3` contient 3 zéros.\n"
        },
        {
          "text": "`[3]`",
          "correct": false,
          "feedback": "Erreur : la multiplication ne change pas les éléments, elle les\nrépète.\n"
        },
        {
          "text": "`[0, 3]`",
          "correct": false,
          "feedback": "Erreur : 3 n'est pas ajouté à la liste, il indique combien de\nfois elle est répétée.\n"
        },
        {
          "text": "`0`",
          "correct": false,
          "feedback": "Erreur : le résultat est une liste, pas un nombre.\n"
        }
      ],
      "explanation": "`[valeur] * n` est la façon la plus simple de créer une liste de\n`n` cases toutes identiques.",
      "variants": [
        {
          "statement": "Qu'affiche `print([0] * 3)` ?",
          "options": [
            {
              "text": "`[0, 0, 0]`",
              "correct": true,
              "feedback": "Bonne réponse : multiplier une liste par un entier la répète.\n`[0] * 3` contient 3 zéros.\n"
            },
            {
              "text": "`[3]`",
              "correct": false,
              "feedback": "Erreur : la multiplication ne change pas les éléments, elle les\nrépète.\n"
            },
            {
              "text": "`[0, 3]`",
              "correct": false,
              "feedback": "Erreur : 3 n'est pas ajouté à la liste, il indique combien de\nfois elle est répétée.\n"
            },
            {
              "text": "`0`",
              "correct": false,
              "feedback": "Erreur : le résultat est une liste, pas un nombre.\n"
            }
          ],
          "explanation": "`[valeur] * n` est la façon la plus simple de créer une liste de\n`n` cases toutes identiques."
        },
        {
          "statement": "Qu'affiche `print([0] * 5)` ?",
          "options": [
            {
              "text": "`[0, 0, 0, 0, 0]`",
              "correct": true,
              "feedback": "Bonne réponse : multiplier une liste par un entier la répète.\n`[0] * 5` contient 5 zéros.\n"
            },
            {
              "text": "`[5]`",
              "correct": false,
              "feedback": "Erreur : la multiplication ne change pas les éléments, elle les\nrépète.\n"
            },
            {
              "text": "`[0, 5]`",
              "correct": false,
              "feedback": "Erreur : 5 n'est pas ajouté à la liste, il indique combien de\nfois elle est répétée.\n"
            },
            {
              "text": "`0`",
              "correct": false,
              "feedback": "Erreur : le résultat est une liste, pas un nombre.\n"
            }
          ],
          "explanation": "`[valeur] * n` est la façon la plus simple de créer une liste de\n`n` cases toutes identiques."
        },
        {
          "statement": "Qu'affiche `print([0] * 2)` ?",
          "options": [
            {
              "text": "`[0, 0]`",
              "correct": true,
              "feedback": "Bonne réponse : multiplier une liste par un entier la répète.\n`[0] * 2` contient 2 zéros.\n"
            },
            {
              "text": "`[2]`",
              "correct": false,
              "feedback": "Erreur : la multiplication ne change pas les éléments, elle les\nrépète.\n"
            },
            {
              "text": "`[0, 2]`",
              "correct": false,
              "feedback": "Erreur : 2 n'est pas ajouté à la liste, il indique combien de\nfois elle est répétée.\n"
            },
            {
              "text": "`0`",
              "correct": false,
              "feedback": "Erreur : le résultat est une liste, pas un nombre.\n"
            }
          ],
          "explanation": "`[valeur] * n` est la façon la plus simple de créer une liste de\n`n` cases toutes identiques."
        }
      ]
    },
    {
      "id": "q24",
      "difficulty": 1,
      "skills": [
        "liste",
        "min",
        "max"
      ],
      "title": "Le plus petit élément",
      "statement": "Qu'affiche `print(min([4, 2, 9]))` ?",
      "options": [
        {
          "text": "`2`",
          "correct": true,
          "feedback": "Bonne réponse : `min` renvoie le plus petit élément de la liste.\n"
        },
        {
          "text": "`9`",
          "correct": false,
          "feedback": "Erreur : 9 est le plus grand, donné par `max`.\n"
        },
        {
          "text": "`4`",
          "correct": false,
          "feedback": "Erreur : 4 est le premier élément, pas forcément le plus\npetit.\n"
        },
        {
          "text": "`3`",
          "correct": false,
          "feedback": "Erreur : 3 est le nombre d'éléments.\n"
        }
      ],
      "explanation": "`min` et `max` parcourent la liste pour trouver ses extrêmes, sans\nse soucier de l'ordre des éléments.",
      "variants": [
        {
          "statement": "Qu'affiche `print(min([4, 2, 9]))` ?",
          "options": [
            {
              "text": "`2`",
              "correct": true,
              "feedback": "Bonne réponse : `min` renvoie le plus petit élément de la liste.\n"
            },
            {
              "text": "`9`",
              "correct": false,
              "feedback": "Erreur : 9 est le plus grand, donné par `max`.\n"
            },
            {
              "text": "`4`",
              "correct": false,
              "feedback": "Erreur : 4 est le premier élément, pas forcément le plus\npetit.\n"
            },
            {
              "text": "`3`",
              "correct": false,
              "feedback": "Erreur : 3 est le nombre d'éléments.\n"
            }
          ],
          "explanation": "`min` et `max` parcourent la liste pour trouver ses extrêmes, sans\nse soucier de l'ordre des éléments."
        },
        {
          "statement": "Qu'affiche `print(min([15, 30, 8, 12]))` ?",
          "options": [
            {
              "text": "`8`",
              "correct": true,
              "feedback": "Bonne réponse : `min` renvoie le plus petit élément de la liste.\n"
            },
            {
              "text": "`30`",
              "correct": false,
              "feedback": "Erreur : 30 est le plus grand, donné par `max`.\n"
            },
            {
              "text": "`15`",
              "correct": false,
              "feedback": "Erreur : 15 est le premier élément, pas forcément le plus\npetit.\n"
            },
            {
              "text": "`4`",
              "correct": false,
              "feedback": "Erreur : 4 est le nombre d'éléments.\n"
            }
          ],
          "explanation": "`min` et `max` parcourent la liste pour trouver ses extrêmes, sans\nse soucier de l'ordre des éléments."
        },
        {
          "statement": "Qu'affiche `print(min([2, 9, 1]))` ?",
          "options": [
            {
              "text": "`1`",
              "correct": true,
              "feedback": "Bonne réponse : `min` renvoie le plus petit élément de la liste.\n"
            },
            {
              "text": "`9`",
              "correct": false,
              "feedback": "Erreur : 9 est le plus grand, donné par `max`.\n"
            },
            {
              "text": "`2`",
              "correct": false,
              "feedback": "Erreur : 2 est le premier élément, pas forcément le plus\npetit.\n"
            },
            {
              "text": "`3`",
              "correct": false,
              "feedback": "Erreur : 3 est le nombre d'éléments.\n"
            }
          ],
          "explanation": "`min` et `max` parcourent la liste pour trouver ses extrêmes, sans\nse soucier de l'ordre des éléments."
        }
      ]
    },
    {
      "id": "q25",
      "difficulty": 2,
      "skills": [
        "liste",
        "indice",
        "calcul"
      ],
      "title": "Deux éléments additionnés",
      "statement": "Qu'affiche ce programme ?\n```python\nliste = [5, 10, 20, 40]\nprint(liste[0] + liste[2])\n```",
      "options": [
        {
          "text": "`25`",
          "correct": true,
          "feedback": "Bonne réponse : `liste[0]` est le premier élément et `liste[2]`\nle troisième, les indices commençant à 0.\n"
        },
        {
          "text": "`15`",
          "correct": false,
          "feedback": "Erreur : c'est la somme des deux premiers éléments, aux indices\n0 et 1.\n"
        },
        {
          "text": "`50`",
          "correct": false,
          "feedback": "Erreur : c'est la somme des éléments d'indices 1 et 3, comme si\nles indices commençaient à 1.\n"
        },
        {
          "text": "`2`",
          "correct": false,
          "feedback": "Erreur : les indices servent à désigner des éléments, ce ne sont\npas eux qui sont additionnés.\n"
        }
      ],
      "explanation": "L'indice 0 désigne le premier élément, l'indice 2 le troisième.\nCette règle vaut pour toute liste.",
      "variants": [
        {
          "statement": "Qu'affiche ce programme ?\n```python\nliste = [5, 10, 20, 40]\nprint(liste[0] + liste[2])\n```",
          "options": [
            {
              "text": "`25`",
              "correct": true,
              "feedback": "Bonne réponse : `liste[0]` est le premier élément et `liste[2]`\nle troisième, les indices commençant à 0.\n"
            },
            {
              "text": "`15`",
              "correct": false,
              "feedback": "Erreur : c'est la somme des deux premiers éléments, aux indices\n0 et 1.\n"
            },
            {
              "text": "`50`",
              "correct": false,
              "feedback": "Erreur : c'est la somme des éléments d'indices 1 et 3, comme si\nles indices commençaient à 1.\n"
            },
            {
              "text": "`2`",
              "correct": false,
              "feedback": "Erreur : les indices servent à désigner des éléments, ce ne sont\npas eux qui sont additionnés.\n"
            }
          ],
          "explanation": "L'indice 0 désigne le premier élément, l'indice 2 le troisième.\nCette règle vaut pour toute liste."
        },
        {
          "statement": "Qu'affiche ce programme ?\n```python\nliste = [3, 9, 1, 7]\nprint(liste[0] + liste[2])\n```",
          "options": [
            {
              "text": "`4`",
              "correct": true,
              "feedback": "Bonne réponse : `liste[0]` est le premier élément et `liste[2]`\nle troisième, les indices commençant à 0.\n"
            },
            {
              "text": "`12`",
              "correct": false,
              "feedback": "Erreur : c'est la somme des deux premiers éléments, aux indices\n0 et 1.\n"
            },
            {
              "text": "`16`",
              "correct": false,
              "feedback": "Erreur : c'est la somme des éléments d'indices 1 et 3, comme si\nles indices commençaient à 1.\n"
            },
            {
              "text": "`2`",
              "correct": false,
              "feedback": "Erreur : les indices servent à désigner des éléments, ce ne sont\npas eux qui sont additionnés.\n"
            }
          ],
          "explanation": "L'indice 0 désigne le premier élément, l'indice 2 le troisième.\nCette règle vaut pour toute liste."
        },
        {
          "statement": "Qu'affiche ce programme ?\n```python\nliste = [100, 50, 25, 12]\nprint(liste[0] + liste[2])\n```",
          "options": [
            {
              "text": "`125`",
              "correct": true,
              "feedback": "Bonne réponse : `liste[0]` est le premier élément et `liste[2]`\nle troisième, les indices commençant à 0.\n"
            },
            {
              "text": "`150`",
              "correct": false,
              "feedback": "Erreur : c'est la somme des deux premiers éléments, aux indices\n0 et 1.\n"
            },
            {
              "text": "`62`",
              "correct": false,
              "feedback": "Erreur : c'est la somme des éléments d'indices 1 et 3, comme si\nles indices commençaient à 1.\n"
            },
            {
              "text": "`2`",
              "correct": false,
              "feedback": "Erreur : les indices servent à désigner des éléments, ce ne sont\npas eux qui sont additionnés.\n"
            }
          ],
          "explanation": "L'indice 0 désigne le premier élément, l'indice 2 le troisième.\nCette règle vaut pour toute liste."
        }
      ]
    },
    {
      "id": "q26",
      "difficulty": 2,
      "skills": [
        "liste",
        "len",
        "chaine"
      ],
      "title": "La longueur d'une liste de mots",
      "statement": "Qu'affiche `print(len(['abc', 'de']))` ?",
      "options": [
        {
          "text": "`2`",
          "correct": true,
          "feedback": "Bonne réponse : `len` compte les éléments de la liste, ici des\nchaînes, quelle que soit leur longueur.\n"
        },
        {
          "text": "`5`",
          "correct": false,
          "feedback": "Erreur : 5 est le nombre total de lettres, mais `len`\nappliqué à la liste compte ses éléments.\n"
        },
        {
          "text": "`3`",
          "correct": false,
          "feedback": "Erreur : 3 est la longueur du premier mot, pas celle de la\nliste.\n"
        },
        {
          "text": "Une erreur, `len` ne s'appliquant qu'aux chaînes",
          "correct": false,
          "feedback": "Erreur : `len` s'applique aussi aux listes.\n"
        }
      ],
      "explanation": "`len` d'une liste compte ses éléments ; `len` d'une chaîne compte\nses caractères. Tout dépend de ce qu'on lui donne.",
      "variants": [
        {
          "statement": "Qu'affiche `print(len(['abc', 'de']))` ?",
          "options": [
            {
              "text": "`2`",
              "correct": true,
              "feedback": "Bonne réponse : `len` compte les éléments de la liste, ici des\nchaînes, quelle que soit leur longueur.\n"
            },
            {
              "text": "`5`",
              "correct": false,
              "feedback": "Erreur : 5 est le nombre total de lettres, mais `len`\nappliqué à la liste compte ses éléments.\n"
            },
            {
              "text": "`3`",
              "correct": false,
              "feedback": "Erreur : 3 est la longueur du premier mot, pas celle de la\nliste.\n"
            },
            {
              "text": "Une erreur, `len` ne s'appliquant qu'aux chaînes",
              "correct": false,
              "feedback": "Erreur : `len` s'applique aussi aux listes.\n"
            }
          ],
          "explanation": "`len` d'une liste compte ses éléments ; `len` d'une chaîne compte\nses caractères. Tout dépend de ce qu'on lui donne."
        },
        {
          "statement": "Qu'affiche `print(len(['nsi', 'snt', 'maths', 'x']))` ?",
          "options": [
            {
              "text": "`4`",
              "correct": true,
              "feedback": "Bonne réponse : `len` compte les éléments de la liste, ici des\nchaînes, quelle que soit leur longueur.\n"
            },
            {
              "text": "`12`",
              "correct": false,
              "feedback": "Erreur : 12 est le nombre total de lettres, mais `len`\nappliqué à la liste compte ses éléments.\n"
            },
            {
              "text": "`3`",
              "correct": false,
              "feedback": "Erreur : 3 est la longueur du premier mot, pas celle de la\nliste.\n"
            },
            {
              "text": "Une erreur, `len` ne s'appliquant qu'aux chaînes",
              "correct": false,
              "feedback": "Erreur : `len` s'applique aussi aux listes.\n"
            }
          ],
          "explanation": "`len` d'une liste compte ses éléments ; `len` d'une chaîne compte\nses caractères. Tout dépend de ce qu'on lui donne."
        },
        {
          "statement": "Qu'affiche `print(len(['salut', 'ok', 'a']))` ?",
          "options": [
            {
              "text": "`3`",
              "correct": true,
              "feedback": "Bonne réponse : `len` compte les éléments de la liste, ici des\nchaînes, quelle que soit leur longueur.\n"
            },
            {
              "text": "`8`",
              "correct": false,
              "feedback": "Erreur : 8 est le nombre total de lettres, mais `len`\nappliqué à la liste compte ses éléments.\n"
            },
            {
              "text": "`5`",
              "correct": false,
              "feedback": "Erreur : 5 est la longueur du premier mot, pas celle de la\nliste.\n"
            },
            {
              "text": "Une erreur, `len` ne s'appliquant qu'aux chaînes",
              "correct": false,
              "feedback": "Erreur : `len` s'applique aussi aux listes.\n"
            }
          ],
          "explanation": "`len` d'une liste compte ses éléments ; `len` d'une chaîne compte\nses caractères. Tout dépend de ce qu'on lui donne."
        }
      ]
    },
    {
      "id": "q27",
      "difficulty": 2,
      "skills": [
        "liste",
        "indices",
        "accumulateur"
      ],
      "title": "Une somme calculée par indices",
      "statement": "Qu'affiche ce programme ?\n```python\nliste = [3, 5, 9, 1]\ns = 0\nfor i in range(len(liste)):\n    s = s + liste[i]\nprint(s)\n```",
      "options": [
        {
          "text": "`18`",
          "correct": true,
          "feedback": "Bonne réponse : `i` parcourt les indices de 0 à 3, et\n`liste[i]` désigne chaque élément, tous additionnés dans `s`.\n"
        },
        {
          "text": "`6`",
          "correct": false,
          "feedback": "Erreur : ce serait la somme des indices, mais c'est `liste[i]`\nqui est ajouté, pas `i`.\n"
        },
        {
          "text": "`4`",
          "correct": false,
          "feedback": "Erreur : 4 est le nombre de tours, pas la somme des éléments.\n"
        },
        {
          "text": "`1`",
          "correct": false,
          "feedback": "Erreur : `s` accumule tous les éléments, pas seulement le\ndernier.\n"
        }
      ],
      "explanation": "Parcourir par indices avec `range(len(liste))` permet d'accéder à\nchaque élément par `liste[i]`.",
      "variants": [
        {
          "statement": "Qu'affiche ce programme ?\n```python\nliste = [3, 5, 9, 1]\ns = 0\nfor i in range(len(liste)):\n    s = s + liste[i]\nprint(s)\n```",
          "options": [
            {
              "text": "`18`",
              "correct": true,
              "feedback": "Bonne réponse : `i` parcourt les indices de 0 à 3, et\n`liste[i]` désigne chaque élément, tous additionnés dans `s`.\n"
            },
            {
              "text": "`6`",
              "correct": false,
              "feedback": "Erreur : ce serait la somme des indices, mais c'est `liste[i]`\nqui est ajouté, pas `i`.\n"
            },
            {
              "text": "`4`",
              "correct": false,
              "feedback": "Erreur : 4 est le nombre de tours, pas la somme des éléments.\n"
            },
            {
              "text": "`1`",
              "correct": false,
              "feedback": "Erreur : `s` accumule tous les éléments, pas seulement le\ndernier.\n"
            }
          ],
          "explanation": "Parcourir par indices avec `range(len(liste))` permet d'accéder à\nchaque élément par `liste[i]`."
        },
        {
          "statement": "Qu'affiche ce programme ?\n```python\nliste = [10, 1, 4, 7]\ns = 0\nfor i in range(len(liste)):\n    s = s + liste[i]\nprint(s)\n```",
          "options": [
            {
              "text": "`22`",
              "correct": true,
              "feedback": "Bonne réponse : `i` parcourt les indices de 0 à 3, et\n`liste[i]` désigne chaque élément, tous additionnés dans `s`.\n"
            },
            {
              "text": "`6`",
              "correct": false,
              "feedback": "Erreur : ce serait la somme des indices, mais c'est `liste[i]`\nqui est ajouté, pas `i`.\n"
            },
            {
              "text": "`4`",
              "correct": false,
              "feedback": "Erreur : 4 est le nombre de tours, pas la somme des éléments.\n"
            },
            {
              "text": "`7`",
              "correct": false,
              "feedback": "Erreur : `s` accumule tous les éléments, pas seulement le\ndernier.\n"
            }
          ],
          "explanation": "Parcourir par indices avec `range(len(liste))` permet d'accéder à\nchaque élément par `liste[i]`."
        },
        {
          "statement": "Qu'affiche ce programme ?\n```python\nliste = [8, 5]\ns = 0\nfor i in range(len(liste)):\n    s = s + liste[i]\nprint(s)\n```",
          "options": [
            {
              "text": "`13`",
              "correct": true,
              "feedback": "Bonne réponse : `i` parcourt les indices de 0 à 1, et\n`liste[i]` désigne chaque élément, tous additionnés dans `s`.\n"
            },
            {
              "text": "`1`",
              "correct": false,
              "feedback": "Erreur : ce serait la somme des indices, mais c'est `liste[i]`\nqui est ajouté, pas `i`.\n"
            },
            {
              "text": "`2`",
              "correct": false,
              "feedback": "Erreur : 2 est le nombre de tours, pas la somme des éléments.\n"
            },
            {
              "text": "`5`",
              "correct": false,
              "feedback": "Erreur : `s` accumule tous les éléments, pas seulement le\ndernier.\n"
            }
          ],
          "explanation": "Parcourir par indices avec `range(len(liste))` permet d'accéder à\nchaque élément par `liste[i]`."
        }
      ]
    },
    {
      "id": "q28",
      "difficulty": 3,
      "skills": [
        "liste",
        "alias",
        "append"
      ],
      "title": "Deux noms pour une même liste",
      "statement": "Qu'affiche ce programme ?\n```python\na = [1, 2]\nb = a\nb.append(3)\nprint(a)\n```",
      "options": [
        {
          "text": "`[1, 2, 3]`",
          "correct": true,
          "feedback": "Bonne réponse : `b = a` ne copie pas la liste, les deux noms\ndésignent la même liste. L'ajout fait par `b` se voit par `a`.\n"
        },
        {
          "text": "`[1, 2]`",
          "correct": false,
          "feedback": "Erreur : il n'y a qu'une seule liste, modifiée par `append`,\nquel que soit le nom utilisé.\n"
        },
        {
          "text": "`[3]`",
          "correct": false,
          "feedback": "Erreur : `append` ajoute à la fin, il ne remplace pas le\ncontenu.\n"
        },
        {
          "text": "Une erreur, `b` ne pouvant modifier une liste créée par `a`",
          "correct": false,
          "feedback": "Erreur : rien n'interdit la modification, et c'est bien la même\nliste qui change.\n"
        }
      ],
      "explanation": "Affecter une liste à une autre variable crée un alias, pas une\ncopie. Pour obtenir une copie indépendante, il faut construire une\nnouvelle liste.",
      "variants": [
        {
          "statement": "Qu'affiche ce programme ?\n```python\na = [1, 2]\nb = a\nb.append(3)\nprint(a)\n```",
          "options": [
            {
              "text": "`[1, 2, 3]`",
              "correct": true,
              "feedback": "Bonne réponse : `b = a` ne copie pas la liste, les deux noms\ndésignent la même liste. L'ajout fait par `b` se voit par `a`.\n"
            },
            {
              "text": "`[1, 2]`",
              "correct": false,
              "feedback": "Erreur : il n'y a qu'une seule liste, modifiée par `append`,\nquel que soit le nom utilisé.\n"
            },
            {
              "text": "`[3]`",
              "correct": false,
              "feedback": "Erreur : `append` ajoute à la fin, il ne remplace pas le\ncontenu.\n"
            },
            {
              "text": "Une erreur, `b` ne pouvant modifier une liste créée par `a`",
              "correct": false,
              "feedback": "Erreur : rien n'interdit la modification, et c'est bien la même\nliste qui change.\n"
            }
          ],
          "explanation": "Affecter une liste à une autre variable crée un alias, pas une\ncopie. Pour obtenir une copie indépendante, il faut construire une\nnouvelle liste."
        },
        {
          "statement": "Qu'affiche ce programme ?\n```python\na = [7]\nb = a\nb.append(9)\nprint(a)\n```",
          "options": [
            {
              "text": "`[7, 9]`",
              "correct": true,
              "feedback": "Bonne réponse : `b = a` ne copie pas la liste, les deux noms\ndésignent la même liste. L'ajout fait par `b` se voit par `a`.\n"
            },
            {
              "text": "`[7]`",
              "correct": false,
              "feedback": "Erreur : il n'y a qu'une seule liste, modifiée par `append`,\nquel que soit le nom utilisé.\n"
            },
            {
              "text": "`[9]`",
              "correct": false,
              "feedback": "Erreur : `append` ajoute à la fin, il ne remplace pas le\ncontenu.\n"
            },
            {
              "text": "Une erreur, `b` ne pouvant modifier une liste créée par `a`",
              "correct": false,
              "feedback": "Erreur : rien n'interdit la modification, et c'est bien la même\nliste qui change.\n"
            }
          ],
          "explanation": "Affecter une liste à une autre variable crée un alias, pas une\ncopie. Pour obtenir une copie indépendante, il faut construire une\nnouvelle liste."
        },
        {
          "statement": "Qu'affiche ce programme ?\n```python\na = [4, 4, 4]\nb = a\nb.append(0)\nprint(a)\n```",
          "options": [
            {
              "text": "`[4, 4, 4, 0]`",
              "correct": true,
              "feedback": "Bonne réponse : `b = a` ne copie pas la liste, les deux noms\ndésignent la même liste. L'ajout fait par `b` se voit par `a`.\n"
            },
            {
              "text": "`[4, 4, 4]`",
              "correct": false,
              "feedback": "Erreur : il n'y a qu'une seule liste, modifiée par `append`,\nquel que soit le nom utilisé.\n"
            },
            {
              "text": "`[0]`",
              "correct": false,
              "feedback": "Erreur : `append` ajoute à la fin, il ne remplace pas le\ncontenu.\n"
            },
            {
              "text": "Une erreur, `b` ne pouvant modifier une liste créée par `a`",
              "correct": false,
              "feedback": "Erreur : rien n'interdit la modification, et c'est bien la même\nliste qui change.\n"
            }
          ],
          "explanation": "Affecter une liste à une autre variable crée un alias, pas une\ncopie. Pour obtenir une copie indépendante, il faut construire une\nnouvelle liste."
        }
      ]
    },
    {
      "id": "q29",
      "difficulty": 3,
      "skills": [
        "liste",
        "liste-de-listes",
        "indice"
      ],
      "title": "Un élément dans une liste de listes",
      "statement": "Qu'affiche ce programme ?\n```python\nnotes = [[12, 15], [9, 11]]\nprint(notes[1][0])\n```",
      "options": [
        {
          "text": "`9`",
          "correct": true,
          "feedback": "Bonne réponse : `notes[1]` est la seconde liste, et `[0]` en\nprend le premier élément.\n"
        },
        {
          "text": "`15`",
          "correct": false,
          "feedback": "Erreur : ce serait `notes[0][1]`, les deux indices ont été\néchangés.\n"
        },
        {
          "text": "`12`",
          "correct": false,
          "feedback": "Erreur : ce serait `notes[0][0]`, le premier élément de la\npremière liste.\n"
        },
        {
          "text": "`[9, 11]`",
          "correct": false,
          "feedback": "Erreur : `notes[1]` seul donnerait cette liste, mais le second\nindice en extrait un élément.\n"
        }
      ],
      "explanation": "Dans une liste de listes, le premier indice choisit la sous-liste,\nle second l'élément dans cette sous-liste.",
      "variants": [
        {
          "statement": "Qu'affiche ce programme ?\n```python\nnotes = [[12, 15], [9, 11]]\nprint(notes[1][0])\n```",
          "options": [
            {
              "text": "`9`",
              "correct": true,
              "feedback": "Bonne réponse : `notes[1]` est la seconde liste, et `[0]` en\nprend le premier élément.\n"
            },
            {
              "text": "`15`",
              "correct": false,
              "feedback": "Erreur : ce serait `notes[0][1]`, les deux indices ont été\néchangés.\n"
            },
            {
              "text": "`12`",
              "correct": false,
              "feedback": "Erreur : ce serait `notes[0][0]`, le premier élément de la\npremière liste.\n"
            },
            {
              "text": "`[9, 11]`",
              "correct": false,
              "feedback": "Erreur : `notes[1]` seul donnerait cette liste, mais le second\nindice en extrait un élément.\n"
            }
          ],
          "explanation": "Dans une liste de listes, le premier indice choisit la sous-liste,\nle second l'élément dans cette sous-liste."
        },
        {
          "statement": "Qu'affiche ce programme ?\n```python\nnotes = [[3, 4], [5, 6]]\nprint(notes[1][0])\n```",
          "options": [
            {
              "text": "`5`",
              "correct": true,
              "feedback": "Bonne réponse : `notes[1]` est la seconde liste, et `[0]` en\nprend le premier élément.\n"
            },
            {
              "text": "`4`",
              "correct": false,
              "feedback": "Erreur : ce serait `notes[0][1]`, les deux indices ont été\néchangés.\n"
            },
            {
              "text": "`3`",
              "correct": false,
              "feedback": "Erreur : ce serait `notes[0][0]`, le premier élément de la\npremière liste.\n"
            },
            {
              "text": "`[5, 6]`",
              "correct": false,
              "feedback": "Erreur : `notes[1]` seul donnerait cette liste, mais le second\nindice en extrait un élément.\n"
            }
          ],
          "explanation": "Dans une liste de listes, le premier indice choisit la sous-liste,\nle second l'élément dans cette sous-liste."
        },
        {
          "statement": "Qu'affiche ce programme ?\n```python\nnotes = [[20, 1], [8, 30]]\nprint(notes[1][0])\n```",
          "options": [
            {
              "text": "`8`",
              "correct": true,
              "feedback": "Bonne réponse : `notes[1]` est la seconde liste, et `[0]` en\nprend le premier élément.\n"
            },
            {
              "text": "`1`",
              "correct": false,
              "feedback": "Erreur : ce serait `notes[0][1]`, les deux indices ont été\néchangés.\n"
            },
            {
              "text": "`20`",
              "correct": false,
              "feedback": "Erreur : ce serait `notes[0][0]`, le premier élément de la\npremière liste.\n"
            },
            {
              "text": "`[8, 30]`",
              "correct": false,
              "feedback": "Erreur : `notes[1]` seul donnerait cette liste, mais le second\nindice en extrait un élément.\n"
            }
          ],
          "explanation": "Dans une liste de listes, le premier indice choisit la sous-liste,\nle second l'élément dans cette sous-liste."
        }
      ]
    },
    {
      "id": "q30",
      "difficulty": 3,
      "skills": [
        "liste",
        "recherche",
        "indice",
        "trace"
      ],
      "title": "La dernière position d'une valeur",
      "statement": "Qu'affiche ce programme ?\n```python\nliste = [6, 7, 6, 9, 6]\npos = -1\nfor i in range(len(liste)):\n    if liste[i] == 6:\n        pos = i\nprint(pos)\n```",
      "options": [
        {
          "text": "`4`",
          "correct": true,
          "feedback": "Bonne réponse : `pos` est réécrit à chaque rencontre de 6. À\nla fin, il garde l'indice de la dernière rencontre, 4.\n"
        },
        {
          "text": "`0`",
          "correct": false,
          "feedback": "Erreur : 0 est l'indice de la première rencontre, mais la\nboucle continue et écrase `pos`.\n"
        },
        {
          "text": "`3`",
          "correct": false,
          "feedback": "Erreur : 3 est le nombre de fois où 6 apparaît, mais `pos`\nreçoit un indice, pas un compte.\n"
        },
        {
          "text": "`6`",
          "correct": false,
          "feedback": "Erreur : c'est l'indice qui est mémorisé, pas la valeur\ncherchée.\n"
        }
      ],
      "explanation": "Sans arrêt anticipé, la boucle parcourt toute la liste : la\nvariable garde la trace de la dernière rencontre.",
      "variants": [
        {
          "statement": "Qu'affiche ce programme ?\n```python\nliste = [6, 7, 6, 9, 6]\npos = -1\nfor i in range(len(liste)):\n    if liste[i] == 6:\n        pos = i\nprint(pos)\n```",
          "options": [
            {
              "text": "`4`",
              "correct": true,
              "feedback": "Bonne réponse : `pos` est réécrit à chaque rencontre de 6. À\nla fin, il garde l'indice de la dernière rencontre, 4.\n"
            },
            {
              "text": "`0`",
              "correct": false,
              "feedback": "Erreur : 0 est l'indice de la première rencontre, mais la\nboucle continue et écrase `pos`.\n"
            },
            {
              "text": "`3`",
              "correct": false,
              "feedback": "Erreur : 3 est le nombre de fois où 6 apparaît, mais `pos`\nreçoit un indice, pas un compte.\n"
            },
            {
              "text": "`6`",
              "correct": false,
              "feedback": "Erreur : c'est l'indice qui est mémorisé, pas la valeur\ncherchée.\n"
            }
          ],
          "explanation": "Sans arrêt anticipé, la boucle parcourt toute la liste : la\nvariable garde la trace de la dernière rencontre."
        },
        {
          "statement": "Qu'affiche ce programme ?\n```python\nliste = [9, 1, 9, 2, 7, 9, 0]\npos = -1\nfor i in range(len(liste)):\n    if liste[i] == 9:\n        pos = i\nprint(pos)\n```",
          "options": [
            {
              "text": "`5`",
              "correct": true,
              "feedback": "Bonne réponse : `pos` est réécrit à chaque rencontre de 9. À\nla fin, il garde l'indice de la dernière rencontre, 5.\n"
            },
            {
              "text": "`0`",
              "correct": false,
              "feedback": "Erreur : 0 est l'indice de la première rencontre, mais la\nboucle continue et écrase `pos`.\n"
            },
            {
              "text": "`3`",
              "correct": false,
              "feedback": "Erreur : 3 est le nombre de fois où 9 apparaît, mais `pos`\nreçoit un indice, pas un compte.\n"
            },
            {
              "text": "`9`",
              "correct": false,
              "feedback": "Erreur : c'est l'indice qui est mémorisé, pas la valeur\ncherchée.\n"
            }
          ],
          "explanation": "Sans arrêt anticipé, la boucle parcourt toute la liste : la\nvariable garde la trace de la dernière rencontre."
        },
        {
          "statement": "Qu'affiche ce programme ?\n```python\nliste = [3, 8, 6, 8, 1]\npos = -1\nfor i in range(len(liste)):\n    if liste[i] == 8:\n        pos = i\nprint(pos)\n```",
          "options": [
            {
              "text": "`3`",
              "correct": true,
              "feedback": "Bonne réponse : `pos` est réécrit à chaque rencontre de 8. À\nla fin, il garde l'indice de la dernière rencontre, 3.\n"
            },
            {
              "text": "`1`",
              "correct": false,
              "feedback": "Erreur : 1 est l'indice de la première rencontre, mais la\nboucle continue et écrase `pos`.\n"
            },
            {
              "text": "`2`",
              "correct": false,
              "feedback": "Erreur : 2 est le nombre de fois où 8 apparaît, mais `pos`\nreçoit un indice, pas un compte.\n"
            },
            {
              "text": "`8`",
              "correct": false,
              "feedback": "Erreur : c'est l'indice qui est mémorisé, pas la valeur\ncherchée.\n"
            }
          ],
          "explanation": "Sans arrêt anticipé, la boucle parcourt toute la liste : la\nvariable garde la trace de la dernière rencontre."
        }
      ]
    }
  ]
}