math-exercises 3.0.131 → 3.0.133

package/lib/exercises/math/percent/evolutions/globalPercent.js

@@ -1,5 +1,5 @@
 import { randint } from "../../../../math/utils/random/randint.js";
-import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercise.js";
 import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { round } from "../../../../math/utils/round.js";
@@ -48,8 +48,26 @@ $$
 Le taux d'évolution global est donc de $${answer}$.
     `;
 };
-const getGlobalPercentQuestion = () => {
-    const indice = randint(2, 4);
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        let wrongAnswer = Number(answer.replace(",", ".").replace(`\\%`, ""));
+        const deviation = Math.random() < 0.5 ? -1 : 1;
+        const percentDeviation = Math.random() * 20 + 1;
+        wrongAnswer += deviation * percentDeviation;
+        wrongAnswer = round(wrongAnswer, 2);
+        tryToAddWrongProp(propositions, `${(wrongAnswer + "").replace(".", ",")} \\%`);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const parsed = percentParser(ans);
+    return parsed === answer.replace("+", "");
+};
+const getGlobalPercentQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const indice = Number(opts.nbEvos);
     const evolutions = [];
     for (let i = 0; i < indice; i++) {
         const randPercent = randint(1, 50);
@@ -59,7 +77,7 @@ const getGlobalPercentQuestion = () => {
     const identifiers = { evolutions };
     return getQuestionFromIdentifiers(identifiers);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         instruction: getInstruction(identifiers),
         answer: getAnswer(identifiers),
@@ -68,32 +86,30 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        options: opts,
     };
     return question;
 };
-const getPropositions = (n, { answer }) => {
-    const propositions = [];
-    addValidProp(propositions, answer);
-    propWhile(propositions, n, () => {
-        let wrongAnswer = Number(answer.replace(",", ".").replace(`\\%`, ""));
-        const deviation = Math.random() < 0.5 ? -1 : 1;
-        const percentDeviation = Math.random() * 20 + 1;
-        wrongAnswer += deviation * percentDeviation;
-        wrongAnswer = round(wrongAnswer, 2);
-        tryToAddWrongProp(propositions, `${(wrongAnswer + "").replace(".", ",")} \\%`);
-    });
-    return shuffle(propositions);
-};
-const isAnswerValid = (ans, { answer }) => {
-    const parsed = percentParser(ans);
-    return parsed === answer.replace("+", "");
+const optsDefault = {
+    nbEvos: "2",
 };
+const options = [
+    {
+        id: "nbEvos",
+        label: "Nombre d'évolutions successives",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["2", "3", "4"],
+        defaultValue: optsDefault.nbEvos,
+    },
+];
 export const globalPercent = {
     id: "globalPercent",
     connector: "=",
     label: "Calculer un taux d'évolution global à partir de taux d'évolution successifs",
     isSingleStep: false,
-    generator: (nb) => getDistinctQuestions(getGlobalPercentQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getGlobalPercentQuestion(opts), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

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/basicProbas/possibleValuesForProba.js

@@ -103,7 +103,7 @@ const createRandomNode = (numberType, isPossibleProba) => {
             case "Fraction": {
                 if (probaFlip(0.7)) {
                     const num = randint(0, 10_000);
-                    const den = randint(num, 20_000);
+                    const den = randint(num, 20_000, [0]);
                     return frac(num, den);
                 }
                 else {
@@ -145,7 +145,7 @@ const createRandomNode = (numberType, isPossibleProba) => {
                     const num = coinFlip()
                         ? randint(10_000, 20_000)
                         : randint(-20_000, -10_000);
-                    const den = randint(0, abs(num).evaluate());
+                    const den = randint(1, abs(num).evaluate());
                     return frac(num, den);
                 }
                 else {

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,
 };