math-exercises 3.0.132 → 3.0.134

package/lib/exercises/math/probaStat/probaAsSumOfProbas.js

@@ -216,8 +216,7 @@ class FiniteProbDistr {
         const dictPToArrayOfIndexes = {};
         for (let i = 0; i < arrProba.length; i++) {
             const p = arrProba[i];
-            console.log("will simplify", p);
-            const tex = p.simplify().toTex();
+            const tex = p.toTex();
             if (dictPToArrayOfIndexes[tex] === undefined) {
                 dictPToArrayOfIndexes[tex] = [];
             }
@@ -233,7 +232,7 @@ class FiniteProbDistr {
         return p;
     }
     getArrIndexForP(p) {
-        return this.dictPToArrayOfIndexes[p.simplify().toTex()];
+        return this.dictPToArrayOfIndexes[p.toTex()];
     }
     getArrFrenchStrings(isDisplayingValue) {
         return Object.entries(this.dictPToArrayOfIndexes)
@@ -273,12 +272,15 @@ const getAnswerValueNode = (identifiers) => {
     const { eventIds, arrProba } = identifiers;
     const evUnion = EventConstructor.fromIdentifiers(eventIds);
     const finiteProbDistr = FiniteProbDistrConstructor.fromArrProba(arrProba.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)));
-    const nodeSumSimplified = operatorComposition(AddNode, evUnion
+    const arrFrac = evUnion
         .getArrElem()
-        .map((evElem) => finiteProbDistr.getPForIndex(evElem.index))).simplify({
-    //!TODO Sebastien : ne doit pas être nécessaire, à fix
-    //nbMaxSteps: 100,
-    });
+        .map((evElem) => finiteProbDistr.getPForIndex(evElem.index));
+    const nodeSumSimplified = (() => {
+        const den = arrFrac[0].rightChild.evaluate();
+        return frac(arrFrac
+            .map((fNode) => fNode.leftChild.evaluate())
+            .reduce((acc, x) => acc + x, 0), den);
+    })();
     return nodeSumSimplified;
 };
 const getAnswerNode = (identifiers) => {
@@ -320,11 +322,7 @@ $$
 p_{${evElem.id}} = ${finiteProbDistr.getPForIndex(evElem.index).toTex()}
 $$`).join(`
 `)}`;
-        const nodeSumSimplified = operatorComposition(AddNode, evUnion
-            .getArrElem()
-            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index))).simplify({
-        //nbMaxSteps: 100,
-        });
+        const nodeSumSimplified = getAnswerNode(identifiers);
         strCorrection += `
 Donc: 
 
@@ -344,7 +342,6 @@ $$`;
 const optsDefault = {
     nbElem: ["4", "6", "10", "12"],
     unionLength: ["2", "3", "4", "5"],
-    isProbasAreNumbers: true,
 };
 const options = [
     {
@@ -363,13 +360,6 @@ const options = [
         values: ["2", "3", "4", "5", "6"],
         defaultValue: optsDefault.unionLength,
     },
-    // {
-    //   id: "isProbasAreNumbers",
-    //   label: "Probabilités sous forme de nombres ?",
-    //   type: GeneratorOptionType.checkbox,
-    //   target: GeneratorOptionTarget.generation,
-    //   defaultValue: optsDefault.isProbasAreNumbers,
-    // },
 ];
 const getKeys = () => {
     return [];
@@ -382,39 +372,41 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     addValidProp(propositions, answer);
     if (isProbasAreNumbers) {
         const finiteProbDistr = FiniteProbDistrConstructor.fromArrProba(arrProba.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)));
-        tryToAddWrongProp(propositions, operatorComposition(MultiplyNode, evUnion
-            .getArrElem()
-            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index)))
-            .simplify({
-        //nbMaxSteps: 100,
-        })
-            .toTex());
-        tryToAddWrongProp(propositions, substract(1, operatorComposition(MultiplyNode, evUnion
-            .getArrElem()
-            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index))))
-            .simplify({
-        //nbMaxSteps: 100,
-        })
-            .toTex());
-        tryToAddWrongProp(propositions, substract(1, operatorComposition(AddNode, evUnion
-            .getArrElem()
-            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index))).simplify({
-        //nbMaxSteps: 100,
-        })).toTex());
-        tryToAddWrongProp(propositions, operatorComposition(AddNode, evUnion
+        const arrFrac = evUnion
             .getArrElem()
-            .map((evElem) => multiply(evElem.index, finiteProbDistr.getPForIndex(evElem.index))))
-            .simplify({
-        //nbMaxSteps: 100,
-        })
-            .toTex());
-        tryToAddWrongProp(propositions, multiply(frac(1, evUnion.getArrElem().length), operatorComposition(AddNode, evUnion
-            .getArrElem()
-            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index))))
-            .simplify({
-        //nbMaxSteps: 100,
-        })
-            .toTex());
+            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index));
+        tryToAddWrongProp(propositions, (() => {
+            const den = arrFrac[0].rightChild.evaluate();
+            return frac(arrFrac
+                .map((fNode) => fNode.leftChild.evaluate())
+                .reduce((acc, x) => acc * x, 0), den);
+        })().toTex());
+        tryToAddWrongProp(propositions, (() => {
+            const den = arrFrac[0].rightChild.evaluate();
+            return frac(den -
+                arrFrac
+                    .map((fNode) => fNode.leftChild.evaluate())
+                    .reduce((acc, x) => acc * x, 0), den);
+        })().toTex());
+        tryToAddWrongProp(propositions, (() => {
+            const den = arrFrac[0].rightChild.evaluate();
+            return frac(den -
+                arrFrac
+                    .map((fNode) => fNode.leftChild.evaluate())
+                    .reduce((acc, x) => acc + x, 0), den);
+        })().toTex());
+        tryToAddWrongProp(propositions, (() => {
+            const den = arrFrac[0].rightChild.evaluate();
+            return frac(arrFrac
+                .map((fNode, i) => fNode.leftChild.evaluate() * i)
+                .reduce((acc, x) => acc + x, 0), den);
+        })().toTex());
+        tryToAddWrongProp(propositions, (() => {
+            const den = arrFrac[0].rightChild.evaluate();
+            return frac(arrFrac
+                .map((fNode) => fNode.leftChild.evaluate())
+                .reduce((acc, x) => acc + x, 0), den * evUnion.getArrElem().length);
+        })().toTex());
     }
     else {
         tryToAddWrongProp(propositions, operatorComposition(MultiplyNode, evUnion.getArrElem().map((evElem) => evElem.p))
@@ -451,10 +443,13 @@ const getValueNode = (tex, arrProba) => {
             return parseInt(texVar.substring(texVar.indexOf("E_{") + 3, texVar.indexOf("}}")));
         }
     });
-    const arrayOfNodes = arrayOfIndexes.map((i) => finiteProbDistr.getPForIndex(i));
-    return operatorComposition(AddNode, arrayOfNodes).simplify({
-    //nbMaxSteps: 100,
-    });
+    const arrFrac = arrayOfIndexes.map((i) => finiteProbDistr.getPForIndex(i));
+    return (() => {
+        const den = arrFrac[0].rightChild.evaluate();
+        return frac(arrFrac
+            .map((fNode) => fNode.leftChild.evaluate())
+            .reduce((acc, x) => acc + x, 0), den);
+    })();
 };
 const isAnswerValid = (ans, { answer, ...identifiers }) => {
     const { arrProba } = identifiers;
@@ -481,12 +476,10 @@ const getProbaAsSumOfProbasQuestion = (optsIn) => {
     const eventIds = evUnion.toIdentifiers();
     const nbUnique = Math.min(randint(3, 7), situation.allElem.length - 1);
     const finiteProbDistr = FiniteProbDistrConstructor.randomDistr(situation.allElem.length, nbUnique);
-    const isProbasAreNumbers = opts.isProbasAreNumbers;
     const identifiers = {
         indexSituation,
         eventIds,
         arrProba: finiteProbDistr.arrProba.map((node) => node.toIdentifiers()),
-        isProbasAreNumbers,
     };
     return getQuestionFromIdentifiers(identifiers, opts);
 };

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

@@ -1 +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;AAOrC,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;AAoKF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}
+{"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;AAiOF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}

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

@@ -3,7 +3,6 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { randint } from "../../../../math/utils/random/randint.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
-import { mdTable } from "../../../../utils/markdown/mdTable.js";
 const getInstruction = (identifiers) => {
     const { a, values, isQuestionIsAboveA } = identifiers;
     return `Si on considère la série suivante :
@@ -20,36 +19,84 @@ La proposition suivante est-elle vraie ?
 const getHint = ({ a }) => {
     return `Regarde l'écart des valeurs par rapport à $${a.frenchify()}$.`;
 };
+// const getCorrection: GetCorrection<Identifiers> = (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 écarts par rapport à $${a.frenchify()}$ :
+// $\\ $
+// ${mdTable(
+//   [
+//     ["\\text{Valeur}", "\\text{Écart}"],
+//     [`\\text{Valeurs inférieures à } ${a.frenchify()}`, "\\text{}"],
+//     ...valuesBelowA.map((v) => [v.frenchify(), (v - a).frenchify()]),
+//     [
+//       "\\text{Total inférieur}",
+//       valuesBelowA
+//         .map((v) => v - a)
+//         .reduce((acc, v) => acc + v, 0)
+//         .frenchify(),
+//     ],
+//     [`\\text{Valeurs supérieures à } ${a.frenchify()}`, "\\text{}"],
+//     ...valuesAboveA.map((v) => [v.frenchify(), `+${(v - a).frenchify()}`]),
+//     [
+//       "\\text{Total supérieur}",
+//       `+${valuesAboveA
+//         .map((v) => v - a)
+//         .reduce((acc, v) => acc + v, 0)
+//         .frenchify()}`,
+//     ],
+//   ],
+//   true,
+// )}
+// $\\ $
+// 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 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 écarts par rapport à $${a.frenchify()}$ : 
+    return `${answer}. En effet : 
 
 $\\ $
+  
+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()}$
 
-${mdTable([
-        ["\\text{Valeur}", "\\text{Écart}"],
-        [`\\text{Valeurs inférieures à } ${a.frenchify()}`, "\\text{}"],
-        ...valuesBelowA.map((v) => [v.frenchify(), (v - a).frenchify()]),
-        [
-            "\\text{Total inférieur}",
-            valuesBelowA
-                .map((v) => v - a)
-                .reduce((acc, v) => acc + v, 0)
-                .frenchify(),
-        ],
-        [`\\text{Valeurs supérieures à } ${a.frenchify()}`, "\\text{}"],
-        ...valuesAboveA.map((v) => [v.frenchify(), `+${(v - a).frenchify()}`]),
-        [
-            "\\text{Total supérieur}",
-            `+${valuesAboveA
-                .map((v) => v - a)
-                .reduce((acc, v) => acc + v, 0)
-                .frenchify()}`,
-        ],
-    ], true)}
+`)
+        .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()}$.
 
 $\\ $
 

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,