math-exercises 3.0.130 → 3.0.132

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,

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

@@ -1,13 +1,20 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
-    aCapB: number;
-    aCapBBarre: number;
-    aBarreCapB: number;
-    aBarreCapBBarre: number;
+    indexSituation: number;
+    values: {
+        "A \\cap B": number;
+        "A \\cap \\overline{B}": number;
+        "\\overline{A} \\cap B": number;
+        "\\overline{A} \\cap \\overline{B}": number;
+    };
     event: string;
     type: string;
     probaFrac: number[];
+    allowedAnsType: string[];
 };
-export declare const probaFromTableWithContext: Exercise<Identifiers>;
+type Options = {
+    allowedAnsType: string[];
+};
+export declare const probaFromTableWithContext: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=probaFromTableWithContext.d.ts.map

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;AAyRF,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,EAmBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE;QACN,WAAW,EAAE,MAAM,CAAC;QACpB,uBAAuB,EAAE,MAAM,CAAC;QAChC,uBAAuB,EAAE,MAAM,CAAC;QAChC,mCAAmC,EAAE,MAAM,CAAC;KAC7C,CAAC;IACF,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAqpBF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAsBF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBpE,CAAC"}