math-exercises 3.0.124 → 3.0.126

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

@@ -32,7 +32,7 @@ $$
 1${isHausse ? "+" : "-"}\\frac{${Math.abs(evolution)}}{100} = ${CM}
 $$
 
-    `;
+`;
 };
 const getEvolutionToCmQuestion = () => {
     const evolution = randint(-99, 101, [0]);
@@ -43,7 +43,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: ["percent"],
+        keys: [],
         answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers),

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

@@ -1,8 +1,13 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
+    indexSituation: number;
     total: number;
     lefties: number;
+    opts: Options;
 };
-export declare const findProportion: Exercise<Identifiers>;
+type Options = {
+    isPercentSymbolRequired: boolean;
+};
+export declare const findProportion: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=findProportion.d.ts.map

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;AAWrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAgGF,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,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,OAAO,CAAC;CACf,CAAC;AAwNF,KAAK,OAAO,GAAG;IACb,uBAAuB,EAAE,OAAO,CAAC;CAClC,CAAC;AAeF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBzD,CAAC"}

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/basicProbas/index.d.ts

@@ -5,4 +5,5 @@ export * from "./getComplementaryProbability.js";
 export * from "./getMissingProbabilityValue.js";
 export * from "./mostLeastProbable.js";
 export * from "./rouletteProbas.js";
+export * from "./possibleValuesForProba.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/basicProbas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/probaStat/basicProbas/index.js

@@ -5,3 +5,4 @@ export * from "./getComplementaryProbability.js";
 export * from "./getMissingProbabilityValue.js";
 export * from "./mostLeastProbable.js";
 export * from "./rouletteProbas.js";
+export * from "./possibleValuesForProba.js";

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.d.ts

@@ -6,7 +6,6 @@ type Identifiers = {
 };
 type Options = {
     numberTypes: string[];
-    nbValues: number;
 };
 export declare const possibleValuesForProba: Exercise<Identifiers, Options>;
 export {};

package/lib/exercises/math/probaStat/basicProbas/possibleValuesForProba.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"possibleValuesForProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/possibleValuesForProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AAkHF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAgNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjE,CAAC"}
+{"version":3,"file":"possibleValuesForProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/possibleValuesForProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;IAClC,qBAAqB,EAAE,OAAO,CAAC;CAChC,CAAC;AA2EF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAwMF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjE,CAAC"}