math-exercises 3.0.173 → 3.0.175

package/lib/exercises/math/probaStat/trees/probabilityTree.js

@@ -0,0 +1,625 @@
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.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 { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.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 { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercise.js";
+import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
+const optionValues = [
+    "Probabilité d'intersection $P(A\\cap C)$",
+    "Probabilité totale $P(C)$",
+    "Probabilité conditionnelle $P_B(A)$",
+    "Probabilité 'simple' $P(A)$",
+    "Probabilité d'inversion de causalité $P_B(A)$",
+];
+const defaultOptionValues = [
+    "Probabilité d'intersection $P(A\\cap C)$",
+    "Probabilité totale $P(C)$",
+    "Probabilité conditionnelle $P_B(A)$",
+    "Probabilité 'simple' $P(A)$",
+];
+const getProbaType = (identifiers) => {
+    const { probaName } = identifiers;
+    return probaName.includes("\\cap")
+        ? "inter"
+        : ["P(C)", "P(D)"].includes(probaName)
+            ? "totale"
+            : ["P(A)", "P(B)"].includes(probaName)
+                ? "simple"
+                : ["P_A(C)", "P_A(D)", "P_B(C)", "P_B(D)"].includes(probaName)
+                    ? "conditionnelle"
+                    : "inversion";
+};
+const buildAll = (identifiers) => {
+    return {
+        pA: NodeConstructor.fromIdentifiers(identifiers.A),
+        pAC: NodeConstructor.fromIdentifiers(identifiers.AC),
+        pAD: NodeConstructor.fromIdentifiers(identifiers.AD),
+        pB: NodeConstructor.fromIdentifiers(identifiers.B),
+        pBC: NodeConstructor.fromIdentifiers(identifiers.BC),
+        pBD: NodeConstructor.fromIdentifiers(identifiers.BD),
+    };
+};
+const getAnswerNode = (identifiers) => {
+    const probas = buildAll(identifiers);
+    switch (identifiers.probaName) {
+        case "P(A)":
+            return probas.pA;
+        case "P(B)":
+            return probas.pB;
+        case "P(A\\cap C)":
+            return multiply(probas.pA, probas.pAC).simplify();
+        case "P(A\\cap D)":
+            return multiply(probas.pA, probas.pAD).simplify();
+        case "P(B\\cap C)":
+            return multiply(probas.pB, probas.pBC).simplify();
+        case "P(B\\cap D)":
+            return multiply(probas.pB, probas.pBD).simplify();
+        case "P_A(C)":
+            return probas.pAC;
+        case "P_A(D)":
+            return probas.pAD;
+        case "P_B(C)":
+            return probas.pBC;
+        case "P_B(D)":
+            return probas.pBD;
+        case "P(C)":
+            return add(multiply(probas.pA, probas.pAC), multiply(probas.pB, probas.pBC)).simplify();
+        case "P(D)":
+        default:
+            return add(multiply(probas.pA, probas.pAD), multiply(probas.pB, probas.pBD)).simplify();
+        case "P_C(A)": {
+            //anc / c
+            const pc = add(multiply(probas.pA, probas.pAC), multiply(probas.pB, probas.pBC)).simplify();
+            return frac(multiply(probas.pA, probas.pAC), pc).simplify();
+        }
+        case "P_C(B)": {
+            //cnb / c
+            const pc = add(multiply(probas.pA, probas.pAC), multiply(probas.pB, probas.pBC)).simplify();
+            return frac(multiply(probas.pB, probas.pBC), pc).simplify();
+        }
+        case "P_D(A)": {
+            //and / d
+            const pd = add(multiply(probas.pA, probas.pAD), multiply(probas.pB, probas.pBD)).simplify();
+            return frac(multiply(probas.pA, probas.pAD), pd).simplify();
+        }
+        case "P_D(B)": {
+            //cnb / c
+            const pd = add(multiply(probas.pA, probas.pAD), multiply(probas.pB, probas.pBD)).simplify();
+            return frac(multiply(probas.pB, probas.pBD), pd).simplify();
+        }
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getTrueProbaName = (identifiers) => {
+    const { probaName, useContraryNames } = identifiers;
+    if (!useContraryNames)
+        return probaName;
+    return probaName
+        .replaceAll("_B", "_{\\overline{A}}")
+        .replaceAll("B", "\\overline{A}")
+        .replaceAll("_D", "_{\\overline{B}}")
+        .replaceAll("C", "B")
+        .replaceAll("D", "\\overline{B}");
+};
+const getInstruction = (identifiers, options) => {
+    const probas = buildAll(identifiers);
+    const type = getProbaType(identifiers);
+    const { useContraryNames } = identifiers;
+    const trueProbaName = getTrueProbaName(identifiers);
+    const tree = [
+        [
+            [
+                [`£${probas.pA.toTex()}£`, "£A£"],
+                [
+                    `£${probas.pB.toTex()}£`,
+                    useContraryNames ? "£\\overline{A}£" : "£B£",
+                ],
+            ],
+        ],
+        [
+            [
+                [`£${probas.pAC.toTex()}£`, useContraryNames ? "£B£" : "£C£"],
+                [
+                    `£${probas.pAD.toTex()}£`,
+                    useContraryNames ? "£\\overline{B}£" : "£D£",
+                ],
+            ],
+            [
+                [`£${probas.pBC.toTex()}£`, useContraryNames ? "£B£" : "£C£"],
+                [
+                    `£${probas.pBD.toTex()}£`,
+                    useContraryNames ? "£\\overline{B}£" : "£D£",
+                ],
+            ],
+        ],
+    ];
+    let instr = `On considère l'arbre de probabilités ci-dessous :
+  
+<svg id="treeDiagram">${JSON.stringify(tree)}</svg>
+  
+${type === "conditionnelle" || type === "simple" ? "Déterminer :" : "Calculer :"} 
+  
+$$
+${trueProbaName}
+$$`;
+    if (options?.allowApproximate) {
+        instr += `
+
+Donner la valeur exacte ou une valeur arrondie au ${options.allowApproximate}.`;
+    }
+    return instr;
+};
+const getProbaAndOpposite = (decimal = false) => {
+    if (!decimal) {
+        const proba = RationalConstructor.randomIrreductibleProba().toTree();
+        return [proba, substract(1, proba).simplify()];
+    }
+    else {
+        const proba = round(randfloat(0.01, 1, 2), 2);
+        return [proba.toTree(), round(1 - proba, 2).toTree()];
+    }
+};
+const getStartStatement = (identifiers) => {
+    return getTrueProbaName(identifiers);
+};
+const getProbabilityTree = (opts) => {
+    const isDecimal = opts?.probaType === "Décimales";
+    const [pA, pB] = getProbaAndOpposite(isDecimal);
+    const [pCSachantA, pDSachantA] = getProbaAndOpposite(isDecimal);
+    const [pCSachantB, pDSachantB] = getProbaAndOpposite(isDecimal);
+    const eventTypes = opts?.eventTypes?.length
+        ? opts.eventTypes
+        : defaultOptionValues;
+    const type = random(eventTypes);
+    const index = optionValues.indexOf(type);
+    let probaName = "";
+    switch (index) {
+        case 0: //inter
+            probaName = random([
+                "P(A\\cap C)",
+                "P(A\\cap D)",
+                "P(B\\cap C)",
+                "P(B\\cap D)",
+            ]);
+            break;
+        case 1: //totale
+            probaName = random(["P(C)", "P(D)"]);
+            break;
+        case 2: //conditionnal
+            probaName = random(["P_A(C)", "P_A(D)", "P_B(C)", "P_B(D)"]);
+            break;
+        case 3: //simple
+            probaName = random(["P(A)", "P(B)"]);
+            break;
+        case 4: //inversion
+            probaName = random(["P_C(A)", "P_D(A)", "P_C(B)", "P_D(B)"]);
+            break;
+    }
+    const identifiers = {
+        A: pA.toIdentifiers(),
+        B: pB.toIdentifiers(),
+        AC: pCSachantA.toIdentifiers(),
+        AD: pDSachantA.toIdentifiers(),
+        BC: pCSachantB.toIdentifiers(),
+        BD: pDSachantB.toIdentifiers(),
+        probaName,
+        useContraryNames: opts?.eventsNames === "Événements et leur contraire",
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getHint = (identifiers) => {
+    const { probaName, useContraryNames } = identifiers;
+    const type = getProbaType(identifiers);
+    const trueProbaName = getTrueProbaName(identifiers);
+    switch (type) {
+        case "conditionnelle": {
+            const splitted = probaName
+                .replaceAll("(", "")
+                .replaceAll(")", "")
+                .split("_")[1];
+            const under = splitted[0];
+            const trueUnder = useContraryNames && under === "B" ? "\\overline{A}" : under;
+            const over = splitted[1];
+            const trueOver = useContraryNames
+                ? over === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : over;
+            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
+
+Dans l'arbre, elle se lit sur la branche partant de $${trueUnder}$ et allant jusqu'à $${trueOver}$.`;
+        }
+        case "inter": {
+            const [first, second] = probaName
+                .replaceAll("P(", "")
+                .replaceAll(")", "")
+                .split("\\cap ");
+            const trueFirst = useContraryNames && first === "B" ? "\\overline{A}" : first;
+            const trueSecond = useContraryNames
+                ? second === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : second;
+            return `La probabilité $${trueProbaName}$ est la probabilité d'une intersection. 
+      
+Pour la calculer, il faut multiplier les probabilités présentes sur les branches suivant le chemin $${trueFirst}$ puis $${trueSecond}$.
+`;
+        }
+        case "totale": {
+            const evenement = probaName[2];
+            const trueEvenement = useContraryNames
+                ? evenement === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : evenement;
+            return `Il y a plusieurs chemins qui mènent à l'événement $${trueEvenement}$. Sa probabilité est la somme des probabilités de chacun de ces chemins. Pour obtenir la probabilité d'un chemin, il faut multiplier les probabilités présentes sur les branches de ce chemin.`;
+        }
+        case "simple": {
+            const trueEvent = useContraryNames && probaName[2] === "B"
+                ? "\\overline{A}"
+                : probaName[2];
+            return `La probabilité $${trueProbaName}$ se lit sur la branche menant à l'événement $${trueEvent}$.`;
+        }
+        case "inversion": {
+            const splitted = probaName
+                .replaceAll("(", "")
+                .replaceAll(")", "")
+                .split("_")[1];
+            const under = splitted[0];
+            const trueUnder = useContraryNames
+                ? under === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : under;
+            const over = splitted[1];
+            const trueOver = useContraryNames && over === "B" ? "\\overline{A}" : over;
+            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
+
+Pour la déterminer, tu peux revenir à la définition d'une probabilité conditionnelle : pour deux évenements $M$ et $N$, on a : 
+
+$$
+P_M(N) = \\frac{P(M \\cap N)}{P(M)}
+$$
+`;
+        }
+    }
+};
+const getCorrection = (identifiers) => {
+    const { probaName } = identifiers;
+    const probas = buildAll(identifiers);
+    const type = getProbaType(identifiers);
+    const trueProbaName = getTrueProbaName(identifiers);
+    const { useContraryNames } = identifiers;
+    switch (type) {
+        case "conditionnelle": {
+            const splitted = probaName
+                .replaceAll("(", "")
+                .replaceAll(")", "")
+                .split("_")[1];
+            const under = splitted[0];
+            const trueUnder = useContraryNames && under === "B" ? "\\overline{A}" : under;
+            const over = splitted[1];
+            const trueOver = useContraryNames
+                ? over === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : over;
+            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
+
+Dans l'arbre, elle se lit sur la branche partant de $${trueUnder}$ et allant jusqu'à $${trueOver}$.
+
+On a donc : 
+
+$$
+${trueProbaName} = ${getAnswer(identifiers)}
+$$`;
+        }
+        case "inter": {
+            const [first, second] = probaName
+                .replaceAll("P(", "")
+                .replaceAll(")", "")
+                .split("\\cap ");
+            const firstProba = first === "A" ? probas.pA : probas.pB;
+            const secondProba = second === "C"
+                ? first === "A"
+                    ? probas.pAC
+                    : probas.pBC
+                : first === "A"
+                    ? probas.pAD
+                    : probas.pBD;
+            const trueFirst = useContraryNames && first === "B" ? "\\overline{A}" : first;
+            const secondFirst = useContraryNames
+                ? second === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : second;
+            return `La probabilité $${trueProbaName}$ est la probabilité d'une intersection. 
+      
+Pour la calculer, il faut multiplier les probabilités présentes sur les branches suivant le chemin $${trueFirst}$ puis $${secondFirst}$. 
+
+On a donc : 
+
+$$
+${trueProbaName} = ${multiply(firstProba, secondProba).toSimplificationTex()}
+$$
+`;
+        }
+        case "totale": {
+            const evenement = probaName[2];
+            const trueEvenement = useContraryNames
+                ? evenement === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : evenement;
+            const first = evenement === "C" ? probas.pAC : probas.pAD;
+            const second = evenement === "C" ? probas.pBC : probas.pBD;
+            const firstWay = multiply(probas.pA, first);
+            const secondWay = multiply(probas.pB, second);
+            return `Il y a plusieurs chemins qui mènent à l'événement $${trueEvenement}$ : le chemin de l'intersection $A\\cap ${trueEvenement}$ et celui de l'intersection $${useContraryNames ? "\\overline{A}" : "B"}\\cap ${trueEvenement}$. La probabilité $${trueProbaName}$ est la somme des probabilités de ces chemins.
+
+On a : 
+
+$$
+P(A\\cap ${trueEvenement}) = ${firstWay.toSimplificationTex()}
+$$
+
+et
+
+$$
+P(${useContraryNames ? "\\overline{A}" : "B"}\\cap ${trueEvenement}) = ${secondWay.toSimplificationTex()}
+$$
+
+Donc : 
+
+$$
+${trueProbaName} = ${add(firstWay.simplify(), secondWay.simplify()).toSimplificationTex()}
+$$      
+`;
+        }
+        case "simple": {
+            const trueEvent = useContraryNames && probaName[2] === "B"
+                ? "\\overline{A}"
+                : probaName[2];
+            return `La probabilité $${trueProbaName}$ se lit sur la branche menant à l'événement $${trueEvent}$.
+      
+On a donc : 
+
+$$
+${trueProbaName} = ${getAnswer(identifiers)}
+$$`;
+        }
+        case "inversion": {
+            const splitted = probaName
+                .replaceAll("(", "")
+                .replaceAll(")", "")
+                .split("_")[1];
+            const under = splitted[0];
+            const trueUnder = useContraryNames
+                ? under === "C"
+                    ? "B"
+                    : "\\overline{B}"
+                : under;
+            const over = splitted[1];
+            const trueOver = useContraryNames && over === "B" ? "\\overline{A}" : over;
+            const total = add(multiply(probas.pA, under === "C" ? probas.pAC : probas.pAD), multiply(probas.pB, under === "C" ? probas.pBC : probas.pBD));
+            const inter = multiply(over === "A" ? probas.pA : probas.pB, under === "C"
+                ? over === "A"
+                    ? probas.pAC
+                    : probas.pBC
+                : over === "A"
+                    ? probas.pAD
+                    : probas.pBD);
+            return `La probabilité $${trueProbaName}$ est la probabilité de $${trueOver}$ sachant $${trueUnder}$.
+
+Pour la déterminer, on revient à la définition d'une probabilité conditionnelle : 
+
+$$
+${trueProbaName} = \\frac{P(${trueOver} \\cap ${trueUnder})}{P(${trueUnder})}
+$$
+
+On calcule donc d'abord $P(${trueOver} \\cap ${trueUnder})$ :
+
+$$
+P(${trueOver} \\cap ${trueUnder}) = ${inter.toSimplificationTex()}
+$$
+
+Puis on calcule la probabilité totale $P(${trueUnder})$ :
+
+$$
+P(${trueUnder})=${total.toSimplificationTex()}
+$$
+
+On a donc : 
+
+$$
+${trueProbaName} = ${frac(inter.simplify(), total.simplify()).toSimplificationTex()}
+$$
+`;
+        }
+    }
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const answerNode = getAnswerNode(identifiers);
+    propWhile(propositions, n, () => {
+        const wrongAnswer = multiply(answerNode, randint(2, 11)).simplify();
+        tryToAddWrongProp(propositions, wrongAnswer.toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }, opts) => {
+    try {
+        const rank = opts?.allowApproximate
+            ? ["dixième", "centième", "millième"].indexOf(opts.allowApproximate) + 1
+            : undefined;
+        return rationalVEA(ans, answer, {
+            allowNonIrreductible: true,
+            allowDecimal: true,
+            decimalPrecision: rank,
+        });
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const options = [
+    {
+        id: "allowApproximate",
+        label: "Autoriser les valeurs approchées au : ",
+        target: GeneratorOptionTarget.vea,
+        type: GeneratorOptionType.select,
+        defaultValue: "centième",
+        values: ["dixième", "centième", "millième"],
+    },
+    {
+        id: "eventTypes",
+        label: "Types de questions",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: defaultOptionValues,
+        values: optionValues,
+    },
+    {
+        id: "probaType",
+        label: "Format des probabilités",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        defaultValue: "Fractions",
+        values: ["Fractions", "Décimales"],
+    },
+    {
+        id: "eventsNames",
+        label: "Noms des événements",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        defaultValue: "Événements et leur contraire",
+        values: [
+            "Événements et leur contraire",
+            "Noms d'événements tous différents",
+        ],
+    },
+];
+const partialOptions = options.filter((p) => p.id !== "eventTypes");
+export const probabilityTree = {
+    id: "probabilityTree",
+    connector: "=",
+    label: "Calculer une probabilité dans un arbre pondéré (tous calculs)",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    options,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const probabilityTreeIntersection = {
+    id: "probabilityTreeIntersection",
+    connector: "=",
+    label: "Calculer une intersection dans un arbre pondéré",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
+        eventTypes: ["Probabilité d'intersection $P(A\\cap C)$"],
+        allowApproximate: opts?.allowApproximate,
+        probaType: opts?.probaType,
+        eventsNames: opts?.eventsNames,
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    options: partialOptions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const probabilityTreeTotalProbability = {
+    id: "probabilityTreeTotalProbability",
+    connector: "=",
+    label: "Calculer une probabilité totale dans un arbre pondéré",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
+        eventTypes: ["Probabilité totale $P(C)$"],
+        allowApproximate: opts?.allowApproximate,
+        probaType: opts?.probaType,
+        eventsNames: opts?.eventsNames,
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    options: partialOptions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const probabilityTreeReadProbability = {
+    id: "probabilityTreeReadProbability",
+    connector: "=",
+    label: "Lire une probabilité dans un arbre pondéré",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
+        eventTypes: [
+            "Probabilité conditionnelle $P_B(A)$",
+            "Probabilité 'simple' $P(A)$",
+        ],
+        allowApproximate: opts?.allowApproximate,
+        probaType: opts?.probaType,
+        eventsNames: opts?.eventsNames,
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    options: partialOptions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};
+export const probabilityTreeInversionProbability = {
+    id: "probabilityTreeInversionProbability",
+    connector: "=",
+    label: "Calculer une probabilité d'inversion de causalité du type $P_B(A)$ dans un arbre pondéré",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbabilityTree({
+        eventTypes: ["Probabilité d'inversion de causalité $P_B(A)$"],
+        allowApproximate: opts?.allowApproximate,
+        probaType: opts?.probaType,
+        eventsNames: opts?.eventsNames,
+    }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    options: partialOptions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/trees/treeInAnswer.d.ts

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

package/lib/exercises/math/probaStat/trees/treeInAnswer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"treeInAnswer.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/treeInAnswer.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;AAElC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,WAAW,CAAC;IACtB,UAAU,EAAE,WAAW,CAAC;CACzB,CAAC;AAyGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAgB9C,CAAC"}