{
  "chapter": {
    "id": "diversite-langages",
    "level": "premiere",
    "theme": "Programmation",
    "title": "Diversité des langages",
    "description": "Constructions élémentaires communes aux langages de\nprogrammation, traits communs et particuliers d'un\nlangage inconnu (blocs, types, indices, opérateurs),\nstyles de programmation, langages de description et\nde requêtes.",
    "parties": [
      {
        "id": "constructions",
        "title": "Constructions élémentaires"
      },
      {
        "id": "comparer",
        "title": "Traits communs et particuliers"
      },
      {
        "id": "styles",
        "title": "Styles et familles de langages"
      }
    ],
    "prerequisites": [],
    "references": []
  },
  "questions": [
    {
      "id": "q01",
      "difficulty": 1,
      "skills": [
        "definition"
      ],
      "title": "Les constructions élémentaires",
      "partie": "constructions",
      "statement": "Quelle liste réunit uniquement des **constructions\nélémentaires** présentes dans presque tous les langages de\nprogrammation ?",
      "options": [
        {
          "text": "Affectation, conditionnelle, boucle, appel de fonction",
          "correct": true,
          "feedback": "Bonne réponse : séquence, affectation, conditionnelle,\nboucles bornée et non bornée, appel de fonction forment le\nsocle commun aux langages.\n"
        },
        {
          "text": "Liste, dictionnaire, tuple, chaîne de caractères",
          "correct": false,
          "feedback": "Erreur : ce sont des **types de données**, et leurs noms\nchangent d'un langage à l'autre.\n"
        },
        {
          "text": "Balise, attribut, sélecteur, propriété de style",
          "correct": false,
          "feedback": "Erreur : ce vocabulaire est celui de HTML et de CSS,\nlangages de description qui ne programment pas.\n"
        },
        {
          "text": "Compilation, interprétation, test, débogage",
          "correct": false,
          "feedback": "Erreur : ce sont des étapes de la vie d'un programme, pas\ndes constructions qu'on écrit dans le code.\n"
        }
      ],
      "explanation": "Un algorithme s'écrit avec quelques constructions : la\nséquence, l'affectation, la conditionnelle, les boucles et\nl'appel de fonction. Les retrouver dans un langage inconnu\nsuffit souvent pour lire ses programmes."
    },
    {
      "id": "q02",
      "difficulty": 1,
      "skills": [
        "boucle"
      ],
      "title": "Répéter sans connaître le nombre de tours",
      "partie": "constructions",
      "statement": "Quelle construction répète un bloc d'instructions **tant\nqu'une condition reste vraie**, sans connaître à l'avance le\nnombre de tours ?",
      "options": [
        {
          "text": "La boucle bornée, comme `for i in range(n)`",
          "correct": false,
          "feedback": "Erreur : une boucle bornée fait un nombre de tours connu\ndès son début.\n"
        },
        {
          "text": "La boucle non bornée, comme `while condition`",
          "correct": true,
          "feedback": "Bonne réponse : la boucle non bornée (`while` en Python,\n« tant que » en pseudo-code) teste sa condition avant\nchaque tour.\n"
        },
        {
          "text": "L'instruction conditionnelle, comme `if condition`",
          "correct": false,
          "feedback": "Erreur : `if` exécute son bloc **au plus une fois**, il ne\nrépète rien.\n"
        },
        {
          "text": "La séquence, qui enchaîne des lignes dans l'ordre",
          "correct": false,
          "feedback": "Erreur : la séquence exécute chaque instruction une seule\nfois, de haut en bas.\n"
        }
      ],
      "explanation": "Les deux boucles existent dans presque tous les langages :\n`for` en C, en JavaScript ou en Python, `while` dans les\ntrois aussi, « répéter » et « tant que » en pseudo-code."
    },
    {
      "id": "q03",
      "difficulty": 2,
      "skills": [
        "traduction",
        "boucle"
      ],
      "title": "Une boucle écrite en pseudo-code",
      "partie": "constructions",
      "statement": "Un logiciel de dessin pour débutants accepte ce programme :\n\n```text\nrépéter 4 fois\n    avancer de 10\n    tourner de 90 degrés\n```\n\nQuelle ligne Python ouvre la boucle équivalente ?",
      "options": [
        {
          "text": "`for i in range(4):`",
          "correct": true,
          "feedback": "Bonne réponse : « répéter 4 fois » est une boucle\n**bornée** de quatre tours.\n"
        },
        {
          "text": "`for i in range(90):`",
          "correct": false,
          "feedback": "Erreur : 90 est l'angle de chaque virage, pas le nombre\nde tours de la boucle.\n"
        },
        {
          "text": "`if i < 4:`",
          "correct": false,
          "feedback": "Erreur : une conditionnelle exécute son bloc au plus une\nfois, le carré ne serait pas tracé.\n"
        },
        {
          "text": "`def repeter(i):`",
          "correct": false,
          "feedback": "Erreur : cette ligne définit une fonction, elle ne répète\nrien tant qu'on ne l'appelle pas.\n"
        }
      ],
      "explanation": "Les mots changent (« répéter », `for`, `repeat`), la\nconstruction reste la même : une boucle bornée dont le\nnombre de tours est connu avant de commencer."
    },
    {
      "id": "q04",
      "difficulty": 2,
      "skills": [
        "trace",
        "boucle"
      ],
      "title": "Un produit calculé en JavaScript",
      "partie": "constructions",
      "statement": "Que vaut `produit` après l'exécution de ce code JavaScript ?\n\n```javascript\nlet produit = 1;\nlet i = 1;\nwhile (i <= 3) {\n  produit = produit * i;\n  i = i + 1;\n}\n```",
      "options": [
        {
          "text": "6",
          "correct": true,
          "feedback": "Bonne réponse : `i` prend les valeurs 1 à 3 (la\ncondition `i <= 3` inclut 3), et le produit vaut 6.\n"
        },
        {
          "text": "2",
          "correct": false,
          "feedback": "Erreur : c'est le produit de 1 à 2, comme si la\ncondition était `i < 3`.\n"
        },
        {
          "text": "24",
          "correct": false,
          "feedback": "Erreur : c'est le produit de 1 à 4 ; la boucle\ns'arrête dès que `i` dépasse 3.\n"
        },
        {
          "text": "3",
          "correct": false,
          "feedback": "Erreur : 3 est le nombre de tours, pas le produit\naccumulé dans `produit`.\n"
        }
      ],
      "explanation": "La boucle `while` de JavaScript s'écrit comme en Python, à\ndeux différences près : la condition entre parenthèses et le\ncorps entre accolades. Ici, elle équivaut à\n`while i <= 3:` en Python.",
      "variants": [
        {
          "statement": "Que vaut `produit` après l'exécution de ce code JavaScript ?\n\n```javascript\nlet produit = 1;\nlet i = 1;\nwhile (i <= 3) {\n  produit = produit * i;\n  i = i + 1;\n}\n```",
          "options": [
            {
              "text": "6",
              "correct": true,
              "feedback": "Bonne réponse : `i` prend les valeurs 1 à 3 (la\ncondition `i <= 3` inclut 3), et le produit vaut 6.\n"
            },
            {
              "text": "2",
              "correct": false,
              "feedback": "Erreur : c'est le produit de 1 à 2, comme si la\ncondition était `i < 3`.\n"
            },
            {
              "text": "24",
              "correct": false,
              "feedback": "Erreur : c'est le produit de 1 à 4 ; la boucle\ns'arrête dès que `i` dépasse 3.\n"
            },
            {
              "text": "3",
              "correct": false,
              "feedback": "Erreur : 3 est le nombre de tours, pas le produit\naccumulé dans `produit`.\n"
            }
          ],
          "explanation": "La boucle `while` de JavaScript s'écrit comme en Python, à\ndeux différences près : la condition entre parenthèses et le\ncorps entre accolades. Ici, elle équivaut à\n`while i <= 3:` en Python."
        },
        {
          "statement": "Que vaut `produit` après l'exécution de ce code JavaScript ?\n\n```javascript\nlet produit = 1;\nlet i = 1;\nwhile (i <= 4) {\n  produit = produit * i;\n  i = i + 1;\n}\n```",
          "options": [
            {
              "text": "24",
              "correct": true,
              "feedback": "Bonne réponse : `i` prend les valeurs 1 à 4 (la\ncondition `i <= 4` inclut 4), et le produit vaut 24.\n"
            },
            {
              "text": "6",
              "correct": false,
              "feedback": "Erreur : c'est le produit de 1 à 3, comme si la\ncondition était `i < 4`.\n"
            },
            {
              "text": "120",
              "correct": false,
              "feedback": "Erreur : c'est le produit de 1 à 5 ; la boucle\ns'arrête dès que `i` dépasse 4.\n"
            },
            {
              "text": "4",
              "correct": false,
              "feedback": "Erreur : 4 est le nombre de tours, pas le produit\naccumulé dans `produit`.\n"
            }
          ],
          "explanation": "La boucle `while` de JavaScript s'écrit comme en Python, à\ndeux différences près : la condition entre parenthèses et le\ncorps entre accolades. Ici, elle équivaut à\n`while i <= 4:` en Python."
        },
        {
          "statement": "Que vaut `produit` après l'exécution de ce code JavaScript ?\n\n```javascript\nlet produit = 1;\nlet i = 1;\nwhile (i <= 5) {\n  produit = produit * i;\n  i = i + 1;\n}\n```",
          "options": [
            {
              "text": "120",
              "correct": true,
              "feedback": "Bonne réponse : `i` prend les valeurs 1 à 5 (la\ncondition `i <= 5` inclut 5), et le produit vaut 120.\n"
            },
            {
              "text": "24",
              "correct": false,
              "feedback": "Erreur : c'est le produit de 1 à 4, comme si la\ncondition était `i < 5`.\n"
            },
            {
              "text": "720",
              "correct": false,
              "feedback": "Erreur : c'est le produit de 1 à 6 ; la boucle\ns'arrête dès que `i` dépasse 5.\n"
            },
            {
              "text": "5",
              "correct": false,
              "feedback": "Erreur : 5 est le nombre de tours, pas le produit\naccumulé dans `produit`.\n"
            }
          ],
          "explanation": "La boucle `while` de JavaScript s'écrit comme en Python, à\ndeux différences près : la condition entre parenthèses et le\ncorps entre accolades. Ici, elle équivaut à\n`while i <= 5:` en Python."
        },
        {
          "statement": "Que vaut `produit` après l'exécution de ce code JavaScript ?\n\n```javascript\nlet produit = 1;\nlet i = 1;\nwhile (i <= 6) {\n  produit = produit * i;\n  i = i + 1;\n}\n```",
          "options": [
            {
              "text": "720",
              "correct": true,
              "feedback": "Bonne réponse : `i` prend les valeurs 1 à 6 (la\ncondition `i <= 6` inclut 6), et le produit vaut 720.\n"
            },
            {
              "text": "120",
              "correct": false,
              "feedback": "Erreur : c'est le produit de 1 à 5, comme si la\ncondition était `i < 6`.\n"
            },
            {
              "text": "5040",
              "correct": false,
              "feedback": "Erreur : c'est le produit de 1 à 7 ; la boucle\ns'arrête dès que `i` dépasse 6.\n"
            },
            {
              "text": "6",
              "correct": false,
              "feedback": "Erreur : 6 est le nombre de tours, pas le produit\naccumulé dans `produit`.\n"
            }
          ],
          "explanation": "La boucle `while` de JavaScript s'écrit comme en Python, à\ndeux différences près : la condition entre parenthèses et le\ncorps entre accolades. Ici, elle équivaut à\n`while i <= 6:` en Python."
        }
      ]
    },
    {
      "id": "q05",
      "difficulty": 1,
      "skills": [
        "affectation"
      ],
      "title": "Trois écritures de l'affectation",
      "partie": "constructions",
      "statement": "On rencontre `x = 5` en Python, `x ← 5` en pseudo-code et\n`x := 5` en Pascal. Que font ces trois instructions ?",
      "options": [
        {
          "text": "Elles testent si la variable x vaut 5",
          "correct": false,
          "feedback": "Erreur : le test d'égalité s'écrit `x == 5` en Python ;\naucune de ces écritures ne compare.\n"
        },
        {
          "text": "Elles affichent la valeur 5 à l'écran",
          "correct": false,
          "feedback": "Erreur : l'affichage passe par une fonction comme\n`print`, pas par une affectation.\n"
        },
        {
          "text": "Elles donnent la valeur 5 à la variable x",
          "correct": true,
          "feedback": "Bonne réponse : ce sont trois notations de la même\nconstruction, l'**affectation**.\n"
        },
        {
          "text": "Elles déclarent une constante x non modifiable",
          "correct": false,
          "feedback": "Erreur : après une affectation, x peut recevoir une autre\nvaleur plus loin dans le programme.\n"
        }
      ],
      "explanation": "Le symbole change d'un langage à l'autre (`=`, `←`, `:=`),\nla construction reste l'affectation. La flèche du\npseudo-code évite de la confondre avec l'égalité\nmathématique."
    },
    {
      "id": "q06",
      "difficulty": 2,
      "skills": [
        "fonction",
        "traduction"
      ],
      "title": "Traduire une fonction écrite en C",
      "partie": "constructions",
      "statement": "Voici une fonction écrite en langage C :\n\n```c\nint carre(int n) {\n    return n * n;\n}\n```\n\nQuelle fonction Python fait la même chose ?",
      "options": [
        {
          "text": "`def carre(n): print(n * n)`",
          "correct": false,
          "feedback": "Erreur : cette fonction affiche le carré mais renvoie\n`None` ; la fonction C **renvoie** une valeur.\n"
        },
        {
          "text": "`def carre(int n): return n * n`",
          "correct": false,
          "feedback": "Erreur : en Python, on n'écrit pas le type devant le\nparamètre ; cette ligne déclenche une `SyntaxError`.\n"
        },
        {
          "text": "`carre = n * n`",
          "correct": false,
          "feedback": "Erreur : c'est une affectation, qui échoue d'ailleurs si\n`n` n'existe pas ; elle ne définit aucune fonction.\n"
        },
        {
          "text": "`def carre(n): return n * n`",
          "correct": true,
          "feedback": "Bonne réponse : même nom, même paramètre, même valeur\nrenvoyée ; seuls les types déclarés et les accolades\ndisparaissent.\n"
        }
      ],
      "explanation": "En C, on écrit le type renvoyé (`int`) et le type de chaque\nparamètre ; les accolades délimitent le corps. Python ne\ndéclare pas les types et délimite le corps par\nl'indentation."
    },
    {
      "id": "q07",
      "difficulty": 3,
      "skills": [
        "unite"
      ],
      "title": "Un algorithme, plusieurs langages",
      "partie": "constructions",
      "statement": "Un algorithme de tri écrit en Python peut être réécrit en\nC, en JavaScript ou en Java. Pourquoi ?",
      "options": [
        {
          "text": "Ces langages sont traduits en Python avant de s'exécuter",
          "correct": false,
          "feedback": "Erreur : chaque langage a son propre interpréteur ou\ncompilateur ; aucun ne passe par Python.\n"
        },
        {
          "text": "Ces langages offrent les mêmes constructions de base",
          "correct": true,
          "feedback": "Bonne réponse : affectation, conditionnelle, boucles et\nfonctions suffisent à écrire le tri, et chacun de ces\nlangages les possède.\n"
        },
        {
          "text": "Ces langages ont la même syntaxe, à l'indentation près",
          "correct": false,
          "feedback": "Erreur : la syntaxe diffère beaucoup (accolades, types\ndéclarés, points-virgules) ; ce qui est commun, ce sont\nles constructions.\n"
        },
        {
          "text": "Le tri y est une fonction prédéfinie et toujours la même",
          "correct": false,
          "feedback": "Erreur : on parle ici de réécrire l'algorithme, pas\nd'appeler une fonction de tri fournie par le langage.\n"
        }
      ],
      "explanation": "Un algorithme ne dépend pas du langage : il repose sur des\nconstructions élémentaires que tous les langages\ngénéralistes proposent, chacun avec sa syntaxe."
    },
    {
      "id": "q08",
      "difficulty": 1,
      "skills": [
        "syntaxe"
      ],
      "title": "Délimiter un bloc en JavaScript",
      "partie": "comparer",
      "statement": "```javascript\nif (note >= 10) {\n  resultat = \"admis\";\n  compteur = compteur + 1;\n}\n```\n\nEn JavaScript, qu'est-ce qui délimite le bloc exécuté quand\nla condition est vraie ?",
      "options": [
        {
          "text": "L'indentation des lignes, comme en Python",
          "correct": false,
          "feedback": "Erreur : en JavaScript, l'indentation ne sert qu'à la\nlisibilité ; on pourrait tout écrire sur une ligne.\n"
        },
        {
          "text": "Les parenthèses qui entourent la condition",
          "correct": false,
          "feedback": "Erreur : les parenthèses entourent la condition\n`note >= 10`, pas les instructions du bloc.\n"
        },
        {
          "text": "Les points-virgules en fin de ligne",
          "correct": false,
          "feedback": "Erreur : le point-virgule termine une instruction, il ne\ndélimite pas un bloc.\n"
        },
        {
          "text": "Les accolades `{` et `}` autour des instructions",
          "correct": true,
          "feedback": "Bonne réponse : C, Java et JavaScript délimitent les\nblocs par des accolades.\n"
        }
      ],
      "explanation": "Python est l'un des rares langages où l'indentation est\nobligatoire et porte le sens : c'est un trait particulier.\nLa plupart des langages utilisent des accolades ou des mots\ncomme `begin` et `end`."
    },
    {
      "id": "q09",
      "difficulty": 2,
      "skills": [
        "type"
      ],
      "title": "Le type déclaré en C",
      "partie": "comparer",
      "statement": "En langage C, on écrit `int n = 5;`. Que précise le mot\n`int` ?",
      "options": [
        {
          "text": "Le type de la variable n, ici un entier",
          "correct": true,
          "feedback": "Bonne réponse : en C, chaque variable est déclarée avec\nson type, qui ne change plus ensuite.\n"
        },
        {
          "text": "La valeur initiale donnée à la variable n",
          "correct": false,
          "feedback": "Erreur : la valeur initiale est 5, écrite après le signe\n`=`.\n"
        },
        {
          "text": "Que la variable n sera affichée à l'écran",
          "correct": false,
          "feedback": "Erreur : l'affichage demande un appel de fonction, comme\n`printf` en C.\n"
        },
        {
          "text": "Que la variable n ne pourra plus changer de valeur",
          "correct": false,
          "feedback": "Erreur : n peut recevoir d'autres entiers ; seul son type\nest fixé.\n"
        }
      ],
      "explanation": "Python déduit le type de la valeur affectée et laisse une\nvariable changer de type ; C impose de le déclarer. Ce\ntrait particulier se repère vite en lisant un programme."
    },
    {
      "id": "q10",
      "difficulty": 2,
      "skills": [
        "unite"
      ],
      "title": "Un trait particulier à Python",
      "partie": "comparer",
      "statement": "Parmi ces caractéristiques, laquelle est **particulière** à\nPython, et non commune à la plupart des langages ?",
      "options": [
        {
          "text": "Les variables reçoivent leurs valeurs par affectation",
          "correct": false,
          "feedback": "Erreur : l'affectation existe dans tous les langages\nimpératifs, sous des notations variées.\n"
        },
        {
          "text": "Une boucle peut répéter un bloc d'instructions",
          "correct": false,
          "feedback": "Erreur : les boucles font partie des constructions\ncommunes à tous les langages généralistes.\n"
        },
        {
          "text": "L'indentation obligatoire délimite les blocs",
          "correct": true,
          "feedback": "Bonne réponse : la plupart des langages utilisent des\naccolades ; en Python, l'indentation fait partie de la\nsyntaxe.\n"
        },
        {
          "text": "Une fonction peut renvoyer une valeur à l'appelant",
          "correct": false,
          "feedback": "Erreur : `return` existe en C, en Java, en JavaScript et\ndans bien d'autres langages.\n"
        }
      ],
      "explanation": "Lire un nouveau langage, c'est trier ses traits communs\n(constructions élémentaires) et ses traits particuliers\n(syntaxe des blocs, déclaration des types, opérateurs)."
    },
    {
      "id": "q11",
      "difficulty": 2,
      "skills": [
        "indice"
      ],
      "title": "Le premier indice d'un tableau",
      "partie": "comparer",
      "statement": "Dans le langage Lua, le premier élément d'un tableau `t`\ns'écrit `t[1]`. Que faut-il en retenir ?",
      "options": [
        {
          "text": "En Lua, t[1] désigne le deuxième élément du tableau",
          "correct": false,
          "feedback": "Erreur : l'énoncé dit le contraire, `t[1]` y est le\n**premier** élément.\n"
        },
        {
          "text": "En Python aussi, le premier élément s'écrit t[1]",
          "correct": false,
          "feedback": "Erreur : en Python, le premier élément s'écrit `t[0]`.\n"
        },
        {
          "text": "La numérotation des indices dépend du langage",
          "correct": true,
          "feedback": "Bonne réponse : Python, C et JavaScript comptent à partir\nde 0, Lua et R à partir de 1.\n"
        },
        {
          "text": "Lua numérote les cases en partant de la dernière",
          "correct": false,
          "feedback": "Erreur : Lua numérote du début, mais en commençant à 1.\n"
        }
      ],
      "explanation": "Le premier indice est un trait particulier fréquent : en\ntraduisant un programme, il faut décaler les indices de un\nquand les deux langages ne suivent pas la même convention."
    },
    {
      "id": "q12",
      "difficulty": 2,
      "skills": [
        "operateur"
      ],
      "title": "Égalité et affectation en Pascal",
      "partie": "comparer",
      "statement": "En Pascal, `a := 3` affecte la valeur 3 à `a`, et `a = 3`\n**teste** si `a` vaut 3. Quelle écriture Python correspond\nà ce test ?",
      "options": [
        {
          "text": "`a == 3`",
          "correct": true,
          "feedback": "Bonne réponse : en Python, le test d'égalité s'écrit avec\ndeux signes `=`.\n"
        },
        {
          "text": "`a = 3`",
          "correct": false,
          "feedback": "Erreur : en Python, `a = 3` est une affectation, comme\n`a := 3` en Pascal.\n"
        },
        {
          "text": "`a === 3`",
          "correct": false,
          "feedback": "Erreur : cette écriture est celle de JavaScript ; elle est\ninvalide en Python.\n"
        },
        {
          "text": "`a != 3`",
          "correct": false,
          "feedback": "Erreur : `!=` teste la **différence**, le contraire de ce\nqu'on cherche.\n"
        }
      ],
      "explanation": "Le même symbole `=` affecte en Python et compare en Pascal :\navant de lire un programme, repérer les symboles\nd'affectation et de comparaison du langage évite les\ncontresens."
    },
    {
      "id": "q13",
      "difficulty": 3,
      "skills": [
        "operateur",
        "type"
      ],
      "title": "La division de deux entiers en C",
      "partie": "comparer",
      "statement": "En langage C, quand `a` et `b` sont deux variables de type\n`int`, l'expression `a / b` donne le **quotient entier** :\navec `a = 7` et `b = 2`, elle vaut 3. Quelle expression\nPython donne ce même résultat ?",
      "options": [
        {
          "text": "`a / b`",
          "correct": false,
          "feedback": "Erreur : en Python, `/` donne toujours un flottant : `7 / 2`\nvaut `3.5`.\n"
        },
        {
          "text": "`a % b`",
          "correct": false,
          "feedback": "Erreur : `%` donne le **reste** de la division, ici 1.\n"
        },
        {
          "text": "`a // b`",
          "correct": true,
          "feedback": "Bonne réponse : `//` donne le quotient de la division\nentière, `7 // 2` vaut 3.\n"
        },
        {
          "text": "`round(a / b)`",
          "correct": false,
          "feedback": "Erreur : `round(3.5)` vaut 4 ; arrondir n'est pas\nprendre le quotient entier.\n"
        }
      ],
      "explanation": "Un même symbole peut changer de sens d'un langage à\nl'autre : `/` divise en entiers en C quand les deux termes\nsont entiers, alors qu'en Python il donne un flottant."
    },
    {
      "id": "q14",
      "difficulty": 1,
      "skills": [
        "syntaxe"
      ],
      "title": "Afficher en JavaScript",
      "partie": "comparer",
      "statement": "Quelle instruction JavaScript joue le rôle de `print(x)` en\nPython, en affichant `x` dans la console ?",
      "options": [
        {
          "text": "`print(x)`, comme en Python",
          "correct": false,
          "feedback": "Erreur : `print` n'existe pas en JavaScript ; le nom de la\nfonction d'affichage change d'un langage à l'autre.\n"
        },
        {
          "text": "`console.log(x)` du navigateur",
          "correct": true,
          "feedback": "Bonne réponse : `console.log` écrit dans la console du\nnavigateur.\n"
        },
        {
          "text": "`echo x`, comme dans le shell",
          "correct": false,
          "feedback": "Erreur : `echo` est une commande du shell, pas une\ninstruction JavaScript.\n"
        },
        {
          "text": "`System.out.println(x)`",
          "correct": false,
          "feedback": "Erreur : c'est l'instruction d'affichage de Java, un autre\nlangage malgré la ressemblance des noms.\n"
        }
      ],
      "explanation": "Tous les langages savent afficher une valeur, mais chacun a\nson instruction : `print` en Python, `console.log` en\nJavaScript, `printf` en C, `System.out.println` en Java."
    },
    {
      "id": "q15",
      "difficulty": 2,
      "skills": [
        "traduction",
        "boucle"
      ],
      "title": "Traduire une boucle de C en Python",
      "partie": "comparer",
      "statement": "Quelle boucle Python parcourt les mêmes valeurs de `i` que\ncette boucle écrite en C ?\n\n```c\nfor (int i = 0; i < 5; i = i + 2) {\n    printf(\"%d\\n\", i);\n}\n```",
      "options": [
        {
          "text": "`for i in range(0, 5):`",
          "correct": false,
          "feedback": "Erreur : sans troisième argument, `range` avance de 1 ;\nla boucle C avance de 2.\n"
        },
        {
          "text": "`for i in range(0, 5, 2):`",
          "correct": true,
          "feedback": "Bonne réponse : début 0, arrêt avant 5 (condition\n`i < 5`), pas de 2.\n"
        },
        {
          "text": "`for i in range(0, 2, 5):`",
          "correct": false,
          "feedback": "Erreur : l'ordre des arguments de `range` est début,\nfin, pas ; ici la fin et le pas sont inversés.\n"
        },
        {
          "text": "`for i in range(2, 5):`",
          "correct": false,
          "feedback": "Erreur : le pas 2 a été pris pour la valeur de départ,\nqui est 0.\n"
        }
      ],
      "explanation": "La boucle `for` de C réunit l'initialisation, la condition\net le pas ; `range(début, fin, pas)` les reprend dans le\nmême ordre, la fin étant exclue comme avec `i < fin`.",
      "variants": [
        {
          "statement": "Quelle boucle Python parcourt les mêmes valeurs de `i` que\ncette boucle écrite en C ?\n\n```c\nfor (int i = 0; i < 5; i = i + 2) {\n    printf(\"%d\\n\", i);\n}\n```",
          "options": [
            {
              "text": "`for i in range(0, 5):`",
              "correct": false,
              "feedback": "Erreur : sans troisième argument, `range` avance de 1 ;\nla boucle C avance de 2.\n"
            },
            {
              "text": "`for i in range(0, 5, 2):`",
              "correct": true,
              "feedback": "Bonne réponse : début 0, arrêt avant 5 (condition\n`i < 5`), pas de 2.\n"
            },
            {
              "text": "`for i in range(0, 2, 5):`",
              "correct": false,
              "feedback": "Erreur : l'ordre des arguments de `range` est début,\nfin, pas ; ici la fin et le pas sont inversés.\n"
            },
            {
              "text": "`for i in range(2, 5):`",
              "correct": false,
              "feedback": "Erreur : le pas 2 a été pris pour la valeur de départ,\nqui est 0.\n"
            }
          ],
          "explanation": "La boucle `for` de C réunit l'initialisation, la condition\net le pas ; `range(début, fin, pas)` les reprend dans le\nmême ordre, la fin étant exclue comme avec `i < fin`."
        },
        {
          "statement": "Quelle boucle Python parcourt les mêmes valeurs de `i` que\ncette boucle écrite en C ?\n\n```c\nfor (int i = 1; i < 10; i = i + 3) {\n    printf(\"%d\\n\", i);\n}\n```",
          "options": [
            {
              "text": "`for i in range(1, 10):`",
              "correct": false,
              "feedback": "Erreur : sans troisième argument, `range` avance de 1 ;\nla boucle C avance de 3.\n"
            },
            {
              "text": "`for i in range(1, 10, 3):`",
              "correct": true,
              "feedback": "Bonne réponse : début 1, arrêt avant 10 (condition\n`i < 10`), pas de 3.\n"
            },
            {
              "text": "`for i in range(1, 3, 10):`",
              "correct": false,
              "feedback": "Erreur : l'ordre des arguments de `range` est début,\nfin, pas ; ici la fin et le pas sont inversés.\n"
            },
            {
              "text": "`for i in range(3, 10):`",
              "correct": false,
              "feedback": "Erreur : le pas 3 a été pris pour la valeur de départ,\nqui est 1.\n"
            }
          ],
          "explanation": "La boucle `for` de C réunit l'initialisation, la condition\net le pas ; `range(début, fin, pas)` les reprend dans le\nmême ordre, la fin étant exclue comme avec `i < fin`."
        },
        {
          "statement": "Quelle boucle Python parcourt les mêmes valeurs de `i` que\ncette boucle écrite en C ?\n\n```c\nfor (int i = 2; i < 12; i = i + 4) {\n    printf(\"%d\\n\", i);\n}\n```",
          "options": [
            {
              "text": "`for i in range(2, 12):`",
              "correct": false,
              "feedback": "Erreur : sans troisième argument, `range` avance de 1 ;\nla boucle C avance de 4.\n"
            },
            {
              "text": "`for i in range(2, 12, 4):`",
              "correct": true,
              "feedback": "Bonne réponse : début 2, arrêt avant 12 (condition\n`i < 12`), pas de 4.\n"
            },
            {
              "text": "`for i in range(2, 4, 12):`",
              "correct": false,
              "feedback": "Erreur : l'ordre des arguments de `range` est début,\nfin, pas ; ici la fin et le pas sont inversés.\n"
            },
            {
              "text": "`for i in range(4, 12):`",
              "correct": false,
              "feedback": "Erreur : le pas 4 a été pris pour la valeur de départ,\nqui est 2.\n"
            }
          ],
          "explanation": "La boucle `for` de C réunit l'initialisation, la condition\net le pas ; `range(début, fin, pas)` les reprend dans le\nmême ordre, la fin étant exclue comme avec `i < fin`."
        },
        {
          "statement": "Quelle boucle Python parcourt les mêmes valeurs de `i` que\ncette boucle écrite en C ?\n\n```c\nfor (int i = 0; i < 9; i = i + 3) {\n    printf(\"%d\\n\", i);\n}\n```",
          "options": [
            {
              "text": "`for i in range(0, 9):`",
              "correct": false,
              "feedback": "Erreur : sans troisième argument, `range` avance de 1 ;\nla boucle C avance de 3.\n"
            },
            {
              "text": "`for i in range(0, 9, 3):`",
              "correct": true,
              "feedback": "Bonne réponse : début 0, arrêt avant 9 (condition\n`i < 9`), pas de 3.\n"
            },
            {
              "text": "`for i in range(0, 3, 9):`",
              "correct": false,
              "feedback": "Erreur : l'ordre des arguments de `range` est début,\nfin, pas ; ici la fin et le pas sont inversés.\n"
            },
            {
              "text": "`for i in range(3, 9):`",
              "correct": false,
              "feedback": "Erreur : le pas 3 a été pris pour la valeur de départ,\nqui est 0.\n"
            }
          ],
          "explanation": "La boucle `for` de C réunit l'initialisation, la condition\net le pas ; `range(début, fin, pas)` les reprend dans le\nmême ordre, la fin étant exclue comme avec `i < fin`."
        }
      ]
    },
    {
      "id": "q16",
      "difficulty": 1,
      "skills": [
        "famille"
      ],
      "title": "HTML, un langage de description",
      "partie": "styles",
      "statement": "Pourquoi HTML n'est-il **pas** un langage de programmation ?",
      "options": [
        {
          "text": "Il décrit la structure d'une page sans rien calculer",
          "correct": true,
          "feedback": "Bonne réponse : HTML n'a ni variables, ni conditions, ni\nboucles ; il décrit un contenu.\n"
        },
        {
          "text": "Il est interprété par le navigateur, sans compilation",
          "correct": false,
          "feedback": "Erreur : Python aussi est interprété, et c'est bien un\nlangage de programmation.\n"
        },
        {
          "text": "Il ne permet pas d'afficher du texte mis en forme",
          "correct": false,
          "feedback": "Erreur : HTML structure justement du texte (titres,\nlistes, liens) que le navigateur affiche.\n"
        },
        {
          "text": "Il n'est compris que par un seul navigateur du marché",
          "correct": false,
          "feedback": "Erreur : tous les navigateurs lisent HTML, qui est un\nstandard du Web.\n"
        }
      ],
      "explanation": "HTML et CSS sont des langages de **description** : ils\ndisent ce qu'il faut afficher et comment, sans décrire de\ncalcul. Les calculs d'une page Web sont confiés à\nJavaScript."
    },
    {
      "id": "q17",
      "difficulty": 2,
      "skills": [
        "famille"
      ],
      "title": "Reconnaître un langage de requêtes",
      "partie": "styles",
      "statement": "À quelle famille appartient le texte suivant ?\n\n```sql\nSELECT nom FROM eleves WHERE age > 16;\n```",
      "options": [
        {
          "text": "Un langage de description de pages Web",
          "correct": false,
          "feedback": "Erreur : une page Web se décrit en HTML, avec des\nbalises.\n"
        },
        {
          "text": "Un langage machine exécuté par le processeur",
          "correct": false,
          "feedback": "Erreur : le langage machine est une suite de codes\nbinaires, pas de mots anglais.\n"
        },
        {
          "text": "Un langage de requêtes sur des données",
          "correct": true,
          "feedback": "Bonne réponse : SQL décrit les données qu'on veut obtenir,\nsans dire comment les parcourir.\n"
        },
        {
          "text": "Un langage de mise en forme, comme CSS",
          "correct": false,
          "feedback": "Erreur : CSS fixe l'apparence d'une page ; ce texte\ninterroge une table de données.\n"
        }
      ],
      "explanation": "SQL, étudié en terminale, est un langage de requêtes : on\ny décrit le résultat attendu (les noms des élèves de plus\nde 16 ans), et le système trouve seul comment le calculer."
    },
    {
      "id": "q18",
      "difficulty": 2,
      "skills": [
        "style"
      ],
      "title": "Le style événementiel",
      "partie": "styles",
      "statement": "```javascript\nbouton.addEventListener(\"click\", saluer);\n```\n\nQuel style de programmation ce code illustre-t-il ?",
      "options": [
        {
          "text": "Séquentiel : saluer s'exécute dès le chargement",
          "correct": false,
          "feedback": "Erreur : `saluer` n'est pas appelée ici ; elle est\nseulement associée au clic.\n"
        },
        {
          "text": "Événementiel : saluer s'exécute à chaque clic",
          "correct": true,
          "feedback": "Bonne réponse : le programme attend une action de\nl'utilisateur et y réagit en appelant la fonction.\n"
        },
        {
          "text": "Logique : le programme déduit des règles",
          "correct": false,
          "feedback": "Erreur : la programmation logique énonce des faits et\ndes règles, sans bouton ni clic.\n"
        },
        {
          "text": "Récursif : saluer s'appelle elle-même",
          "correct": false,
          "feedback": "Erreur : rien n'indique que `saluer` s'appelle ; la ligne\nrelie une fonction à un événement.\n"
        }
      ],
      "explanation": "En programmation événementielle, l'ordre d'exécution dépend\ndes actions de l'utilisateur (clic, frappe au clavier) : on\nassocie à chaque événement la fonction qui le traite."
    },
    {
      "id": "q19",
      "difficulty": 2,
      "skills": [
        "style"
      ],
      "title": "Le style impératif",
      "partie": "styles",
      "statement": "Un programme enchaîne des instructions qui **modifient pas à\npas** les valeurs des variables, par exemple\n`total = total + x` dans une boucle. Quel style de\nprogrammation est-ce ?",
      "options": [
        {
          "text": "Le style logique, fait de faits et de règles",
          "correct": false,
          "feedback": "Erreur : un programme logique ne modifie pas de\nvariables pas à pas.\n"
        },
        {
          "text": "Le style événementiel, piloté par des clics",
          "correct": false,
          "feedback": "Erreur : rien ici ne dépend d'une action de\nl'utilisateur.\n"
        },
        {
          "text": "Le style de description, comme celui de HTML",
          "correct": false,
          "feedback": "Erreur : HTML ne contient ni variables ni boucles.\n"
        },
        {
          "text": "Le style impératif, fait d'ordres successifs",
          "correct": true,
          "feedback": "Bonne réponse : les programmes Python vus en classe\nsont surtout écrits dans ce style.\n"
        }
      ],
      "explanation": "Le style impératif décrit **comment** calculer : une suite\nd'instructions qui changent l'état du programme. C,\nPython et JavaScript permettent tous ce style."
    },
    {
      "id": "q20",
      "difficulty": 3,
      "skills": [
        "style"
      ],
      "title": "Le style fonctionnel",
      "partie": "styles",
      "statement": "Qu'est-ce qu'un programme écrit dans le style\n**fonctionnel** privilégie ?",
      "options": [
        {
          "text": "Des boucles qui modifient un compteur à chaque tour",
          "correct": false,
          "feedback": "Erreur : modifier un compteur relève du style impératif.\n"
        },
        {
          "text": "Des fonctions qui ne modifient aucune variable",
          "correct": true,
          "feedback": "Bonne réponse : on compose des fonctions qui renvoient\nde nouvelles valeurs au lieu de modifier les anciennes.\n"
        },
        {
          "text": "Des objets qui regroupent données et méthodes",
          "correct": false,
          "feedback": "Erreur : c'est la définition du style objet, vu en\nterminale.\n"
        },
        {
          "text": "Des événements déclenchés par l'utilisateur",
          "correct": false,
          "feedback": "Erreur : c'est le style événementiel, celui des pages\nWeb interactives.\n"
        }
      ],
      "explanation": "Un même langage permet souvent plusieurs styles : Python\nautorise le style impératif, le style fonctionnel et le\nstyle objet. Certains langages, comme Haskell, sont conçus\npour le style fonctionnel."
    },
    {
      "id": "q21",
      "difficulty": 3,
      "skills": [
        "unite"
      ],
      "title": "Pourquoi tant de langages",
      "partie": "styles",
      "statement": "Pourquoi existe-t-il de nombreux langages de programmation ?",
      "options": [
        {
          "text": "Chacun facilite certains usages ou certains styles",
          "correct": true,
          "feedback": "Bonne réponse : C pour les systèmes, JavaScript pour le\nWeb, Python pour le calcul et l'enseignement, etc.\n"
        },
        {
          "text": "Chaque processeur n'accepte qu'un seul de ces langages",
          "correct": false,
          "feedback": "Erreur : le processeur n'exécute que son langage machine ;\nles autres langages y sont traduits.\n"
        },
        {
          "text": "Chacun résout des problèmes que les autres ne savent pas",
          "correct": false,
          "feedback": "Erreur : les langages généralistes calculent tous les\nmêmes choses ; ils diffèrent par la commodité.\n"
        },
        {
          "text": "Les anciens langages ne peuvent plus être exécutés",
          "correct": false,
          "feedback": "Erreur : C (1972) ou Fortran (1957) sont encore utilisés\naujourd'hui.\n"
        }
      ],
      "explanation": "Tous les langages généralistes permettent d'écrire les mêmes\nalgorithmes ; ils se distinguent par leur syntaxe, leurs\nstyles et leurs domaines d'usage."
    }
  ]
}