math-exercises 3.0.178 → 3.0.179

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductOrthoInSquare.js

@@ -102,7 +102,7 @@ const getScalarProductOrthoInSquareQuestion = () => {
     //puis on reverse tout possiblement
     const isFirstVecOnAB = coinFlip();
     const vecs = {
-        AB: { projLength: c, reps: ["AB", "DC"] },
+        AB: { projLength: c, reps: ["AB", "DC"] }, //base
         AC: { projLength: c, reps: ["AC"] },
         AD: { projLength: c, reps: ["AD", "IK", "BC"] },
         AJ: { projLength: isFirstVecOnAB ? c : c / 2, reps: ["AJ", "LC"] },
@@ -141,7 +141,7 @@ const getScalarProductOrthoInSquareQuestion = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
+// const getHint: GetHint<Identifiers> = () => {
 //   return `Utilise la définition du produit scalaire par projeté orthogonal : si $H$ est le projeté orthogonal du point $C$ sur la droite $(AB)$, alors :
 // $$
 // \\overline{AB}\\cdot\\overline{AC} = \\overline{AB}\\cdot\\overline{AH}
@@ -159,33 +159,48 @@ const getScalarProductOrthoInSquareQuestion = () => {
 // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
 //   const { areSameDirection, vec1Name, vec2Name, c } = identifiers;
 //   const vecs = [
-//     ["AB", "DC"],
+//     ["AB", "DC"], //base
 //     ["AC"],
-//     ["AD", "IK", "BC"],
+//     ["AD", "IK", "BC"], //base
 //     ["AJ", "LC"],
 //     ["AO", "LK", "OC", "IJ"],
 //     ["AK", "IC"],
-//     ["AI", "IB", "LO", "OJ", "DK", "KC"],
-//     ["AL", "LD", "IO", "OK", "BJ", "JC"],
+//     ["AI", "IB", "LO", "OJ", "DK", "KC"], //base
+//     ["AL", "LD", "IO", "OK", "BJ", "JC"], //base
 //   ];
+//   const baseIndexes = [0, 2, 6, 7];
+//   if (!areSameDirection) return `plus tard`;
+//   const reversedVecs = vecs.map((e) =>
+//     e.map((f) => f.split("").reverse().join("")),
+//   );
+//   const reversedFirst = vec1Name.split("").reverse().join("");
 //   const index1 = vecs.findIndex(
-//     (e) =>
-//       e.includes(vec1Name) || e.includes(vec1Name.split("").reverse().join("")),
+//     (e) => e.includes(vec1Name) || e.includes(reversedFirst),
 //   );
 //   const firstIsReversed = !vecs[index1].includes(vec1Name);
+//   const reversedSecond = vec2Name.split("").reverse().join("");
 //   const index2 = vecs.findIndex(
-//     (e) =>
-//       e.includes(vec2Name) || e.includes(vec2Name.split("").reverse().join("")),
+//     (e) => e.includes(vec2Name) || e.includes(reversedSecond),
 //   );
 //   const secondIsReversed = !vecs[index2].includes(vec2Name);
-//   if (vec1Name[0] === vec2Name[0]) return `immédiat`;
-//   for (let i = 0; i < vecs[index1].length; i++) {
-//     const rep = vecs[index1][i];
-//     const origin1 = rep[0];
-//     const sameOrigin = vecs[index2].find((e) => e[0] === origin1);
-//     if (sameOrigin)
-//       return `on prend $${rep}$ et $${sameOrigin}$. ${sameOrigin[1]} à projeter sur ${rep}`;
+//   if (vec1Name[0] === vec2Name[0]) {
+//     const firstIsBase = baseIndexes.includes(index1);
+//     return `Le projeté orthogonal de $${
+//       firstIsBase ? vec2Name[1] : vec1Name[1]
+//     }$ sur la droite $(${firstIsBase ? vec1Name : vec2Name})$ est $${"a"}$.
+// On a donc :
+// immédiat`;
 //   }
+//   const sameOrigin =
+//     vecs[index2].find((e) => e[0] === vec1Name[0]) ||
+//     reversedVecs[index2].find((e) => e[0] === vec1Name[0]);
+//   if (sameOrigin)
+//     return `on prend $${vec1Name}$ et $${sameOrigin}$. eet ${sameOrigin[1]} à projeter sur ${vec1Name}`;
+//   const sameOrigin2 =
+//     vecs[index1].find((e) => e[0] === vec2Name[0]) ||
+//     reversedVecs[index1].find((e) => e[0] === vec2Name[0]);
+//   if (sameOrigin2)
+//     return `on prend $${vec2Name}$ et $${sameOrigin2}$. ${vec2Name[1]} à projeter sur ${sameOrigin2}`;
 //   return `On a :
 // ${alignTex([[]])}
 // `;

package/lib/exercises/math/probaStat/conditional/conditionalProbaFromTableWithContext.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    situationIndex: number;
+    aCapB: number;
+    aCapBBarre: number;
+    aBarreCapB: number;
+    aBarreCapBBarre: number;
+    knowing: "A" | "\\overline{A}" | "B" | "\\overline{B}";
+    asked: "A" | "\\overline{A}" | "B" | "\\overline{B}";
+};
+export declare const conditionalProbaFromTableWithContext: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=conditionalProbaFromTableWithContext.d.ts.map

package/lib/exercises/math/probaStat/conditional/conditionalProbaFromTableWithContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionalProbaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/conditional/conditionalProbaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,OAAO,EAAE,GAAG,GAAG,eAAe,GAAG,GAAG,GAAG,eAAe,CAAC;IACvD,KAAK,EAAE,GAAG,GAAG,eAAe,GAAG,GAAG,GAAG,eAAe,CAAC;CACtD,CAAC;AA+NF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CAAC,WAAW,CAsBtE,CAAC"}

package/lib/exercises/math/probaStat/conditional/conditionalProbaFromTableWithContext.js

@@ -0,0 +1,195 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { twoEventsSituations } from "../twoEventsSituations.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre, knowing, asked } = identifiers;
+    const total = aBarreCapB + aBarreCapBBarre + aCapB + aCapBBarre;
+    let cap;
+    switch (knowing) {
+        case "A":
+            cap = asked === "B" ? aCapB : aCapBBarre;
+            break;
+        case "\\overline{A}":
+            cap = asked === "B" ? aBarreCapB : aBarreCapBBarre;
+            break;
+        case "B":
+            cap = asked === "A" ? aCapB : aBarreCapB;
+            break;
+        case "\\overline{B}":
+        default:
+            cap = asked === "A" ? aCapBBarre : aBarreCapBBarre;
+            break;
+    }
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, frac(cap, total).simplify().toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductibleProba().toTree().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre, knowing, asked } = identifiers;
+    let total;
+    let cap;
+    switch (knowing) {
+        case "A":
+            total = aCapB + aCapBBarre;
+            cap = asked === "B" ? aCapB : aCapBBarre;
+            break;
+        case "\\overline{A}":
+            total = aBarreCapB + aBarreCapBBarre;
+            cap = asked === "B" ? aBarreCapB : aBarreCapBBarre;
+            break;
+        case "B":
+            total = aCapB + aBarreCapB;
+            cap = asked === "A" ? aCapB : aBarreCapB;
+            break;
+        case "\\overline{B}":
+        default:
+            total = aCapBBarre + aBarreCapBBarre;
+            cap = asked === "A" ? aCapBBarre : aBarreCapBBarre;
+            break;
+    }
+    return frac(cap, total).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { situationIndex, aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre, knowing, asked, } = identifiers;
+    const situation = twoEventsSituations[situationIndex];
+    return `${situation.instruction.context} : 
+  
+  ${mdTable([
+        [
+            " ",
+            situation.instruction.table.B,
+            situation.instruction.table["\\overline{B}"],
+            "Total",
+        ],
+        [
+            situation.instruction.table.A,
+            dollarize(aCapB),
+            dollarize(aCapBBarre),
+            dollarize(aCapB + aCapBBarre),
+        ],
+        [
+            situation.instruction.table["\\overline{A}"],
+            dollarize(aBarreCapB),
+            dollarize(aBarreCapBBarre),
+            dollarize(aBarreCapB + aBarreCapBBarre),
+        ],
+        [
+            "Total",
+            dollarize(aCapB + aBarreCapB),
+            dollarize(aCapBBarre + aBarreCapBBarre),
+            dollarize(aCapB + aCapBBarre + aBarreCapB + aBarreCapBBarre),
+        ],
+    ])}
+  
+On choisit au hasard ${situation.events[knowing]}. Quelle est la probabilité que ce soit ${situation.events[asked]} ?`;
+};
+const getHint = (identifiers) => {
+    const { situationIndex } = identifiers;
+    const situation = twoEventsSituations[situationIndex];
+    return `Ici, il ne faut pas prendre le total des ${situation.population}s comme dénumérateur...`;
+};
+const getCorrection = (identifiers) => {
+    const { situationIndex, aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre, knowing, asked, } = identifiers;
+    const situation = twoEventsSituations[situationIndex];
+    let total;
+    let cap;
+    switch (knowing) {
+        case "A":
+            total = aCapB + aCapBBarre;
+            cap = asked === "B" ? aCapB : aCapBBarre;
+            break;
+        case "\\overline{A}":
+            total = aBarreCapB + aBarreCapBBarre;
+            cap = asked === "B" ? aBarreCapB : aBarreCapBBarre;
+            break;
+        case "B":
+            total = aCapB + aBarreCapB;
+            cap = asked === "A" ? aCapB : aBarreCapB;
+            break;
+        case "\\overline{B}":
+        default:
+            total = aCapBBarre + aBarreCapBBarre;
+            cap = asked === "A" ? aCapBBarre : aBarreCapBBarre;
+            break;
+    }
+    return `Le total correspondant au cas "${situation.events[knowing]}" est $${total}$. Parmi ces ${situation.population}s, ceux correspondant au cas "${situation.events[asked]}" est $${cap}$. Donc la probabilité recherchée vaut :
+  
+$$
+${frac(cap, total).toSimplificationTex()}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getConditionalProbaFromTableWithContextQuestion = () => {
+    const situationIndex = randint(0, twoEventsSituations.length);
+    const aCapB = randint(1, 20);
+    const aCapBBarre = randint(1, 20, [aCapB]);
+    const aBarreCapB = randint(1, 20, [aCapB, aCapBBarre]);
+    const aBarreCapBBarre = randint(1, 20, [aCapB, aCapBBarre, aBarreCapB]);
+    const AEvents = ["A", "\\overline{A}"];
+    const BEvents = ["B", "\\overline{B}"];
+    const isKnowingA = coinFlip();
+    const knowing = (isKnowingA ? random(AEvents) : random(BEvents));
+    const asked = (isKnowingA ? random(BEvents) : random(AEvents));
+    const identifiers = {
+        aBarreCapB,
+        aBarreCapBBarre,
+        aCapB,
+        aCapBBarre,
+        situationIndex,
+        knowing,
+        asked,
+    };
+    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 conditionalProbaFromTableWithContext = {
+    id: "conditionalProbaFromTableWithContext",
+    connector: "=",
+    label: "Calculer une probabilité conditionnelle dans un tableau à double entrée (avec contexte)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getConditionalProbaFromTableWithContextQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/conditional/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/conditional/conditionalProbaWriteFromFrench.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionalProbaWriteFromFrench.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/conditional/conditionalProbaWriteFromFrench.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAK9B,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,CAcjE,CAAC"}

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

@@ -0,0 +1,220 @@
+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: "La personne est un adulte.",
+        "(A)": "que le prénom soit Jean-Michel",
+        "(B)": "que la personne soit un adulte",
+        "(A \\cap B)": "que le prénom soit Jean-Michel et que la personne soit un adulte",
+        "_A(B)": "que la personne soit un adulte, sachant que son prénom est Jean-Michel",
+        "_B(A)": "que le prénom soit Jean-Michel, sachant que la personne est un adulte",
+    },
+    {
+        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 += `
+
+Écrire 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: "Écrire une probabilité conditionnelle en langage mathématique",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getConditionalProbaWriteFromFrenchQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/probaStat/conditional/conditionalProbability.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../exercise.js";
+type Identifiers = {
+    flip: number;
+    pA?: number;
+    pB?: number;
+    pAB?: number;
+    pA_B?: number;
+    pB_A?: number;
+};
+type Options = {
+    probaType: string[];
+};
+export declare const conditionalProbability: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=conditionalProbability.d.ts.map

package/lib/exercises/math/probaStat/conditional/conditionalProbability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionalProbability.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/conditional/conditionalProbability.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,QAAQ,EAmBT,MAAM,sBAAsB,CAAC;AAO9B,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAoRF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAyDF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBjE,CAAC"}