math-exercises 3.0.123 → 3.0.125

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

@@ -1,60 +1,143 @@
-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 { rationalVEA } from "../../../exercises/vea/rationalVEA.js";
 import { randfloat } from "../../../math/utils/random/randfloat.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 { percentParser } from "../../../tree/parsers/percentParser.js";
+import { random } from "../../../utils/alea/random.js";
 import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
 import { approxOrEqual } from "../../../utils/latex/approxOrEqual.js";
-const getInstruction = (identifiers) => {
-    const { total, lefties } = identifiers;
-    return `Dans un lycée de $${total}$ élèves, $${lefties}$ sont gauchers. Quelle est la proportion de gauchers dans ce lycée, en pourcentage ? Arrondir au centième de pourcentage.`;
-};
-const getHint = () => {
-    return `La proportion de gauchers en pourcentage s'obtient par la formule  :
+const situations = [
+    {
+        instruction: (total, lefties) => `${random([
+            `Dans un lycée de $${total}$ élèves, $${lefties}$ sont gauchers.`,
+            `Dans un lycée, $${lefties}$ élèves sont gauchers sur un total de $${total}$ élèves.`,
+        ])}
+Quelle est la proportion de gauchers dans ce lycée, en pourcentage ?`,
+        hint: `La proportion de gauchers en pourcents s'obtient par la formule  :
+    
+$$
+\\frac{\\text{nombre de gauchers}}{\\text{nombre total d'élèves}}\\times 100
+$$
+`,
+        correction: `La proportion de gauchers en pourcentage dans ce lycée est de`,
+        randTotal: () => randint(500, 2000),
+    },
+    {
+        instruction: (total, lefties) => `${random([
+            `Dans une casse automobile, il y a $${total}$ voitures dont $${lefties}$ ont le volant à gauche.`,
+            `Dans une casse automobile, $${lefties}$ voitures ont le volant à gauche. Il y a au total $${total}$ voitures.`,
+        ])}      
+Quelle est la proportion de voitures avec le volant à gauche dans cette casse, en pourcentage ?`,
+        hint: `La proportion, en pourcents, de voitures avec le volant à gauche s'obtient par la formule  :
+    
+$$
+\\frac{\\text{nombre de voitures avec volant à gauche}}{\\text{nombre total de voitures}}\\times 100
+$$
+`,
+        correction: `La proportion, en pourcentage, de voitures avec le volant à gauche est de`,
+        randTotal: () => randint(100, 500),
+    },
+    {
+        instruction: (total, lefties) => `${random([
+            `Dans un restaurant italien, sur un total de $${total}$ clients, $${lefties}$ ont commandé des pâtes.`,
+            `Dans un restaurant italien, $${lefties}$ clients ont commandé des pâtes. Il y a au total $${total}$ clients.`,
+        ])} 
+Quelle est la proportion de clients qui ont commandé des pâtes, en pourcentage ?`,
+        hint: `La proportion en pourcents de clients qui ont commandé des pâtes s'obtient par la formule  :
+    
+$$
+\\frac{\\text{nombre de clients ayant commandé des pâtes}}{\\text{nombre total de clients}}\\times 100
+$$
+`,
+        correction: `La proportion en pourcentage de clients ayant commandé des pâtes est de`,
+        randTotal: () => randint(30, 200),
+    },
+    {
+        instruction: (total, lefties) => `${random([
+            `Dans une cagette de $${total}$ pommes, $${lefties}$ sont véreuses.`,
+            `Dans une cagette de pommes, $${lefties}$ sont véreuses. Il y a au total $${total}$ pommes.`,
+        ])}
+Quelle est la proportion de pommes véreuses dans la cagette, en pourcentage ?`,
+        hint: `La proportion, en pourcents, de pommes véreuses s'obtient par la formule  :
     
 $$
-\\frac{\\text{nombre de gauchers}}{\\text{nombre d'élèves}}\\times 100
+\\frac{\\text{nombre de pommes véreuses}}{\\text{nombre total de pommes}}\\times 100
 $$
-`;
+`,
+        correction: `La proportion, en pourcentage, de pommes véreuses est de`,
+        randTotal: () => randint(30, 100),
+    },
+    {
+        instruction: (total, lefties) => `${random([
+            `Dans un car scolaire transportant $${total}$ élèves, $${lefties}$ sont du côté gauche.`,
+            `Dans un car scolaire, $${lefties}$ élèves sont du côté gauche. Le car transporte $${total}$ élèves.`,
+        ])}    
+Quelle est la proportion d'élèves du côté gauche du car, en pourcentage ?`,
+        hint: `La proportion en pourcents d'élèves du gauche du car s'obtient par la formule  :
+    
+$$
+\\frac{\\text{nombre d'élèves du côté gauche}}{\\text{nombre d'élèves dans le car}}\\times 100
+$$
+`,
+        correction: `La proportion en pourcentage d'élèves du côté gauche est de`,
+        randTotal: () => randint(20, 40),
+    },
+    {
+        instruction: (total, lefties) => `${random([
+            `Dans un champ, au mois de septembre, sur $${total}$ champignons, $${lefties}$ sont vénéneux.`,
+            `Dans un champ, au mois de septembre, $${lefties}$ champignons sont vénéneux sur un total de $${total}$ champignons.`,
+        ])}    
+Quelle est la proportion de champignons vénéneux dans ce champ, en pourcentage ?`,
+        hint: `La proportion de champignons vénéneux dans ce champ, en pourcents, s'obtient par la formule  :
+    
+$$
+\\frac{\\text{nombre de champignons vénéneux}}{\\text{nombre total de champignons}}\\times 100
+$$
+`,
+        correction: `La proportion en pourcentage de champignons vénéneux dans ce champ est de`,
+        randTotal: () => randint(20, 400),
+    },
+];
+const getInstruction = (identifiers) => {
+    const { indexSituation, total, lefties, opts } = identifiers;
+    const situation = situations[indexSituation];
+    return `${situation.instruction(total, lefties)} 
+  
+Arrondir au centième de pourcent.
+${opts.isPercentSymbolRequired
+        ? `
+  
+Ne pas oublier le symbole $\\%$ à la fin.`
+        : ``}`;
+};
+const getHint = (identifiers) => {
+    const { indexSituation } = identifiers;
+    const situation = situations[indexSituation];
+    return situation.hint;
 };
 const getCorrection = (identifiers) => {
-    const { total, lefties } = identifiers;
+    const { indexSituation, total, lefties, opts } = identifiers;
+    const situation = situations[indexSituation];
     const frac = (100 * lefties) / total;
-    return `La proportion de gauchers en pourcentage dans ce lycée est de : 
+    return `On a : 
 
 $$
 \\frac{${lefties}}{${total}}\\times 100 ${approxOrEqual(frac, 2).join("")}
 $$
 
-Il y a donc $${getAnswer(identifiers)}$ de gauchers dans ce lycée.
-`;
+${situation.correction} $${getAnswer(identifiers)}$.
+${opts.isPercentSymbolRequired
+        ? `
+  
+Attention, ici le symbole "$\\%$" est requis à la fin.`
+        : ``}`;
 };
 const getAnswer = (identifiers) => {
     const { total, lefties } = identifiers;
     const answer = round((lefties / total) * 100, 2).frenchify() + "\\%";
     return answer;
 };
-const getFindProportionQuestion = () => {
-    const total = randint(120, 200);
-    const lefties = randint(30, 120);
-    const identifiers = { total, lefties };
-    return getQuestionFromIdentifiers(identifiers);
-};
-const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
-        keys: ["percent"],
-        answerFormat: "tex",
-        identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
-    };
-    return question;
-};
 const getPropositions = (n, { answer, total, lefties }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -64,32 +147,66 @@ const getPropositions = (n, { answer, total, lefties }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, lefties, total }) => {
+const isAnswerValid = (ans, { answer, opts }) => {
     try {
-        if (ans.includes("\\%")) {
-            return percentParser(ans) === answer;
-        }
-        const nb = ans.unfrenchify();
-        if (!isNaN(nb)) {
-            const value = answer.replace("\\%", "").unfrenchify();
-            return nb === value || nb === round(value / 100, 4);
+        if (opts.isPercentSymbolRequired) {
+            if (!ans.includes("\\%")) {
+                return false;
+            }
+            else {
+                return percentParser(ans) === answer;
+            }
         }
         else {
-            return rationalVEA(ans, frac(lefties, total).simplify().toTex());
+            const texs = [answer, answer.replace("\\%", "")];
+            return texs.includes(ans);
         }
     }
     catch (err) {
         return handleVEAError(err);
     }
-    const texs = [answer, answer.replace("\\%", "")];
-    return texs.includes(ans);
 };
+const getFindProportionQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const indexSituation = randint(0, situations.length);
+    const situation = situations[indexSituation];
+    const total = situation.randTotal();
+    const lefties = round(randfloat(0.1, 0.9) * total, 0);
+    return getQuestionFromIdentifiers({ indexSituation, total, lefties, opts });
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["percent"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    isPercentSymbolRequired: false,
+};
+const options = [
+    {
+        id: "isPercentSymbolRequired",
+        label: "Symbole pourcent requis",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        values: [false, true],
+        defaultValue: optsDefault.isPercentSymbolRequired,
+    },
+];
 export const findProportion = {
     id: "findProportion",
     connector: "=",
     label: "Calculer une proportion en pourcentage",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getFindProportionQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getFindProportionQuestion(opts), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

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

@@ -2,7 +2,11 @@ import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
     int: number;
     power: number;
+    opts: Options;
 };
-export declare const calculateNegativePower: Exercise<Identifiers>;
+type Options = {
+    isPowerAllowed: boolean;
+};
+export declare const calculateNegativePower: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=calculateNegativePower.d.ts.map

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,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA+GF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"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"}

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

@@ -1,23 +1,47 @@
-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 { randint } from "../../../math/utils/random/randint.js";
+import { isFunctionNode } from "../../../tree/nodes/functions/functionNode.js";
 import { isNumberNode, NumberNode, } from "../../../tree/nodes/numbers/numberNode.js";
 import { frac, isFractionNode, } from "../../../tree/nodes/operators/fractionNode.js";
+import { isOperatorNode, OperatorIds, } from "../../../tree/nodes/operators/operatorNode.js";
 import { PowerNode } from "../../../tree/nodes/operators/powerNode.js";
 import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const isNodeContainingOperatorId = (node, opId) => {
+    if (isFunctionNode(node)) {
+        return isNodeContainingOperatorId(node.child, opId);
+    }
+    else if (isOperatorNode(node)) {
+        if (node.id === opId) {
+            return true;
+        }
+        else {
+            return (isNodeContainingOperatorId(node.leftChild, opId) ||
+                isNodeContainingOperatorId(node.rightChild, opId));
+        }
+    }
+    else {
+        return false;
+    }
+};
 const getInstruction = (identifiers) => {
-    const { int, power } = identifiers;
+    const { int, power, opts } = 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 : 
 
 $$
 ${statement}
-$$`;
+$$
+
+${opts.isPowerAllowed
+        ? `La réponse pourra comporter un exposant.`
+        : `La réponse ne devra comporter aucun exposant.`}`;
 };
 const getAnswer = (identifiers) => {
-    const { int, power } = identifiers;
-    const fraction = frac(1, new PowerNode(int.toTree(), Math.abs(power).toTree()));
+    const { int, power, opts } = identifiers;
+    const powerNode = new PowerNode(int.toTree(), Math.abs(power).toTree());
+    const fraction = frac(1, opts.isPowerAllowed ? powerNode : powerNode.evaluate().toTree());
     const answer = fraction.simplify();
     return answer.toTex();
 };
@@ -29,32 +53,35 @@ a^{-x} = \\frac{1}{a^x}
 $$`;
 };
 const getCorrection = (identifiers) => {
-    const { int, power } = identifiers;
+    const { int, power, opts } = 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();
     return `Puisque $a^{-x} = \\frac{1}{a^x}$, on a : 
   
 $$
-${statement} = ${fraction.toSimplificationTex()}
-$$`;
-};
-const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
-        keys: [],
-        answerFormat: "tex",
-        identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
-    };
-    return question;
-};
-const getCalculatePowerQuestion = () => {
-    const int = randint(1, 11);
-    const power = randint(-5, 0);
-    const identifiers = { int, power };
-    return getQuestionFromIdentifiers(identifiers);
+${statement} = ${simplificationTex}
+$$
+
+${(() => {
+        if (!opts.isPowerAllowed) {
+            const fractionNoPower = frac(1, new PowerNode(int.toTree(), Math.abs(power).toTree()).evaluate().toTree());
+            const texNoPower = fractionNoPower.toTex();
+            return !simplificationTex.includes(texNoPower)
+                ? `
+
+$$
+${statement} = ${texNoPower}
+$$
+      
+`
+                : ``;
+        }
+        else {
+            return ``;
+        }
+    })()}
+`;
 };
 const getPropositions = (n, { answer, int, power }) => {
     const propositions = [];
@@ -78,10 +105,13 @@ const getPropositions = (n, { answer, int, power }) => {
     });
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, opts }) => {
     try {
         const parsed = parseAlgebraic(ans);
-        if (!isNumberNode(parsed) && !isFractionNode(parsed)) {
+        if (!isNumberNode(parsed) &&
+            !(isFractionNode(parsed) &&
+                (opts.isPowerAllowed ||
+                    !isNodeContainingOperatorId(parsed, OperatorIds.power)))) {
             return false;
         }
         return parsed.simplify().toTex() === answer;
@@ -90,12 +120,46 @@ const isAnswerValid = (ans, { answer }) => {
         return handleVEAError(err);
     }
 };
+const getCalculatePowerQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const int = randint(1, 11);
+    const power = randint(-5, 0);
+    const identifiers = { int, power, opts };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    isPowerAllowed: true,
+};
+const options = [
+    {
+        id: "isPowerAllowed",
+        label: "Exposant accepté dans la réponse",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        values: [true, false],
+        defaultValue: optsDefault.isPowerAllowed,
+    },
+];
 export const calculateNegativePower = {
     id: "calculateNegativePower",
     connector: "=",
     label: "Calculer une puissance négative",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getCalculatePowerQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculatePowerQuestion(opts), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

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

@@ -1 +1 @@
-{"version":3,"file":"probaFromTableNoContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableNoContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA2TF,KAAK,OAAO,GAAG;IAEb,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AAmBF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBlE,CAAC"}
+{"version":3,"file":"probaFromTableNoContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableNoContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA2TF,KAAK,OAAO,GAAG;IAEb,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AA+BF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBlE,CAAC"}

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

@@ -3,6 +3,7 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { Rational } from "../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
 import { rationalParser } from "../../../tree/parsers/rationalParser.js";
 import { random } from "../../../utils/alea/random.js";
 import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
@@ -248,12 +249,19 @@ const options = [
         type: GeneratorOptionType.checkbox,
     },
 ];
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
         const parsed = rationalParser(ans);
         if (!parsed)
             return false;
-        return parsed.simplify().toTex() === answer;
+        return (parsed.simplify().toTex() === answer ||
+            (() => {
+                const { probaFrac } = identifiers;
+                const answerNode = new Rational(probaFrac[0], probaFrac[1])
+                    .simplify()
+                    .toTree();
+                return substract(parsed.simplify(), answerNode).evaluate() === 0;
+            })());
     }
     catch (err) {
         return handleVEAError(err);

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

@@ -1 +1 @@
-{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAwRF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAkB3D,CAAC"}
+{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAyRF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAkB3D,CAAC"}

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

@@ -34,7 +34,8 @@ ${mdTable([
     ])}
 
 On choisit un élève au hasard. Quelle est la probabilité de tomber sur ${event} ?
-    `;
+    
+Donner la valeur exacte.`;
 };
 const getAnswer = (identifiers) => {
     const { probaFrac } = identifiers;

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

@@ -3,6 +3,9 @@ type Identifiers = {
     randomValues: number[];
     randomQuartile: number;
 };
-export declare const quartilesList: Exercise<Identifiers>;
+type Options = {
+    nbValues: number;
+};
+export declare const quartilesList: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=quartilesList.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"quartilesList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartilesList.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAeT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAgGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAc/C,CAAC"}
+{"version":3,"file":"quartilesList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartilesList.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,QAAQ,EAkBT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAyGF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAeF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBxD,CAAC"}

package/lib/exercises/math/probaStat/stats1var/quartilesList.js

@@ -2,7 +2,8 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { firstQuartile, thirdQuartile, } from "../../../../math/utils/stats/quartiles.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
-import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
+import { random } from "../../../../utils/alea/random.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
 import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
 const getInstruction = ({ randomQuartile, randomValues, }) => {
     let quartileToString = "";
@@ -15,7 +16,7 @@ $$
 ${randomValues.join(";\\ ")}
 $$
 
-Calculer le ${quartileToString} de cette série de valeurs.`;
+Calculer le ${quartileToString} de cette série de $${randomValues.length}$ valeurs.`;
 };
 const getAnswer = (identifiers) => {
     const { randomValues, randomQuartile } = identifiers;
@@ -24,18 +25,6 @@ const getAnswer = (identifiers) => {
     else
         return thirdQuartile(randomValues).frenchify();
 };
-const getQuartiles = () => {
-    const randomValues = [];
-    const length = randint(5, 9);
-    for (let i = 0; i < length; i++)
-        randomValues.push(randint(1, 20));
-    const randomQuartile = randint(0, 2);
-    const identifiers = {
-        randomValues: randomValues.sort((a, b) => a - b),
-        randomQuartile,
-    };
-    return getQuestionFromIdentifiers(identifiers);
-};
 const getHint = (identifiers) => {
     const { randomQuartile } = identifiers;
     if (randomQuartile === 0)
@@ -54,18 +43,6 @@ Puisque $${rank.toTex()} = ${rankEv.frenchify()}$, le ${numeral} quartile est la
 
 Le ${numeral} quartile est donc $${getAnswer(identifiers)}$.`;
 };
-const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
-        instruction: getInstruction(identifiers),
-        answer: getAnswer(identifiers),
-        keys: [],
-        answerFormat: "tex",
-        identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
-    };
-    return question;
-};
 const getPropositions = (n, { answer, randomValues }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -81,12 +58,54 @@ const getPropositions = (n, { answer, randomValues }) => {
 const isAnswerValid = (ans, { answer }) => {
     return ans === answer;
 };
+const getQuartiles = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const randomValues = [];
+    const length = Array.isArray(opts.nbValues)
+        ? random(opts.nbValues.map((v) => +v))
+        : opts.nbValues;
+    for (let i = 0; i < length; i++)
+        randomValues.push(randint(1, 20));
+    const randomQuartile = randint(0, 2);
+    const identifiers = {
+        randomValues: randomValues.sort((a, b) => a - b),
+        randomQuartile,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    nbValues: 12,
+};
+const options = [
+    {
+        id: "nbValues",
+        label: "Nombre de valeurs dans la liste",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [4, 5, 7, 8, 11, 12, 19, 20],
+        defaultValue: [optsDefault.nbValues],
+    },
+];
 export const quartilesList = {
     id: "quartilesList",
     connector: "=",
     label: "Calcul des quartiles d'une liste de valeurs",
     isSingleStep: false,
-    generator: (nb) => getDistinctQuestions(getQuartiles, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getQuartiles(opts ?? optsDefault), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormula.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAgHF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA8HF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}