math-exercises 3.0.131 → 3.0.133

package/lib/exercises/math/probaStat/probaFromTableWithContext.js

@@ -1,26 +1,235 @@
-import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { Rational } from "../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
 import { frac } from "../../../tree/nodes/operators/fractionNode.js";
-import { rationalParser } from "../../../tree/parsers/rationalParser.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { random } from "../../../utils/alea/random.js";
 import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 import { dollarize } from "../../../utils/latex/dollarize.js";
 import { mdTable } from "../../../utils/markdown/mdTable.js";
-const getInstruction = ({ aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre, event, }) => {
-    return `Le tableau suivant donne le nombre de filles et de garçons portant des lunettes dans un lycée : 
+const rebuildIdentifiers = (oldIds) => {
+    const newIds = {
+        indexSituation: 0,
+        values: {
+            "A \\cap B": oldIds.aCapB,
+            "A \\cap \\overline{B}": oldIds.aCapBBarre,
+            "\\overline{A} \\cap B": oldIds.aBarreCapB,
+            "\\overline{A} \\cap \\overline{B}": oldIds.aBarreCapBBarre,
+        },
+        event: oldIds.event,
+        type: oldIds.type,
+        probaFrac: oldIds.probaFrac,
+        allowedAnsType: ["exacte", "arrondie à 2 décimales"],
+    };
+    return newIds;
+};
+const situations = [
+    //genre et lunettes
+    {
+        events: {
+            //single
+            A: "une fille",
+            "\\overline{A}": "un garçon",
+            B: "un élève qui porte des lunettes",
+            "\\overline{B}": "un élève qui ne porte pas de lunettes",
+            //intersection
+            "A \\cap B": "une fille qui porte des lunettes",
+            "A \\cap \\overline{B}": "une fille qui ne porte pas de lunettes",
+            "\\overline{A} \\cap B": "un garçon qui porte des lunettes",
+            "\\overline{A} \\cap \\overline{B}": "un garçon qui ne porte pas de lunettes",
+            //union
+            "A \\cup B": "une fille ou un élève qui porte des lunettes",
+            "A \\cup \\overline{B}": "une fille ou un élève qui ne porte pas de lunettes",
+            "\\overline{A} \\cup B": "un garçon ou un élève qui porte des lunettes",
+            "\\overline{A} \\cup \\overline{B}": "un garçon ou un élève qui ne porte pas de lunettes",
+        },
+        instruction: {
+            context: `Le tableau suivant donne le nombre de filles et de garçons portant des lunettes dans un lycée`,
+            table: {
+                A: `Une fille`,
+                "\\overline{A}": `Un garçon`,
+                B: `Porte des lunettes`,
+                "\\overline{B}": `Ne porte pas de lunettes`,
+            },
+            beforeQuestion: `On choisit un élève au hasard.`,
+        },
+        hint: {
+            single: `On lit le total d'élèves correspondant au cas demandé, puis on divise par le total des élèves.`,
+            intersection: `On lit la case des élèves correspondant à la fois aux deux cas demandés.`,
+            union: `On compte tous les élèves qui sont soit dans le premier cas, 
+soit dans le second (ou à la fois dans les deux). Attention à ne pas compter certains élèves en double.`,
+        },
+        correction: {
+            total: `Le total des élèves se lit à l'intersection de la ligne "Total" et de la colonne "Total"`,
+        },
+    },
+    //chien et sport
+    {
+        events: {
+            A: "une personne qui possède un chien",
+            "\\overline{A}": "une personne qui ne possède pas de chien",
+            B: "une personne qui fait du sport",
+            "\\overline{B}": "une personne qui ne fait pas de sport",
+            "A \\cap B": "une personne qui possède un chien et fait du sport",
+            "A \\cap \\overline{B}": "une personne qui possède un chien mais ne fait pas de sport",
+            "\\overline{A} \\cap B": "une personne qui n’a pas de chien mais fait du sport",
+            "\\overline{A} \\cap \\overline{B}": "une personne qui n’a pas de chien et ne fait pas de sport",
+            "A \\cup B": "une personne qui possède un chien ou qui fait du sport",
+            "A \\cup \\overline{B}": "une personne qui possède un chien ou ne fait pas de sport",
+            "\\overline{A} \\cup B": "une personne qui n’a pas de chien ou qui fait du sport",
+            "\\overline{A} \\cup \\overline{B}": "une personne qui n’a pas de chien ou ne fait pas de sport",
+        },
+        instruction: {
+            context: "Le tableau suivant donne les résultats d’une enquête sur la possession d’un chien et la pratique du sport",
+            table: {
+                A: "Possède un chien",
+                "\\overline{A}": "Ne possède pas de chien",
+                B: "Fait du sport",
+                "\\overline{B}": "Ne fait pas de sport",
+            },
+            beforeQuestion: "On choisit une personne au hasard parmi les sondés.",
+        },
+        hint: {
+            single: "On lit le total des personnes correspondant au cas demandé, puis on divise par le total des sondés.",
+            intersection: "On repère la case correspondant aux deux caractéristiques simultanées.",
+            union: "On additionne les individus appartenant à l’un ou l’autre des groupes, sans double comptage.",
+        },
+        correction: {
+            total: `Le total des élèves se lit à l'intersection de la ligne "Total" et de la colonne "Total"`,
+        },
+    },
+    //vélo et ponctualité
+    {
+        events: {
+            A: "un élève qui vient au lycée à vélo",
+            "\\overline{A}": "un élève qui ne vient pas au lycée à vélo",
+            B: "un élève qui arrive à l'heure",
+            "\\overline{B}": "un élève qui arrive en retard",
+            "A \\cap B": "un élève qui vient à vélo et arrive à l'heure",
+            "A \\cap \\overline{B}": "un élève qui vient à vélo et arrive en retard",
+            "\\overline{A} \\cap B": "un élève qui ne vient pas à vélo et arrive à l'heure",
+            "\\overline{A} \\cap \\overline{B}": "un élève qui ne vient pas à vélo et arrive en retard",
+            "A \\cup B": "un élève qui vient à vélo ou qui arrive à l'heure",
+            "A \\cup \\overline{B}": "un élève qui vient à vélo ou arrive en retard",
+            "\\overline{A} \\cup B": "un élève qui ne vient pas à vélo ou arrive à l'heure",
+            "\\overline{A} \\cup \\overline{B}": "un élève qui ne vient pas à vélo ou arrive en retard",
+        },
+        instruction: {
+            context: "Le tableau suivant indique le mode de transport et la ponctualité des élèves d'un lycée",
+            table: {
+                A: "Vient à vélo",
+                "\\overline{A}": "Ne vient pas à vélo",
+                B: "Arrive à l'heure",
+                "\\overline{B}": "Arrive en retard",
+            },
+            beforeQuestion: "On choisit un élève au hasard.",
+        },
+        hint: {
+            single: `On lit le total d'élèves correspondant au cas demandé, puis on divise par le total des élèves.`,
+            intersection: `On lit la case des élèves correspondant à la fois aux deux cas demandés.`,
+            union: `On compte tous les élèves qui sont soit dans le premier cas, 
+soit dans le second (ou à la fois dans les deux). Attention à ne pas compter certains élèves en double.`,
+        },
+        correction: {
+            total: `Le total des élèves se lit à l'intersection de la ligne "Total" et de la colonne "Total"`,
+        },
+    },
+    //révision et réussite
+    {
+        events: {
+            A: "un élève qui a révisé pour le contrôle",
+            "\\overline{A}": "un élève qui n’a pas révisé pour le contrôle",
+            B: "un élève qui a réussi le contrôle",
+            "\\overline{B}": "un élève qui a échoué au contrôle",
+            "A \\cap B": "un élève qui a révisé et a réussi",
+            "A \\cap \\overline{B}": "un élève qui a révisé mais a échoué",
+            "\\overline{A} \\cap B": "un élève qui n’a pas révisé mais a réussi",
+            "\\overline{A} \\cap \\overline{B}": "un élève qui n’a pas révisé et a échoué",
+            "A \\cup B": "un élève qui a révisé ou qui a réussi le contrôle",
+            "A \\cup \\overline{B}": "un élève qui a révisé ou a échoué",
+            "\\overline{A} \\cup B": "un élève qui n’a pas révisé ou a réussi",
+            "\\overline{A} \\cup \\overline{B}": "un élève qui n’a pas révisé ou a échoué",
+        },
+        instruction: {
+            context: "Le tableau suivant présente les résultats d’un contrôle selon que les élèves ont révisé ou non",
+            table: {
+                A: "A révisé",
+                "\\overline{A}": "N’a pas révisé",
+                B: "A réussi",
+                "\\overline{B}": "A échoué",
+            },
+            beforeQuestion: "On choisit un élève au hasard.",
+        },
+        hint: {
+            single: `On lit le total d'élèves correspondant au cas demandé, puis on divise par le total des élèves.`,
+            intersection: `On lit la case des élèves correspondant à la fois aux deux cas demandés.`,
+            union: `On compte tous les élèves qui sont soit dans le premier cas, 
+soit dans le second (ou à la fois dans les deux). Attention à ne pas compter certains élèves en double.`,
+        },
+        correction: {
+            total: `Le total des élèves se lit à l'intersection de la ligne "Total" et de la colonne "Total"`,
+        },
+    },
+    //cinéma et lecture
+    {
+        events: {
+            A: "un élève qui va souvent au cinéma",
+            "\\overline{A}": "un élève qui ne va pas souvent au cinéma",
+            B: "un élève qui lit régulièrement des livres",
+            "\\overline{B}": "un élève qui ne lit pas régulièrement de livres",
+            "A \\cap B": "un élève qui va souvent au cinéma et lit régulièrement",
+            "A \\cap \\overline{B}": "un élève qui va souvent au cinéma mais ne lit pas régulièrement",
+            "\\overline{A} \\cap B": "un élève qui ne va pas au cinéma mais lit régulièrement",
+            "\\overline{A} \\cap \\overline{B}": "un élève qui ne va pas au cinéma et ne lit pas régulièrement",
+            "A \\cup B": "un élève qui va souvent au cinéma ou lit régulièrement",
+            "A \\cup \\overline{B}": "un élève qui va au cinéma ou ne lit pas régulièrement",
+            "\\overline{A} \\cup B": "un élève qui ne va pas au cinéma ou lit régulièrement",
+            "\\overline{A} \\cup \\overline{B}": "un élève qui ne va pas au cinéma ou ne lit pas régulièrement",
+        },
+        instruction: {
+            context: "Le tableau suivant décrit les habitudes culturelles des élèves d’un lycée",
+            table: {
+                A: "Va au cinéma",
+                "\\overline{A}": "Ne va pas au cinéma",
+                B: "Lit",
+                "\\overline{B}": "Ne lit pas",
+            },
+            beforeQuestion: "On choisit un élève au hasard parmi ceux du lycée.",
+        },
+        hint: {
+            single: `On lit le total d'élèves correspondant au cas demandé, puis on divise par le total des élèves.`,
+            intersection: `On lit la case des élèves correspondant à la fois aux deux cas demandés.`,
+            union: `On compte tous les élèves qui sont soit dans le premier cas, 
+soit dans le second (ou à la fois dans les deux). Attention à ne pas compter certains élèves en double.`,
+        },
+        correction: {
+            total: `Le total des élèves se lit à l'intersection de la ligne "Total" et de la colonne "Total"`,
+        },
+    },
+];
+const getInstruction = ({ indexSituation, values, event, allowedAnsType, }) => {
+    const situation = situations[indexSituation];
+    const { "A \\cap B": aCapB, "A \\cap \\overline{B}": aCapBBarre, "\\overline{A} \\cap B": aBarreCapB, "\\overline{A} \\cap \\overline{B}": aBarreCapBBarre, } = values;
+    return `${situation.instruction.context} : 
 
 ${mdTable([
-        [" ", "Porte des lunettes", "Ne porte pas de lunettes", "Total"],
         [
-            "Filles",
+            " ",
+            situation.instruction.table.B,
+            situation.instruction.table["\\overline{B}"],
+            "Total",
+        ],
+        [
+            situation.instruction.table.A,
             dollarize(aCapB),
             dollarize(aCapBBarre),
             dollarize(aCapB + aCapBBarre),
         ],
         [
-            "Garçons",
+            situation.instruction.table["\\overline{A}"],
             dollarize(aBarreCapB),
             dollarize(aBarreCapBBarre),
             dollarize(aBarreCapB + aBarreCapBBarre),
@@ -33,23 +242,34 @@ ${mdTable([
         ],
     ])}
 
-On choisit un élève au hasard. Quelle est la probabilité de tomber sur ${event} ?
+${situation.instruction.beforeQuestion} 
+Quelle est la probabilité de tomber sur ${situation.events[event]} ?
     
-Donner la valeur exacte.`;
+Donner ${getStrAllowedAnswerTypes(getStrInternalAllowedAnswerTypes(allowedAnsType))}.`;
 };
-const getAnswer = (identifiers) => {
-    const { probaFrac } = identifiers;
-    const answer = new Rational(probaFrac[0], probaFrac[1])
+const getAnswerNode = (identifiers) => {
+    const { probaFrac, allowedAnsType } = identifiers;
+    const exactNode = new Rational(probaFrac[0], probaFrac[1])
         .simplify()
-        .toTree()
-        .toTex();
-    return answer;
+        .toTree();
+    return createFormattedNode(exactNode, getStrInternalAllowedAnswerTypes(allowedAnsType));
 };
-const getProbaFromTableWithContextQuestion = () => {
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getProbaFromTableWithContextQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const allowedAnsType = opts.allowedAnsType;
     const aCapB = randint(1, 20);
     const aCapBBarre = randint(1, 20, [aCapB]);
     const aBarreCapB = randint(1, 20, [aCapB, aCapBBarre]);
     const aBarreCapBBarre = randint(1, 20, [aCapB, aCapBBarre, aBarreCapB]);
+    const values = {
+        "A \\cap B": aCapB,
+        "A \\cap \\overline{B}": aCapBBarre,
+        "\\overline{A} \\cap B": aBarreCapB,
+        "\\overline{A} \\cap \\overline{B}": aBarreCapBBarre,
+    };
     const total = aBarreCapB + aBarreCapBBarre + aCapB + aCapBBarre;
     const aTotal = aCapB + aCapBBarre;
     const bTotal = aCapB + aBarreCapB;
@@ -65,53 +285,41 @@ const getProbaFromTableWithContextQuestion = () => {
     switch (type) {
         case "singleEvent":
             [event, proba] = random([
-                ["une fille", [aTotal, total]],
-                ["un élève qui porte des lunettes", [bTotal, total]],
-                ["un garçon", [aBarreTotal, total]],
-                ["un élève qui ne porte pas de lunettes", [bBarreTotal, total]],
+                ["A", [aTotal, total]],
+                ["B", [bTotal, total]],
+                ["\\overline{A}", [aBarreTotal, total]],
+                ["\\overline{B}", [bBarreTotal, total]],
             ]);
             break;
         case "intersection":
             [event, proba] = random([
-                ["une fille qui porte des lunettes", [aCapB, total]],
-                ["un garçon qui porte des lunettes", [aBarreCapB, total]],
-                ["une fille qui ne porte pas de lunettes", [aCapBBarre, total]],
-                ["un garçon qui ne porte pas de lunettes", [aBarreCapBBarre, total]],
+                ["A \\cap B", [aCapB, total]],
+                ["\\overline{A} \\cap B", [aBarreCapB, total]],
+                ["A \\cap \\overline{B}", [aCapBBarre, total]],
+                ["\\overline{A} \\cap \\overline{B}", [aBarreCapBBarre, total]],
             ]);
             break;
         case "union":
             [event, proba] = random([
-                [
-                    "une fille ou un élève qui porte des lunettes",
-                    [total - aBarreCapBBarre, total],
-                ],
-                [
-                    "une fille ou un élève qui ne porte pas de lunettes",
-                    [total - aBarreCapB, total],
-                ],
-                [
-                    "un garçon ou un élève qui porte des lunettes",
-                    [total - aCapBBarre, total],
-                ],
-                [
-                    "un garçon ou un élève qui ne porte pas de lunettes",
-                    [total - aCapB, total],
-                ],
+                ["A \\cup B", [total - aBarreCapBBarre, total]],
+                ["A \\cup \\overline{B}", [total - aBarreCapB, total]],
+                ["\\overline{A} \\cup B", [total - aCapBBarre, total]],
+                ["\\overline{A} \\cup \\overline{B}", [total - aCapB, total]],
             ]);
             break;
     }
+    const indexSituation = randint(0, situations.length);
     const identifiers = {
-        aBarreCapB,
-        aBarreCapBBarre,
-        aCapB,
-        aCapBBarre,
+        values,
+        indexSituation,
         event,
         type,
         probaFrac: proba,
+        allowedAnsType,
     };
     return getQuestionFromIdentifiers(identifiers);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -120,119 +328,170 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        options: opts,
     };
     return question;
 };
-const getPropositions = (n, { answer, aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre }) => {
+const getPropositions = (n, { answer, values, allowedAnsType }) => {
+    const { "A \\cap B": aCapB, "A \\cap \\overline{B}": aCapBBarre, "\\overline{A} \\cap B": aBarreCapB, "\\overline{A} \\cap \\overline{B}": aBarreCapBBarre, } = values;
     const propositions = [];
     addValidProp(propositions, answer);
-    propWhile(propositions, n, () => {
-        tryToAddWrongProp(propositions, new Rational(random([aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre]), random([aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre]) +
+    function createWrongNode() {
+        const exactNode = new Rational(random([aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre]), random([aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre]) +
             random([aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre]))
             .simplify()
-            .toTree()
-            .toTex());
+            .toTree();
+        return createFormattedNode(exactNode, getStrInternalAllowedAnswerTypes(allowedAnsType));
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, createWrongNode().toTex());
     });
     return shuffleProps(propositions, n);
 };
 // const options: GeneratorOption[] = [allowNonIrreductibleOption];
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
-        const parsed = rationalParser(ans);
-        if (!parsed)
+        const ansNode = parseAlgebraic(ans);
+        if (!ansNode)
             return false;
-        return parsed.simplify({ decimalToFractions: true }).toTex() === answer;
+        return getAllValidNodes(identifiers).some((answerNode) => {
+            return substract(ansNode, answerNode).simplify().evaluate() === 0;
+        });
     }
     catch (err) {
         return handleVEAError(err);
     }
 };
 const getHint = (identifiers) => {
-    const { type } = identifiers;
+    const { indexSituation, type } = identifiers;
+    const situation = situations[indexSituation];
     switch (type) {
         case "singleEvent":
-            return `Lit le total d'élèves correspondant au cas demandé, puis divise par le total des élèves.`;
+            return situation.hint.single;
         case "union":
-            return `Compte tous les élèves qui sont soit dans le premier cas, soit dans le second (ou à la fois dans les deux). Attention à ne pas compter certains élèves en double.`;
+            return situation.hint.union;
         case "intersection":
         default:
-            return `Lit la case des élèves correspondant à la fois aux deux cas demandés.`;
+            return situation.hint.intersection;
     }
 };
 const getCorrection = (identifiers) => {
-    const { aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre, probaFrac, type, event, } = identifiers;
+    const { values, probaFrac, type, event, indexSituation, allowedAnsType } = identifiers;
+    const situation = situations[indexSituation];
+    const { "A \\cap B": aCapB, "A \\cap \\overline{B}": aCapBBarre, "\\overline{A} \\cap B": aBarreCapB, "\\overline{A} \\cap \\overline{B}": aBarreCapBBarre, } = values;
     const aTotal = aCapB + aCapBBarre;
     const bTotal = aCapB + aBarreCapB;
     const aBarreTotal = aBarreCapB + aBarreCapBBarre;
     const bBarreTotal = aBarreCapBBarre + aCapBBarre;
+    const strRoundTo = allowedAnsType.length === 1 &&
+        allowedAnsType[0] === "arrondie à 2 décimales"
+        ? `Arrondi à $2$ décimales, cela donne $${getAnswerNode(identifiers).toTex()}$.`
+        : "";
     switch (type) {
         case "singleEvent": {
-            const singleEvnmt = event === "une fille"
-                ? "Filles"
-                : event === "un garçon"
-                    ? "Garçons"
-                    : event === "un élève qui porte des lunettes"
-                        ? "Porte des lunettes"
-                        : "Ne porte pas de lunettes";
-            const isLine = event === "une fille" || event === "un garçon";
-            return `On lit le total de la ${isLine ? "ligne" : "colonne"} "${singleEvnmt}" : c'est $${probaFrac[0]}$. 
+            const tableLabel = situation.instruction.table[event];
+            const isLine = event === "A" || event === "\\overline{A}";
+            return `On lit le total de la ${isLine ? "ligne" : "colonne"} "${tableLabel}" : c'est $${probaFrac[0]}$. 
       
-Le total des élèves se lit à l'intersection de la ligne "Total" et de la colonne "Total" : c'est $${probaFrac[1]}$.
+${situation.correction.total} : c'est $${probaFrac[1]}$.
 
 La probabilité recherchée vaut donc :
 
 $$
 ${frac(probaFrac[0], probaFrac[1]).toSimplificationTex()}
-$$`;
+$$
+
+${strRoundTo}
+`;
         }
         case "union": {
-            const unionEvements = event.split(" ou ");
-            const rowTotal = unionEvements[0] === "une fille" ? aTotal : aBarreTotal;
-            const columnTotal = unionEvements[1] === "un élève qui porte des lunettes"
-                ? bTotal
-                : bBarreTotal;
-            unionEvements[0] = unionEvements[0]
-                .replace("une", "")
-                .replace("un", "")
-                .trim();
-            unionEvements[1] = unionEvements[1].replace("un élève qui ", "");
-            return `On additionne les totaux de la ligne "${unionEvements[0]}" et de la colonne "${unionEvements[1]}" : cela donne $${rowTotal} + ${columnTotal} = ${rowTotal + columnTotal}$. 
+            const unionEvements = event.split(" \\cup ");
+            const rowTotal = unionEvements[0] === "A" ? aTotal : aBarreTotal;
+            const columnTotal = unionEvements[1] === "B" ? bTotal : bBarreTotal;
+            const tableLabels = unionEvements.map((event) => situation.instruction.table[event]);
+            return `On additionne les totaux de la ligne "${tableLabels[0]}" et de la colonne "${tableLabels[1]}" : cela donne $${rowTotal} + ${columnTotal} = ${rowTotal + columnTotal}$. 
       
-On doit ensuite soustraire la case à l'intersection de la ligne "${unionEvements[0]}" et de la colonne "${unionEvements[1]}", car on l'a compté deux fois dans les totaux. Cela donne $${rowTotal + columnTotal} - ${rowTotal + columnTotal - probaFrac[0]} = ${probaFrac[0]}
+On doit ensuite soustraire la case à l'intersection de la ligne "${tableLabels[0]}" et de la colonne "${tableLabels[1]}", car on l'a compté deux fois dans les totaux. Cela donne $${rowTotal + columnTotal} - ${rowTotal + columnTotal - probaFrac[0]} = ${probaFrac[0]}
       $.
 
-Le total des élèves se lit à l'intersection de la ligne "Total" et de la colonne "Total" : c'est $${probaFrac[1]}$.
+${situation.correction.total} : c'est $${probaFrac[1]}$.
 
-La probabilité de tomber sur ${event} vaut donc :
+La probabilité de tomber sur ${situation.events[event]} vaut donc :
 
 $$
 ${frac(probaFrac[0], probaFrac[1]).toSimplificationTex()}
-$$`;
+$$
+
+${strRoundTo}
+`;
         }
         case "intersection":
         default: {
-            const interEvemnts = event.split(" qui ");
-            return `On lit la case à l'intersection de la colonne "${interEvemnts[1]}"  et de la ligne "${interEvemnts[0]
-                .replace("une", "")
-                .replace("un", "")
-                .trim()}s" : c'est $${probaFrac[0]}$. 
+            const interEvemnts = event.split(" \\cap ");
+            const tableLabels = interEvemnts.map((event) => situation.instruction.table[event]);
+            return `On lit la case à l'intersection de la colonne "${tableLabels[1]}"  et de la ligne "${tableLabels[0]}" : c'est $${probaFrac[0]}$. 
 
-Le total des élèves se lit à l'intersection de la ligne "Total" et de la colonne "Total" : c'est $${probaFrac[1]}$.
+${situation.correction.total} : c'est $${probaFrac[1]}$.
 
-La probabilité de tomber sur ${event} vaut donc :
+La probabilité de tomber sur ${situation.events[event]} vaut donc :
 
 $$
 ${frac(probaFrac[0], probaFrac[1]).toSimplificationTex()}
-$$`;
+$$
+
+${strRoundTo}
+`;
         }
     }
 };
+const getStrInternalAllowedAnswerTypes = (allowedAnsType) => {
+    return allowedAnsType.toSorted((a, b) => a.localeCompare(b)).join(" | ");
+};
+const getStrAllowedAnswerTypes = (strInternalAllowedAnswerTypes) => {
+    switch (strInternalAllowedAnswerTypes) {
+        case "arrondie à 2 décimales | exacte":
+            return "la valeur exacte ou la valeur arrondie à $2$ décimales";
+        case "arrondie à 2 décimales":
+            return "la valeur arrondie à $2$ décimales";
+        case "exacte":
+            return "la valeur exacte";
+    }
+};
+const createFormattedNode = (exactNode, strInternalAllowedAnswerTypes) => {
+    switch (strInternalAllowedAnswerTypes) {
+        case "arrondie à 2 décimales":
+            return round(exactNode.evaluate(), 2).toTree();
+        default:
+            return exactNode;
+    }
+};
+const getAllValidNodes = (identifiers) => {
+    return identifiers.allowedAnsType.map((ansType) => getAnswerNode((() => {
+        const identifiersCopy = Object.assign({}, identifiers);
+        identifiersCopy.allowedAnsType = [ansType];
+        return identifiersCopy;
+    })()));
+};
+const optsDefault = {
+    allowedAnsType: ["exacte", "arrondie à 2 décimales"],
+};
+const options = [
+    {
+        id: "allowedAnsType",
+        label: "Forme de réponse acceptée",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["exacte", "arrondie à 2 décimales"],
+        defaultValue: optsDefault.allowedAnsType,
+    },
+];
 export const probaFromTableWithContext = {
     id: "probaFromTableWithContext",
     connector: "=",
     label: "Utiliser un tableau à double entrée pour calculer une probabilité (avec contexte)",
     isSingleStep: true,
-    generator: (nb, options) => getDistinctQuestions(() => getProbaFromTableWithContextQuestion(options), nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getProbaFromTableWithContextQuestion(opts), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -240,4 +499,5 @@ export const probaFromTableWithContext = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    rebuildIdentifiers: rebuildIdentifiers,
 };

package/lib/exercises/math/probaStat/stats1var/medianWithList.d.ts

@@ -2,6 +2,9 @@ import { Exercise } from "../../../exercise.js";
 type Identifiers = {
     sortedValues: number[];
 };
-export declare const medianWithList: Exercise<Identifiers>;
+type Options = {
+    nbValues: string;
+};
+export declare const medianWithList: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=medianWithList.d.ts.map

package/lib/exercises/math/probaStat/stats1var/medianWithList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"medianWithList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithList.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EAeT,MAAM,sBAAsB,CAAC;AAE9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAkFF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}
+{"version":3,"file":"medianWithList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithList.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,QAAQ,EAkBT,MAAM,sBAAsB,CAAC;AAE9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA2FF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAsBF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAezD,CAAC"}