math-exercises 3.0.188 → 3.0.190

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/probaStat/stats1var/medianWithList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"medianWithList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithList.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAkBT,MAAM,sBAAsB,CAAC;AAE9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAsBF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBzD,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBzE,CAAC"}
+{"version":3,"file":"medianWithList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithList.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAkBT,MAAM,sBAAsB,CAAC;AAE9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAsBF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBzD,CAAC;AAEF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBzE,CAAC"}

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

@@ -1,3 +1,4 @@
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
 import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { median } from "../../../../math/utils/stats/median.js";
@@ -81,9 +82,9 @@ const isAnswerValid = (ans, { answer, sortedValues }) => {
     }
 };
 const getMedianList = (optsIn) => {
-    const arrayedOptions = optsIn;
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
     const opts = {
-        nbValues: random(arrayedOptions.nbValues ?? optsDefault.nbValues),
+        nbValues: random(arrayedOpts.nbValues),
         isOrdered: optsIn?.isOrdered ?? false,
     };
     const length = Number(opts.nbValues);
@@ -123,7 +124,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
     };
     return question;
 };
-const optsDefault = {
+const arrayedOptsDefault = {
     nbValues: ["7", "8"],
 };
 const options = [
@@ -133,7 +134,7 @@ const options = [
         target: GeneratorOptionTarget.generation,
         type: GeneratorOptionType.multiselect,
         values: ["4", "5", "7", "8", "11", "12", "19", "20"],
-        defaultValue: optsDefault.nbValues,
+        defaultValue: arrayedOptsDefault.nbValues,
     },
 ];
 export const medianWithList = {

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

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindRankFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAKhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAM1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;IACrD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA0OF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmB1E,CAAC"}
+{"version":3,"file":"arithmeticFindRankFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAKhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAM1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;IACrD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAsPF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmB1E,CAAC"}

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

@@ -24,7 +24,7 @@ const getAnswerNode = (identifiers, opts) => {
     const { situationIndex, initial, reason, valueAsked } = identifiers;
     const situation = situations[situationIndex];
     const rankDecoder = situation.rankDecoder;
-    return situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueAsked, rankDecoder).answerNode;
+    return situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueAsked, rankDecoder, situation.digitsValue, situation.digitsTarget).answerNode;
 };
 const getAnswer = (identifiers, optsIn) => {
     const opts = optsIn ?? optsDefault;
@@ -54,12 +54,12 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
     const arrNodeWrong = [];
     //student: uses valueAsked as if it were rankAsked
     {
-        const nodeWrong = situation.variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, valueAsked, situation.rankDecoder);
-        tryToAddWrongProp(propositions, nodeWrong.simplify().toTex());
+        const nodeWrong = situation.variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, valueAsked, situation.rankDecoder, situation.digitsValue, situation.digitsTarget);
+        tryToAddWrongProp(propositions, round(nodeWrong.simplify().evaluate(), 0).toTree().toTex());
         arrNodeWrong.push(nodeWrong);
     }
     const rankValid = (() => {
-        const { rankNode } = situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueAsked, situation.rankDecoder);
+        const { rankNode } = situation.variationFindRank.getAnswerStuff(initial, reason, firstRank, valueAsked, situation.rankDecoder, situation.digitsValue, situation.digitsTarget);
         return round(rankNode.evaluate(), 0);
     })();
     //pseudo terror
@@ -67,7 +67,7 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
         if (coinFlip()) {
             //student: rankValid - 1
             {
-                const nodeWrong = (rankValid - 1).toTree();
+                const nodeWrong = round(rankValid - 1, 0).toTree();
                 tryToAddWrongProp(propositions, nodeWrong.toTex());
                 arrNodeWrong.push(nodeWrong);
             }
@@ -75,7 +75,7 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
         else {
             //student: rankValid + 1
             {
-                const nodeWrong = (rankValid + 1).toTree();
+                const nodeWrong = round(rankValid + 1, 0).toTree();
                 tryToAddWrongProp(propositions, nodeWrong.toTex());
                 arrNodeWrong.push(nodeWrong);
             }
@@ -83,7 +83,7 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
     }
     //random around
     {
-        const nodeWrong = Math.max(1, rankValid + randint(-5, 6, [0])).toTree();
+        const nodeWrong = round(Math.max(1, rankValid + randint(-5, 6, [0])), 0).toTree();
         tryToAddWrongProp(propositions, nodeWrong.toTex());
         arrNodeWrong.push(nodeWrong);
     }
@@ -94,7 +94,7 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
             if (coinFlip()) {
                 //student: rankValid - 1
                 {
-                    const nodeWrong = (nodePicked.evaluate() - 1).toTree();
+                    const nodeWrong = round(nodePicked.evaluate() - 1, 0).toTree();
                     tryToAddWrongProp(propositions, nodeWrong.toTex());
                     arrNodeWrong.push(nodeWrong);
                 }
@@ -102,7 +102,7 @@ const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
             else {
                 //student: rankValid + 1
                 {
-                    const nodeWrong = (nodePicked.evaluate() + 1).toTree();
+                    const nodeWrong = round(nodePicked.evaluate() + 1, 0).toTree();
                     tryToAddWrongProp(propositions, nodeWrong.toTex());
                     arrNodeWrong.push(nodeWrong);
                 }

package/lib/exercises/utils/options/arrayedOptions.d.ts

@@ -0,0 +1,2 @@
+export declare const defaultArrayedOptsWhereNeeded: <Options, ArrayedOptions>(optsIn: Options | undefined, arrayedOptions: ArrayedOptions) => ArrayedOptions & {};
+//# sourceMappingURL=arrayedOptions.d.ts.map

package/lib/exercises/utils/options/arrayedOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrayedOptions.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/options/arrayedOptions.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,6BAA6B,GAAI,OAAO,EAAE,cAAc,EACnE,QAAQ,OAAO,GAAG,SAAS,EAC3B,gBAAgB,cAAc,wBAmB/B,CAAC"}

package/lib/exercises/utils/options/arrayedOptions.js

@@ -0,0 +1,16 @@
+export const defaultArrayedOptsWhereNeeded = (optsIn, arrayedOptions) => {
+    const arrayedOptionsIn = optsIn;
+    return {
+        ...arrayedOptions,
+        ...(arrayedOptionsIn
+            ? Object.keys(arrayedOptionsIn).reduce((acc, key) => {
+                const dictIn = arrayedOptionsIn;
+                acc = {
+                    ...acc,
+                    ...(dictIn[key]?.length > 0 ? { [key]: dictIn[key] } : {}),
+                };
+                return acc;
+            }, {})
+            : {}),
+    };
+};

package/lib/index.d.ts

@@ -1341,15 +1341,6 @@ declare const mathExercises: (Exercise<{
 }, {
     parameter: string;
 }> | Exercise<{
-    xValues: number[];
-    yValues: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    xValues: number[];
-    yValues: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    xValues: number[];
-    yValues: number[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
     trinomial: number[];
     leftbound: number;
     rightbound: number;
@@ -1358,10 +1349,6 @@ declare const mathExercises: (Exercise<{
     xB: number;
     yA: number;
     yB: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    situationIndex: number;
-    initial: number;
-    growth: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     correctA: number;
     correctB: number;
@@ -1430,6 +1417,39 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     nodeIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     pointIds: import("./math/geometry/point.js").PointIdentifiers[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xValues: number[];
+    yValues: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xValues: number[];
+    yValues: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    xValues: number[];
+    yValues: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    id: string;
+    situationIndex: number;
+    initial: number;
+    growth: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationId: string;
+    initial: number;
+    growth: number;
+    x: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    situationId: string;
+    initial: number;
+    growth: number;
+    y: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    initial: number;
+    growth: number;
+    situationId: string;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    initial: number;
+    growth: number;
+    situationId: string;
+    threshold: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     xValue: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     polynomeCoeffs: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
@@ -1915,6 +1935,18 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     q: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
     a: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    q: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    f0: number;
+    f1: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    k: number;
+    a: number;
+    fakeParams: {
+        a: number;
+        k: number;
+    }[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     affine1Ids: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
     affine2Ids: import("./math/polynomials/generalAffine.js").GeneralAffineIdentifiers;
@@ -3287,23 +3319,23 @@ declare const mathExercises: (Exercise<{
     probasIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     intervalIds: import("./tree/nodes/sets/intervalNode.js").IntervalNodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
-    xi: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
 }, {
     averageFormulation: string;
 }> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
+    xi: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    params: import("./exercises/math/probaStat/randomVariable/utils/randomVariableSituations.js").RandomVariableSituationParams;
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
     initTable: string[][];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    params: import("./exercises/math/probaStat/randomVariable/situations/randomVariableSituations.js").RandomVariableSituationParams;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     xValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
     pValues: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];