math-exercises 3.0.124 → 3.0.126

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

@@ -0,0 +1,90 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { dictNameForSerie, isLess } = identifiers;
+    const series = Object.entries(dictNameForSerie);
+    return `On considère les séries suivantes :
+
+${series.map(([name, values]) => {
+        return `Série ${name} : ${values
+            .map((value) => `$${value.frenchify()}$`)
+            .join(" ; ")}`;
+    }).join(`
+    
+`)}
+ 
+Quelle série a l'écart-type le plus ${isLess ? `petit` : `grand`} ?`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { dictNameForSerie, answerName } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, `la série $${answerName}$`, "raw");
+    Object.keys(dictNameForSerie)
+        .toSorted((name1, name2) => name1.localeCompare(name2))
+        .forEach((name) => {
+        tryToAddWrongProp(propositions, `la série $${name}$`, "raw");
+    });
+    tryToAddWrongProp(propositions, `aucune des deux car leurs écart-type sont égaux`, "raw");
+    return propositions;
+};
+const getHint = () => {
+    return `L'écart-type est un indicateur de dispersion. 
+Plus il est important, plus les valeurs sont éparpillées. 
+Plus il est petit, plus les valeurs sont regroupées autour de la moyenne.`;
+};
+const getCorrection = (identifiers) => {
+    const { answerName, isLess } = identifiers;
+    const wrongName = answerName === "A" ? "B" : "A";
+    return `Ici les deux séries ont une moyenne de $10$ 
+mais les valeurs de la série $${answerName}$ sont ${isLess ? `moins` : `plus`} éparpillées autour de $10$ que les valeurs de la série $${wrongName}$. 
+Ainsi la série $${answerName}$ a l'écart-type le plus ${isLess ? `petit` : `grand`}.`;
+};
+const getInterpretIndicatorsForListsQuestion = () => {
+    const a = randint(1, 4);
+    const b = randint(2, 5) * a;
+    const series = [
+        [10 - a, 10, 10, 10 + a],
+        [10 - b, 10, 10, 10 + b],
+    ];
+    const isLess = coinFlip();
+    const answerIndexUnshuffled = isLess ? 0 : 1;
+    const shuffleArray = randomMany([...Array(series.length).keys()], series.length);
+    const shuffledSeries = shuffleArray.map((i) => series[i]);
+    const answerIndexShuffled = shuffleArray.indexOf(answerIndexUnshuffled);
+    const names = ["A", "B"];
+    const dictNameForSerie = Object.fromEntries(names.map((name, i) => [name, shuffledSeries[i]]));
+    const answerName = names[answerIndexShuffled];
+    return getQuestionFromIdentifiers({
+        dictNameForSerie,
+        answerName,
+        isLess,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const interpretIndicatorsForLists = {
+    id: "interpretIndicatorsForLists",
+    label: "Interpréter des indicateurs statistiques pour une série statistique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getInterpretIndicatorsForListsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    hasHintAndCorrection: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/exercises/math/probaStat/stats1var/plausibilityOfAverage.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    values: number[];
+    isAboveA: boolean;
+    isQuestionIsAboveA: boolean;
+};
+export declare const plausibilityOfAverage: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=plausibilityOfAverage.d.ts.map

package/lib/exercises/math/probaStat/stats1var/plausibilityOfAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plausibilityOfAverage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/plausibilityOfAverage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAyKF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}

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

@@ -0,0 +1,151 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { a, values, isQuestionIsAboveA } = identifiers;
+    return `Si on considère la série suivante :
+
+$$
+${values.map((v) => v.frenchify()).join(" ; ")}
+$$
+
+La proposition suivante est-elle vraie ?
+
+"La moyenne de cette série est strictement ${isQuestionIsAboveA ? `supérieure` : `inférieure`} à $${a.frenchify()}$."
+`;
+};
+const getHint = ({ a }) => {
+    return `Regarder l'écart des valeurs par rapport à $${a.frenchify()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, values, isAboveA } = identifiers;
+    const answer = getAnswer(identifiers);
+    const valuesBelowA = values.filter((v) => v < a);
+    const valuesAboveA = values.filter((v) => v > a);
+    return `${answer}, car si l'on regarde les valeurs strictement inférieures à $${a.frenchify()}$ : 
+  
+${valuesBelowA
+        .map((v) => `
+    
+$${v.frenchify()}$ est $${(a - v).frenchify()}$ points en dessous de $${a.frenchify()}$
+
+`)
+        .join("")}
+Ce qui fait en tout $${valuesBelowA
+        .map((v) => a - v)
+        .reduce((acc, v) => acc + v, 0)
+        .frenchify()}$ points en dessous de $${a.frenchify()}$.
+
+Si l'on regarde les valeurs strictement supérieures à $${a.frenchify()}$ : 
+  
+${valuesAboveA
+        .map((v) => `
+    
+$${v.frenchify()}$ est $${(v - a).frenchify()}$ points en dessus de $${a.frenchify()}$
+
+`)
+        .join("")}
+Ce qui fait en tout $${valuesAboveA
+        .map((v) => v - a)
+        .reduce((acc, v) => acc + v, 0)
+        .frenchify()}$ points au dessus de $${a.frenchify()}$.
+
+Le total ${isAboveA ? `supérieur` : `inférieur`} est plus grand, en valeur absolue, que le total ${isAboveA ? `inférieur` : `supérieur`} donc on peut affirmer que la moyenne de cette série est strictement ${isAboveA ? `supérieure` : `inférieure`} à $${a.frenchify()}$.`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, answer == "Oui" ? "Non" : "Oui", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { isAboveA, isQuestionIsAboveA } = identifiers;
+    return isQuestionIsAboveA
+        ? isAboveA
+            ? "Oui"
+            : "Non"
+        : isAboveA
+            ? "Non"
+            : "Oui";
+};
+const getPlausibilityOfAverageQuestion = () => {
+    function generateA(typeA) {
+        switch (typeA) {
+            case "10":
+            default:
+                return randint(1, 6) * 10;
+            case "110":
+                return randint(1, 6) * 100 + 10;
+            case "1010":
+                return randint(60, 100) * 100 + 10;
+        }
+    }
+    const typeA = random(["10", "110", "1010"]);
+    const a = generateA(typeA);
+    const seriesAvgAbove0 = [
+        [-3, -3, -1, 0, +2, +7],
+        [-3, -3, -1, 0, +1, +8],
+        [-3, -3, -1, 0, +3, +6],
+        [-4, -2, -1, 0, +2, +7],
+        [-5, -1, -1, 0, +1, +8],
+        [-3, -3, 0, 0, +2, +7],
+        [-3, -3, 0, 0, +1, +8],
+        [-3, -3, 0, 0, +3, +6],
+        [-4, -2, 0, 0, +2, +7],
+        [-5, -1, 0, 0, +1, +8],
+        [-4, -3, 0, +1, +1, +7],
+        [-4, -3, 0, +1, +2, +6],
+        [-4, -3, 0, +3, +3, +3],
+        [-5, -2, 0, +2, +2, +5],
+        [-6, -1, 0, +2, +3, +4],
+    ];
+    [...seriesAvgAbove0].forEach(([a, b, c, d, e, f]) => {
+        seriesAvgAbove0.push([a - 1, b - 1, c, d, e + 1, f + 1]);
+        seriesAvgAbove0.push([a - 2, b - 2, c, d, e + 2, f + 2]);
+        seriesAvgAbove0.push([a - 3, b - 3, c, d, e + 3, f + 3]);
+    });
+    const isAboveA = coinFlip();
+    const values = (isAboveA
+        ? random(seriesAvgAbove0)
+        : random(seriesAvgAbove0)
+            .toReversed()
+            .map((v) => -v)).map((v) => v + a);
+    const isQuestionIsAboveA = coinFlip();
+    return getQuestionFromIdentifiers({
+        a,
+        values,
+        isAboveA,
+        isQuestionIsAboveA,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const plausibilityOfAverage = {
+    id: "plausibilityOfAverage",
+    label: "S’assurer de la vraisemblance, de la cohérence d’un résultat (moyenne d'une série)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlausibilityOfAverageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/probaStat/stats1var/quartilesList.d.ts

@@ -3,6 +3,9 @@ type Identifiers = {
     randomValues: number[];
     randomQuartile: number;
 };
-export declare const quartilesList: Exercise<Identifiers>;
+type Options = {
+    nbValues: number;
+};
+export declare const quartilesList: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=quartilesList.d.ts.map

package/lib/exercises/math/probaStat/stats1var/quartilesList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quartilesList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartilesList.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAeT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAgGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAc/C,CAAC"}
+{"version":3,"file":"quartilesList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartilesList.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,QAAQ,EAkBT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAyGF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAeF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBxD,CAAC"}

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

@@ -2,7 +2,8 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { firstQuartile, thirdQuartile, } from "../../../../math/utils/stats/quartiles.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
-import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
+import { random } from "../../../../utils/alea/random.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
 import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
 const getInstruction = ({ randomQuartile, randomValues, }) => {
     let quartileToString = "";
@@ -15,7 +16,7 @@ $$
 ${randomValues.join(";\\ ")}
 $$
 
-Calculer le ${quartileToString} de cette série de valeurs.`;
+Calculer le ${quartileToString} de cette série de $${randomValues.length}$ valeurs.`;
 };
 const getAnswer = (identifiers) => {
     const { randomValues, randomQuartile } = identifiers;
@@ -24,18 +25,6 @@ const getAnswer = (identifiers) => {
     else
         return thirdQuartile(randomValues).frenchify();
 };
-const getQuartiles = () => {
-    const randomValues = [];
-    const length = randint(5, 9);
-    for (let i = 0; i < length; i++)
-        randomValues.push(randint(1, 20));
-    const randomQuartile = randint(0, 2);
-    const identifiers = {
-        randomValues: randomValues.sort((a, b) => a - b),
-        randomQuartile,
-    };
-    return getQuestionFromIdentifiers(identifiers);
-};
 const getHint = (identifiers) => {
     const { randomQuartile } = identifiers;
     if (randomQuartile === 0)
@@ -54,18 +43,6 @@ Puisque $${rank.toTex()} = ${rankEv.frenchify()}$, le ${numeral} quartile est la
 
 Le ${numeral} quartile est donc $${getAnswer(identifiers)}$.`;
 };
-const getQuestionFromIdentifiers = (identifiers) => {
-    const question = {
-        instruction: getInstruction(identifiers),
-        answer: getAnswer(identifiers),
-        keys: [],
-        answerFormat: "tex",
-        identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
-    };
-    return question;
-};
 const getPropositions = (n, { answer, randomValues }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -81,12 +58,54 @@ const getPropositions = (n, { answer, randomValues }) => {
 const isAnswerValid = (ans, { answer }) => {
     return ans === answer;
 };
+const getQuartiles = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const randomValues = [];
+    const length = Array.isArray(opts.nbValues)
+        ? random(opts.nbValues.map((v) => +v))
+        : opts.nbValues;
+    for (let i = 0; i < length; i++)
+        randomValues.push(randint(1, 20));
+    const randomQuartile = randint(0, 2);
+    const identifiers = {
+        randomValues: randomValues.sort((a, b) => a - b),
+        randomQuartile,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    nbValues: 12,
+};
+const options = [
+    {
+        id: "nbValues",
+        label: "Nombre de valeurs dans la liste",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: [4, 5, 7, 8, 11, 12, 19, 20],
+        defaultValue: [optsDefault.nbValues],
+    },
+];
 export const quartilesList = {
     id: "quartilesList",
     connector: "=",
     label: "Calcul des quartiles d'une liste de valeurs",
     isSingleStep: false,
-    generator: (nb) => getDistinctQuestions(getQuartiles, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getQuartiles(opts ?? optsDefault), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormula.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAgHF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA8HF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}

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

@@ -2,11 +2,13 @@ import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercis
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
-import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { EqualNode, isEqualNode, } from "../../../../tree/nodes/equations/equalNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { parseLatex } from "../../../../tree/parsers/latexParser.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 const getInstruction = (identifiers) => {
     const { firstValue, reason } = identifiers;
     const firstRank = 0;
@@ -81,7 +83,17 @@ const isAnswerValid = (ans, { reason, firstValue }) => {
         allowRawRightChildAsSolution: true,
     });
     const texs = equal.toAllValidTexs();
-    return texs.includes(ans);
+    return (texs.includes(ans) ||
+        (() => {
+            let nodeAns = parseLatex(ans);
+            if (isEqualNode(nodeAns)) {
+                nodeAns = nodeAns.rightChild;
+            }
+            const differenceNode = substract(nodeAns, formula);
+            return (differenceNode.evaluate({ n: 0 }) === 0 &&
+                differenceNode.evaluate({ n: 1 }) === 0 &&
+                differenceNode.evaluate({ n: 5 }) === 0);
+        })());
 };
 export const geometricFindExplicitFormula = {
     id: "geometricFindExplicitFormula",

package/lib/exercises/math/sequences/geometric/geometricReasonUsage.d.ts

@@ -2,6 +2,7 @@ import { Exercise } from "../../../../exercises/exercise.js";
 type Identifiers = {
     reason: number;
     startRank: number;
+    askedRank: number;
     startValue: number;
 };
 export declare const geometricReasonUsage: Exercise<Identifiers>;

package/lib/exercises/math/sequences/geometric/geometricReasonUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricReasonUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAqEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAYtD,CAAC"}
+{"version":3,"file":"geometricReasonUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAwGF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAYtD,CAAC"}

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

@@ -1,20 +1,26 @@
-import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
 const getInstruction = (identifiers) => {
-    const { reason, startRank, startValue } = identifiers;
-    const askedRank = startRank + 1;
+    const { reason, startRank, startValue, askedRank } = identifiers;
     return `$(u_n)$ est une suite géométrique de raison $q = ${reason}$ et on sait que $u_{${startRank}} = ${startValue}$. Calculer : $u_{${askedRank}}$`;
 };
 const getAnswer = (identifiers) => {
-    const { reason, startValue } = identifiers;
-    const answer = (startValue * reason).toString();
+    const answer = getAnswerNode(identifiers).evaluate().frenchify();
     return answer;
 };
+const getAnswerNode = (identifiers) => {
+    const { reason, startValue, startRank, askedRank } = identifiers;
+    return multiply(startValue, power(reason, substract(askedRank, startRank)));
+};
 const getStartStatement = (identifiers) => {
-    const { startRank } = identifiers;
-    const askedRank = startRank + 1;
+    const { askedRank } = identifiers;
     return `u_{${askedRank}}`;
 };
 const getQuestionFromIdentifiers = (identifiers) => {
@@ -31,26 +37,44 @@ const getQuestionFromIdentifiers = (identifiers) => {
 const getGeometricReasonUsage = () => {
     const reason = randint(2, 10);
     const startRank = randint(0, 20);
+    const askedRank = startRank +
+        probaLawFlip([
+            [1, 0.5],
+            [2, 0.3],
+            [3, 0.2],
+        ]);
     const startValue = randint(1, 10);
-    const identifiers = { startValue, reason, startRank };
+    const identifiers = { startValue, reason, startRank, askedRank };
     return getQuestionFromIdentifiers(identifiers);
 };
-const getPropositions = (n, { answer, startValue, reason }) => {
+const getPropositions = (n, { answer, startValue, reason, askedRank, startRank }) => {
     const propositions = [];
     addValidProp(propositions, answer);
-    if (startValue + reason !== 4)
-        tryToAddWrongProp(propositions, (startValue + reason).toString());
+    //next term
+    tryToAddWrongProp(propositions, getAnswerNode({
+        startValue,
+        startRank,
+        reason,
+        askedRank: startRank + 1,
+    })
+        .evaluate()
+        .frenchify());
+    //arithmetic
+    tryToAddWrongProp(propositions, add(startValue, reason).evaluate().frenchify());
+    tryToAddWrongProp(propositions, add(startValue, multiply(reason, substract(askedRank, startRank)))
+        .evaluate()
+        .frenchify());
+    //savoir ses tables
     propWhile(propositions, n, () => {
         tryToAddWrongProp(propositions, startValue * (reason + randint(-reason + 1, 6, [0])) + "");
     });
-    return shuffle(propositions);
+    return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, startRank }) => {
-    return [
-        answer,
-        `u_{${startRank}}=${answer}`,
-        `u_${startRank}=${answer}`,
-    ].includes(ans);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { askedRank } = identifiers;
+    return ([answer, `u_{${askedRank}}=${answer}`, `u_${askedRank}=${answer}`].includes(ans) ||
+        //tant pis pour les tables
+        parseAlgebraic(ans).evaluate() === getAnswerNode(identifiers).evaluate());
 };
 export const geometricReasonUsage = {
     id: "geometricReasonUsage",

package/lib/exercises/math/sequences/sequenceEvaluation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequenceEvaluation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequenceEvaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+MF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAYpD,CAAC"}
+{"version":3,"file":"sequenceEvaluation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequenceEvaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkOF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAYpD,CAAC"}

package/lib/exercises/math/sequences/sequenceEvaluation.js

@@ -5,7 +5,9 @@ import { randint } from "../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
 import { AddNode } from "../../../tree/nodes/operators/addNode.js";
 import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 const getInstruction = (identifiers) => {
     const { termeid, affine, termeAdd, termeMult } = identifiers;
     const aff = new Affine(affine[0], affine[1], "n");
@@ -149,7 +151,22 @@ const isAnswerValid = (ans, { affine, termeid, termeAdd, termeMult }) => {
         });
     }
     const latexs = validanswer.toAllValidTexs();
-    return latexs.includes(ans);
+    return (latexs.includes(ans) ||
+        (() => {
+            //allow "5 \\times n - 10"
+            const ansWithoutTimes = ans.replaceAll("\\times", "").replaceAll(" ", "");
+            const [nodeAns, nodeAnsWithoutTimes] = [ans, ansWithoutTimes].map((tex) => parseAlgebraic(tex));
+            const differenceNode = substract(nodeAns, nodeAnsWithoutTimes);
+            const isSameNode = differenceNode.evaluate({ n: 0 }) === 0 &&
+                differenceNode.evaluate({ n: 1 }) === 0 &&
+                differenceNode.evaluate({ n: 5 }) === 0;
+            if (!isSameNode) {
+                return false;
+            }
+            else {
+                return latexs.includes(ansWithoutTimes);
+            }
+        })());
 };
 export const sequenceEvaluation = {
     id: "sequenceEvaluation",

package/lib/exercises/pc/chemicalReactions/chemicalEquations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chemicalEquations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/chemicalEquations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,eAAe,EAChB,MAAM,mDAAmD,CAAC;AAG3D,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAwDF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}
+{"version":3,"file":"chemicalEquations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/chemicalEquations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,eAAe,EAChB,MAAM,mDAAmD,CAAC;AAI3D,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAuEF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}

package/lib/exercises/pc/chemicalReactions/chemicalEquations.js

@@ -17,7 +17,20 @@ const getAnswer = (identifiers) => {
 };
 const getKeys = (identifiers) => {
     const reaction = new Reaction(identifiers.reactionArray);
-    return [...reaction.getKeyIds(), "rightarrow"];
+    return [
+        "rightarrow",
+        ...reaction.getSpeciesFormula().map((formula) => {
+            return {
+                id: "custom",
+                label: formula,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: formula,
+                },
+            };
+        }),
+    ];
 };
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
@@ -44,7 +57,9 @@ const getPropositions = (n, { answer, reactionArray }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    const ansNoSpace = ans.replaceAll(" ", "");
+    const answerNoSpace = answer.replaceAll(" ", "");
+    return ansNoSpace === answerNoSpace;
 };
 export const chemicalEquations = {
     id: "chemicalEquations",

package/lib/exercises/pc/electricity/calculateUEqualsRI.d.ts

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

package/lib/exercises/pc/electricity/calculateUEqualsRI.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateUEqualsRI.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/electricity/calculateUEqualsRI.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}