math-exercises 3.0.150 → 3.0.152

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    xValues: number[];
+    yValues: NodeIdentifiers[];
+    atLeastXIndex: number;
+};
+export declare const calculateProbaFromProbaLaw: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=calculateProbaFromProbaLaw.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"calculateProbaFromProbaLaw.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/calculateProbaFromProbaLaw.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAoIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}

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

@@ -0,0 +1,135 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.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 { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getAnswer = (identifiers) => {
+    const { yValues, atLeastXIndex } = identifiers;
+    return operatorComposition(AddNode, yValues.slice(atLeastXIndex).map((e) => reifyAlgebraic(e)))
+        .simplify()
+        .toTex();
+};
+const getPropositions = (n, { answer, xValues, yValues }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    for (let i = 1; i < xValues.length; i++) {
+        tryToAddWrongProp(propositions, getAnswer({
+            xValues,
+            yValues,
+            atLeastXIndex: i,
+        }));
+    }
+    return shuffleProps(propositions, n);
+};
+const getInstruction = (identifiers) => {
+    const { xValues, yValues, atLeastXIndex } = identifiers;
+    const ys = yValues.map((n) => reifyAlgebraic(n).toTex());
+    const x = xValues[atLeastXIndex];
+    return `Lors d'un jeu de grattage, on observe le gain obtenu. À chaque gain est associé la probabilité suivante : 
+  
+${mdTable([
+        ["Gain (en €)", ...xValues.map((x) => `$${x.frenchify()}$`)],
+        ["Probabilité", ...ys.map((y) => `$${y}$`)],
+    ])}
+
+Quelle est la probabilité de gagner au moins $${x}€$ ?
+`;
+};
+const getHint = (identifiers) => {
+    const { xValues, atLeastXIndex } = identifiers;
+    const x = xValues[atLeastXIndex];
+    return `Pour gagner au moins $${x}€$, on peut gagner ${xValues
+        .slice(atLeastXIndex)
+        .map((x) => `soit $${x.frenchify()}€$`)
+        .join(", ")}. 
+  
+Il suffit alors d'additionner les probabilités correspondantes.`;
+};
+const getCorrection = (identifiers) => {
+    const { xValues, yValues, atLeastXIndex } = identifiers;
+    const x = xValues[atLeastXIndex];
+    const answer = getAnswer(identifiers);
+    return `On additionne les probabilités des gains supérieurs ou égaux à $${x}€$ : 
+  
+$$
+${operatorComposition(AddNode, yValues.slice(atLeastXIndex).map((y) => reifyAlgebraic(y))).toTex()} = ${answer}
+$$
+
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCalculateProbaFromProbaLawQuestion = () => {
+    const xValues = [
+        0,
+        randint(1, 5),
+        randint(5, 10),
+        5 * randint(10, 20),
+        100 * randint(1, 10),
+    ];
+    const probas = [
+        randfloat(0.1, 0.3, 2),
+        randfloat(0.02, 0.04, 3),
+        randfloat(0.01, 0.02, 3),
+        randfloat(0.001, 0.009, 3),
+    ];
+    const left = round(1 - probas.reduce((acc, curr) => acc + curr, 0), 4);
+    probas.unshift(left);
+    const identifiers = {
+        xValues,
+        yValues: probas.map((e) => e.toTree().toIdentifiers()),
+        atLeastXIndex: randint(1, 4),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
+        },
+    };
+};
+export const calculateProbaFromProbaLaw = {
+    id: "calculateProbaFromProbaLaw",
+    connector: "=",
+    label: "Calculer la probabilité de gagner au moins $x$ euros dans un jeu de grattage",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateProbaFromProbaLawQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    proba: NodeIdentifiers;
+    knownEffectif: number;
+};
+export declare const findEffectifFromProba: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findEffectifFromProba.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findEffectifFromProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/findEffectifFromProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAoGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}

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

@@ -0,0 +1,109 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.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 { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, Math.max(0, Number(answer) + randint(-5, 10, [0])).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { knownEffectif, proba } = identifiers;
+    const probaNode = reifyAlgebraic(proba);
+    return substract(frac(knownEffectif, probaNode), knownEffectif)
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { knownEffectif, proba } = identifiers;
+    return `Dans un sac, il y a $${knownEffectif}$ jetons jaunes, et un nombre inconnu de jetons rouges. On tire un jeton au hasard dans le sac et on note sa couleur. Après plusieurs essais, on estime que la probabilité d'obtenir un jeton jaune est de $${reifyAlgebraic(proba).toTex()}$. 
+
+Combien il y a t il de jetons rouges dans le sac ?`;
+};
+const getHint = () => {
+    return `Cherche d'abord le nombre total de jetons dans le sac. Pour cela, utilise le fait que la probabilité d'obtenir un jeton jaune est égale au nombre de jetons jaunes divisé par le nombre total de jetons.`;
+};
+const getCorrection = (identifiers) => {
+    const { knownEffectif, proba } = identifiers;
+    const probaNode = reifyAlgebraic(proba);
+    const N = frac(knownEffectif, probaNode).simplify();
+    return `On détermine le nombre total de jetons dans le sac. On sait que la probabilité d'obtenir un jeton jaune est égale au nombre de jetons jaunes divisé par le nombre total de jetons. 
+  
+Si on note $N$ le nombre total de jetons, on a donc : 
+
+$$
+${frac(knownEffectif, "N").toTex()} = ${probaNode.toTex()}.
+$$
+
+d'où : 
+
+$$
+N = ${frac(knownEffectif, probaNode).toSimplificationTex()}
+$$
+
+Puisqu'il y a $${knownEffectif}$ jetons jaunes dans le sac, il y a donc : 
+
+$$
+${substract(N, knownEffectif).toSimplificationTex()}
+$$
+
+jetons rouges.`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindEffectifFromProbaQuestion = () => {
+    const proba = RationalConstructor.randomIrreductibleProba().toTree();
+    const knownEffectif = multiply(proba, proba.rightChild.evaluate() * randint(2, 11)).simplify();
+    const identifiers = {
+        knownEffectif: knownEffectif.evaluate(),
+        proba: proba.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const findEffectifFromProba = {
+    id: "findEffectifFromProba",
+    connector: "=",
+    label: "Utiliser une probabilité pour retrouver un effectif",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindEffectifFromProbaQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"getMissingProbabilityValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/getMissingProbabilityValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAiHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}
+{"version":3,"file":"getMissingProbabilityValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/getMissingProbabilityValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAwHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}

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

@@ -89,6 +89,13 @@ const getQuestionFromIdentifiers = (identifiers) => ({
     identifiers,
     hint: getHint(identifiers),
     correction: getCorrection(identifiers),
+    style: {
+        tableOptions: {
+            firstColumnIsHeader: true,
+            firstCellIsDivided: false,
+            firstRowIsHeader: false,
+        },
+    },
 });
 export const getMissingProbabilityValue = {
     id: "getMissingProbabilityValue",

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    labels: string[];
+    pValues: number[];
+    missingIndex: number;
+};
+export declare const getMissingProbabilityValueMiddleSchool: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=getMissingProbabilityValueMiddleSchool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getMissingProbabilityValueMiddleSchool.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/getMissingProbabilityValueMiddleSchool.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AA4HF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAoBxE,CAAC"}

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

@@ -0,0 +1,120 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+const getPropositions = (n, { answer }) => {
+    const props = [];
+    addValidProp(props, answer);
+    propWhile(props, n, () => {
+        const numeric = answer.unfrenchify();
+        const offset = randfloat(-0.2, 0.2, 2);
+        const candidate = round(numeric + offset, 2).frenchify();
+        tryToAddWrongProp(props, candidate);
+    });
+    return shuffleProps(props, n);
+};
+const getAnswer = ({ pValues, missingIndex }) => {
+    return pValues[missingIndex].frenchify();
+};
+const getInstruction = ({ labels, pValues, missingIndex, }) => {
+    return `Un sac contient des jetons. Chaque jeton est rouge ou vert ou bleu. On tire un jeton au hasard et on regarde sa couleur.
+
+On a les informations suivantes :
+
+${mdTable([
+        ["Issue", ...labels.map((l) => dollarize(l))],
+        [
+            "Probabilité",
+            ...pValues.map((p, i) => i === missingIndex ? "..." : dollarize(p.frenchify())),
+        ],
+    ])}
+
+Quelle est la probabilité manquante ?`;
+};
+const getHint = () => {
+    return `La somme des probabilités des issues élémentaires est égale à $1$.`;
+};
+const getCorrection = ({ labels, pValues, missingIndex, }) => {
+    const knownTerms = labels
+        .map((_l, i) => (i === missingIndex ? null : pValues[i].frenchify()))
+        .filter(Boolean)
+        .join("+");
+    const sumKnown = round(pValues.filter((_, i) => i !== missingIndex).reduce((s, v) => s + v, 0), 2);
+    const missing = round(1 - sumKnown, 2);
+    return `
+On additionne les probabilités connues :
+
+$$
+${knownTerms} = ${sumKnown.frenchify()}
+$$
+
+Puisque la somme des probabilités des issues élémentaires vaut $1$, on peut en déduire la probabilité manquante : 
+
+
+$$
+P(${labels[missingIndex]}) = 1 - ${sumKnown.frenchify()} = ${missing.frenchify()}
+$$
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const a = parseAlgebraic(ans);
+        const b = parseAlgebraic(answer);
+        return a.simplify().equals(b.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getMissingProbabilityValueMiddleSchoolQuestion = () => {
+    const labels = ["rouge", "vert", "bleu"];
+    const raw = labels.map(() => Math.random());
+    const total = raw.reduce((s, v) => s + v, 0);
+    const pValues = raw.map((v) => round(v / total, 2));
+    // ajustement pour que la somme fasse exactement 1
+    const sumRounded = pValues.reduce((s, v) => s + v, 0);
+    const diff = round(1 - sumRounded, 2);
+    pValues[pValues.length - 1] = round(pValues[pValues.length - 1] + diff, 2);
+    const missingIndex = Math.floor(Math.random() * labels.length);
+    return getQuestionFromIdentifiers({ labels, pValues, missingIndex });
+};
+const getQuestionFromIdentifiers = (identifiers) => ({
+    answer: getAnswer(identifiers),
+    instruction: getInstruction(identifiers),
+    keys: getKeys(identifiers),
+    answerFormat: "tex",
+    identifiers,
+    hint: getHint(identifiers),
+    correction: getCorrection(identifiers),
+    style: {
+        tableOptions: {
+            firstColumnIsHeader: true,
+            firstCellIsDivided: false,
+            firstRowIsHeader: false,
+        },
+    },
+});
+export const getMissingProbabilityValueMiddleSchool = {
+    id: "getMissingProbabilityValueMiddleSchool",
+    label: "Déterminer la probabilité manquante",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMissingProbabilityValueMiddleSchoolQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -7,4 +7,8 @@ export * from "./mostLeastProbable.js";
 export * from "./rouletteProbas.js";
 export * from "./possibleValuesForProba.js";
 export * from "./rangeBasicProbas.js";
+export * from "./pickEquiprobableTo.js";
+export * from "./getMissingProbabilityValueMiddleSchool.js";
+export * from "./findEffectifFromProba.js";
+export * from "./calculateProbaFromProbaLaw.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;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,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;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC"}

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

@@ -7,3 +7,7 @@ export * from "./mostLeastProbable.js";
 export * from "./rouletteProbas.js";
 export * from "./possibleValuesForProba.js";
 export * from "./rangeBasicProbas.js";
+export * from "./pickEquiprobableTo.js";
+export * from "./getMissingProbabilityValueMiddleSchool.js";
+export * from "./findEffectifFromProba.js";
+export * from "./calculateProbaFromProbaLaw.js";

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type WheelItem = {
+    value: number;
+    indexColor: number;
+};
+type Identifiers = {
+    arrItem: WheelItem[];
+    typeAsked: string;
+};
+export declare const pickEquiprobableTo: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pickEquiprobableTo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pickEquiprobableTo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/pickEquiprobableTo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAqKrC,KAAK,SAAS,GAAG;IACf,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAgIF,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA2NF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAmBpD,CAAC"}