math-exercises 3.0.157 → 3.0.159

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/findValueForFairRandomVariable.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/findValueForFairRandomVariable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findValueForFairRandomVariable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/findValueForFairRandomVariable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,SAAS,EAAE,eAAe,EAAE,CAAC;CAC9B,CAAC;AA0HF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAmBhE,CAAC"}

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

@@ -0,0 +1,141 @@
+import { addValidProp, shuffleProps, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.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 { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        throw Error("QCM not implemented");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { probasIds, valuesIds } = identifiers;
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    const xIndex = probas.findIndex((e) => !e.isNumeric) > -1
+        ? probas.findIndex((e) => !e.isNumeric)
+        : values.findIndex((e) => !e.isNumeric);
+    let esp = (xIndex === 0
+        ? multiply(values[1], probas[1])
+        : multiply(values[0], probas[0]));
+    for (let i = xIndex === 0 ? 2 : 1; i < values.length; i++) {
+        if (i === xIndex)
+            continue;
+        esp = add(esp, multiply(values[i], probas[i]));
+    }
+    const simp = esp.simplify();
+    const isXMissing = values.some((x) => !x.isNumeric);
+    const coeff = isXMissing ? probas[xIndex] : values[xIndex];
+    const x = frac(simp, coeff).simplify().evaluate();
+    return x.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { probasIds, valuesIds } = identifiers;
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    return `On joue à un jeu de hasard. On note $X$ la variable aléatoire égale au gain du joueur. La loi de probabilité de $X$ est donnée ci-dessous: 
+
+${mdTable([
+        ["$x_i$ (en $€$)", ...values.map((e) => e.toTex())],
+        ["$P(X=x_i)$", ...probas.map((e) => e.toTex())],
+    ])}
+
+Pour quelle valeur de $x$ le jeu est-il équitable ? `;
+};
+const getHint = () => {
+    return `Un jeu est équitable si l'espérance de gain est nulle. 
+  
+Calcule donc $E(X)$ en fonction de $x$, puis résous l'équation $E(x) = 0$.`;
+};
+const getCorrection = (identifiers) => {
+    return ``;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindProbaForFairGameQuestion = () => {
+    const xValues = [
+        0,
+        randint(1, 5),
+        randint(5, 10),
+        5 * randint(10, 20),
+        100 * randint(1, 10),
+    ];
+    const probas = [
+        randfloat(0.1, 0.3, 2),
+        randfloat(0.02, 0.04, 3),
+        randfloat(0.01, 0.02, 3),
+        randfloat(0.001, 0.009, 3),
+    ];
+    const left = round(1 - probas.reduce((acc, curr) => acc + curr, 0), 4);
+    probas.unshift(left);
+    const xNodes = xValues.map((e) => e.toTree());
+    const yNodes = probas.map((e) => e.toTree());
+    const isXMissing = coinFlip();
+    if (isXMissing) {
+        xNodes[randint(0, xValues.length)] = "x".toTree();
+    }
+    else {
+        yNodes[randint(0, xValues.length)] = "x".toTree();
+    }
+    const identifiers = {
+        valuesIds: xNodes.map((e) => e.toIdentifiers()),
+        probasIds: yNodes.map((e) => e.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),
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
+        },
+    };
+};
+export const findValueForFairRandomVariable = {
+    id: "findValueForFairRandomVariable",
+    connector: "=",
+    label: "Compléter la loi de probabilité d'une variable aléatoire pour rendre un jeu équitable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindProbaForFairGameQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/findValueToMatchRandomVariableAverage.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/findValueToMatchRandomVariableAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findValueToMatchRandomVariableAverage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/findValueToMatchRandomVariableAverage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AA6JF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAmBvE,CAAC"}

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

@@ -0,0 +1,174 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.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 { add, AddNode } 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 { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const ansNb = answer.unfrenchify();
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, (ansNb + randfloat(-3, 3, 2)).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { probasIds, valuesIds, avgIds } = identifiers;
+    const esp = reifyAlgebraic(avgIds);
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    const xIndex = probas.findIndex((e) => !e.isNumeric) > -1
+        ? probas.findIndex((e) => !e.isNumeric)
+        : values.findIndex((e) => !e.isNumeric);
+    let partialEsp = (xIndex === 0
+        ? multiply(values[1], probas[1])
+        : multiply(values[0], probas[0]));
+    for (let i = xIndex === 0 ? 2 : 1; i < values.length; i++) {
+        if (i === xIndex)
+            continue;
+        partialEsp = add(partialEsp, multiply(values[i], probas[i]));
+    }
+    const simp = partialEsp.simplify();
+    const sum = substract(esp, simp);
+    const isXMissing = values.some((x) => !x.isNumeric);
+    const coeff = isXMissing ? probas[xIndex] : values[xIndex];
+    const x = round(frac(sum, coeff).simplify().evaluate(), 5);
+    return x.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { probasIds, valuesIds, avgIds } = identifiers;
+    const avg = reifyAlgebraic(avgIds);
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    return `La loi de probabilité d'une variable aléatoire $X$ est donnée ci-dessous: 
+
+${mdTable([
+        ["$x_i$", ...values.map((e) => dollarize(e.toTex()))],
+        ["$P(X=x_i)$", ...probas.map((e) => dollarize(e.toTex()))],
+    ])}
+
+On sait de plus que l'espérance de $X$ vaut $E(X) = ${avg.toTex()}$.
+
+Que vaut $x$ ? `;
+};
+const getHint = () => {
+    return `Si $X$ est une variable aléatoire qui prend les valeurs $x_1$, $x_2$, $\\ldots$, $x_n$ de probabilités respectives $p_1$, $p_2$, $\\ldots$, $p_n$, alors son espérance $E(X)$ vaut : 
+  
+$$
+E(X) = x_1p_1 + x_2p_2 + \\ldots + x_np_n
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { probasIds, valuesIds, avgIds } = identifiers;
+    const avg = reifyAlgebraic(avgIds);
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    const sum = operatorComposition(AddNode, values.map((v, i) => multiply(v, probas[i])));
+    const sumSimp = sum.simplify();
+    return `On calcule l'espérance de $X$ : 
+  
+${alignTex([
+        ["", "E(X)"],
+        ["=", sum.toTex()],
+        ["=", sumSimp.toTex()],
+    ])}
+
+On résout alors l'équation $E(X) = ${avg.toTex()}$. Cela donne : 
+
+$$
+x = ${getAnswer(identifiers)}
+$$
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindProbaForFairGameQuestion = () => {
+    const xValues = [
+        0,
+        randint(1, 5),
+        randint(5, 10),
+        5 * randint(10, 20),
+        100 * randint(1, 10),
+    ];
+    const probas = [
+        randfloat(0.1, 0.3, 2),
+        randfloat(0.02, 0.04, 3),
+        randfloat(0.01, 0.02, 3),
+        randfloat(0.001, 0.009, 3),
+    ];
+    const left = round(1 - probas.reduce((acc, curr) => acc + curr, 0), 4);
+    probas.unshift(left);
+    const avg = round(xValues.reduce((acc, curr, i) => acc + curr * probas[i], 0), 5);
+    const xNodes = xValues.map((e) => e.toTree());
+    const yNodes = probas.map((e) => e.toTree());
+    const isXMissing = coinFlip();
+    if (isXMissing) {
+        xNodes[randint(0, xValues.length)] = "x".toTree();
+    }
+    else {
+        yNodes[randint(1, xValues.length)] = "x".toTree();
+    }
+    const identifiers = {
+        valuesIds: xNodes.map((e) => e.toIdentifiers()),
+        probasIds: yNodes.map((e) => e.toIdentifiers()),
+        avgIds: avg.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),
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
+        },
+    };
+};
+export const findValueToMatchRandomVariableAverage = {
+    id: "findValueToMatchRandomVariableAverage",
+    connector: "=",
+    label: "Compléter la loi de probabilité d'une variable aléatoire pour rendre un jeu équitable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindProbaForFairGameQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -2,4 +2,5 @@ export * from "./randomVariableAverage.js";
 export * from "./randomVariableVariance.js";
 export * from "./isTableProbabilityLaw.js";
 export * from "./randomVariableStandardDeviation.js";
+export * from "./findValueToMatchRandomVariableAverage.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AAErD,cAAc,4CAA4C,CAAC"}

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

@@ -2,3 +2,5 @@ export * from "./randomVariableAverage.js";
 export * from "./randomVariableVariance.js";
 export * from "./isTableProbabilityLaw.js";
 export * from "./randomVariableStandardDeviation.js";
+// export * from "./findValueForFairRandomVariable.js";
+export * from "./findValueToMatchRandomVariableAverage.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/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;AAsNF,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

@@ -158,6 +158,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
                 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

@@ -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

@@ -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;AAijBF,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"}

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

@@ -442,6 +442,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/sequences/arithmetic/arithmeticFindExplicitFormulaFirstTermRandom.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    firstValue: number;
+    reason: number;
+    firstRank: number;
+};
+export declare const arithmeticFindExplicitFormulaFirstTermRandom: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=arithmeticFindExplicitFormulaFirstTermRandom.d.ts.map

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFirstTermRandom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindExplicitFormulaFirstTermRandom.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFirstTermRandom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyHF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAoB5E,CAAC"}