math-exercises 3.0.125 → 3.0.127

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

@@ -1,4 +1,4 @@
-import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
@@ -13,93 +13,70 @@ import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
-import { parseLatex } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { probaFlip } from "../../../../utils/alea/probaFlip.js";
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getAnswer = (identifiers) => {
-    const { arrayOfNodeIds, isFilterPossibleProba } = identifiers;
-    const arrayOfPossibleProbas = arrayOfNodeIds
-        .map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds))
-        .filter((node) => {
-        return isFilterPossibleProba
-            ? node.evaluate() >= 0 && substract(node, 1).evaluate() <= 0
-            : node.evaluate() < 0 || substract(node, 1).evaluate() > 0;
-    })
-        .toSorted((nodeA, nodeB) => substract(nodeA, nodeB).evaluate());
-    const answer = arrayOfPossibleProbas.map((node) => node.toTex()).join(";");
-    return answer;
-};
 const getInstruction = (identifiers) => {
-    const { arrayOfNodeIds, isFilterPossibleProba } = identifiers;
-    const arrNode = arrayOfNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
-    return `Parmi les valeurs de la liste ci-dessous, donner celles qui sont des valeurs ${isFilterPossibleProba ? "possibles" : "impossibles"} pour une probabilité
-(séparer les valeurs par des points-virgules) : 
-$$
-${arrNode.map((node) => node.toTex()).join(" \\hspace{2mm} ; \\hspace{2mm} ")}
-$$
-`;
+    const { isFilterPossibleProba } = identifiers;
+    return `Parmi les valeurs de la liste ci-dessous, donner celles qui sont des valeurs ${isFilterPossibleProba ? "**possibles**" : "**impossibles**"} pour une probabilité.`;
 };
 const getHint = () => {
-    return "Une probabilité est toujours comprise entre $0\\%$ et $100\\%$.";
+    return "Une probabilité est un nombre compris entre $0$ et $1$.";
 };
 const getCorrection = (identifiers) => {
+    const { arrayOfNodeIds, isFilterPossibleProba } = identifiers;
+    const allAnswerTexs = arrayOfNodeIds
+        .map((nodeIds) => {
+        const node = NodeConstructor.fromIdentifiers(nodeIds);
+        const isPossibleProba = node.evaluate() >= 0 && substract(node, 1).evaluate() <= 0;
+        return { tex: node.toTex(), isPossibleProba };
+    })
+        .filter(({ isPossibleProba }) => isPossibleProba === isFilterPossibleProba)
+        .map(({ tex }) => tex);
     return `Les valeurs possibles pour une probabilité sont comprises entre $0$ inclus et $1$ inclus.
-La liste à constituer était donc : 
+${allAnswerTexs.length > 1
+        ? `Les réponses attendues (valeurs ${isFilterPossibleProba ? `possibles` : `impossibles`}) étaient`
+        : `La réponse attendue (valeur ${isFilterPossibleProba ? `possible` : `impossible`}) était`} donc : 
 
+${allAnswerTexs
+        .map((tex) => `
+  
 $$
-${getAnswer(identifiers)}
+${tex}
 $$
-`;
+
+`)
+        .join("")}`;
 };
-const getPropositions = (n, { answer, ...identifiers }) => {
+const getPropositions = (_, { answer, ...identifiers }) => {
     const { arrayOfNodeIds, isFilterPossibleProba } = identifiers;
     const propositions = [];
     // addValidProp(propositions, answer);
-    const allProbas = arrayOfNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
-    const possibleNodes = allProbas.filter((node) => node.evaluate() >= 0 && substract(node, 1).evaluate() <= 0);
-    const impossibleNodes = allProbas.filter((node) => node.evaluate() < 0 || substract(node, 1).evaluate() > 0);
-    const validNodes = isFilterPossibleProba ? possibleNodes : impossibleNodes;
-    //we keep the order of the question
-    addValidProp(propositions, validNodes.map((node) => node.toTex()).join(" ; "));
-    while (propositions.length < n) {
-        const pickedNodes = allProbas.filter(coinFlip);
-        tryToAddWrongProp(propositions, pickedNodes.map((node) => node.toTex()).join(" ; "));
-    }
-    return shuffleProps(propositions, n);
-};
-const isAnswerValid = (ans, { answer }) => {
-    const ansWithoutTrailingSemicolon = ans.slice(-1) === ";" ? ans.slice(0, -1) : ans;
-    const arrTex = ansWithoutTrailingSemicolon.split(";");
-    const arrNode = arrTex
-        .map((tex) => parseLatex(tex))
-        .toSorted((nodeA, nodeB) => substract(nodeA, nodeB).evaluate());
-    const arrTexSorted = arrNode.map((node) => node.toTex());
-    const ansRefined = arrTexSorted.join(";");
-    return ansRefined === answer;
-};
-const getKeys = (identifiers) => {
-    const { arrayOfNodeIds } = identifiers;
-    const arrNode = arrayOfNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
-    return [
-        "semicolon",
-        ...arrNode.map((node) => {
-            return {
-                id: "custom",
-                label: node.toTex(),
-                labelType: "tex",
-                mathfieldInstructions: {
-                    method: "write",
-                    content: node.toTex(),
-                },
-            };
-        }),
-    ];
+    const allProbasObj = arrayOfNodeIds.map((nodeIds) => {
+        const node = NodeConstructor.fromIdentifiers(nodeIds);
+        const isPossibleProba = node.evaluate() >= 0 && substract(node, 1).evaluate() <= 0;
+        return { tex: node.toTex(), isPossibleProba };
+    });
+    allProbasObj.forEach(({ tex, isPossibleProba }) => {
+        if (isPossibleProba === isFilterPossibleProba) {
+            addValidProp(propositions, tex);
+        }
+        else {
+            tryToAddWrongProp(propositions, tex);
+        }
+    });
+    return propositions;
 };
 const optsDefault = {
-    numberTypes: ["Entier", "Décimal", "Fraction", "Puiss10", "Sci", "Réel"],
-    nbValues: 8,
+    numberTypes: [
+        "Entier",
+        "Décimal",
+        "Fraction",
+        "Puissance de 10",
+        "Écriture scientifique",
+        "Réel",
+    ],
 };
 const options = [
     {
@@ -107,17 +84,16 @@ const options = [
         label: "Types de nombres",
         type: GeneratorOptionType.multiselect,
         target: GeneratorOptionTarget.generation,
-        values: ["Entier", "Décimal", "Fraction", "Puiss10", "Sci", "Réel"],
+        values: [
+            "Entier",
+            "Décimal",
+            "Fraction",
+            "Puissance de 10",
+            "Écriture scientifique",
+            "Réel",
+        ],
         defaultValue: optsDefault.numberTypes,
     },
-    {
-        id: "nbValues",
-        label: "Longueur de la liste",
-        type: GeneratorOptionType.select,
-        target: GeneratorOptionTarget.generation,
-        values: [5, 6, 7, 8, 9, 10],
-        defaultValue: optsDefault.nbValues,
-    },
 ];
 const createRandomNode = (numberType, isPossibleProba) => {
     if (isPossibleProba) {
@@ -136,9 +112,9 @@ const createRandomNode = (numberType, isPossibleProba) => {
                     return frac(num, den);
                 }
             }
-            case "Puiss10":
+            case "Puissance de 10":
                 return power(10, randint(-15, 1));
-            case "Sci":
+            case "Écriture scientifique":
                 if (probaFlip(0.7)) {
                     return multiply(randfloat(1, 10, randint(1, 5)), power(10, randint(-15, 0)));
                 }
@@ -180,9 +156,9 @@ const createRandomNode = (numberType, isPossibleProba) => {
                     return frac(num, den);
                 }
             }
-            case "Puiss10":
+            case "Puissance de 10":
                 return power(10, randint(1, 15));
-            case "Sci":
+            case "Écriture scientifique":
                 if (probaFlip(0.7)) {
                     return coinFlip()
                         ? multiply(randfloat(1, 10, randint(1, 5), [1]), power(10, randint(0, 15)))
@@ -208,22 +184,24 @@ const createRandomNode = (numberType, isPossibleProba) => {
 };
 const getPossibleValuesForProbaQuestion = (optsIn) => {
     const opts = Object.assign(optsDefault, optsIn) ?? optsDefault;
+    const nbPropositions = 4;
     const isFilterPossibleProba = coinFlip();
     //create numberType list
     const dictNumberTypeToPriority = {
         Entier: 1,
-        Puiss10: 2,
+        "Puissance de 10": 2,
         Décimal: 3,
         Fraction: 4,
         Réel: 5,
+        "Écriture scientifique": 6,
     };
     let arrNumberType = [...opts.numberTypes];
     //filler
-    while (arrNumberType.length < opts.nbValues) {
+    while (arrNumberType.length < nbPropositions) {
         arrNumberType.push(...shuffle(opts.numberTypes));
     }
     arrNumberType = arrNumberType
-        .slice(0, opts.nbValues)
+        .slice(0, nbPropositions)
         .toSorted((numberType1, numberType2) => dictNumberTypeToPriority[numberType1] -
         dictNumberTypeToPriority[numberType2]);
     //create list
@@ -265,9 +243,8 @@ const getPossibleValuesForProbaQuestion = (optsIn) => {
 };
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: getKeys(identifiers),
+        keys: [],
         answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers),
@@ -284,10 +261,10 @@ export const possibleValuesForProba = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     answerType: "QCM",
+    isQCM: true,
     hasHintAndCorrection: true,
 };

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../exercise.js";
+type Identifiers = {
+    situationIndex: number;
+    dictShuffle: Record<string, string>;
+    pType: string;
+};
+export declare const conditionalProbaWriteFromFrench: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=conditionalProbaWriteFromFrench.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"conditionalProbaWriteFromFrench.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/conditionalProbaWriteFromFrench.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAK3B,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA8QF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAejE,CAAC"}

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

@@ -0,0 +1,221 @@
+import { randint } from "../../../math/utils/random/randint.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../exercise.js";
+import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+import { random } from "../../../utils/alea/random.js";
+const situations = [
+    {
+        context: "Martine est à la plage pour faire de la pêche à pied. Elle ramasse un coquillage.",
+        strA: "C'est une moule.",
+        strB: "Il y a un petit crabe à l'intérieur.",
+        "(A)": "que ce soit une moule",
+        "(B)": "qu'il y ait un petit crabe à l'intérieur",
+        "(A \\cap B)": "que ce soit une moule avec un petit crabe à l'intérieur",
+        "_A(B)": "qu'il y ait un petit crabe à l'intérieur, sachant que c'est une moule",
+        "_B(A)": "que ce soit une moule, sachant qu'il y a un petit crabe à l'intérieur",
+    },
+    {
+        context: "Pour payer sa baguette multi-graines, Ahmed prend un billet au hasard dans son portefeuille.",
+        strA: "C'est un billet de $10$ euros.",
+        strB: "Il est froissé.",
+        "(A)": "que ce soit un billet de $10$ euros",
+        "(B)": "qu'il soit froissé",
+        "(A \\cap B)": "que ce soit un billet froissé de $10$ euros",
+        "_A(B)": "qu'il soit froissé, sachant que c'est un billet de $10$ euros",
+        "_B(A)": "que ce soit un billet de $10$ euros, sachant qu'il est froissé",
+    },
+    {
+        context: "Cynthia change de station de radio. Elle tombe sur un morceau de musique.",
+        strA: "C'est de la pop.",
+        strB: "Les paroles sont en anglais.",
+        "(A)": "que ce soit de la pop",
+        "(B)": "que les paroles soient en anglais",
+        "(A \\cap B)": "que ce soit un morceau de pop en anglais",
+        "_A(B)": "que les paroles soient en anglais, sachant que c'est de la pop",
+        "_B(A)": "que ce soit de la pop, sachant que les paroles sont en anglais",
+    },
+    {
+        context: "À la maison, Henri et Raphaël jouent au Monopoly. Raphaël lance les dés.",
+        strA: "Le résultat du lancer est un double $6$.",
+        strB: "Les dés sont tombés par terre.",
+        "(A)": "que le résulat du lancer soit un double $6$",
+        "(B)": "que les dés soient tombés par terre",
+        "(A \\cap B)": "que les dés soient tombés par terre et aient donné un double $6$",
+        "_A(B)": "que les dés soient tombés par terre, sachant que le résultat du lancer est un double $6$",
+        "_B(A)": "que ce soit un double $6$, sachant que les dés sont tombés par terre",
+    },
+    {
+        context: "Au hasard, la maîtresse ouvre le dictionnaire et pose son doigt sur un mot.",
+        strA: "C'est un mot de $7$ lettres.",
+        strB: 'Le mot se termine par la lettre "e".',
+        "(A)": "que ce soit un mot de $7$ lettres",
+        "(B)": 'que le mot se termine par un "e"',
+        "(A \\cap B)": 'que ce soit un mot de $7$ lettres qui se termine par un "e"',
+        "_A(B)": 'que ce soit un mot qui se termine par un "e", sachant que c\'est un mot de $7$ lettres',
+        "_B(A)": 'que ce soit un mot de $7$ lettres sachant qu\'il se termine par un "e"',
+    },
+    {
+        context: "Dans une émission TV, le présentateur demande son prénom à quelqu'un dans le public.",
+        strA: "Le prénom est Jean-Michel.",
+        strB: 'Le prénom commence par la lettre "A".',
+        "(A)": "que le prénom soit Jean-Michel",
+        "(B)": 'que le prénom commence par la lettre "J"',
+        "(A \\cap B)": 'que le prénom soit Jean-Michel et qu\'il commence par un "A"',
+        "_A(B)": 'que le prénom commence par un "A", sachant que c\'est Jean-Michel',
+        "_B(A)": 'que le prénom soit Jean-Michel, sachant qu\'il commence par un "A"',
+    },
+    {
+        context: "Il est $14$h$37$. Yohann et Sarah sont assis en classe. C'est un cours sur les probabilités.",
+        strA: "Yohann dort.",
+        strB: "Sarah est attentive.",
+        "(A)": "que Yohann dorme",
+        "(B)": "que Sarah soit attentive",
+        "(A \\cap B)": "que Yohann dorme tandis que Sarah est attentive",
+        "_A(B)": "que Sarah soit attentive, sachant que Yohann dort",
+        "_B(A)": "que Yohann dorme, sachant que Sarah est attentive",
+    },
+];
+const shuffleSituation = (situation, dictShuffle) => {
+    function replaceKey(strSrc, dictReplacement) {
+        return Object.keys(dictReplacement).reduce((acc, x) => {
+            return acc.replace(x, dictReplacement[x]);
+        }, strSrc);
+    }
+    const arrayOfTemporaryKeys = [
+        ...Array(Object.keys(dictShuffle).length).keys(),
+    ].map((i) => {
+        return `temporaryKey{${i}}`;
+    });
+    const dictReplacementOriginaltoTemporary = Object.fromEntries(Object.keys(dictShuffle).map((originalKey, i) => {
+        return [originalKey, arrayOfTemporaryKeys[i]];
+    }));
+    const dictReplacementTemporaryToShuffledOriginal = Object.fromEntries(Object.keys(dictShuffle).map((originalKey) => {
+        return [
+            dictReplacementOriginaltoTemporary[originalKey],
+            dictShuffle[originalKey],
+        ];
+    }));
+    return Object.fromEntries(Object.entries(situation).map(([k, v]) => [
+        k === "(A \\cap B)"
+            ? k
+            : replaceKey(replaceKey(k, dictReplacementOriginaltoTemporary), dictReplacementTemporaryToShuffledOriginal),
+        v,
+    ]));
+};
+const getInstruction = (identifiers) => {
+    const { situationIndex, dictShuffle, pType } = identifiers;
+    const situation = shuffleSituation(situations[situationIndex], dictShuffle);
+    let instruction = `${situation.context}`;
+    instruction += `
+
+Soit $A$ l'évenement : 
+
+> ${situation.strA}
+
+Soit $B$ l'évenement : 
+
+> ${situation.strB}`;
+    instruction += `
+
+Écris en langage mathématique : 
+
+La probabilité ${situation[pType]}.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { pType } = identifiers;
+    switch (pType) {
+        case "(A \\cap B)":
+            return `P\\left(A\\cap B\\right)`;
+        case "_A(B)":
+            return `P_A\\left(B\\right)`;
+        case "_B(A)":
+            return `P_B\\left(A\\right)`;
+        default:
+            return "";
+    }
+};
+const getHint = () => {
+    return `Si $M$ et $N$ sont deux évenements, alors
+
+$P(M \\cap N)$ est la probabilité de l'évènement "$M$ et $N$".
+
+$P_M(N)$ est la probabilité de l'évènement $N$, sachant que l'évènement $M$ est réalisé.
+
+$P_N(M)$ est la probabilité de l'évènement $M$, sachant que l'évènement $N$ est réalisé.`;
+};
+const getCorrection = (identifiers) => {
+    const { situationIndex, dictShuffle, pType } = identifiers;
+    const situation = shuffleSituation(situations[situationIndex], dictShuffle);
+    return `La probabilité ${situation[pType]}${pType === "_A(B)" || pType === "_B(A)" ? ", est" : " n'est pas"} une probabilité conditionnelle.
+${(() => {
+        switch (pType) {
+            case "(A \\cap B)":
+                return `C'est la probabilité de l'évènement "$A$ et $B$", sans condition particulière.`;
+            case "_A(B)":
+                return `C'est la probabilité sachant A (donc conditionnelle), $P_A$, de l'évènement "$B$".`;
+            case "_B(A)":
+                return `C'est la probabilité sachant B (donc conditionnelle), $P_B$, de l'évènement "$A$".`;
+        }
+    })()}
+Elle se note $P${pType}$.`;
+};
+const getConditionalProbaWriteFromFrenchQuestion = () => {
+    const pType = random(["(A \\cap B)", "_A(B)", "_B(A)"]);
+    const situationIndex = randint(0, situations.length);
+    const arrABShuffled = shuffle(["A", "B"]);
+    const dictShuffle = Object.fromEntries(["A", "B"].map((c, i) => [c, arrABShuffled[i]]));
+    const identifiers = { situationIndex, dictShuffle, pType };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["P", "cap", "underscore", "A", "B"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `P\\left(A\\cap B\\right)`, "tex");
+    tryToAddWrongProp(propositions, `P_A\\left(B\\right)`, "tex");
+    tryToAddWrongProp(propositions, `P_B\\left(A\\right)`, "tex");
+    tryToAddWrongProp(propositions, `P(A)`, "tex");
+    tryToAddWrongProp(propositions, `P(B)`, "tex");
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { pType } = identifiers;
+    switch (pType) {
+        case "(A \\cap B)":
+            return (`P\\left(A\\cap B\\right)`.trim() === ans ||
+                `P\\left(B\\cap A\\right)`.trim() === ans);
+        case "_A(B)":
+            return `P_A\\left(B\\right)`.trim() === ans.trim();
+        case "_B(A)":
+            return `P_B\\left(A\\right)`.trim() === ans.trim();
+        default:
+            return false;
+    }
+};
+export const conditionalProbaWriteFromFrench = {
+    id: "conditionalProbaWriteFromFrench",
+    connector: "=",
+    label: "Ecrire une probabilité en langage mathématique",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getConditionalProbaWriteFromFrenchQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+};

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

@@ -13,4 +13,6 @@ export * from "./unionIntersectionProba.js";
 export * from "./checkEquiprobability.js";
 export * from "./events/index.js";
 export * from "./basicProbas/index.js";
+export * from "./probaAsSumOfProbas.js";
+export * from "./conditionalProbaWriteFromFrench.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC"}

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

@@ -13,3 +13,5 @@ export * from "./unionIntersectionProba.js";
 export * from "./checkEquiprobability.js";
 export * from "./events/index.js";
 export * from "./basicProbas/index.js";
+export * from "./probaAsSumOfProbas.js";
+export * from "./conditionalProbaWriteFromFrench.js";

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

@@ -0,0 +1,29 @@
+import { Exercise } from "../../exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    indexSituation: number;
+    eventIds: EventIdentifiers;
+    arrProba: NodeIdentifiers[];
+};
+type EventIdentifiers = {
+    type: "elementary";
+    index: number;
+    id: string;
+    str: string;
+    p: NodeIdentifiers;
+} | {
+    type: "union";
+    id: string;
+    str: string;
+    p: NodeIdentifiers;
+    arrSubEvent: EventIdentifiers[];
+    isTailoredStr: boolean;
+};
+type Options = {
+    nbElem: number[];
+    unionLength: number[];
+    isProbasAreNumbers: boolean[];
+};
+export declare const probaAsSumOfProbas: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=probaAsSumOfProbas.d.ts.map

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

@@ -0,0 +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"}