math-exercises 3.0.170 → 3.0.172

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

@@ -0,0 +1,211 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./utils/randomVariableSituations.js";
+const getAnswer = (identifiers) => {
+    const { params } = identifiers;
+    const va = getRandomVariableSituation(params).getVA();
+    return new DiscreteSetNode(va.xValues).simplify().toTex();
+};
+const getPropositions = (_n, { answer, params }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    switch (params.id) {
+        case "coin":
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.a.toTree(), params.b.toTree()])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode(["\\text{Pile}".toTree(), "\\text{Face}".toTree()])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.a.toTree(), (-params.b).toTree()])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.a.toTree(), params.b.toTree()])
+                .simplify()
+                .toTex());
+            break;
+        case "urne":
+            tryToAddWrongProp(propositions, new DiscreteSetNode([
+                "\\text{Blanche}".toTree(),
+                "\\text{Rouge}".toTree(),
+                "\\text{Noire}".toTree(),
+            ])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([
+                params.b.toTree(),
+                params.r.toTree(),
+                params.n.toTree(),
+            ])
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([
+                params.gb.toTree(),
+                params.gr.toTree(),
+                (-params.gn).toTree(),
+            ])
+                .simplify()
+                .toTex());
+            break;
+        case "diceMultiple": {
+            const allValues = [...Array(params.n).keys()].map((i) => i + 1);
+            const multiples = [];
+            for (let i = 1; i < params.n; i++) {
+                if (i % params.winningMultiple === 0) {
+                    multiples.push(i);
+                }
+            }
+            tryToAddWrongProp(propositions, new DiscreteSetNode(multiples.map((m) => m.toTree()))
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode(allValues.map((v) => v.toTree()))
+                .simplify()
+                .toTex());
+            tryToAddWrongProp(propositions, new DiscreteSetNode([params.gain.toTree(), params.loss.toTree()])
+                .simplify()
+                .toTex());
+        }
+    }
+    return shuffle(propositions);
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Quel est l'ensemble des valeurs possibles pour $X$ ?`);
+};
+const getHint = (identifiers) => {
+    const { params } = identifiers;
+    switch (params.id) {
+        case "coin":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd des points) en fonction du résultat de ses lancers. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        case "urne":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd de l'argent) en fonction de la boule qu'il a tirée. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        case "diceMultiple":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd de l'argent) en fonction de la face obtenue. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        case "cards":
+            return `La variable aléatoire $X$ donne le gain algébrique du joueur (c'est à dire un gain qui peut être négatif si le joueur perd de l'argent) en fonction de la carte qu'il a tirée. Les valeurs $x_i$ qu'elle prend sont donc les valeurs de gain (ou de perte) possibles.`;
+        // case "diceSum":
+        //   return `Chaque dé peut valoir $1$, $2$, $3$ ou $4$. Cela créé donc $16$ résultats possibles, par exemple $1+1=2$, $3+4=7$, etc... Détermine tous les résultats possibles.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    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.
+- $1$ pile, $1$ face : le gain du joueur est alors $${substract(params.a, params.b).toSimplificationTex()}$ points.
+- $2$ faces: le gain du joueur est alors $${opposite(multiply(2, params.b)).toSimplificationTex()}$ points.
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+        case "urne":
+            return `Le gain pour chaque tirage vaut : 
+
+- $${params.gb}$ si on tire une boule blanche ; 
+- $${params.gr}$ si on tire une boule rouge ;
+- $${params.gn}$ si on tire une boule noire.
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+        case "diceMultiple":
+            return `Si on obtient un multiple de $${params.winningMultiple}$, on gagne $${params.gain}\\ €$, donc $X$ vaut $${params.gain}$ dans ce cas. Sinon, on perd $${params.loss}\\ €$, donc $X$ vaut $-${params.loss}$. 
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+        case "cards":
+            return `Le gain pour chaque tirage vaut : 
+
+- $${params.gAs}$ si on tire un as ; 
+- $${params.gFigure}$ si on tire une figure ;
+- $${params.gOther}$ si on tire une autre carte.
+
+L'ensemble des valeurs possibles pour $X$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+        //     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 ["lbrace", "semicolon", "rbrace"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = discreteSetParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationValuesQuestion = () => {
+    const params = buildRandomVariableSituation();
+    const identifiers = {
+        params,
+    };
+    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 randomVariableSituationValues = {
+    id: "randomVariableSituationValues",
+    label: "Donner l'ensemble des valeurs possibles d'une variable aléatoire avec contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationValuesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getAnswer,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituationVariance.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/randomVariableSituationVariance.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAE7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AA4GF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAqBjE,CAAC"}

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

@@ -0,0 +1,113 @@
+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 { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { buildRandomVariableSituation, getRandomVariableSituation, } from "./utils/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.getVariance().simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const context = getRandomVariableSituation(params).getContext();
+    return (context +
+        `
+  
+Que vaut la variance $V(X)$ de $X$ ?
+
+Donner la valeur exacte ou une valeur arrondie au centième.`);
+};
+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
+$$
+
+La variance $V(X)$ s'obtient par la formule :
+  
+$$
+V(X) = p_1(x_1-E(X))^2 + \\ldots + p_n(x_n-E(X))^2
+$$
+`;
+};
+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()],
+    ])}
+  
+Enfin, on calcule la variance : 
+
+${alignTex([
+        ["V(X)", "=", va.getVariance().toTex()],
+        ["", "=", va.getVariance().simplify().toTex()],
+    ])}`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRandomVariableSituationAverageQuestion = () => {
+    const params = buildRandomVariableSituation();
+    const identifiers = {
+        params,
+    };
+    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 randomVariableSituationVariance = {
+    id: "randomVariableSituationVariance",
+    connector: "=",
+    label: "Calculer la variance $V(X)$ d'une variable aléatoire dans un contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRandomVariableSituationAverageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -25,7 +25,7 @@ const getInstruction = (identifiers) => {
     const va = new RandomVariable(xValuesIds.map((e) => reifyAlgebraic(e)), yValuesIds.map((e) => reifyAlgebraic(e)));
     return `Soit $X$ une variable aléatoire dont la loi de probabilités est donnée ci-dessous.
 
-${va.getLawTable()}
+${va.getLawMdTable()}
 
 Que vaut l'écart type $\\sigma(X)$ de $X$ ?
 

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

@@ -27,7 +27,7 @@ const getInstruction = (identifiers) => {
     const va = new RandomVariable(xValuesIds.map((e) => reifyAlgebraic(e)), yValuesIds.map((e) => reifyAlgebraic(e)));
     return `Soit $X$ une variable aléatoire dont la loi de probabilités est donnée ci-dessous.
 
-${va.getLawTable()}
+${va.getLawMdTable()}
 
 Que vaut la variance $V(X)$ de $X$ ?
 

package/lib/exercises/math/probaStat/randomVariable/utils/buildVAOfGivenAverage.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Génère une loi de probabilité pour une variable aléatoire X
+ * dans le contexte d'un jeu de hasard fictif (valeurs en euros).
+ *
+ * Contraintes :
+ * - Les x_i sont des entiers, avec au moins un négatif et au moins un positif
+ * - Les p_i sont dans ]0, 1[, à 3 décimales maximum
+ * - ∑ p_i = 1  (somme des probabilités)
+ * - ∑ x_i * p_i = expectedValue  (espérance cible, entier)
+ */
+interface ProbabilityEntry {
+    x: number;
+    p: number;
+}
+type ProbabilityLaw = ProbabilityEntry[];
+/**
+ * Génère une loi de probabilité pour un jeu de hasard fictif.
+ *
+ * @param count         Nombre de valeurs distinctes de X (3 à 10)
+ * @param expectedValue Espérance cible — entier strictement compris entre
+ *                      min(x_i) et max(x_i). Pour un jeu "légèrement perdant"
+ *                      typique, une valeur négative proche de 0 convient.
+ * @returns             Tableau trié { x, p }[] représentant la loi
+ *
+ * @example
+ * generateProbabilityLaw(5, -1)
+ * // [{ x: -10, p: 0.124 }, { x: -2, p: 0.253 }, { x: 1, p: 0.387 }, ...]
+ */
+export declare function generateProbabilityLaw(count: number, expectedValue: number): ProbabilityLaw;
+export {};
+//# sourceMappingURL=buildVAOfGivenAverage.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/utils/buildVAOfGivenAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildVAOfGivenAverage.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/utils/buildVAOfGivenAverage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,UAAU,gBAAgB;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,KAAK,cAAc,GAAG,gBAAgB,EAAE,CAAC;AA4LzC;;;;;;;;;;;;GAYG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,MAAM,EACb,aAAa,EAAE,MAAM,GACpB,cAAc,CAYhB"}

package/lib/exercises/math/probaStat/randomVariable/utils/buildVAOfGivenAverage.js

@@ -0,0 +1,192 @@
+/**
+ * Génère une loi de probabilité pour une variable aléatoire X
+ * dans le contexte d'un jeu de hasard fictif (valeurs en euros).
+ *
+ * Contraintes :
+ * - Les x_i sont des entiers, avec au moins un négatif et au moins un positif
+ * - Les p_i sont dans ]0, 1[, à 3 décimales maximum
+ * - ∑ p_i = 1  (somme des probabilités)
+ * - ∑ x_i * p_i = expectedValue  (espérance cible, entier)
+ */
+// ── Utilitaires ──────────────────────────────────────────────────────────────
+function round(value, decimals) {
+    const factor = Math.pow(10, decimals);
+    return Math.round(value * factor) / factor;
+}
+function randomInt(min, max) {
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+// ── Génération des valeurs x_i ───────────────────────────────────────────────
+function generateXValues(count) {
+    const negativePool = [-50, -20, -10, -5, -3, -2, -1];
+    const positivePool = [1, 2, 3, 5, 10, 20, 50, 100, 200];
+    const values = new Set();
+    // Garantir au moins une valeur négative et une positive
+    values.add(negativePool[randomInt(0, negativePool.length - 1)]);
+    values.add(positivePool[randomInt(0, positivePool.length - 1)]);
+    const allPool = [...negativePool, 0, ...positivePool];
+    let attempts = 0;
+    while (values.size < count && attempts < 200) {
+        values.add(allPool[randomInt(0, allPool.length - 1)]);
+        attempts++;
+    }
+    return Array.from(values)
+        .sort((a, b) => a - b)
+        .slice(0, count);
+}
+// ── Cœur : génération des probabilités avec espérance cible ──────────────────
+/**
+ * Résout le problème de trouver des p_i à 3 décimales vérifiant :
+ *   (1)  ∑ p_i = 1
+ *   (2)  ∑ x_i * p_i = expectedValue
+ *   (3)  p_i ∈ ]0, 1[
+ *
+ * Stratégie en millièmes entiers (travailler sur q_i = 1000 * p_i ∈ ℤ) :
+ *
+ * Étape A — Point de départ aléatoire
+ *   On tire des poids w_i aléatoires et on les normalise pour obtenir
+ *   une solution approchée de (1).
+ *
+ * Étape B — Correction vers l'espérance cible
+ *   On dispose d'un degré de liberté dans le plan des solutions :
+ *     ∑ δ_i = 0         (conserver la somme à 1)
+ *     ∑ x_i δ_i = ΔE    (corriger l'espérance)
+ *   La correction de norme minimale dans ce plan est :
+ *
+ *     v' = x - (x·u) u   avec u = (1/√n, …, 1/√n)
+ *     v  = v' / ‖v'‖
+ *     δ  = β · v   avec β = ΔE / (x · v)
+ *
+ * Étape C — Arrondi contrôlé en millièmes
+ *   On arrondit chaque q_i = round(1000 * (p_i + δ_i)), puis on corrige
+ *   les deux résidus (somme et espérance) en cherchant la paire (i, j)
+ *   et les deltas ±1 millième qui réduisent simultanément les deux écarts.
+ */
+function generateProbabilities(xValues, expectedValue) {
+    const SCALE = 1000; // travail en millièmes
+    const n = xValues.length;
+    const ETarget = expectedValue * SCALE; // espérance en millièmes·unités
+    // ── Vérification de faisabilité ──────────────────────────────────────────
+    // Avec p_i > 0 et ∑ p_i = 1, l'espérance est une combinaison convexe stricte
+    // des x_i, donc E ∈ ]min(x), max(x)[ est nécessaire et suffisant.
+    const xMin = Math.min(...xValues);
+    const xMax = Math.max(...xValues);
+    if (expectedValue <= xMin || expectedValue >= xMax) {
+        throw new Error(`Espérance cible ${expectedValue} hors de l'intervalle ouvert ` +
+            `]${xMin}, ${xMax}[ défini par les valeurs de X. ` +
+            `Choisissez une espérance dans cet intervalle.`);
+    }
+    const MAX_ATTEMPTS = 3000;
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+        // ── Étape A : point de départ aléatoire normalisé ──────────────────────
+        const weights = Array.from({ length: n }, () => randomInt(1, 20));
+        const wSum = weights.reduce((a, b) => a + b, 0);
+        let p = weights.map((w) => w / wSum);
+        // ── Étape B : correction vers l'espérance cible ────────────────────────
+        // Direction orthogonale à u = (1/√n,…,1/√n) dans l'espace de x
+        const sqrtN = Math.sqrt(n);
+        const u = Array(n).fill(1 / sqrtN);
+        const xDotU = xValues.reduce((acc, xi, i) => acc + xi * u[i], 0);
+        const vPrime = xValues.map((xi, i) => xi - xDotU * u[i]);
+        const vNorm = Math.sqrt(vPrime.reduce((acc, vi) => acc + vi * vi, 0));
+        if (vNorm < 1e-10)
+            continue;
+        const v = vPrime.map((vi) => vi / vNorm);
+        const ECurrent = p.reduce((acc, pi, i) => acc + pi * xValues[i], 0);
+        const deltaE = expectedValue - ECurrent;
+        const xDotV = xValues.reduce((acc, xi, i) => acc + xi * v[i], 0);
+        if (Math.abs(xDotV) < 1e-10)
+            continue;
+        const beta = deltaE / xDotV;
+        p = p.map((pi, i) => pi + beta * v[i]);
+        // Rejeter si des probabilités sont hors ]0, 1[
+        if (p.some((pi) => pi <= 0 || pi >= 1))
+            continue;
+        // ── Étape C : arrondi contrôlé en millièmes ────────────────────────────
+        let q = p.map((pi) => Math.round(pi * SCALE));
+        q = q.map((qi) => Math.max(qi, 1)); // garantir q_i >= 1
+        // Correction itérative des deux résidus (somme et espérance)
+        let converged = false;
+        for (let iter = 0; iter < 500; iter++) {
+            const sumQ = q.reduce((a, b) => a + b, 0);
+            const espQ = q.reduce((acc, qi, i) => acc + qi * xValues[i], 0);
+            const dS = SCALE - sumQ; // résidu de somme (en millièmes)
+            const dE = ETarget - espQ; // résidu d'espérance (en millièmes·€)
+            if (dS === 0 && dE === 0) {
+                converged = true;
+                break;
+            }
+            // Chercher la paire (i, j) et les deltas entiers (d1, d2) ∈ {-1,0,1}²
+            // qui minimisent |dS_new| + λ|dE_new| tout en respectant q_i ≥ 1.
+            let bestScore = Infinity;
+            let bestMove = null;
+            for (let i = 0; i < n; i++) {
+                for (let j = i === -1 ? 0 : i + 1; j < n; j++) {
+                    if (i === j)
+                        continue;
+                    for (const d1 of [-1, 0, 1]) {
+                        for (const d2 of [-1, 0, 1]) {
+                            if (d1 === 0 && d2 === 0)
+                                continue;
+                            const newQi = q[i] + d1;
+                            const newQj = q[j] + d2;
+                            if (newQi < 1 || newQj < 1 || newQi >= SCALE || newQj >= SCALE)
+                                continue;
+                            const newDS = Math.abs(dS - (d1 + d2));
+                            const newDE = Math.abs(dE - (xValues[i] * d1 + xValues[j] * d2));
+                            // Priorité absolue à réduire |dS|, puis |dE|
+                            const score = newDS * 1_000_000 + newDE;
+                            if (score < bestScore) {
+                                bestScore = score;
+                                bestMove = { i, j, d1, d2 };
+                            }
+                        }
+                    }
+                }
+            }
+            if (!bestMove)
+                break;
+            q[bestMove.i] += bestMove.d1;
+            q[bestMove.j] += bestMove.d2;
+        }
+        if (!converged)
+            continue;
+        // ── Validation finale ──────────────────────────────────────────────────
+        const finalSum = q.reduce((a, b) => a + b, 0);
+        const finalEsp = q.reduce((acc, qi, i) => acc + qi * xValues[i], 0);
+        if (finalSum !== SCALE)
+            continue;
+        if (finalEsp !== ETarget)
+            continue;
+        if (q.some((qi) => qi <= 0 || qi >= SCALE))
+            continue;
+        return q.map((qi) => round(qi / SCALE, 3));
+    }
+    throw new Error(`Impossible de générer une loi valide après ${MAX_ATTEMPTS} tentatives. ` +
+        `Essayez avec une espérance différente ou davantage de valeurs.`);
+}
+// ── Point d'entrée public ─────────────────────────────────────────────────────
+/**
+ * Génère une loi de probabilité pour un jeu de hasard fictif.
+ *
+ * @param count         Nombre de valeurs distinctes de X (3 à 10)
+ * @param expectedValue Espérance cible — entier strictement compris entre
+ *                      min(x_i) et max(x_i). Pour un jeu "légèrement perdant"
+ *                      typique, une valeur négative proche de 0 convient.
+ * @returns             Tableau trié { x, p }[] représentant la loi
+ *
+ * @example
+ * generateProbabilityLaw(5, -1)
+ * // [{ x: -10, p: 0.124 }, { x: -2, p: 0.253 }, { x: 1, p: 0.387 }, ...]
+ */
+export function generateProbabilityLaw(count, expectedValue) {
+    if (count < 3 || count > 10) {
+        throw new Error("Le nombre de valeurs doit être compris entre 3 et 10.");
+    }
+    if (!Number.isInteger(expectedValue)) {
+        throw new Error("L'espérance cible doit être un entier.");
+    }
+    const xValues = generateXValues(count);
+    const probabilities = generateProbabilities(xValues, expectedValue);
+    return xValues.map((x, i) => ({ x, p: probabilities[i] }));
+}

package/lib/exercises/math/probaStat/randomVariable/utils/randomVariableSituations.d.ts

@@ -1,12 +1,41 @@
-export declare const situations: ({
-    id: string;
-    label: string;
-    xis: never[];
-    pis: never[];
-} | {
-    label: string;
-    id?: undefined;
-    xis?: undefined;
-    pis?: undefined;
-})[];
+import { RandomVariable } from "../../../../../math/probability/randomVariable.js";
+type UrneParams = {
+    b: number;
+    r: number;
+    n: number;
+    gb: number;
+    gr: number;
+    gn: number;
+};
+type CoinParams = {
+    b: number;
+    a: number;
+    n: number;
+};
+type DiceMultipleParams = {
+    n: number;
+    winningMultiple: number;
+    gain: number;
+    loss: number;
+};
+type CardsParams = {
+    gAs: number;
+    gFigure: number;
+    gOther: number;
+};
+export type SituationParams = (UrneParams & {
+    id: "urne";
+}) | (CoinParams & {
+    id: "coin";
+}) | (DiceMultipleParams & {
+    id: "diceMultiple";
+}) | (CardsParams & {
+    id: "cards";
+});
+export declare const getRandomVariableSituation: (params: SituationParams) => {
+    getContext: () => string;
+    getVA: () => RandomVariable;
+};
+export declare const buildRandomVariableSituation: () => SituationParams;
+export {};
 //# sourceMappingURL=randomVariableSituations.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/utils/randomVariableSituations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"randomVariableSituations.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/utils/randomVariableSituations.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;;;;;;;;;;IAqCtB,CAAC"}
+{"version":3,"file":"randomVariableSituations.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/utils/randomVariableSituations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0CAA0C,CAAC;AAU1E,KAAK,UAAU,GAAG;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAqDF,KAAK,UAAU,GAAG;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmEF,KAAK,kBAAkB,GAAG;IACxB,CAAC,EAAE,MAAM,CAAC;IACV,eAAe,EAAE,MAAM,CAAC;IACxB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAkCF,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA4BF,MAAM,MAAM,eAAe,GACvB,CAAC,UAAU,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,GAC7B,CAAC,UAAU,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,GAC7B,CAAC,kBAAkB,GAAG;IAAE,EAAE,EAAE,cAAc,CAAA;CAAE,CAAC,GAC7C,CAAC,WAAW,GAAG;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AAIpC,eAAO,MAAM,0BAA0B,GAAI,QAAQ,eAAe;;;CAajE,CAAC;AAEF,eAAO,MAAM,4BAA4B,QAAO,eAkB/C,CAAC"}