math-exercises 3.0.187 → 3.0.189

package/lib/exercises/math/probaStat/randomVariable/situations/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 "./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/situations/randomVariableSituationVariance.d.ts

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

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

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

package/lib/exercises/math/probaStat/randomVariable/situations/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 "./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/situations/randomVariableSituations.d.ts

@@ -0,0 +1,41 @@
+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 RandomVariableSituationParams = (UrneParams & {
+    id: "urne";
+}) | (CoinParams & {
+    id: "coin";
+}) | (DiceMultipleParams & {
+    id: "diceMultiple";
+}) | (CardsParams & {
+    id: "cards";
+});
+export declare const getRandomVariableSituation: (params: RandomVariableSituationParams) => {
+    getContext: () => string;
+    getVA: () => RandomVariable;
+};
+export declare const buildRandomVariableSituation: () => RandomVariableSituationParams;
+export {};
+//# sourceMappingURL=randomVariableSituations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"randomVariableSituations.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/randomVariable/situations/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;AAsDF,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,6BAA6B,GACrC,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,GACrC,QAAQ,6BAA6B;;;CActC,CAAC;AAEF,eAAO,MAAM,4BAA4B,QACnC,6BAkBH,CAAC"}

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

@@ -0,0 +1,173 @@
+import { RandomVariable } from "../../../../../math/probability/randomVariable.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../../math/utils/random/randTupleInt.js";
+import { binom } from "../../../../../tree/nodes/operators/binomialCoefficientNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { pluralize } from "../../../../../utils/strings/pluralize.js";
+const getUrneRandomParams = () => {
+    const [b, r, n] = randTupleInt(3, {
+        from: 1,
+        to: 5,
+        allDifferent: false,
+    });
+    const [gb, gr] = randTupleInt(2, {
+        from: 1,
+        to: 10,
+        allDifferent: true,
+    });
+    const gn = randint(-10, 0);
+    return { b, r, n, gb, gr, gn };
+};
+const getUrneSituation = (params) => {
+    const { b, r, n, gb, gr, gn } = params;
+    return {
+        getContext: () => {
+            const getWord = (g) => g > 0 ? `rapporte $${g}\\ €$` : `fait perdre $${Math.abs(g)}\\ €$`;
+            return `Une urne contient $${b}$ ${pluralize("boule", b)} ${pluralize("blanche", b)}, $${r}$ ${pluralize("boule", r)} ${pluralize("rouge", r)} et $${n}$ ${pluralize("boule", r)} ${pluralize("noire", n)}. On tire au hasard une boule de l'urne. Tirer une boule blanche ${getWord(gb)}, une boule rouge ${getWord(gr)} et une boule noire ${getWord(gn)}. La variable aléatoire $X$ associe à chaque tirage le gain algébrique du joueur.`;
+        },
+        getVA: () => {
+            const total = b + r + n;
+            const sorted = [
+                { gain: gb, eff: b },
+                { gain: gr, eff: r },
+                { gain: gn, eff: r },
+            ].sort((a, b) => a.gain - b.gain);
+            return new RandomVariable(sorted.map((s) => s.gain), sorted.map((s) => frac(s.eff, total).simplify()));
+        },
+    };
+};
+const getCoinRandomParams = () => {
+    const n = 2;
+    let a, b;
+    do {
+        a = randint(1, 10);
+        b = randint(1, 10);
+    } while (2 * a === a - b || -2 * b === a - b);
+    return { a, b, n };
+};
+const getCoinSituation = (params) => {
+    const { a, b, n } = params;
+    return {
+        getContext: () => {
+            return `On lance $${n}$ fois d'affilée une pièce de monnaie bien équilibrée. Chaque pile rapporte $${a}$ ${pluralize("point", a)} et chaque face fait perdre $${b}$ ${pluralize("point", b)}. La variable aléatoire $X$ associe à chaque tirage le gain algébrique du joueur.`;
+        },
+        // values k(a+b)−nb pourk = 0;...n;
+        // P(X = k(a+b)-nb) = (k parmi n) (1/2)^n
+        getVA: () => {
+            const values = [];
+            const probas = [];
+            for (let i = 0; i < n + 1; i++) {
+                const value = (a + b) * i - n * b;
+                values.push(value);
+                probas.push(multiply(binom(n, i), power(frac(1, 2), n)).simplify());
+            }
+            return new RandomVariable(values, probas);
+        },
+    };
+};
+const getDiceMultipleRandomParams = () => {
+    const n = 6;
+    const winningMultiple = random([2, 3]);
+    const gain = randint(1, 10);
+    const loss = randint(1, 10);
+    return { n, gain, loss, winningMultiple };
+};
+const getDiceMultipleSituation = (params) => {
+    const { gain, loss, n, winningMultiple } = params;
+    return {
+        getContext: () => {
+            return `Un jeu consiste à lancer un dé bien équilibré à $${n}$ faces. On gagne $${gain}\\ €$ si on obtient un multiple de $${winningMultiple}$, et on perd $${loss}\\ €$ sinon.`;
+        },
+        // values k(a+b)−nb pourk = 0;...n;
+        // P(X = k(a+b)-nb) = (k parmi n) (1/2)^n
+        getVA: () => {
+            const values = [-loss, gain];
+            let multiples = 0;
+            for (let i = 2; i <= n; i++) {
+                if (i % winningMultiple === 0) {
+                    multiples++;
+                }
+            }
+            return new RandomVariable(values, [
+                frac(n - multiples, n).simplify(),
+                frac(multiples, n).simplify(),
+            ]);
+        },
+    };
+};
+const getCardsRandomParams = () => {
+    const gAs = randint(5, 10);
+    const gFigure = randint(1, gAs);
+    const gOther = randint(-10, 0);
+    return { gAs, gFigure, gOther };
+};
+const getCardsSituation = (params) => {
+    const { gAs, gFigure, gOther } = params;
+    return {
+        getContext: () => {
+            return `Un jeu consiste à tirer au hasard une carte dans un jeu de $52$ cartes. Si on tire un as, on gagne $${gAs}\\ €$; si on tire une figure, on gagne $${gFigure}\\ €$; dans les autres cas, on perd $${Math.abs(gOther)}\\ €$.`;
+        },
+        // values k(a+b)−nb pourk = 0;...n;
+        // P(X = k(a+b)-nb) = (k parmi n) (1/2)^n
+        getVA: () => {
+            return new RandomVariable([gOther, gFigure, gAs], [frac(52 - 16, 52).simplify(), frac(12, 52).simplify(), frac(1, 13)]);
+        },
+    };
+};
+// | (DiceSumParams & { id: "diceSum" });
+export const getRandomVariableSituation = (params) => {
+    switch (params.id) {
+        case "coin":
+            return getCoinSituation(params);
+        case "urne":
+            return getUrneSituation(params);
+        case "diceMultiple":
+            return getDiceMultipleSituation(params);
+        case "cards":
+            return getCardsSituation(params);
+        // case "diceSum":
+        //   return getDiceSumSituation(params);
+    }
+};
+export const buildRandomVariableSituation = () => {
+    const id = random(["urne", "coin", "diceMultiple", "cards"]);
+    switch (id) {
+        case "coin":
+            return { ...getCoinRandomParams(), id: "coin" };
+        case "urne":
+            return { ...getUrneRandomParams(), id: "urne" };
+        case "diceMultiple":
+            return { ...getDiceMultipleRandomParams(), id: "diceMultiple" };
+        case "cards":
+            return { ...getCardsRandomParams(), id: "cards" };
+        // case "diceSum":
+        //   return { ...getDiceSumRandomParams(), id: "diceSum" };
+    }
+};
+// {
+//   //param nbFaces; g_2, g_3, g_4, g_5, g_6
+//   label:
+//     "On lance un dé équilibré à 12 faces (ou 4 ou 6 ou 20. Paramétrable ?). On gagne g_2€ pour chaque multiple de 2, g_3€ pour chaque multiples de 3 ... g_6€ pour chaque multiple de 6. Les gains sont cumulables. X donne le gain total du joueur.",
+// },
+// {
+//   //param b;r , gb;gr
+//   label:
+//     "Une urne contient b boules rouges blanches et r boules rouges. On tire deux boules successivement et avec remise (ou sans remise : paramétrable). Une boule rouge rapporte x points, une boule noire en fait perdre y. La varialbe aléatoire X associe à chaque tirage le est le gain algébrique du joueur.",
+// },
+// {
+// },
+// {
+//   label:
+//     ,
+// },
+// {
+//   label:
+//     "On lance deux dès équilibrés à 6 faces (ou 4, ou 12, ou 20) et on fait la différence des points. La variable aléatoire X associe à chaque tirage le gain algébrique du joueur.",
+// },
+// {
+//   label:
+//     "On lance deux dès équilibrés à 6 faces (ou 4, ou 12, ou 20) et on fait la CL... des points. La variable aléatoire X associe à chaque tirage le gain algébrique du joueur.",
+// },

package/lib/exercises/math/python/list/pyListMutationMix.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pyListMutationMix.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/list/pyListMutationMix.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAyIrC,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,IACd,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAErC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,cAAc,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;CACxC,CAAC;AAsbF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}
+{"version":3,"file":"pyListMutationMix.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/python/list/pyListMutationMix.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAyIrC,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,MAAM,CAAC,CAAC,IAAI;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,IACd,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,GAChC,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC;AAErC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,cAAc,EAAE,WAAW,CAAC,OAAO,CAAC,EAAE,CAAC;CACxC,CAAC;AAoaF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}

package/lib/exercises/math/python/list/pyListMutationMix.js

@@ -265,21 +265,26 @@ const getPropositions = (n, { answer, ...identifiers }) => {
         };
         return getAnswer(identifiersWrong);
     }
+    function checkAndTryToAddWrongProp(str) {
+        if (!str.includes("undefined")) {
+            tryToAddWrongProp(propositions, codifyChunk(str), "raw");
+        }
+    }
     //indexAsked-1
     {
-        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => index - 1)), "raw");
+        checkAndTryToAddWrongProp(createAnswerWrong((index) => index - 1));
     }
     //indexAsked+1
     {
-        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => index + 1)), "raw");
+        checkAndTryToAddWrongProp(createAnswerWrong((index) => index + 1));
     }
     //student: lst[index]=value -> lst[value]=index
     if (typeof value === "number") {
-        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong(() => value, () => index)), "raw");
+        checkAndTryToAddWrongProp(createAnswerWrong(() => value, () => index));
     }
     //-indexAsked
     {
-        tryToAddWrongProp(propositions, codifyChunk(createAnswerWrong((index) => -index)), "raw");
+        checkAndTryToAddWrongProp(createAnswerWrong((index) => -index));
     }
     //append
     {
@@ -289,13 +294,13 @@ const getPropositions = (n, { answer, ...identifiers }) => {
                 return { ...instruction, type: "append" };
             }),
         };
-        tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+        checkAndTryToAddWrongProp(getAnswer(identifiersWrong));
     }
     //filler
     {
         propWhile(propositions, n, () => {
             const identifiersWrong = createRandomIdentifiers();
-            tryToAddWrongProp(propositions, codifyChunk(getAnswer(identifiersWrong)), "raw");
+            checkAndTryToAddWrongProp(getAnswer(identifiersWrong));
         });
     }
     return shuffleProps(propositions, n);

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRecurrenceFormulaFromSituation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindRecurrenceFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRecurrenceFormulaFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAGhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAW1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;CACtD,CAAC;AAiRF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CACjE,WAAW,EACX,OAAO,CAoBR,CAAC"}
+{"version":3,"file":"arithmeticFindRecurrenceFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRecurrenceFormulaFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAGhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAW1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;CACtD,CAAC;AAmRF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CACjE,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRecurrenceFormulaFromSituation.js

@@ -24,7 +24,7 @@ const getAnswerNode = (identifiers, opts) => {
     const firstRank = opts?.firstTermRankOne ? 1 : 0;
     const { situationIndex, initial, reason } = identifiers;
     const situation = situations[situationIndex];
-    return situation.variationFindRecurrenceFormula.getAnswerNode(initial, reason, firstRank);
+    return situation.variationFindRecurrenceFormula.getAnswerNode(initial, reason, firstRank, situation.digitsValue);
 };
 const getAnswer = (identifiers, optsIn) => {
     const opts = optsIn ?? optsDefault;
@@ -42,7 +42,7 @@ const getCorrection = (identifiers, optsIn) => {
     const firstRank = opts?.firstTermRankOne ? 1 : 0;
     const { situationIndex, initial, reason } = identifiers;
     const situation = situations[situationIndex];
-    return situation.variationFindRecurrenceFormula.getCorrectionStuff(initial, reason, firstRank).str;
+    return situation.variationFindRecurrenceFormula.getCorrectionStuff(initial, reason, firstRank, situation.digitsValue).str;
 };
 const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
     const opts = optsIn ?? optsDefault;

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoConsecutiveTerms.js

@@ -220,7 +220,7 @@ const createRandomIdentifiersRaw = (opts) => {
         }
     })();
     const rank1 = randint(firstRank + 1, 5);
-    const rank2 = rank1 + randint(1, 5);
+    const rank2 = rank1 + 1;
     function valueForRank(initial, reason, rank) {
         return initial * Math.pow(reason, rank);
     }

package/lib/exercises/math/sequences/geometric/geometricFindRandomTermFromTwoConsecutiveTerms.js

@@ -235,7 +235,7 @@ const options = [generatorOptionFirstTermRankOne];
 export const geometricFindRandomTermFromTwoConsecutiveTerms = {
     id: "geometricFindRandomTermFromTwoConsecutiveTerms",
     connector: "=",
-    label: "Connaissant deux termes consécutifs d'une suite géométrique, en donner une formule générale",
+    label: "Connaissant deux termes consécutifs d'une suite géométrique, calculer un autre terme",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindRandomTermFromTwoConsecutiveTermsQuestion(opts), nb),
     options,

package/lib/exercises/vea/percentVEA.d.ts

@@ -1,2 +1,7 @@
-export {};
+/**
+ *
+ * @param ans élève, % accepté ou non
+ * @param answer doit être sous forme x%
+ */
+export declare const percentVEA: (ans: string, answer: string) => boolean;
 //# sourceMappingURL=percentVEA.d.ts.map