math-exercises 3.0.69 → 3.0.70

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

@@ -3,33 +3,53 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { addValidProp, tryToAddWrongProp, } from "../../../exercise.js";
 import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
-const getArithmeticThresholdFind = () => {
-    const firstValue = randint(-10, 10);
-    const reason = randint(-10, 10, [0]);
-    let randValue = firstValue;
+const getInstruction = (identifiers) => {
+    const { firstValue, reason, randValue } = identifiers;
     const formula = new Polynomial([firstValue, reason], "n");
-    let instruction = `$(u_n)$ est une suite arithmétique définie par $u_n = ${formula
-        .toTree()
-        .toTex()}$. `;
+    let instruction = `$(u_n)$ est une suite arithmétique définie par 
+  
+$$
+u_n = ${formula.toTree().toTex()}
+$$
+
+`;
     if (reason > 0) {
-        randValue += randint(reason, 100);
         instruction += `À partir de quel rang $n$ a-t-on $u_n > ${randValue}$ ?`;
     }
     else {
-        randValue += randint(-100, reason);
         instruction += `À partir de quel rang $n$ a-t-on $u_n < ${randValue}$ ?`;
     }
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { firstValue, reason, randValue } = identifiers;
     const answer = (Math.floor((randValue - firstValue) / reason) + 1).toString();
+    return answer;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction,
+        instruction: getInstruction(identifiers),
         startStatement: `n`,
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["r", "n", "u", "underscore", "inf", "sup", "approx"],
         answerFormat: "tex",
-        identifiers: { randValue, firstValue, reason },
+        identifiers,
     };
     return question;
 };
+const getArithmeticThresholdFind = () => {
+    const firstValue = randint(-10, 10);
+    const reason = randint(-10, 10, [0]);
+    let randValue = firstValue;
+    if (reason > 0) {
+        randValue += randint(reason, 100);
+    }
+    else {
+        randValue += randint(-100, reason);
+    }
+    const identifiers = { randValue, firstValue, reason };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, randValue, firstValue, reason }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -45,8 +65,6 @@ export const arithmeticThresholdFind = {
     id: "arithmeticThresholdFind",
     connector: "=",
     label: "Calculer un seuil à l'aide d'une suite arithmétique",
-    levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
-    sections: ["Suites"],
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getArithmeticThresholdFind, nb),
     qcmTimer: 60,
@@ -54,4 +72,5 @@ export const arithmeticThresholdFind = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"firstIntegersSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/firstIntegersSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA8EF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAmBlD,CAAC"}
+{"version":3,"file":"firstIntegersSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/firstIntegersSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAkBlD,CAAC"}

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

@@ -20,6 +20,9 @@ const getAnswer = (identifiers) => {
 const getFirstIntegersSumQuestion = () => {
     const final = randint(20, 100);
     const identifiers = { final };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -75,9 +78,7 @@ export const firstIntegersSum = {
     id: "firstIntegersSum",
     connector: "=",
     label: "Somme des $n$ premiers entiers",
-    levels: ["1rePro", "1reTech", "1reSpé", "1reESM"],
     isSingleStep: true,
-    sections: ["Suites"],
     generator: (nb) => getDistinctQuestions(getFirstIntegersSumQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -89,4 +90,5 @@ export const firstIntegersSum = {
     getHint,
     getCorrection,
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"recognizeArithmeticFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA0EF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAgBnE,CAAC"}
+{"version":3,"file":"recognizeArithmeticFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAoGF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAenE,CAAC"}

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

@@ -3,6 +3,38 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { randint } from "../../../../math/utils/random/randint.js";
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    return `Parmi les suites suivantes, laquelle semble être arithmétique ?`;
+};
+const getAnswer = (identifiers) => {
+    const { sequences, answerIndex } = identifiers;
+    const names = ["u", "v", "w", "z"];
+    const rightSequence = sequences[answerIndex];
+    const answer = `\\text{Suite } ${names[answerIndex]} : \\quad ${rightSequence.join("\\ ; \\ ")}`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `Une suite est arithmétique lorsque, pour passer d'un terme au suivant, on additionne ou on soustrait toujours par le même nombre.`;
+};
+const getCorrection = (identifiers) => {
+    const { sequences, answerIndex } = identifiers;
+    const names = ["u", "v", "w", "z"];
+    const rightSequence = sequences[answerIndex];
+    const reason = rightSequence[1] - rightSequence[0];
+    return `La suite $${names[answerIndex]}$ semble bien être arithmétique, puisque pour passer d'un terme au suivant, on additionne par $${reason}$.`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        identifiers,
+    };
+    return question;
+};
 const getRecognizeArithmeticFromFirstTermsQuestion = () => {
     const sequences = [];
     const firstGeoTerm = randint(1, 4);
@@ -30,18 +62,8 @@ const getRecognizeArithmeticFromFirstTermsQuestion = () => {
         .map((el, index) => firstTerm + index * reason);
     const answerIndex = randint(0, 4);
     sequences.splice(answerIndex, 0, rightSequence);
-    const names = ["u", "v", "w", "z"];
-    const answer = `\\text{Suite } ${names[answerIndex]} : \\quad ${rightSequence.join("\\ ; \\ ")}`;
-    const question = {
-        answer,
-        instruction: `Parmi les suites suivantes, laquelle semble être arithmétique ?`,
-        keys: [],
-        answerFormat: "tex",
-        hint: `Une suite est arithmétique lorsque, pour passer d'un terme au suivant, on additionne ou on soustrait toujours par le même nombre.`,
-        correction: `La suite $${names[answerIndex]}$ semble bien être arithmétique, puisque pour passer d'un terme au suivant, on additionne par $${reason}$.`,
-        identifiers: { sequences, answerIndex },
-    };
-    return question;
+    const identifiers = { sequences, answerIndex };
+    return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer, sequences, answerIndex }) => {
     const propositions = [];
@@ -60,9 +82,7 @@ const isAnswerValid = (ans, { answer }) => {
 export const recognizeArithmeticFromFirstTerms = {
     id: "recognizeArithmeticFromFirstTerms",
     label: "Reconnaître une suite arithmétique via ses premiers termes",
-    levels: ["1reSpé", "1rePro", "1reTech", "1reESM"],
     isSingleStep: true,
-    sections: ["Suites"],
     generator: (nb) => getDistinctQuestions(getRecognizeArithmeticFromFirstTermsQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -72,4 +92,5 @@ export const recognizeArithmeticFromFirstTerms = {
     subject: "Mathématiques",
     hasHintAndCorrection: true,
     pdfOptions: { shouldSpreadPropositions: true },
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"recognizeArithmeticFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA8EF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}
+{"version":3,"file":"recognizeArithmeticFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAiGF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}

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

@@ -5,6 +5,40 @@ import { Point } from "../../../../math/geometry/point.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) => {
+    return `La suite $u$ représentée ci-dessous semble-t-elle arithmétique ?`;
+};
+const getAnswer = (identifiers) => {
+    const { isAri, sequence } = identifiers;
+    return isAri ? "Oui" : "Non";
+};
+const getGGBOptions = (identifiers) => {
+    const { isAri, sequence } = identifiers;
+    const commands = sequence.flatMap((nb, index) => new Point(`A_${index}`, index.toTree(), nb.toTree()).toGGBCommand({
+        showLabel: false,
+    }));
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: false,
+        xAxis: { natural: true },
+    });
+    const yMin = Math.min(...sequence.slice(0, 5));
+    const yMax = Math.max(...sequence.slice(0, 5));
+    return ggb.getOptions({
+        coords: [-1, 7, Math.min(-1, yMin - 2), Math.max(1, yMax + 2)],
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
 const getRandomFirstNonAriTerms = () => {
     const type = randint(0, 3);
     switch (type) {
@@ -38,28 +72,8 @@ const getRecognizeArithmeticFromGraphQuestion = () => {
     const sequence = isAri
         ? new Array(10).fill(0).map((el, index) => firstAriTerm + reason * index)
         : getRandomFirstNonAriTerms();
-    const answer = isAri ? "Oui" : "Non";
-    const commands = sequence.flatMap((nb, index) => new Point(`A_${index}`, index.toTree(), nb.toTree()).toGGBCommand({
-        showLabel: false,
-    }));
-    const ggb = new GeogebraConstructor({
-        commands,
-        lockedAxesRatio: false,
-        xAxis: { natural: true },
-    });
-    const yMin = Math.min(...sequence.slice(0, 5));
-    const yMax = Math.max(...sequence.slice(0, 5));
-    const question = {
-        answer,
-        instruction: `La suite $u$ représentée ci-dessous semble-t-elle arithmétique ?`,
-        keys: [],
-        ggbOptions: ggb.getOptions({
-            coords: [-1, 7, Math.min(-1, yMin - 2), Math.max(1, yMax + 2)],
-        }),
-        answerFormat: "tex",
-        identifiers: { sequence, isAri },
-    };
-    return question;
+    const identifiers = { sequence, isAri };
+    return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -74,9 +88,7 @@ const isAnswerValid = (ans, { answer }) => {
 export const recognizeArithmeticFromGraph = {
     id: "recognizeArithmeticFromGraph",
     label: "Reconnaître graphiquement si une suite est arithmétique",
-    levels: ["1reESM", "1rePro", "1reSpé", "1reTech"],
     isSingleStep: true,
-    sections: ["Suites"],
     generator: (nb) => getDistinctQuestions(getRecognizeArithmeticFromGraphQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -85,4 +97,5 @@ export const recognizeArithmeticFromGraph = {
     answerType: "QCU",
     hasGeogebra: true,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"recognizeReasonFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeReasonFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAgEF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAiB/D,CAAC"}
+{"version":3,"file":"recognizeReasonFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeReasonFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAsEF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAkB/D,CAAC"}

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

@@ -34,6 +34,9 @@ const getRecognizeReasonFromFirstTermsQuestion = () => {
         .fill(0)
         .map((el, index) => firstTerm + index * reason);
     const identifiers = { sequence, reason };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -72,4 +75,5 @@ export const recognizeReasonFromFirstTerms = {
     getHint,
     getCorrection,
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"recognizeReasonFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAkDF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAe1D,CAAC"}
+{"version":3,"file":"recognizeReasonFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAqEF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}

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

@@ -3,12 +3,16 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { Point } from "../../../../math/geometry/point.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-const getRecognizeReasonFromGraphQuestion = () => {
-    const firstTerm = randint(1, 20);
-    const reason = randint(-5, 6, [0]);
-    const sequence = new Array(10)
-        .fill(0)
-        .map((el, index) => firstTerm + index * reason);
+const getInstruction = (identifiers) => {
+    return `Déterminer la raison de la suite arithmétique $u$ représentée ci-dessous :`;
+};
+const getAnswer = (identifiers) => {
+    const { reason } = identifiers;
+    const answer = reason + "";
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { sequence } = identifiers;
     const yMin = Math.min(...sequence.slice(0, 5));
     const yMax = Math.max(...sequence.slice(0, 5));
     const commands = sequence.flatMap((nb, index) => new Point(`A_${index}`, index.toTree(), nb.toTree()).toGGBCommand({
@@ -19,19 +23,30 @@ const getRecognizeReasonFromGraphQuestion = () => {
         xAxis: { natural: true },
         lockedAxesRatio: false,
     });
-    const answer = reason + "";
+    return ggb.getOptions({
+        coords: [-1, 7, Math.min(-1, yMin - 2), Math.max(1, yMax + 2)],
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer,
-        instruction: `Déterminer la raison de la suite arithmétique $u$ représentée ci-dessous :`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
-        ggbOptions: ggb.getOptions({
-            coords: [-1, 7, Math.min(-1, yMin - 2), Math.max(1, yMax + 2)],
-        }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: { reason, sequence },
+        identifiers,
     };
     return question;
 };
+const getRecognizeReasonFromGraphQuestion = () => {
+    const firstTerm = randint(1, 20);
+    const reason = randint(-5, 6, [0]);
+    const sequence = new Array(10)
+        .fill(0)
+        .map((el, index) => firstTerm + index * reason);
+    const identifiers = { reason, sequence };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -46,9 +61,7 @@ const isAnswerValid = (ans, { answer }) => {
 export const recognizeReasonFromGraph = {
     id: "recognizeReasonFromGraph",
     label: "Reconnaître graphiquement la raison d'une suite arithmétique",
-    levels: ["1reESM", "1reSpé", "1rePro", "1reTech"],
     isSingleStep: true,
-    sections: ["Suites"],
     generator: (nb) => getDistinctQuestions(getRecognizeReasonFromGraphQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -56,4 +69,5 @@ export const recognizeReasonFromGraph = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"explicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/explicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAoCF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"explicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/explicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAyDF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}

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

@@ -2,21 +2,39 @@ import { shuffleProps, tryToAddWrongProp, addValidProp, } from "../../../exercis
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { Polynomial, PolynomialConstructor, } from "../../../math/polynomials/polynomial.js";
 import { randint } from "../../../math/utils/random/randint.js";
-const getExplicitFormulaUsageQuestion = () => {
-    const u = PolynomialConstructor.randomWithOrder(2, "n");
-    const rank = randint(0, 4);
+const getInstruction = (identifiers) => {
+    const { rank, coeffs } = identifiers;
+    const u = new Polynomial(coeffs);
+    return `Soit $u$ la suite définie pour tout $n\\geq 0$ par 
+  
+$$
+u_n = ${u.toTree().toTex()}
+$$ 
+      
+Calculer $u_${rank}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { rank, coeffs } = identifiers;
+    const u = new Polynomial(coeffs);
     const answer = u.calculate(rank) + "";
+    return answer;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: answer,
-        instruction: `Soit $u$ la suite définie pour tout $n\\geq 0$ par $u_n = ${u
-            .toTree()
-            .toTex()}$. Calculer $u_${rank}$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["u", "underscore", "equal"],
         answerFormat: "tex",
-        identifiers: { rank, coeffs: u.coefficients },
+        identifiers,
     };
     return question;
 };
+const getExplicitFormulaUsageQuestion = () => {
+    const u = PolynomialConstructor.randomWithOrder(2, "n");
+    const rank = randint(0, 4);
+    const identifiers = { rank, coeffs: u.coefficients };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, rank, coeffs }) => {
     const propositions = [];
     const u = new Polynomial(coeffs);
@@ -36,13 +54,12 @@ export const explicitFormulaUsage = {
     id: "explicitFormulaUsage",
     connector: "=",
     label: "Utiliser la formule explicite d'une suite",
-    levels: ["1reESM", "1reSpé", "1reTech"],
     isSingleStep: true,
-    sections: ["Suites"],
     generator: (nb) => getDistinctQuestions(getExplicitFormulaUsageQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

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,EAQT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAmDF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}
+{"version":3,"file":"genericSequenceVariations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/genericSequenceVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAqEF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}

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

@@ -1,9 +1,17 @@
 import { shuffleProps, tryToAddWrongProp, addValidProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
-import { PolynomialConstructor } from "../../../math/polynomials/polynomial.js";
+import { Polynomial, PolynomialConstructor, } from "../../../math/polynomials/polynomial.js";
 import { randint } from "../../../math/utils/random/randint.js";
-const getGenericSequenceVariationsQuestion = () => {
-    const u = PolynomialConstructor.randomWithOrder(2, "n");
+const getInstruction = (identifiers) => {
+    const { coeffs } = identifiers;
+    const u = new Polynomial(coeffs);
+    return `Soit $u$ la suite définie par $u_n = ${u
+        .toTree()
+        .toTex()}$. Quel est le sens de variations de $u$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { coeffs } = identifiers;
+    const u = new Polynomial(coeffs);
     const [b, a] = u.coefficients.slice(1);
     const root = Math.ceil((-a - b) / (2 * a));
     const answer = root <= 0
@@ -11,17 +19,23 @@ const getGenericSequenceVariationsQuestion = () => {
             ? "Croissante"
             : "Décroissante"
         : `${a > 0 ? "Croissante" : "Décroissante"} à partir du rang ${root}`;
+    return answer;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer,
-        instruction: `Soit $u$ la suite définie par $u_n = ${u
-            .toTree()
-            .toTex()}$. Quel est le sens de variations de $u$ ?`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "raw",
-        identifiers: { coeffs: u.coefficients },
+        identifiers,
     };
     return question;
 };
+const getGenericSequenceVariationsQuestion = () => {
+    const u = PolynomialConstructor.randomWithOrder(2, "n");
+    const identifiers = { coeffs: u.coefficients };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, coeffs }) => {
     const [b, a] = coeffs.slice(1);
     const root = Math.ceil((-a - b) / (2 * a));
@@ -38,13 +52,12 @@ export const genericSequenceVariations = {
     id: "genericSequenceVariations",
     connector: "=",
     label: "Déterminer le sens de variations d'une suite en étudiant la différence de deux termes",
-    levels: ["1reESM", "1rePro", "1reTech"],
     isSingleStep: true,
-    sections: ["Suites"],
     generator: (nb) => getDistinctQuestions(getGenericSequenceVariationsQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     answerType: "QCU",
     getPropositions,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

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,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyFF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}
+{"version":3,"file":"geometricExplicitFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricExplicitFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,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"}

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

@@ -41,14 +41,21 @@ ${alignTex([
 const getKeys = () => {
     return [];
 };
+const getStartStatement = (identifiers) => {
+    const { askedRank } = identifiers;
+    return `u_{${askedRank}}`;
+};
 const getGeometricExplicitFormulaUsage = () => {
     const askedRank = randint(0, 10);
     const firstValue = randint(-5, 10, [0]);
     const reason = randint(2, 10);
     const identifiers = { firstValue, reason, askedRank };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
-        startStatement: `u_{${askedRank}}`,
+        startStatement: getStartStatement(identifiers),
         answer: getAnswer(identifiers),
         keys: getKeys(identifiers),
         answerFormat: "tex",
@@ -81,8 +88,6 @@ export const geometricExplicitFormulaUsage = {
     id: "geometricExplicitFormulaUsage",
     connector: "=",
     label: "Utiliser la formule générale d'une suite géométrique",
-    levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
-    sections: ["Suites"],
     isSingleStep: false,
     generator: (nb) => getDistinctQuestions(getGeometricExplicitFormulaUsage, nb),
     qcmTimer: 60,
@@ -96,4 +101,5 @@ export const geometricExplicitFormulaUsage = {
     getHint,
     getCorrection,
     getKeys,
+    getQuestionFromIdentifiers,
 };

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,EAQT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAgFF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAiHF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAc9D,CAAC"}