math-exercises 3.0.133 → 3.0.134

package/lib/exercises/math/calculLitteral/distributivity/doubleDistri.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"doubleDistri.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/doubleDistri.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAgKF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"doubleDistri.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/distributivity/doubleDistri.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,aAAa,EAAE,MAAM,EAAE,CAAC;CACzB,CAAC;AAuKF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/calculLitteral/distributivity/doubleDistri.js

@@ -103,6 +103,10 @@ const getPropositions = (n, { answer, affine1Coeffs, affine2Coeffs }) => {
         new Affine(affine1Coeffs[1], affine1Coeffs[0]),
         new Affine(affine2Coeffs[1], affine2Coeffs[0]),
     ];
+    tryToAddWrongProp(propositions, affines[0]
+        .multiply(new Affine(affines[1].a, randint(-9, 10, [affines[1].b])))
+        .toTree()
+        .toTex());
     tryToAddWrongProp(propositions, affines[0]
         .multiply(new Affine(-affines[1].a, randint(-9, 10, [affines[1].b])))
         .toTree()

package/lib/exercises/math/functions/trinoms/roots/rootsReading.d.ts

@@ -4,6 +4,9 @@ type Identifiers = {
     b: number;
     c: number;
 };
-export declare const rootsReading: Exercise<Identifiers>;
+type Options = {
+    withNoCoeffB: boolean;
+};
+export declare const rootsReading: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=rootsReading.d.ts.map

package/lib/exercises/math/functions/trinoms/roots/rootsReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAY9C,CAAC"}
+{"version":3,"file":"rootsReading.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgHF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAUF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAcvD,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/rootsReading.js

@@ -1,8 +1,9 @@
-import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
 import { randomColor } from "../../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
 import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trinom.js";
+import { randfloat } from "../../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
 import { divide } from "../../../../../tree/nodes/operators/divideNode.js";
 import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
@@ -39,13 +40,22 @@ const getGGBOptions = (identifiers) => {
     });
     return ggb.getOptions({ coords: trinom.getCoords() });
 };
-const getRootsReadingQuestion = () => {
-    const nbRoots = probaLawFlip([
-        [0, 0.2],
-        [1, 0.4],
-        [2, 0.4],
-    ]);
-    const trinom = TrinomConstructor.randomNiceRoots(nbRoots);
+const getRootsReadingQuestion = (opts) => {
+    let trinom;
+    if (opts?.withNoCoeffB) {
+        const x1 = randint(-10, 10);
+        const x2 = -x1;
+        const a = randfloat(-3, 3, 3, [0]);
+        trinom = TrinomConstructor.fromRoots([x1, x2], a);
+    }
+    else {
+        const nbRoots = probaLawFlip([
+            [0, 0.2],
+            [1, 0.4],
+            [2, 0.4],
+        ]);
+        trinom = TrinomConstructor.randomNiceRoots(nbRoots);
+    }
     const identifiers = { a: trinom.a, b: trinom.b, c: trinom.c };
     return getQuestionFromIdentifiers(identifiers);
 };
@@ -89,11 +99,20 @@ const isAnswerValid = (ans, { a, b, c }) => {
     return (!!studentNumbers.length &&
         studentNumbers.every((nb, index) => Math.abs(nb - roots[index]) < 0.2));
 };
+const options = [
+    {
+        id: "withNoCoeffB",
+        label: "N'utiliser que des polynômes de la forme $ax^2 + b$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: false,
+    },
+];
 export const rootsReading = {
     id: "rootsReading",
     label: "Lire graphiquement les racines d'un trinôme",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getRootsReadingQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getRootsReadingQuestion(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -101,4 +120,5 @@ export const rootsReading = {
     hasGeogebra: true,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    options,
 };

package/lib/exercises/math/geometry/cartesian/midpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"midpoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/midpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA+IF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAa1C,CAAC"}
+{"version":3,"file":"midpoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/midpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAsKF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAa1C,CAAC"}

package/lib/exercises/math/geometry/cartesian/midpoint.js

@@ -6,6 +6,7 @@ import { PointNode } from "../../../../tree/nodes/geometry/pointNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
 const getPoints = (identifiers) => {
@@ -73,9 +74,15 @@ const getQuestionFromIdentifiers = (identifiers) => {
     };
     return question;
 };
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer, coordsA, coordsB }) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, new Point("I", frac(add(coordsA[0], coordsA[1]), 2), frac(add(coordsB[0], coordsB[1]), 2))
+        .simplify()
+        .toTexWithCoords());
+    tryToAddWrongProp(propositions, new Point("I", frac(substract(coordsA[0], coordsB[0]), 2), frac(substract(coordsB[0], coordsB[1]), 2))
+        .simplify()
+        .toTexWithCoords());
     propWhile(propositions, n, () => {
         const [tempCoords1, tempsCoords2] = distinctRandTupleInt(2, 2, {
             from: -9,

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFirstRankOne.d.ts

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

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFirstRankOne.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindExplicitFormulaFirstRankOne.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFirstRankOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA4GF,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAAC,WAAW,CAgBzE,CAAC"}

package/lib/exercises/math/sequences/arithmetic/arithmeticFindExplicitFormulaFirstRankOne.js

@@ -0,0 +1,105 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    return `$(u_n)$ est une suite arithmétique de premier terme $u_{1} = ${identifiers.firstValue}$ et de raison $r = ${identifiers.reason}$. 
+  
+Donner l'expression de $u_n$ en fonction de $n$.`;
+};
+const getHint = (_identifiers) => {
+    return `Utilise la formule générale d'une suite arithmétique : 
+    
+$$
+u_n = u_1 + (n-1) \\times r
+$$
+
+où $u_1$ est le premier terme et $r$ la raison.`;
+};
+const getCorrection = (identifiers) => {
+    const answer = getAnswer(identifiers);
+    return `La formule générale d'une suite arithmétique est :
+    
+$$
+u_n = u_1 + (n-1) \\times r
+$$
+
+où $u_1$ est le premier terme et $r$ la raison.
+    
+Ici, puisque $u_1 = ${identifiers.firstValue}$ et $r = ${identifiers.reason}$, on a : 
+
+$$
+${answer}
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { firstValue, reason } = identifiers;
+    const formula = new Polynomial([firstValue - reason, reason], "n");
+    const answer = "u_n=" + formula.toTex();
+    return answer;
+};
+const getArithmeticFindExplicitFormula = () => {
+    const firstValue = randint(-10, 10);
+    const reason = randint(-10, 10, [0]);
+    const identifiers = { firstValue, reason };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["un", "equal", "n"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, firstValue, reason }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, "u_n=" +
+            new Polynomial([firstValue + randint(-3, 4), reason + randint(-3, 4, [-reason])], "n")
+                .toTree()
+                .toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const formated = ans.replaceAll("u_n", "").replaceAll("=", "");
+        const parsed = parseAlgebraic(formated);
+        if (!parsed)
+            return false;
+        return (parsed
+            .simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        })
+            .toTex() === answer.split("=")[1]);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const arithmeticFindExplicitFormulaFirstRankOne = {
+    id: "arithmeticFindExplicitFormulaFirstRankOne",
+    connector: "=",
+    label: "Déterminer la formule générale d'une suite arithmétique (premier terme $u_1$)",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticFindExplicitFormula(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sequences/arithmetic/arithmeticFindTermFirstRankOne.d.ts

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

package/lib/exercises/math/sequences/arithmetic/arithmeticFindTermFirstRankOne.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindTermFirstRankOne.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticFindTermFirstRankOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAsGF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAehE,CAAC"}

package/lib/exercises/math/sequences/arithmetic/arithmeticFindTermFirstRankOne.js

@@ -0,0 +1,99 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { firstTerm, reason, askedRank } = identifiers;
+    return `Soit $u$ la suite arithmétique de premier terme $u_1 = ${firstTerm}$ et de raison $r = ${reason}$.
+
+Calculer $u_{${askedRank}}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { firstTerm, reason, askedRank } = identifiers;
+    const answer = firstTerm + reason * (askedRank - 1);
+    return answer.frenchify();
+};
+const getHint = () => {
+    return `Le terme général d'une suite arithmétique est : 
+    
+$$
+u_n = u_1 + r \\times (n-1)
+$$
+
+où $u_1$ est le premier terme et $r$ la raison.`;
+};
+const getCorrection = (identifiers) => {
+    const { firstTerm, reason, askedRank } = identifiers;
+    return `Le terme général de la suite $u$ est : 
+
+${alignTex([
+        [`u_n`, "=", `u_1 + r \\times (n-1)`],
+        [
+            "",
+            "=",
+            new AddNode(firstTerm.toTree(), new MultiplyNode(reason.toTree(), new SubstractNode(new VariableNode("n"), (1).toTree()))).toTex(),
+        ],
+    ])}    
+
+Il suffit alors de remplacer $n$ par $${askedRank}$ dans la formule : 
+
+${alignTex([
+        [
+            `u_{${askedRank}}`,
+            "=",
+            `${new AddNode(firstTerm.toTree(), new MultiplyNode(reason.toTree(), (askedRank - 1).toTree())).toTex()}`,
+        ],
+        ["", "=", `${getAnswer(identifiers)}`],
+    ])}
+    `;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getArithmeticFindTermQuestion = () => {
+    const firstRank = 1;
+    const firstTerm = randint(-15, 15);
+    const reason = randint(-10, 10, [0]);
+    const askedRank = randint(5, 15);
+    const identifiers = { firstRank, askedRank, firstTerm, reason };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, askedRank, firstTerm, reason }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const fake = firstTerm + reason * (askedRank - randint(-4, 4, [1]));
+        tryToAddWrongProp(propositions, fake + "");
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const arithmeticFindTermFirstRankOne = {
+    id: "arithmeticFindTermFirstRankOne",
+    connector: "=",
+    label: "Calculer un terme d'une suite arithmétique à partir de son premier terme ($u_1$) et sa raison",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getArithmeticFindTermQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sequences/arithmetic/arithmeticRecurrenceFormulaUsage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAgEF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}
+{"version":3,"file":"arithmeticRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAwEF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}

package/lib/exercises/math/sequences/arithmetic/arithmeticRecurrenceFormulaUsage.js

@@ -5,7 +5,15 @@ import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
     const { firstRank, firstValue, reason } = identifiers;
     const askedRank = firstRank + 1;
-    return `$(u_n)$ est une suite définie par $u_{n+1} = ${reason} + u_n$ et $u_{${firstRank}} = ${firstValue}$. Calculer : $u_{${askedRank}}$`;
+    return `$(u_n)$ est une suite définie par :
+  
+$$
+u_{n+1} = ${reason} + u_n
+$$
+
+et $u_{${firstRank}} = ${firstValue}$. 
+
+Calculer le terme $u_{${askedRank}}$.`;
 };
 const getAnswer = (identifiers) => {
     const { firstValue, reason } = identifiers;

package/lib/exercises/math/sequences/arithmetic/index.d.ts

@@ -1,5 +1,6 @@
 export * from "./arithmeticExplicitFormulaUsage.js";
 export * from "./arithmeticFindExplicitFormula.js";
+export * from "./arithmeticFindExplicitFormulaFirstRankOne.js";
 export * from "./arithmeticFindReason.js";
 export * from "./arithmeticReasonUsage.js";
 export * from "./arithmeticRecurrenceFormulaUsage.js";
@@ -14,5 +15,6 @@ export * from "./arithmeticFindExplictFormulaFirstTermRandom.js";
 export * from "./arithmeticFindReasonRandomRange.js";
 export * from "./arithmeticFindRandomTermFromTwoTerms.js";
 export * from "./arithmeticFindTerm.js";
+export * from "./arithmeticFindTermFirstRankOne.js";
 export * from "./arithmeticFindAntecedent.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/arithmetic/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AACpD,cAAc,oCAAoC,CAAC;AACnD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wCAAwC,CAAC;AACvD,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kDAAkD,CAAC;AACjE,cAAc,sCAAsC,CAAC;AACrD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,yBAAyB,CAAC;AACxC,cAAc,+BAA+B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,qCAAqC,CAAC;AAEpD,cAAc,oCAAoC,CAAC;AACnD,cAAc,gDAAgD,CAAC;AAE/D,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,wCAAwC,CAAC;AACvD,cAAc,oCAAoC,CAAC;AACnD,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,kDAAkD,CAAC;AACjE,cAAc,sCAAsC,CAAC;AACrD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,yBAAyB,CAAC;AACxC,cAAc,qCAAqC,CAAC;AACpD,cAAc,+BAA+B,CAAC"}

package/lib/exercises/math/sequences/arithmetic/index.js

@@ -1,5 +1,6 @@
 export * from "./arithmeticExplicitFormulaUsage.js";
 export * from "./arithmeticFindExplicitFormula.js";
+export * from "./arithmeticFindExplicitFormulaFirstRankOne.js";
 export * from "./arithmeticFindReason.js";
 export * from "./arithmeticReasonUsage.js";
 export * from "./arithmeticRecurrenceFormulaUsage.js";
@@ -14,4 +15,5 @@ export * from "./arithmeticFindExplictFormulaFirstTermRandom.js";
 export * from "./arithmeticFindReasonRandomRange.js";
 export * from "./arithmeticFindRandomTermFromTwoTerms.js";
 export * from "./arithmeticFindTerm.js";
+export * from "./arithmeticFindTermFirstRankOne.js";
 export * from "./arithmeticFindAntecedent.js";

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

@@ -1 +1 @@
-{"version":3,"file":"genericSequenceVariations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/genericSequenceVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAqEF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}
+{"version":3,"file":"genericSequenceVariations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/genericSequenceVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAyEF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}

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

@@ -5,7 +5,11 @@ import { randint } from "../../../math/utils/random/randint.js";
 const getInstruction = (identifiers) => {
     const { coeffs } = identifiers;
     const u = new Polynomial(coeffs, "n");
-    return `Soit $u$ la suite définie par $u_n = ${u.toTree().toTex()}$. 
+    return `Soit $u$ la suite définie par :
+  
+$$
+u_n = ${u.toTree().toTex()}
+$$ 
     
 Quel est le sens de variations de $u$ ?`;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"geometricExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkGF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAmB/D,CAAC"}
+{"version":3,"file":"geometricExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAwGF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAmB/D,CAAC"}

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

@@ -13,7 +13,13 @@ const getInstruction = (identifiers) => {
     const { firstValue, reason, askedRank } = identifiers;
     const formula = new MultiplyNode(new NumberNode(firstValue), new PowerNode(new NumberNode(reason), new VariableNode("n")));
     const formulaTex = formula.toTex();
-    return `$(u_n)$ est une suite géométrique définie par $u_n = ${formulaTex}$. Calculer : $u_{${askedRank}}$`;
+    return `$(u_n)$ est une suite géométrique définie par : 
+  
+$$
+u_n = ${formulaTex}
+$$
+
+Calculer le terme $u_{${askedRank}}$.`;
 };
 const getAnswer = (identifiers) => {
     const { firstValue, reason, askedRank } = identifiers;

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;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"}
+{"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,CAe9D,CAAC"}

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

@@ -98,7 +98,7 @@ const isAnswerValid = (ans, { reason, firstValue }) => {
 export const geometricFindExplicitFormula = {
     id: "geometricFindExplicitFormula",
     connector: "=",
-    label: "Déterminer la formule générale d'une suite géométrique",
+    label: "Déterminer la formule générale d'une suite géométrique (premier rang $u_0$)",
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getGeometricFindExplicitFormula, nb),
     qcmTimer: 60,

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindExplicitFormulaFirstRankOne.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFirstRankOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAoIF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAe1E,CAAC"}

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

@@ -0,0 +1,112 @@
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+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 { 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 = 1;
+    return `$(u_n)$ est une suite géométrique de premier terme $u_{${firstRank}} = ${firstValue}$ et de raison $q = ${reason}$. 
+  
+Donner l'expression de $u_n$ en fonction de $n$.`;
+};
+const getAnswer = (identifiers) => {
+    const { firstValue, reason } = identifiers;
+    const formula = new MultiplyNode(new NumberNode(firstValue), new PowerNode(new NumberNode(reason), substract("n", 1)));
+    const answer = "u_n=" + formula.toTex();
+    return answer;
+};
+const getHint = () => {
+    return `Utilise la formule générale d'une suite géométrique : 
+    
+$$
+u_n = u_1 \\times r^{n-1}
+$$
+
+où $u_1$ est le premier terme et $r$ la raison.`;
+};
+const getCorrection = (identifiers) => {
+    const { firstValue, reason } = identifiers;
+    const answer = getAnswer(identifiers);
+    return `La formule générale d'une suite géométrique est :
+    
+$$
+u_n = u_1 \\times r^{n-1}
+$$
+
+où $u_1$ est le premier terme et $r$ la raison.
+    
+Ici, puisque $u_1 = ${firstValue}$ et $r = ${reason}$, on a : 
+
+$$
+${answer}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["un", "equal", "n"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getGeometricFindExplicitFormula = () => {
+    const firstValue = randint(1, 10);
+    const reason = randint(2, 10);
+    const identifiers = { reason, firstValue };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, reason, firstValue }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "u_n=" +
+        new MultiplyNode(new NumberNode(firstValue), new PowerNode(new NumberNode(reason), new VariableNode("n"))).toTex());
+    tryToAddWrongProp(propositions, "u_n=" +
+        new MultiplyNode(new NumberNode(reason), new PowerNode(new NumberNode(firstValue), substract("n", 1))).toTex());
+    propWhile(propositions, n, () => {
+        const wrongAnswer = new MultiplyNode(new NumberNode(firstValue + randint(-firstValue, 2 * firstValue + 1)), new PowerNode(new NumberNode(reason + +randint(-reason + 1, 2 * reason + 1)), substract("n", 1)));
+        tryToAddWrongProp(propositions, "u_n=" + wrongAnswer.toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { reason, firstValue }) => {
+    const formula = new MultiplyNode(new NumberNode(firstValue), new PowerNode(new NumberNode(reason), substract("n", 1)));
+    const equal = new EqualNode(new VariableNode("u_n"), formula, {
+        allowRawRightChildAsSolution: true,
+    });
+    const texs = equal.toAllValidTexs();
+    return (texs.includes(ans) ||
+        (() => {
+            const splitted = ans.split("=");
+            const rightTerm = splitted[1] ?? splitted[0];
+            const nodeAns = parseLatex(rightTerm);
+            const differenceNode = substract(nodeAns, formula);
+            return (differenceNode.evaluate({ n: 0 }) === 0 &&
+                differenceNode.evaluate({ n: 1 }) === 0 &&
+                differenceNode.evaluate({ n: 5 }) === 0);
+        })());
+};
+export const geometricFindExplicitFormulaFirstRankOne = {
+    id: "geometricFindExplicitFormulaFirstRankOne",
+    connector: "=",
+    label: "Déterminer la formule générale d'une suite géométrique (premier rang $u_1$)",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getGeometricFindExplicitFormula, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindTermFirstRankOne.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindTermFirstRankOne.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAiGF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAe/D,CAAC"}

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

@@ -0,0 +1,97 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { firstTerm, reason, askedRank } = identifiers;
+    return `Soit $u$ la suite géométrique de premier terme $u_1 = ${firstTerm}$ et de raison $q = ${reason}$. Calculer $u_{${askedRank}}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { firstTerm, reason, askedRank } = identifiers;
+    const answer = firstTerm * Math.pow(reason, askedRank - 1);
+    return answer.frenchify();
+};
+const getHint = () => {
+    return `Le terme général d'une suite geométrique est : 
+    
+$$
+u_n = u_1 \\times q^{n-1}
+$$
+
+où $u_1$ est le premier terme et $q$ la raison.`;
+};
+const getCorrection = (identifiers) => {
+    const { firstTerm, reason, askedRank } = identifiers;
+    return `Le terme général de la suite $u$ est : 
+
+${alignTex([
+        [`u_n`, "=", `u_1 \\times q^{n-1}`],
+        [
+            "",
+            "=",
+            new MultiplyNode(firstTerm.toTree(), new PowerNode(reason.toTree(), new SubstractNode(new VariableNode("n"), (1).toTree()))).toTex(),
+        ],
+    ])}    
+
+Il suffit alors de remplacer $n$ par $${askedRank}$ dans la formule : 
+
+${alignTex([
+        [
+            `u_{${askedRank}}`,
+            "=",
+            `${new MultiplyNode(firstTerm.toTree(), new PowerNode(reason.toTree(), (askedRank - 1).toTree())).toTex()}`,
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+    `;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        identifiers,
+    };
+    return question;
+};
+const getGeometricFindTermQuestion = () => {
+    const firstRank = 1;
+    const firstTerm = randint(-10, 10, [0]);
+    const reason = randint(2, 6);
+    const askedRank = randint(5, 12);
+    const identifiers = { firstRank, askedRank, firstTerm, reason };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, askedRank, firstTerm, reason }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const fake = firstTerm * Math.pow(reason, askedRank - randint(-5, 3, [1]));
+        tryToAddWrongProp(propositions, fake + "");
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const geometricFindTermFirstRankOne = {
+    id: "geometricFindTermFirstRankOne",
+    connector: "=",
+    label: "Calculer un terme d'une suite géométrique à partir de son premier terme ($u_1$) et sa raison",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getGeometricFindTermQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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,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"}
+{"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;AA0GF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAYtD,CAAC"}

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

@@ -9,7 +9,9 @@ import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
 const getInstruction = (identifiers) => {
     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}}$`;
+    return `$(u_n)$ est une suite géométrique de raison $q = ${reason}$ et on sait que $u_{${startRank}} = ${startValue}$. 
+  
+Calculer le terme $u_{${askedRank}}$.`;
 };
 const getAnswer = (identifiers) => {
     const answer = getAnswerNode(identifiers).evaluate().frenchify();

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

@@ -1 +1 @@
-{"version":3,"file":"geometricRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAwEF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"geometricRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgFF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}

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

@@ -5,7 +5,15 @@ import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
     const { firstRank, firstValue, reason } = identifiers;
     const askedRank = firstRank + 1;
-    return `$(u_n)$ est une suite définie par $u_{n+1} = ${reason}\\times u_n$ et $u_{${firstRank}} = ${firstValue}$. Calculer : $u_{${askedRank}}$`;
+    return `$(u_n)$ est une suite définie par :
+  
+$$
+u_{n+1} = ${reason}\\times u_n
+$$
+
+et $u_{${firstRank}} = ${firstValue}$. 
+
+Calculer le terme $u_{${askedRank}}$.`;
 };
 const getAnswer = (identifiers) => {
     const { firstValue, reason } = identifiers;

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

@@ -1,11 +1,13 @@
 export * from "./geometricExplicitFormulaUsage.js";
 export * from "./geometricFindExplicitFormula.js";
+export * from "./geometricFindExplicitFormulaFirstRankOne.js";
 export * from "./geometricFindReason.js";
 export * from "./geometricFirstTermsSum.js";
 export * from "./geometricReasonUsage.js";
 export * from "./geometricRecurrenceFormulaUsage.js";
 export * from "./geometricFindExplicitFormulaFirstTermRandom.js";
 export * from "./geometricFindTerm.js";
+export * from "./geometricFindTermFirstRankOne.js";
 export * from "./geometricRecognizeReasonFromFirstTerms.js";
 export * from "./geometricFirstTermsGeneralSum.js";
 export * from "./geometricVariations.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wBAAwB,CAAC;AACvC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,oCAAoC,CAAC;AACnD,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAE9D,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,kDAAkD,CAAC;AACjE,cAAc,wBAAwB,CAAC;AACvC,cAAc,oCAAoC,CAAC;AAEnD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,oCAAoC,CAAC;AACnD,cAAc,0BAA0B,CAAC"}

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

@@ -1,11 +1,13 @@
 export * from "./geometricExplicitFormulaUsage.js";
 export * from "./geometricFindExplicitFormula.js";
+export * from "./geometricFindExplicitFormulaFirstRankOne.js";
 export * from "./geometricFindReason.js";
 export * from "./geometricFirstTermsSum.js";
 export * from "./geometricReasonUsage.js";
 export * from "./geometricRecurrenceFormulaUsage.js";
 export * from "./geometricFindExplicitFormulaFirstTermRandom.js";
 export * from "./geometricFindTerm.js";
+export * from "./geometricFindTermFirstRankOne.js";
 export * from "./geometricRecognizeReasonFromFirstTerms.js";
 export * from "./geometricFirstTermsGeneralSum.js";
 export * from "./geometricVariations.js";

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

@@ -1 +1 @@
-{"version":3,"file":"recurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/recurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAiEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}
+{"version":3,"file":"recurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/recurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAwEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}

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

@@ -5,9 +5,16 @@ import { randint } from "../../../math/utils/random/randint.js";
 const getInstruction = (identifiers) => {
     const { rank, u0, coeffs } = identifiers;
     const u = new Polynomial(coeffs, "u_n");
-    return `Soit $u$ la suite définie par $u_0 = ${u0}$ et pour tout $n\\geq 1$, $u_{n+1} = ${u
-        .toTree()
-        .toTex()}$. Calculer $u_${rank}$.`;
+    return `Soit $u$ la suite définie par : 
+  
+- $u_0 = ${u0}$,
+
+- pour tout $n\\geq 1$ :
+$$
+u_{n+1} = ${u.toTree().toTex()}
+$$
+
+Calculer $u_${rank}$.`;
 };
 const getAnswer = (identifiers) => {
     const { rank, u0, coeffs } = identifiers;

package/lib/index.d.ts

@@ -1197,7 +1197,9 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     c: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    withNoCoeffB: boolean;
+}> | Exercise<{
     trinomIdentifiers: import("./tree/nodes/polynomials/trinomNode.js").TrinomNodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     trinomCoeffs: number[];
@@ -2492,6 +2494,9 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     firstValue: number;
     reason: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    firstValue: number;
+    reason: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     rank1: number;
     reason: number;
@@ -2547,6 +2552,10 @@ declare const mathExercises: (Exercise<{
     firstTerm: number;
     reason: number;
     askedRank: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    firstTerm: number;
+    reason: number;
+    askedRank: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
     b: number;
@@ -2558,6 +2567,9 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     reason: number;
     firstValue: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    reason: number;
+    firstValue: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     value1: number;
     reason: number;
@@ -2583,6 +2595,10 @@ declare const mathExercises: (Exercise<{
     firstTerm: number;
     reason: number;
     askedRank: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    firstTerm: number;
+    reason: number;
+    askedRank: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     sequence: number[];
     reason: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/lib/server.js

@@ -83,8 +83,11 @@ const runServer = () => {
         const identifiers = req.query.identifiers
             ? JSON.parse(req.query.identifiers)
             : undefined;
-        const answer = req.query.answer;
+        console.log("raw", req.query.answer);
+        console.log("dec", decodeURI(req.query.answer));
+        const answer = JSON.parse(decodeURI(req.query.answer));
         const exo = allExercises.find((exo) => exo.id == exoId);
+        console.log("ans", answer);
         if (!exo) {
             res.send("Exo not found");
             return;
@@ -93,7 +96,7 @@ const runServer = () => {
             res.send("no getPropositions");
             return;
         }
-        const props = exo.getPropositions(n, { answer, ...identifiers }, options);
+        const props = exo.getPropositions(n, { answer: exo.getAnswer?.(identifiers, options) ?? "", ...identifiers }, options);
         res.json(props);
     });
     app.get("/isAnswerTableValid", (req, res) => {
@@ -137,7 +140,9 @@ const runServer = () => {
             res.send("no isAnswerValid");
             return;
         }
+        console.log("there");
         const valid = exo.isAnswerValid(studentAnswer, { answer, ...identifiers }, options);
+        console.log(valid);
         res.json(valid);
     });
     app.get("/isGGBAnswerValid", (req, res) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.133",
+  "version": "3.0.134",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [