math-exercises 3.0.188 → 3.0.189

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

@@ -4,12 +4,6 @@ export * from "./isTableProbabilityLaw.js";
 export * from "./randomVariableStandardDeviation.js";
 export * from "./findValueToMatchRandomVariableAverage.js";
 export * from "./calculateProbaFromVATableLaw.js";
-export * from "./randomVariableSituationValues.js";
-export * from "./randomVariableSituationComputeProbability.js";
-export * from "./randomVariableSituationAverage.js";
-export * from "./randomVariableSituationVariance.js";
-export * from "./randomVariableSituationStandardDeviation.js";
-export * from "./randomVariableSituationIsGameFavorable.js";
-export * from "./randomVariableSituationProbabilityLaw.js";
+export * from "./situations/index.js";
 export * from "./missingValueInRandomVariableProbabilityLaw.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;AAGrD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,mCAAmC,CAAC;AAClD,cAAc,oCAAoC,CAAC;AACnD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,qCAAqC,CAAC;AACpD,cAAc,sCAAsC,CAAC;AACrD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4CAA4C,CAAC;AAE3D,cAAc,iDAAiD,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;AAGrD,cAAc,4CAA4C,CAAC;AAC3D,cAAc,mCAAmC,CAAC;AAElD,cAAc,uBAAuB,CAAC;AAEtC,cAAc,iDAAiD,CAAC"}

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

@@ -6,12 +6,6 @@ export * from "./randomVariableStandardDeviation.js";
 // export * from "./findValueToMatchRandomVariableAverage.js";
 export * from "./findValueToMatchRandomVariableAverage.js";
 export * from "./calculateProbaFromVATableLaw.js";
-export * from "./randomVariableSituationValues.js";
-export * from "./randomVariableSituationComputeProbability.js";
-export * from "./randomVariableSituationAverage.js";
-export * from "./randomVariableSituationVariance.js";
-export * from "./randomVariableSituationStandardDeviation.js";
-export * from "./randomVariableSituationIsGameFavorable.js";
-export * from "./randomVariableSituationProbabilityLaw.js";
+export * from "./situations/index.js";
 // export * from "./decideWhichGameIsLessRisky.js";
 export * from "./missingValueInRandomVariableProbabilityLaw.js";

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

@@ -0,0 +1,8 @@
+export * from "./randomVariableSituationAverage.js";
+export * from "./randomVariableSituationComputeProbability.js";
+export * from "./randomVariableSituationIsGameFavorable.js";
+export * from "./randomVariableSituationProbabilityLaw.js";
+export * from "./randomVariableSituationStandardDeviation.js";
+export * from "./randomVariableSituationValues.js";
+export * from "./randomVariableSituationVariance.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/situations/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,gDAAgD,CAAC;AAC/D,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4CAA4C,CAAC;AAC3D,cAAc,+CAA+C,CAAC;AAC9D,cAAc,oCAAoC,CAAC;AACnD,cAAc,sCAAsC,CAAC"}

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

@@ -0,0 +1,7 @@
+export * from "./randomVariableSituationAverage.js";
+export * from "./randomVariableSituationComputeProbability.js";
+export * from "./randomVariableSituationIsGameFavorable.js";
+export * from "./randomVariableSituationProbabilityLaw.js";
+export * from "./randomVariableSituationStandardDeviation.js";
+export * from "./randomVariableSituationValues.js";
+export * from "./randomVariableSituationVariance.js";

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationAverage.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { RandomVariableSituationParams } from "./randomVariableSituations.js";
+type Identifiers = {
+    params: RandomVariableSituationParams;
+};
+type Options = {
+    averageFormulation: string;
+};
+export declare const randomVariableSituationAverage: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=randomVariableSituationAverage.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituationAverage.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/situations/randomVariableSituationAverage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,6BAA6B,EAC9B,MAAM,+BAA+B,CAAC;AAEvC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,6BAA6B,CAAC;CACvC,CAAC;AAqGF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAWF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBzE,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationAverage.js

@@ -0,0 +1,112 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, 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 { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./randomVariableSituations.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductibleWithSign().toTree().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return va.getAverage().simplify().toTex();
+};
+const getInstruction = (identifiers, opts) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    const question = opts?.averageFormulation === "Calculer $E(X)$"
+        ? "Déterminer l'espérance $E(X)$ de $X$."
+        : "Déterminer le gain moyen auquel un joueur peut s'attendre après un grand nombre de parties.";
+    return (context +
+        `
+  
+${question}`);
+};
+const getHint = () => {
+    return `Dresse la loi de probabilité de $X$. Pour cela, détermine les valeurs possibles $x_i$ que peut prendre $X$, puis pour chaque valeur, calcule la probabilité $p_i$ associée.
+  
+Tu peux alors calculer l'espérance de $X$ par la formule : 
+
+$$
+E(X) = x_1\\times p_1 + \\ldots + x_n\\times p_n
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return `On dresse la loi de probabilité de $X$ : 
+  
+${va.getLawMdTable()}
+
+Puis on calcule l'espérance : 
+
+${alignTex([
+        ["E(X)", "=", va.getAverage().toTex()],
+        ["", "=", va.getAverage().simplify().toTex()],
+    ])}
+  `;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationAverageQuestion = (opts) => {
+    const params = buildRandomVariableSituation();
+    const identifiers = {
+        params,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const options = [
+    {
+        id: "averageFormulation",
+        label: "Formulation de la consigne",
+        target: GeneratorOptionTarget.instruction,
+        type: GeneratorOptionType.select,
+        values: ["Calculer $E(X)$", "Calculer le gain moyen"],
+        defaultValue: "Calculer $E(X)$",
+    },
+];
+export const randomVariableSituationAverage = {
+    id: "randomVariableSituationAverage",
+    connector: "=",
+    label: "Calculer l'espérance $E(X)$ d'une variable aléatoire dans un contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationAverageQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationComputeProbability.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { RandomVariableSituationParams } from "./randomVariableSituations.js";
+type Identifiers = {
+    params: RandomVariableSituationParams;
+    xi: number;
+};
+export declare const randomVariableSituationComputeProbability: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=randomVariableSituationComputeProbability.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationComputeProbability.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituationComputeProbability.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/situations/randomVariableSituationComputeProbability.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,6BAA6B,EAC9B,MAAM,+BAA+B,CAAC;AAEvC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,6BAA6B,CAAC;IACtC,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4LF,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAAC,WAAW,CAuBzE,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationComputeProbability.js

@@ -0,0 +1,176 @@
+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 { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { pluralize } from "../../../../../utils/strings/pluralize.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./randomVariableSituations.js";
+const getPropositions = (n, { answer, params }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const va = getRandomVariableSituation(params).getVA();
+    for (const p of va.yValues) {
+        tryToAddWrongProp(propositions, p.toTex());
+    }
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductibleProba().toTree().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { params, xi } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    const index = va.xValues.findIndex((x) => x.evaluate() === xi);
+    return va.yValues[index].toTex();
+};
+const getInstruction = (identifiers) => {
+    const { params, xi } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Calculer $P(X = ${xi})$.`);
+};
+const getHint = (identifiers) => {
+    const { xi } = identifiers;
+    return `Détermine l'ensemble des issues possibles pour cette expérience aléatoire. Puis, détermine les issues qui réalisent l'événement $X = ${xi}$. Tu peux alors utiliser l'équiprobabilité pour déterminer $P(X = ${xi})$.`;
+};
+const getCorrection = (identifiers) => {
+    const { xi, params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    const index = va.xValues.findIndex((x) => x.evaluate() === xi);
+    switch (params.id) {
+        case "coin": {
+            const throws = index === 0
+                ? "deux fois faces"
+                : index === 1
+                    ? "une fois pile, et une fois face"
+                    : "deux fois piles";
+            return `Cette expérience aléatoire a $4$ issues : 
+      
+- obtenir deux faces;
+- obtenir face au premier lancer, puis pile au deuxième;
+- obtenir pile au premier lancer, puis face au deuxième;
+- obtenir deux piles. 
+
+L'issue $X = ${xi}$ se réalise si on obtient ${throws}.
+      
+${index === 0 || index === 2
+                ? `Il n'y a qu'une issue qui réalise cet évènement sur les $4$ issues possibles. La probabilité recherchée vaut donc : 
+  
+$$
+${frac(1, 4).toTex()}
+$$`
+                : `Il y a deux issues qui réalise cet évènement sur les $4$ issues possibles. La probabilité recherchée vaut donc :  
+
+$$
+${frac(2, 4).toSimplificationTex()}
+$$`}
+ `;
+        }
+        case "urne": {
+            const effectif = xi === params.gb ? params.b : xi === params.gr ? params.r : params.n;
+            const color = xi === params.gb ? "blanche" : xi === params.gr ? "rouge" : "noire";
+            return `L'issue $X = ${xi}$ se réalise si on tire une boule ${color}.
+      
+Puisqu'il y a $${effectif}$ ${pluralize("boule", effectif)} ${pluralize(color, effectif)} sur un total de $${params.b + params.r + params.n}$ boules, la probabilité recherchée vaut : 
+
+$$
+P(X=${xi}) = ${getAnswer(identifiers)}
+$$`;
+        }
+        case "diceMultiple": {
+            const multiples = [];
+            for (let i = 1; i < params.n; i++) {
+                if (i % params.winningMultiple === 0) {
+                    multiples.push(i);
+                }
+            }
+            return `L'issue $X = ${xi}$ se réalise si on ${xi > 0 ? `obtient` : "n'obtient pas"} un multiple de $${params.winningMultiple}$.
+      
+Les faces du dés qui sont des multiples de $${params.winningMultiple}$ sont : $${multiples.join("\\ ; \\ ")}$.
+
+Il y a donc $${multiples.length}$ multiples de $${params.winningMultiple}$ possibles sur les $${params.n}$ faces.
+
+La probabilité recherchée est donc : 
+
+$$
+P(X=${xi}) = ${frac(multiples.length, params.n).toSimplificationTex()}
+$$
+`;
+            // case "diceSum":
+            //   return ``
+        }
+        case "cards": {
+            const effectif = xi === params.gAs ? "4" : xi === params.gFigure ? "12" : "36";
+            const card = xi === params.gAs
+                ? "as"
+                : xi === params.gFigure
+                    ? "figures"
+                    : "cartes qui ne sont ni des as ni des figures";
+            const card2 = xi === params.gAs
+                ? "un as"
+                : xi === params.gFigure
+                    ? "une figure"
+                    : "une carte qui n'est ni un as ni une figure";
+            return `L'issue $X = ${xi}$ se réalise si on tire ${card2}.
+      
+Puisqu'il y a $${effectif}$ ${card} sur un total de $52$ cartes, la probabilité recherchée vaut : 
+
+$$
+P(X=${xi}) = ${frac(effectif, 52).toSimplificationTex()}
+$$`;
+        }
+    }
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationComputeProbabilityQuestion = () => {
+    const params = buildRandomVariableSituation();
+    const xi = random(getRandomVariableSituation(params).getVA().xValues).evaluate();
+    const identifiers = {
+        params,
+        xi,
+    };
+    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 randomVariableSituationComputeProbability = {
+    id: "randomVariableSituationComputeProbability",
+    connector: "=",
+    label: "Calculer une probabilité du type $P(X=k)$ pour une variable aléatoire $X$ dans un contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationComputeProbabilityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationIsGameFavorable.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { RandomVariableSituationParams } from "./randomVariableSituations.js";
+type Identifiers = {
+    params: RandomVariableSituationParams;
+};
+export declare const randomVariableSituationIsGameFavorable: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=randomVariableSituationIsGameFavorable.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationIsGameFavorable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituationIsGameFavorable.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/situations/randomVariableSituationIsGameFavorable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,6BAA6B,EAC9B,MAAM,+BAA+B,CAAC;AAEvC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,6BAA6B,CAAC;CACvC,CAAC;AA2FF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAqBxE,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationIsGameFavorable.js

@@ -0,0 +1,94 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./randomVariableSituations.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Favorable au joueur", "raw");
+    tryToAddWrongProp(propositions, "Défavorable au joueur", "raw");
+    tryToAddWrongProp(propositions, "Équitable", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    const ev = va.getAverage().evaluate();
+    if (ev > 0)
+        return "Favorable au joueur";
+    if (ev < 0)
+        return "Défavorable au joueur";
+    return "Équitable";
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Ce jeu est-il favorable au joueur, défavorable au joueur, ou équitable ? `);
+};
+const getHint = () => {
+    return `Dresse la loi de probabilité de $X$. Pour cela, détermine les valeurs possibles $x_i$ que peut prendre $X$, puis pour chaque valeur, calcule la probabilité $p_i$ associée.
+  
+Tu peux alors calculer l'espérance de $X$ par la formule : 
+
+$$
+E(X) = x_1\\times p_1 + \\ldots + x_n\\times p_n
+$$
+
+On dit alors que le jeu est favorable au joueur si $E(X)>0$, defavorable au joueur si $E(X)<0$, et équitable si $E(X)=0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    const avg = va.getAverage();
+    return `On dresse la loi de probabilité de $X$ : 
+  
+${va.getLawMdTable()}
+
+Puis on calcule l'espérance : 
+
+${alignTex([
+        ["E(X)", "=", avg.toTex()],
+        ["", "=", avg.simplify().toTex()],
+    ])}
+ 
+Puisque $E(X)${avg.toSignInequationTex().slice(-2)}$, le jeu est ${getAnswer(identifiers).toLocaleLowerCase()}.`;
+};
+const getRandomVariableSituationAverageQuestion = (opts) => {
+    const params = buildRandomVariableSituation();
+    const identifiers = {
+        params,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const randomVariableSituationIsGameFavorable = {
+    id: "randomVariableSituationIsGameFavorable",
+    connector: "=",
+    label: "Déterminer si un jeu est favorable, défavorable ou équitable à l'aide de l'espérance d'une variable aléatoire dans un contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationAverageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationProbabilityLaw.d.ts

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

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationProbabilityLaw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituationProbabilityLaw.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/situations/randomVariableSituationProbabilityLaw.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,6BAA6B,EAC9B,MAAM,+BAA+B,CAAC;AAEvC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,6BAA6B,CAAC;IACtC,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AA+MF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAiBvE,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/situations/randomVariableSituationProbabilityLaw.js

@@ -0,0 +1,166 @@
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { xTableLineVEA } from "../../../../../exercises/vea/xTableLineVEA.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.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 { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./randomVariableSituations.js";
+const getAnswerTable = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return va.getLawTable();
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Déterminer la loi de probabilité de $X$.`);
+};
+const getHint = () => {
+    return `Détermine les valeurs possibles $x_i$ que peut prendre $X$. Puis, pour chaque valeur, calcule la probabilité $p_i$ associée.`;
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    const table = getRandomVariableSituation(params).getVA().getLawMdTable();
+    switch (params.id) {
+        case "coin":
+            return `On liste toutes les issues possibles : 
+      
+- $2$ piles : le gain du joueur est alors $${multiply(2, params.a).toSimplificationTex()}$ points. De plus, la probabilité d'obtenir $2$ piles est  : 
+
+$$
+\\frac{1}{2}\\times \\frac{1}{2} = \\frac{1}{4}
+$$
+
+- $1$ pile, $1$ face : le gain du joueur est alors $${substract(params.a, params.b).toSimplificationTex()}$ points. De plus, il y a deux possibilités pour réaliser cette issue : obtenir pile au premier lancer puis face au deuxième, ou obtenir face au premier lance puis pile au deuxième. La probabilité de cette issue est donc : 
+
+$$
+\\frac{1}{2}\\times \\frac{1}{2} + \\frac{1}{2}\\times \\frac{1}{2} = \\frac{1}{2}
+$$
+
+
+- $2$ faces: le gain du joueur est alors $${opposite(multiply(2, params.b)).toSimplificationTex()}$ points. De plus, la probabilité d'obtenir $2$ piles est  : 
+
+$$
+\\frac{1}{2}\\times \\frac{1}{2} = \\frac{1}{4}
+$$
+
+La loi de probabilité de $X$ est donc : 
+
+${table}
+
+`;
+        case "urne": {
+            const total = params.n + params.r + params.b;
+            return `On s'intéresse à chaque issue : 
+
+- Tirer une boule blanche : le gain algébrique est $${params.gb}$, et la probabilité vaut $${frac(params.b, total).toSimplificationTex()}$ ; 
+- Tirer une boule rouge : le gain algébrique est $${params.gr}$, et la probabilité vaut $${frac(params.r, total).toSimplificationTex()}$ ; 
+- Tirer une boule noire : le gain algébrique est $${params.gn}$, et la probabilité vaut $${frac(params.n, total).toSimplificationTex()}$.
+
+La loi de probabilité de $X$ est donc : 
+
+${table}
+`;
+        }
+        case "diceMultiple": {
+            const multiples = [];
+            for (let i = 1; i <= params.n; i++) {
+                if (i % params.winningMultiple === 0) {
+                    multiples.push(i);
+                }
+            }
+            return `Les faces du dés qui sont des multiples de $${params.winningMultiple}$ sont : $${multiples.join("\\ ; \\ ")}$.
+      
+La probabilité d'obtenir un multiple de $${params.winningMultiple}$ est donc $${frac(multiples.length, params.n).toSimplificationTex()}$, et dans ce cas on gagne $${params.gain}\\ €$.
+
+La probabilité de ne pas obtenir un multiple de $${params.winningMultiple}$ est alors $${frac(params.n - multiples.length, params.n).toSimplificationTex()}$, et dans ce cas on perd $${params.loss}\\ €$.
+
+La loi de probabilité de $X$ est donc : 
+
+${table}
+`;
+        }
+        case "cards": {
+            return `On s'intéresse à chaque issue : 
+
+- Tirer un as : le gain algébrique est $${params.gAs}$, et la probabilité vaut $${frac(4, 52).toSimplificationTex()}$ ; 
+- Tirer une figure: le gain algébrique est $${params.gFigure}$, et la probabilité vaut $${frac(12, 52).toSimplificationTex()}$ ; 
+- Tirer une autre carte : le gain algébrique est $${params.gOther}$, et la probabilité vaut $${frac(36, 52).toSimplificationTex()}$.
+
+La loi de probabilité de $X$ est donc : 
+
+${table}
+`;
+        }
+        //     case "diceSum": {
+        //       const results = [["\\ ", "1", "2", "3", "4"], ["1"], ["2"], ["3"], ["4"]];
+        //       for (let i = 1; i < 5; i++) {
+        //         for (let j = 1; j < 5; j++) {
+        //           results[i][j] = (i + j).frenchify();
+        //         }
+        //       }
+        //       return `Voici tous les résultats possibles en fonction du résultat de chaque dé :
+        // ${mdTable(results, true)}
+        // Les valeurs possibles pour $X$ sont donc :
+        // ${mdTable(getAnswerTable(identifiers), true)}`;
+        //     }
+    }
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        const sorted = ans[0]
+            .map((v, i) => [v, ans[1][i]])
+            .sort((a, b) => a[0].unfrenchify() - b[0].unfrenchify());
+        const sortedStudentAns = [sorted.map((x) => x[0]), sorted.map((x) => x[1])];
+        return (xTableLineVEA(sortedStudentAns[0], answerTable[0]) &&
+            xTableLineVEA(sortedStudentAns[1], answerTable[1]));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationValuesQuestion = () => {
+    const params = buildRandomVariableSituation();
+    const values = getRandomVariableSituation(params).getVA().xValues;
+    const identifiers = {
+        params,
+        initTable: [
+            [`$x_i$`, ...values.map((_e) => "")],
+            [`$P(X=x_i)$`, ...values.map((_e) => "")],
+        ],
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: identifiers.initTable,
+    };
+};
+export const randomVariableSituationProbabilityLaw = {
+    id: "randomVariableSituationProbabilityLaw",
+    label: "Dresser la loi de probabilité d'une variable aléatoire avec contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    getAnswerTable,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "valueTable",
+};