math-exercises 3.0.156 → 3.0.158

package/lib/exercises/math/probaStat/independancy/independancyFindCup.js

@@ -0,0 +1,118 @@
+import { addValidProp, shuffleProps, propWhile, 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 { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, multiply(pA, pB).simplify().toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(0, 1, randint(1, 3)).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    return substract(add(pA, pB), multiply(pA, pB)).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    return `On considère deux événements indépendants $A$ et $B$, tels que $P(A) = ${pA.toTex()}$ et $P(B) = ${pB.toTex()}$.
+  
+Déterminer $P(A\\cup B)$.`;
+};
+const getHint = () => {
+    return `Deux événements $A$ et $B$ sont indépendants si et seulement si $P(A)\\times P(B) = P(A\\cap B)$.
+  
+D'autre part, on rappelle la formule de l'union :
+
+$$
+P(A \\cup B) = P(A) + P(B) - P(A \\cap B)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    const pAB = multiply(pA, pB);
+    const pABSimp = pAB.simplify();
+    return `Puisque $A$ et $B$ sont indépendants, alors on a :
+  
+${alignTex([
+        ["P(A\\cap B)", "=", "P(A)\\times P(B)"],
+        ["", "=", pAB.toTex()],
+        ["", "=", pABSimp.toTex()],
+    ])}
+
+On utilise ensuite la formule de l'union : 
+
+${alignTex([
+        ["P(A \\cup B)", "=", "P(A) + P(B) - P(A \\cap B)"],
+        ["", "=", substract(add(pA, pB), pABSimp).toTex()],
+        ["", "=", substract(add(pA, pB), pABSimp).simplify().toTex()],
+    ])}
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIndependancyFindCupQuestion = () => {
+    const pA = randfloat(0, 1, randint(1, 3));
+    const pB = randfloat(0, 1, randint(1, 3));
+    const identifiers = {
+        pAIds: pA.toTree().toIdentifiers(),
+        pBIds: pB.toTree().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 independancyFindCup = {
+    id: "independancyFindCup",
+    connector: "=",
+    label: "Calculer l'union de deux événements indépendants",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIndependancyFindCupQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,5 @@
+export * from "./independancy.js";
+export * from "./isIndependantFromDefinition.js";
+export * from "./independancyFindCap.js";
+export * from "./independancyFindCup.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from "./independancy.js";
+export * from "./isIndependantFromDefinition.js";
+export * from "./independancyFindCap.js";
+export * from "./independancyFindCup.js";

package/lib/exercises/math/probaStat/independancy/isIndependantFromDefinition.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    pAIds: NodeIdentifiers;
+    pBIds: NodeIdentifiers;
+    pABIds: NodeIdentifiers;
+};
+export declare const isIndependantFromDefinition: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isIndependantFromDefinition.d.ts.map

package/lib/exercises/math/probaStat/independancy/isIndependantFromDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isIndependantFromDefinition.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/isIndependantFromDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;IACvB,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AA8FF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAqB7D,CAAC"}

package/lib/exercises/math/probaStat/independancy/isIndependantFromDefinition.js

@@ -0,0 +1,106 @@
+import { addValidProp, shuffleProps, 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";
+import { round } from "../../../../math/utils/round.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { pABIds, pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    const pAB = reifyAlgebraic(pABIds);
+    return Math.abs(substract(pAB, multiply(pA, pB)).evaluate()) < 0.0001
+        ? "Oui"
+        : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { pABIds, pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    const pAB = reifyAlgebraic(pABIds);
+    return `On considère deux événements $A$ et $B$ tels que $P(A)= ${pA.toTex()}$, $P(B)=${pB.toTex()}$ et $P(A\\cap B) = ${pAB.toTex()}$.
+  
+Les événements $A$ et $B$ sont-ils indépendants ?`;
+};
+const getHint = () => {
+    return `Deux événements sont indépendants si et seulement si :
+  
+$$
+P(A\\cap B) = P(A)\\times P(B)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { pAIds, pBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pB = reifyAlgebraic(pBIds);
+    const isIndependant = getAnswer(identifiers) === "Oui";
+    return `Deux événements sont indépendants si et seulement si :
+  
+$$
+P(A\\cap B) = P(A)\\times P(B)
+$$
+
+Ici, on a :
+
+$$
+P(A)\\times P(B) = ${multiply(pA, pB).toSimplificationTex()}
+$$
+
+${isIndependant
+        ? `Puisque $P(A\\cap B) = P(A)\\times P(B)$, les évènements $A$ et $B$ sont bien indépendants.`
+        : `Puisque $P(A\\cap B) \\neq P(A)\\times P(B)$, les évènements $A$ et $B$ ne sont pas indépendants.`}
+`;
+};
+const getIsIndependantFromDefinitionQuestion = () => {
+    const pA = randfloat(0.1, 1, randint(1, 3));
+    const pB = randfloat(0.1, 1, randint(1, 3));
+    const isInde = coinFlip();
+    const pAB = isInde
+        ? round(pA * pB, 5)
+        : randfloat(0, Math.min(pA, pB), randint(1, 3), [round(pA * pB, 5)]);
+    const identifiers = {
+        pAIds: pA.toTree().toIdentifiers(),
+        pABIds: pAB.toTree().toIdentifiers(),
+        pBIds: pB.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const isIndependantFromDefinition = {
+    id: "isIndependantFromDefinition",
+    label: "Déterminer si deux événements sont indépendants en comparant $P(A\\cap B)$ et $P(A)\\times P(B)$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsIndependantFromDefinitionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -2,7 +2,7 @@ export * from "./conditionalProbability.js";
 export * from "./probabilityTree.js";
 export * from "./stats1var/index.js";
 export * from "./stats2var/index.js";
-export * from "./independancy.js";
+export * from "./independancy/index.js";
 export * from "./issuesCountingForCards.js";
 export * from "./probaFromTableNoContext.js";
 export * from "./probaFromTableWithContext.js";

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;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC;AACrD,cAAc,+BAA+B,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,yBAAyB,CAAC;AACxC,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;AACrD,cAAc,+BAA+B,CAAC"}

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

@@ -2,7 +2,7 @@ export * from "./conditionalProbability.js";
 export * from "./probabilityTree.js";
 export * from "./stats1var/index.js";
 export * from "./stats2var/index.js";
-export * from "./independancy.js";
+export * from "./independancy/index.js";
 export * from "./issuesCountingForCards.js";
 export * from "./probaFromTableNoContext.js";
 export * from "./probaFromTableWithContext.js";

package/lib/exercises/math/probaStat/randomVariable/randomVariableStandardDeviation.js

@@ -18,7 +18,7 @@ const getPropositions = (n, { answer }) => {
 const getAnswer = (identifiers) => {
     const { xValuesIds, yValuesIds } = identifiers;
     const va = new RandomVariable(xValuesIds.map((e) => reifyAlgebraic(e)), yValuesIds.map((e) => reifyAlgebraic(e)));
-    return round(va.getStandardDeviation().simplify().evaluate(), 2).frenchify();
+    return round(va.getStandardDeviation().evaluate(), 2).frenchify();
 };
 const getInstruction = (identifiers) => {
     const { xValuesIds, yValuesIds } = identifiers;

package/lib/exercises/math/probaStat/stats1var/etendueTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"etendueTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/etendueTable.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AA6GF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}
+{"version":3,"file":"etendueTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/etendueTable.ts"],"names":[],"mappings":"AAIA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAmHF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/etendueTable.js

@@ -45,7 +45,11 @@ const getHint = () => {
 const getCorrection = (identifiers) => {
     const { randomValues } = identifiers;
     return `La plus grande valeur de cette série est $${randomValues[randomValues.length - 1]}$ et la plus petite est $${randomValues[0]}$.
-  
+
+$$
+${randomValues[randomValues.length - 1]} - ${randomValues[0]} = ${randomValues[randomValues.length - 1] - randomValues[0]}
+$$
+
 L'étendue de la série est donc $${randomValues[randomValues.length - 1] - randomValues[0]}$.
   `;
 };

package/lib/exercises/math/probaStat/stats1var/medianWithList.js

@@ -19,7 +19,7 @@ const getAnswer = (identifiers) => {
     return median([...sortedValues].sort((a, b) => a - b)).frenchify();
 };
 const getHint = (_, opts) => {
-    return `La médiane est la valeur centrale de la série : il y a autant de valeur inférieures à la médiane que de valeurs supérieures à la médiane.
+    return `La médiane est la valeur centrale de la série : il y a autant de valeurs inférieures à la médiane que de valeurs supérieures à la médiane.
 
 ${opts?.isOrdered
         ? "Les valeurs sont déjà rangées par ordre croissant."

package/lib/exercises/math/probaStat/stats1var/medianWithTable.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"medianWithTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithTable.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAiIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"medianWithTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithTable.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAiJF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/math/probaStat/stats1var/medianWithTable.js

@@ -55,7 +55,6 @@ const getCorrection = (identifiers) => {
         eccs.push(s);
     }
     const total = eccs[eccs.length - 1];
-    const rank = total / 2;
     return `On dresse le tableau des effectifs cumulés croissants (ECC) : 
   
 ${mdTable([
@@ -64,11 +63,26 @@ ${mdTable([
         ["ECC", ...eccs.map((e) => dollarize(e))],
     ])}
 
-L'effectif total est donc $${total}$. 
+L'effectif total est donc $${total}$.
 
-Puisque $\\frac{${total}}{2} = ${rank.frenchify()}$, la médiane est ${rank % 1 === 0
-        ? `entre la $${rank}$ème et la $${rank + 1}$ème valeur.`
-        : `la $${Math.ceil(rank)}$ème valeur.`}
+${(() => {
+        switch (total % 2) {
+            case 0: {
+                const rank = total / 2;
+                return `L'effectif est pair. La médiane est entre la $${rank}$ème et la $${rank + 1}$ème valeur.`;
+            }
+            case 1: {
+                const rank = (total + 1) / 2;
+                return `L'effectif est impair.
+
+$$
+\\frac{${total}+1}{2} = ${rank.frenchify()}
+$$
+
+La médiane est la $${rank.frenchify()}$ème valeur.`;
+            }
+        }
+    })()}
 
 La médiane est donc $${getAnswer(identifiers)}$.`;
 };

package/lib/exercises/math/probaStat/stats1var/plausibilityOfAverage.js

@@ -89,7 +89,7 @@ Si l'on regarde les valeurs strictement supérieures à $${a.frenchify()}$ :
 ${valuesAboveA
         .map((v) => `
     
-$${v.frenchify()}$ est $${(v - a).frenchify()}$ points en dessus de $${a.frenchify()}$
+$${v.frenchify()}$ est $${(v - a).frenchify()}$ points au dessus de $${a.frenchify()}$
 
 `)
         .join("")}

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headsOrTailsTwiceOutcomes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAS9B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA+MF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}
+{"version":3,"file":"headsOrTailsTwiceOutcomes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAS9B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA6NF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.js

@@ -9,6 +9,7 @@ const arrStrOutcomeSmall = [`P`, `F`];
 const getInstruction = (identifiers) => {
     const { arrIndex } = identifiers;
     const strRand = arrIndex.join("");
+    const topRow = [`\\text{Lancer} \\ 1$ /// $\\text{Lancer} \\ 2`, "P", "F"];
     return `On tire deux fois à pile ou face avec une pièce de monnaie.
 On note les issues de cette expérience aléatoire dans le tableau ci-dessous. 
 
@@ -18,14 +19,14 @@ ${(() => {
                 {
                     return random([
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{...}", "(P,F)"],
-                            ["\\text{Lancer 1 : } F", "\\text{}", "\\text{}"],
+                            topRow,
+                            ["P", "\\text{...}", "(P;F)"],
+                            ["F", "\\text{}", "\\text{}"],
                         ], true)}`,
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{...}", "\\text{}"],
-                            ["\\text{Lancer 1 : } F", "(F,P)", "\\text{}"],
+                            topRow,
+                            ["P", "\\text{...}", "\\text{}"],
+                            ["F", "(F;P)", "\\text{}"],
                         ], true)}`,
                     ]);
                 }
@@ -34,14 +35,14 @@ ${(() => {
                 {
                     return random([
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "(P,P)", "\\text{...}"],
-                            ["\\text{Lancer 1 : } F", "\\text{}", "\\text{}"],
+                            topRow,
+                            ["P", "(P;P)", "\\text{...}"],
+                            ["F", "\\text{}", "\\text{}"],
                         ], true)}`,
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{}", "\\text{...}"],
-                            ["\\text{Lancer 1 : } F", "\\text{}", "(F,F)"],
+                            topRow,
+                            ["P", "\\text{}", "\\text{...}"],
+                            ["F", "\\text{}", "(F;F)"],
                         ], true)}`,
                     ]);
                 }
@@ -50,14 +51,14 @@ ${(() => {
                 {
                     return random([
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "(P,P)", "\\text{}"],
-                            ["\\text{Lancer 1 : } F", "\\text{...}", "\\text{}"],
+                            topRow,
+                            ["P", "(P;P)", "\\text{}"],
+                            ["F", "\\text{...}", "\\text{}"],
                         ], true)}`,
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{}", "\\text{}"],
-                            ["\\text{Lancer 1 : } F", "\\text{...}", "(F,F)"],
+                            topRow,
+                            ["P", "\\text{}", "\\text{}"],
+                            ["F", "\\text{...}", "(F;F)"],
                         ], true)}`,
                     ]);
                 }
@@ -66,14 +67,14 @@ ${(() => {
                 {
                     return random([
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{}", "(P,F)"],
-                            ["\\text{Lancer 1 : } F", "\\text{}", "\\text{...}"],
+                            topRow,
+                            ["P", "\\text{}", "(P;F)"],
+                            ["F", "\\text{}", "\\text{...}"],
                         ], true)}`,
                         `${mdTable([
-                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-                            ["\\text{Lancer 1 : } P", "\\text{}", "\\text{}"],
-                            ["\\text{Lancer 1 : } F", "(F,P)", "\\text{...}"],
+                            topRow,
+                            ["P", "\\text{}", "\\text{}"],
+                            ["F", "(F;P)", "\\text{...}"],
                         ], true)}`,
                     ]);
                 }
@@ -106,17 +107,14 @@ const getCorrection = (identifiers) => {
             ? highlighted(strEventSmall)
             : strEventSmall;
     });
+    const topRow = [`\\text{Lancer 1}$ /// $\\text{Lancer 2}`, "P", "F"];
     return `Dans le tableau ci-dessous, 
 le premier élément dans la parenthèse désigne le résultat du premier lancer 
 et le deuxième élémént le résultat du deuxième lancer.
 
 $P$ désigne $Pile$ et $F$ désigne $Face$.
   
-${mdTable([
-        ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-        ["\\text{Lancer 1 : } P", arrStr[0], arrStr[2]],
-        ["\\text{Lancer 1 : } F", arrStr[1], arrStr[3]],
-    ], true)}
+${mdTable([topRow, ["P", arrStr[0], arrStr[2]], ["F", arrStr[1], arrStr[3]]], true)}
 `;
 };
 const getPropositions = (n, { answer }) => {
@@ -153,6 +151,20 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: false,
+                firstRowIsHeader: false,
+                firstCellIsDivided: true,
+            },
+        },
+        correctionStyle: {
+            tableOptions: {
+                firstCellIsDivided: true,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: true,
+            },
+        },
     };
     return question;
 };

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"headsOrTailsTwiceProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAY9B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAuLF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"headsOrTailsTwiceProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAY9B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA8LF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.js

@@ -85,9 +85,9 @@ const getCorrection = (identifiers) => {
     return `Dans le tableau ci-dessous, on a indiqué en vert les issues qui réalisent l'évènement "${event.str}" : 
   
 ${mdTable([
-        ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
-        ["\\text{Lancer 1 : } P", arrStr[0], arrStr[2]],
-        ["\\text{Lancer 1 : } F", arrStr[1], arrStr[3]],
+        [`\\text{Lancer} \\ 1$ /// $\\text{Lancer} \\ 2`, "P", "F"],
+        ["P", arrStr[0], arrStr[2]],
+        ["F", arrStr[1], arrStr[3]],
     ], true)}
 
 Sur les $${nbOutcomes.frenchify()}$ issues possibles, ${nbRealized === 1 ? "une seule réalise" : `$${nbRealized}$ réalisent`} l'évènement "${event.str}".
@@ -137,6 +137,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        correctionStyle: {
+            tableOptions: {
+                firstCellIsDivided: true,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: true,
+            },
+        },
     };
     return question;
 };

package/lib/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numberPoolTwiceProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAiB9B,KAAK,WAAW,GAAG;IAEjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA6NF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}
+{"version":3,"file":"numberPoolTwiceProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAiB9B,KAAK,WAAW,GAAG;IAEjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAoOF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.js

@@ -109,9 +109,9 @@ const getCorrection = (identifiers) => {
     return `Dans le tableau ci-dessous, on a indiqué en vert les issues qui réalisent l'évènement "${event.str}" : 
   
 ${mdTable([
-        ["\\text{}", ...numberPool.map((i) => `n_2 : ${i}`)],
+        ["n_1$ /// $n_2", ...numberPool.map((i) => `${i}`)],
         ...Object.entries(arrArrStr).map(([s, arrStr]) => [
-            `n_1 : ${+s}`,
+            `${+s}`,
             ...Object.values(arrStr),
         ]),
     ], true)}
@@ -171,6 +171,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        correctionStyle: {
+            tableOptions: {
+                firstCellIsDivided: true,
+                firstColumnIsHeader: true,
+                firstRowIsHeader: true,
+            },
+        },
     };
     return question;
 };

package/lib/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"twoStepExperimentProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AA0B9B,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAyiBF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"twoStepExperimentProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/twoStepExperimentProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AA0B9B,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAwjBF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}