math-exercises 3.0.131 → 3.0.132

package/lib/exercises/math/percent/findProportion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findProportion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/findProportion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAgOF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}
+{"version":3,"file":"findProportion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/findProportion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA4NF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}

package/lib/exercises/math/percent/findProportion.js

@@ -6,10 +6,10 @@ import { round } from "../../../math/utils/round.js";
 import { frac } from "../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../../tree/nodes/operators/substractNode.js";
-import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { percentParser } from "../../../tree/parsers/percentParser.js";
+import { valueParser } from "../../../tree/parsers/valueParser.js";
 import { random } from "../../../utils/alea/random.js";
 import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
-import { alignTex } from "../../../utils/latex/alignTex.js";
 const situations = [
     {
         instruction: (total, lefties) => `${random([
@@ -114,14 +114,10 @@ const getHint = (identifiers) => {
     const situation = situations[indexSituation];
     return `${situation.hint}
 
-Rappel :
+Pour transformer un nombre décimal en pourcentage, on le multiplie par $100$. Par exemple, 
 
 $$
-2\\% = 0,02
-$$
-
-$$
-2,01\\% = 0,0201
+0,345 = 34,5\\%
 $$
 
 `;
@@ -135,16 +131,9 @@ const getCorrection = (identifiers) => {
     const middleSymbol = isEqual ? "=" : "\\approx";
     return `On a : 
 
-${alignTex([
-        [`${fractionNode.toTex()}`, middleSymbol, `${roundedProportion.frenchify()}`],
-        [
-            "",
-            middleSymbol,
-            `${roundedProportion.frenchify()} \\times 100 \\times \\frac{1}{100}`,
-        ],
-        ["", middleSymbol, `${roundedProportion.frenchify()} \\times 100 \\ \\%`],
-        ["", middleSymbol, `${getAnswer(identifiers)}`],
-    ])}
+$$
+${fractionNode.toTex()} ${middleSymbol} ${roundedProportion.frenchify()}
+$$
 
 ${situation.correction} $${getAnswer(identifiers)}$.`;
 };
@@ -163,14 +152,19 @@ const getPropositions = (n, { answer, total, lefties }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, ...identifiers }) => {
-    const { lefties, total } = identifiers;
+const isAnswerValid = (ans, { answer, lefties, total }) => {
     try {
-        const percentNode = frac(1, 100);
-        const refinedAns = ans.replaceAll("\\%", `({${percentNode.toTex()}})`);
-        const nodeAns = parseAlgebraic(refinedAns);
-        const nodeAnswer = round(lefties / total, 4);
-        return substract(nodeAns, nodeAnswer).simplify().evaluate() === 0;
+        if (ans.includes("\\%")) {
+            const parsed = percentParser(ans);
+            return parsed === answer;
+        }
+        else {
+            const answerValue = round(lefties / total, 4);
+            const studentAns = valueParser(ans);
+            if (!studentAns)
+                return false;
+            return answerValue === studentAns;
+        }
     }
     catch (err) {
         return handleVEAError(err);
@@ -181,7 +175,11 @@ const getFindProportionQuestion = () => {
     const situation = situations[indexSituation];
     const total = situation.randTotal();
     const lefties = round(randfloat(0.1, 0.9) * total, 0);
-    return getQuestionFromIdentifiers({ indexSituation, total, lefties });
+    return getQuestionFromIdentifiers({
+        indexSituation,
+        total,
+        lefties,
+    });
 };
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {

package/lib/exercises/math/percent/percentToDecimal.d.ts

@@ -3,6 +3,9 @@ type Identifiers = {
     isPercentToDecimal: boolean;
     nb: number;
 };
-export declare const percentToDecimal: Exercise<Identifiers>;
+type Options = {
+    conversionType: string;
+};
+export declare const percentToDecimal: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=percentToDecimal.d.ts.map

package/lib/exercises/math/percent/percentToDecimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"percentToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/percentToDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA8IF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"percentToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/percentToDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4JF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAsBF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe3D,CAAC"}

package/lib/exercises/math/percent/percentToDecimal.js

@@ -1,4 +1,4 @@
-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 { Decimal, DecimalConstructor, } from "../../../math/numbers/decimals/decimal.js";
 import { Integer, IntegerConstructor, } from "../../../math/numbers/integer/integer.js";
@@ -7,6 +7,7 @@ import { round } from "../../../math/utils/round.js";
 import { numberParser } from "../../../tree/parsers/numberParser.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
 import { probaFlip } from "../../../utils/alea/probaFlip.js";
+import { random } from "../../../utils/alea/random.js";
 const getAnswer = ({ nb, isPercentToDecimal }) => {
     const dec = new Decimal(nb);
     const tex = dec.toTree().toTex();
@@ -48,39 +49,6 @@ En effet, on a bien $${answer} = \\frac{${answer.replace("\\%", "")}}{100} = ${n
 const getKeys = () => {
     return ["percent"];
 };
-const getPercentToDecimalQuestion = () => {
-    const isPercentToDecimal = coinFlip();
-    const isNatural = coinFlip();
-    const percentNb = probaFlip(0.3)
-        ? isNatural
-            ? new Integer(IntegerConstructor.random(1, [0]))
-            : DecimalConstructor.random(0, 10)
-        : coinFlip()
-            ? isNatural
-                ? new Integer(IntegerConstructor.random(2))
-                : DecimalConstructor.random(10, 100)
-            : isNatural
-                ? new Integer(IntegerConstructor.random(3))
-                : DecimalConstructor.random(100, 200);
-    const nb = percentNb.times(0.01);
-    const identifiers = {
-        isPercentToDecimal,
-        nb: round(nb.value, 10),
-    };
-    return getQuestionFromIdentifiers(identifiers);
-};
-const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
-        keys: getKeys(identifiers),
-        answerFormat: "tex",
-        identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
-    };
-    return question;
-};
 const getPropositions = (n, { answer, isPercentToDecimal, nb }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -113,12 +81,64 @@ const isAnswerValid = (ans, { answer, isPercentToDecimal }) => {
         return parsed + "\\%" === answer;
     }
 };
+const getPercentToDecimalQuestion = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const opts = {
+        conversionType: random(arrayedOptions.conversionType),
+    };
+    const isPercentToDecimal = opts.conversionType === "Pourcentage vers Décimal";
+    const isNatural = coinFlip();
+    const percentNb = probaFlip(0.3)
+        ? isNatural
+            ? new Integer(IntegerConstructor.random(1, [0]))
+            : DecimalConstructor.random(0, 10)
+        : coinFlip()
+            ? isNatural
+                ? new Integer(IntegerConstructor.random(2))
+                : DecimalConstructor.random(10, 100)
+            : isNatural
+                ? new Integer(IntegerConstructor.random(3))
+                : DecimalConstructor.random(100, 200);
+    const nb = percentNb.times(0.01);
+    const identifiers = {
+        isPercentToDecimal,
+        nb: round(nb.value, 10),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    conversionType: ["Pourcentage vers Décimal", "Décimal vers Pourcentage"],
+};
+const options = [
+    {
+        id: "conversionType",
+        label: "Type de conversion",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Pourcentage vers Décimal", "Décimal vers Pourcentage"],
+        defaultValue: optsDefault.conversionType,
+    },
+];
 export const percentToDecimal = {
     id: "percentToDecimal",
     connector: "=",
     label: "Écrire un pourcentage sous forme décimale et vice-versa",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getPercentToDecimalQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getPercentToDecimalQuestion(opts), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

package/lib/exercises/math/powers/calculateNegativePower.d.ts

@@ -2,7 +2,7 @@ import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
     int: number;
     power: number;
-    opts: Options;
+    isPowerAllowed: boolean;
 };
 type Options = {
     isPowerAllowed: boolean;

package/lib/exercises/math/powers/calculateNegativePower.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateNegativePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculateNegativePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AA0CrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AA4JF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAeF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjE,CAAC"}
+{"version":3,"file":"calculateNegativePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculateNegativePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AA0CrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AA4KF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAcF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBjE,CAAC"}

package/lib/exercises/math/powers/calculateNegativePower.js

@@ -25,8 +25,14 @@ const isNodeContainingOperatorId = (node, opId) => {
         return false;
     }
 };
+const rebuildIdentifiers = (oldIds) => {
+    const newIds = Object.assign({}, oldIds, {
+        isPowerAllowed: true,
+    });
+    return newIds;
+};
 const getInstruction = (identifiers) => {
-    const { int, power, opts } = identifiers;
+    const { int, power, isPowerAllowed } = identifiers;
     const statement = new PowerNode(new NumberNode(int), new NumberNode(power)).toTex();
     return `Calculer et donner le résultat sous la forme d'une fraction ou d'un entier : 
 
@@ -34,14 +40,14 @@ $$
 ${statement}
 $$
 
-${opts.isPowerAllowed
+${isPowerAllowed
         ? `La réponse pourra comporter un exposant.`
         : `La réponse ne devra comporter aucun exposant.`}`;
 };
 const getAnswer = (identifiers) => {
-    const { int, power, opts } = identifiers;
+    const { int, power, isPowerAllowed } = identifiers;
     const powerNode = new PowerNode(int.toTree(), Math.abs(power).toTree());
-    const fraction = frac(1, opts.isPowerAllowed ? powerNode : powerNode.evaluate().toTree());
+    const fraction = frac(1, isPowerAllowed ? powerNode : powerNode.evaluate().toTree());
     const answer = fraction.simplify();
     return answer.toTex();
 };
@@ -53,7 +59,7 @@ a^{-x} = \\frac{1}{a^x}
 $$`;
 };
 const getCorrection = (identifiers) => {
-    const { int, power, opts } = identifiers;
+    const { int, power, isPowerAllowed } = identifiers;
     const statement = new PowerNode(new NumberNode(int), new NumberNode(power)).toTex();
     const fraction = frac(1, new PowerNode(int.toTree(), Math.abs(power).toTree()));
     const simplificationTex = fraction.toSimplificationTex();
@@ -64,7 +70,7 @@ ${statement} = ${simplificationTex}
 $$
 
 ${(() => {
-        if (!opts.isPowerAllowed) {
+        if (!isPowerAllowed) {
             const fractionNoPower = frac(1, new PowerNode(int.toTree(), Math.abs(power).toTree()).evaluate().toTree());
             const texNoPower = fractionNoPower.toTex();
             return !simplificationTex.includes(texNoPower)
@@ -105,12 +111,12 @@ const getPropositions = (n, { answer, int, power }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, opts }) => {
+const isAnswerValid = (ans, { answer, isPowerAllowed }) => {
     try {
         const parsed = parseAlgebraic(ans);
         if (!isNumberNode(parsed) &&
             !(isFractionNode(parsed) &&
-                (opts.isPowerAllowed ||
+                (isPowerAllowed ||
                     !isNodeContainingOperatorId(parsed, OperatorIds.power)))) {
             return false;
         }
@@ -122,9 +128,10 @@ const isAnswerValid = (ans, { answer, opts }) => {
 };
 const getCalculatePowerQuestion = (optsIn) => {
     const opts = optsIn ?? optsDefault;
+    const isPowerAllowed = opts.isPowerAllowed;
     const int = randint(1, 11);
     const power = randint(-5, 0);
-    const identifiers = { int, power, opts };
+    const identifiers = { int, power, isPowerAllowed };
     return getQuestionFromIdentifiers(identifiers, opts);
 };
 const getQuestionFromIdentifiers = (identifiers, opts) => {
@@ -149,7 +156,6 @@ const options = [
         label: "Exposant accepté dans la réponse",
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.checkbox,
-        values: [true, false],
         defaultValue: optsDefault.isPowerAllowed,
     },
 ];
@@ -168,4 +174,5 @@ export const calculateNegativePower = {
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
     shouldHaveCalculator: false,
+    rebuildIdentifiers: rebuildIdentifiers,
 };

package/lib/exercises/math/probaStat/basicStats/calculateFrequencyInList.d.ts

@@ -2,7 +2,11 @@ import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
     values: number[];
     target: number;
+    allowedAnsType: string[];
 };
-export declare const calculateFrequencyInList: Exercise<Identifiers>;
+type Options = {
+    allowedAnsType: string[];
+};
+export declare const calculateFrequencyInList: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=calculateFrequencyInList.d.ts.map

package/lib/exercises/math/probaStat/basicStats/calculateFrequencyInList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateFrequencyInList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/calculateFrequencyInList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAoHF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}
+{"version":3,"file":"calculateFrequencyInList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicStats/calculateFrequencyInList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AA8LF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAsBF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBnE,CAAC"}

package/lib/exercises/math/probaStat/basicStats/calculateFrequencyInList.js

@@ -1,11 +1,19 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { RationalConstructor } 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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { probaFlip } from "../../../../utils/alea/probaFlip.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const rebuildIdentifiers = (oldIds) => {
+    const newIds = Object.assign({}, oldIds, {
+        allowedAnsType: ["exacte", "arrondie à 2 décimales"],
+    });
+    return newIds;
+};
 const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -17,13 +25,17 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     });
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
-    const { target, values } = identifiers;
+const getAnswerNode = (identifiers) => {
+    const { target, values, allowedAnsType } = identifiers;
     const nb = values.filter((v) => v === target).length;
-    return frac(nb, values.length).simplify({ fractionsToDecimal: true }).toTex();
+    const exactNode = frac(nb, values.length);
+    return createFormattedNode(exactNode, getStrInternalAllowedAnswerTypes(allowedAnsType));
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
 };
 const getInstruction = (identifiers) => {
-    const { target, values } = identifiers;
+    const { target, values, allowedAnsType } = identifiers;
     const length = values.length;
     return `Voici une liste de nombres : 
   
@@ -35,7 +47,7 @@ $$
 
 Quelle est la fréquence d'apparition du nombre $${target}$ dans cette liste ?
 
-Donner la réponse sous forme de fraction, ou si possible de nombre décimal ou de pourcentage.`;
+Donner ${getStrAllowedAnswerTypes(getStrInternalAllowedAnswerTypes(allowedAnsType))}.`;
 };
 const getHint = (identifiers) => {
     const { target } = identifiers;
@@ -59,25 +71,32 @@ $$
 const getKeys = () => {
     return ["percent"];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
+        let ansNode;
         if (ans.includes("%")) {
             const formated = ans.replace("\\%", "");
             const nb = formated.unfrenchify();
             if (isNaN(nb))
                 return false;
-            return (frac(nb, 100).simplify({ fractionsToDecimal: true }).toTex() === answer);
+            ansNode = frac(nb, 100);
         }
         else {
-            const parsed = parseAlgebraic(ans);
-            return parsed.simplify({ fractionsToDecimal: true }).toTex() === answer;
+            ansNode = parseAlgebraic(ans);
         }
+        if (!ansNode)
+            return false;
+        return getAllValidNodes(identifiers).some((answerNode) => {
+            return substract(ansNode, answerNode).simplify().evaluate() === 0;
+        });
     }
     catch (err) {
         return handleVEAError(err);
     }
 };
-const getCalculateFrequencyInListQuestion = () => {
+const getCalculateFrequencyInListQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const allowedAnsType = opts.allowedAnsType;
     const target = randint(1, 10);
     const length = randint(6, 13);
     const values = [];
@@ -87,10 +106,11 @@ const getCalculateFrequencyInListQuestion = () => {
     const identifiers = {
         target,
         values,
+        allowedAnsType,
     };
     return getQuestionFromIdentifiers(identifiers);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     return {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -99,14 +119,57 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        options: opts,
     };
 };
+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 calculateFrequencyInList = {
     id: "calculateFrequencyInList",
     connector: "=",
     label: "Calculer la fréquence d'apparition d'un nombre dans une liste",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getCalculateFrequencyInListQuestion(opts), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -114,4 +177,5 @@ export const calculateFrequencyInList = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    rebuildIdentifiers: rebuildIdentifiers,
 };

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

@@ -207,7 +207,7 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
 export const conditionalProbaWriteFromFrench = {
     id: "conditionalProbaWriteFromFrench",
     connector: "=",
-    label: "Ecrire une probabilité en langage mathématique",
+    label: "Écrire une probabilité en langage mathématique",
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getConditionalProbaWriteFromFrenchQuestion, nb),
     qcmTimer: 60,

package/lib/exercises/math/probaStat/probaAsSumOfProbas.d.ts

@@ -20,9 +20,9 @@ type EventIdentifiers = {
     isTailoredStr: boolean;
 };
 type Options = {
-    nbElem: number[];
-    unionLength: number[];
-    isProbasAreNumbers: boolean[];
+    nbElem: string[];
+    unionLength: string[];
+    isProbasAreNumbers: boolean;
 };
 export declare const probaAsSumOfProbas: Exercise<Identifiers, Options>;
 export {};

package/lib/exercises/math/probaStat/probaAsSumOfProbas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probaAsSumOfProbas.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaAsSumOfProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAkBT,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAc7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,gBAAgB,GACjB;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,eAAe,CAAC;CACpB,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,eAAe,CAAC;IACnB,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AA4eN,KAAK,OAAO,GAAG;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,kBAAkB,EAAE,OAAO,EAAE,CAAC;CAC/B,CAAC;AAyTF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe7D,CAAC"}
+{"version":3,"file":"probaAsSumOfProbas.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaAsSumOfProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAkBT,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,gBAAgB,GACjB;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,eAAe,CAAC;CACpB,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,eAAe,CAAC;IACnB,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AA4eN,KAAK,OAAO,GAAG;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAqRF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe7D,CAAC"}

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

@@ -112,7 +112,7 @@ class SituationConstructor {
         const str = `On lance un dé à $${nbSides}$ faces numérotées de $1$ à $${nbSides}$. 
     Le dé n'est pas équilibré.`;
         const strElem = `Pour $i$ allant de $1$ à $${nbSides}$, on note $E_i$ l'évènement:
-"Le résultat est $i$.".`;
+"Le résultat est $i$".`;
         const nbPickSomeElem = Math.min(nbSides, 6);
         const allIndexesElem = [...Array(nbSides).keys()].map((i) => i + 1);
         const dictAllElem = Object.fromEntries(allIndexesElem.map((index) => [
@@ -342,9 +342,9 @@ $$`;
     return strCorrection;
 };
 const optsDefault = {
-    nbElem: [4, 6, 10, 12],
-    unionLength: [2, 3, 4, 5],
-    isProbasAreNumbers: [true, false],
+    nbElem: ["4", "6", "10", "12"],
+    unionLength: ["2", "3", "4", "5"],
+    isProbasAreNumbers: true,
 };
 const options = [
     {
@@ -352,7 +352,7 @@ const options = [
         label: "Nombre d'évènements élémentaires",
         type: GeneratorOptionType.multiselect,
         target: GeneratorOptionTarget.generation,
-        values: [4, 6, 10, 12],
+        values: ["4", "6", "10", "12"],
         defaultValue: optsDefault.nbElem,
     },
     {
@@ -360,47 +360,19 @@ const options = [
         label: "Longueur de l'union",
         type: GeneratorOptionType.multiselect,
         target: GeneratorOptionTarget.generation,
-        values: [2, 3, 4, 5, 6],
+        values: ["2", "3", "4", "5", "6"],
         defaultValue: optsDefault.unionLength,
     },
-    {
-        id: "isProbasAreNumbers",
-        label: "Probabilités sous forme de nombres ?",
-        type: GeneratorOptionType.multiselect,
-        target: GeneratorOptionTarget.generation,
-        values: [true, false],
-        defaultValue: optsDefault.isProbasAreNumbers,
-    },
+    // {
+    //   id: "isProbasAreNumbers",
+    //   label: "Probabilités sous forme de nombres ?",
+    //   type: GeneratorOptionType.checkbox,
+    //   target: GeneratorOptionTarget.generation,
+    //   defaultValue: optsDefault.isProbasAreNumbers,
+    // },
 ];
-const getKeys = (identifiers) => {
-    const { indexSituation, arrProba } = identifiers;
-    const isProbasAreNumbers = true;
-    const situation = arrayOfSituations[indexSituation];
-    return [
-        ...[
-            ...new Set(situation.someElem
-                .map((event) => {
-                if (isProbasAreNumbers) {
-                    const finiteProbDistr = FiniteProbDistrConstructor.fromArrProba(arrProba.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)));
-                    return finiteProbDistr.getPForIndex(event.index).simplify();
-                }
-                else {
-                    return event.p;
-                }
-            })
-                .map((node) => node.toTex())),
-        ].map((tex) => {
-            return {
-                id: "custom",
-                label: tex,
-                labelType: "tex",
-                mathfieldInstructions: {
-                    method: "write",
-                    content: tex,
-                },
-            };
-        }),
-    ];
+const getKeys = () => {
+    return [];
 };
 const getPropositions = (n, { answer, ...identifiers }) => {
     const { eventIds, arrProba } = identifiers;
@@ -499,7 +471,7 @@ const isAnswerValid = (ans, { answer, ...identifiers }) => {
 };
 const getProbaAsSumOfProbasQuestion = (optsIn) => {
     const opts = Object.assign(optsDefault, optsIn) ?? optsDefault;
-    const unionLength = random(opts.unionLength);
+    const unionLength = Number(random(opts.unionLength));
     const indexSituation = random([...Array(arrayOfSituations.length).keys()].filter((indexSituation) => {
         const situation = arrayOfSituations[indexSituation];
         return situation.someElem.length >= unionLength;
@@ -509,7 +481,7 @@ const getProbaAsSumOfProbasQuestion = (optsIn) => {
     const eventIds = evUnion.toIdentifiers();
     const nbUnique = Math.min(randint(3, 7), situation.allElem.length - 1);
     const finiteProbDistr = FiniteProbDistrConstructor.randomDistr(situation.allElem.length, nbUnique);
-    const isProbasAreNumbers = random(opts.isProbasAreNumbers);
+    const isProbasAreNumbers = opts.isProbasAreNumbers;
     const identifiers = {
         indexSituation,
         eventIds,