math-exercises 3.0.64 → 3.0.66

package/lib/exercises/math/calcul/operations/numberInverse.js

@@ -0,0 +1,113 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nb } = identifiers;
+    const value = reifyAlgebraic(nb);
+    tryToAddWrongProp(propositions, opposite(value).toTex());
+    tryToAddWrongProp(propositions, "0");
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(1, 10).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { nb } = identifiers;
+    const value = reifyAlgebraic(nb);
+    return frac(1, value).simplify({ fractionsToDecimal: true }).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { nb } = identifiers;
+    const value = reifyAlgebraic(nb);
+    return `Quel est l'inverse de $${value.toTex()}$ ?`;
+};
+const getHint = (identifiers) => {
+    return `Pour $x\\neq 0$, $a\\neq 0$ et $b\\neq 0$ :
+  
+- L'inverse de $x$ est $\\frac{1}{x}$.
+
+- L'inverse de $\\frac{a}{b}$ est $\\frac{b}{a}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nb } = identifiers;
+    const value = reifyAlgebraic(nb);
+    if (isFractionNode(value)) {
+        return `Pour $a\\neq 0$ et $b\\neq 0$, l'inverse de $\\frac{a}{b}$ est $\\frac{b}{a}$.
+    
+L'inverse de $${value.toTex()}$ est donc $${getAnswer(identifiers)}$.`;
+    }
+    else {
+        return `Pour $x\\neq 0$, l'inverse de $x$ est $\\frac{1}{x}$.
+    
+L'inverse de $${value.toTex()}$ est donc $${getAnswer(identifiers)}$.`;
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify({ fractionsToDecimal: true }).toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getNumberInverseQuestion = (ops) => {
+    //1 2 4 5 et inverse décimal et opposés
+    //10 100 1000 1000 et inverse
+    const isFrac = probaFlip(0.4);
+    let nb;
+    if (isFrac) {
+        const frac = RationalConstructor.randomIrreductible();
+        nb = frac.toTree();
+    }
+    else {
+        const abs = random([1, 2, 4, 5, 10, 100, 1000]);
+        const isInv = coinFlip();
+        const isOpp = coinFlip();
+        const signed = (isOpp ? -1 : 1) * abs;
+        nb = isInv ? frac(1, signed).evaluate().toTree() : signed.toTree();
+    }
+    const identifiers = {
+        nb: nb.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const numberInverse = {
+    id: "numberInverse",
+    connector: "=",
+    label: "Déterminer l'inverse d'un nombre",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getNumberInverseQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/proportionality/rectangleSideAfterReduction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectangleSideAfterReduction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/rectangleSideAfterReduction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CAGnB,CAAC;AAoPF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAoB7D,CAAC"}
+{"version":3,"file":"rectangleSideAfterReduction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/rectangleSideAfterReduction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CAGnB,CAAC;AAsPF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAoB7D,CAAC"}

package/lib/exercises/math/calcul/proportionality/rectangleSideAfterReduction.js

@@ -107,7 +107,9 @@ const getInstruction = (identifiers) => {
     // Output the SVG string
     const sideIsOnFirstRect = askedIndex < 2;
     const sideTypeAsked = askedIndex % 2 === 0 ? "longueur" : "largeur";
-    const sidesString = lengths.map((e, i) => e === 0 ? "" : `${i % 2 === 0 ? "longueur" : "largeur"} $${e}$ cm`);
+    const sidesString = lengths.map((e, i) => e === 0
+        ? ""
+        : `${i % 2 === 0 ? "longueur" : "largeur"} $${e}\\ \\textrm{cm}$`);
     return `Sur la figure suivante, le premier rectangle a pour ${sideIsOnFirstRect
         ? sidesString[askedIndex === 1 ? 0 : 1]
         : sidesString[0] + " et pour " + sidesString[1]}. 
@@ -118,7 +120,7 @@ Le deuxième rectangle est une réduction du premier rectangle et a pour ${sideI
   
 ${d3n.svgString()}
 
-Quelle est la ${sideTypeAsked} (en cm) du ${sideIsOnFirstRect ? "premier" : "deuxième"} rectangle ? Arrondir à $0,1$ cm si nécessaire.`;
+Quelle est la ${sideTypeAsked} (en $\\textrm{cm}$) du ${sideIsOnFirstRect ? "premier" : "deuxième"} rectangle ? Arrondir à $0,1\\ \\textrm{cm}$ si nécessaire.`;
 };
 // const getHint: GetHint<Identifiers> = (identifiers) => {};
 // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};

package/lib/exercises/math/calcul/proportionality/scaleCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scaleCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/scaleCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IAEtB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAqFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}
+{"version":3,"file":"scaleCalculation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/scaleCalculation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,OAAO,CAAC;IAEtB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AA+HF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}

package/lib/exercises/math/calcul/proportionality/scaleCalculation.js

@@ -5,59 +5,89 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { Measure } from "../../../../pc/measure/measure.js";
 import { DistanceUnit } from "../../../../pc/units/distanceUnits.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
-const getScaleCalculationQuestion = () => {
-    const isSmallScale = coinFlip();
-    const scale = isSmallScale ? randint(1, 5) * 10 : randint(5, 100) * 1000;
+const getInstruction = (identifiers) => {
+    const { scale, isSmallScale, fakeDistance } = identifiers;
     const realUnit = isSmallScale ? DistanceUnit.m : DistanceUnit.km;
     const cm = DistanceUnit.cm;
-    const fakeDistanceNb = isSmallScale ? randint(5, 100) : randint(1, 100);
-    const fakeDistance = new Measure(fakeDistanceNb, 0, cm);
-    const realDistanceNb = (scale * fakeDistance.evaluate()) / (isSmallScale ? 100 : 100000);
+    const fakeDistanceMeasure = new Measure(fakeDistance, 0, cm);
+    const realDistanceNb = (scale * fakeDistanceMeasure.evaluate()) / (isSmallScale ? 100 : 100000);
     const realDistance = new Measure(realDistanceNb, 0, realUnit);
     const instruction = isSmallScale
         ? `Un bateau de $${realDistance.toTex({
             notScientific: true,
-        })}$ est représenté par un modèle réduit de $${fakeDistance.toTex({
+        })}$ est représenté par un modèle réduit de $${fakeDistanceMeasure.toTex({
             notScientific: true,
         })}$. Quelle est l'échelle du modèle réduit ?`
         : `La distance entre deux villes est de $${realDistance.toTex({
             notScientific: true,
-        })}$. Sur une carte, cette distance mesure $${fakeDistance.toTex({
+        })}$. Sur une carte, cette distance mesure $${fakeDistanceMeasure.toTex({
             notScientific: true,
         })}$. Quelle est l'échelle de la carte ?`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { scale, isSmallScale, fakeDistance } = identifiers;
     const answer = new Rational(1, scale).toTex();
-    const question = {
-        answer,
-        instruction,
-        keys: [],
-        answerFormat: "tex",
-        hint: `Convertis les longueurs en $${cm.toTex()}$, puis fais un calcul de propotionnalité.`,
-        correction: `On convertit d'abord les longueurs en cm : 
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { scale, isSmallScale, fakeDistance } = identifiers;
+    const cm = DistanceUnit.cm;
+    return `Convertis les longueurs en $${cm.toTex()}$, puis fais un calcul de proportionnalité.`;
+};
+const getCorrection = (identifiers) => {
+    const { scale, isSmallScale, fakeDistance } = identifiers;
+    const realUnit = isSmallScale ? DistanceUnit.m : DistanceUnit.km;
+    const cm = DistanceUnit.cm;
+    const fakeDistanceMeasure = new Measure(fakeDistance, 0, cm);
+    const realDistanceNb = (scale * fakeDistanceMeasure.evaluate()) / (isSmallScale ? 100 : 100000);
+    const realDistance = new Measure(realDistanceNb, 0, realUnit);
+    const answer = getAnswer(identifiers);
+    return `On convertit d'abord les longueurs en cm : 
     
 $$
 ${realDistance.toTex({ notScientific: true })} = ${realDistance
-            .convert("cm")
-            .toTex({ notScientific: true })}
+        .convert("cm")
+        .toTex({ notScientific: true })}
 $$
 
-Puis, on fait un calcul de proportionnalité : puisque $${fakeDistance.toTex({
-            notScientific: true,
-        })}$ représentent $${realDistance.convert("cm").toTex({
-            notScientific: true,
-        })}$ réels, alors $1${cm.toTex()}$ représente $\\frac{${realDistance
-            .convert("cm")
-            .toTex({ notScientific: true, hideUnit: true })}}{${fakeDistance.toTex({
-            notScientific: true,
-            hideUnit: true,
-        })}}=${scale}${cm.toTex()}$ réels.
+Puis on fait un calcul de proportionnalité : puisque $${fakeDistanceMeasure.toTex({
+        notScientific: true,
+    })}$ représentent $${realDistance.convert("cm").toTex({
+        notScientific: true,
+    })}$ réels, alors $1\\ ${cm.toTex()}$ représente $\\frac{${realDistance
+        .convert("cm")
+        .toTex({
+        notScientific: true,
+        hideUnit: true,
+    })}}{${fakeDistanceMeasure.toTex({
+        notScientific: true,
+        hideUnit: true,
+    })}}=${scale}\\ ${cm.toTex()}$ réels.
 
 L'échelle est donc de $${answer}$.
-    `,
-        identifiers: {
-            scale,
-            fakeDistance: fakeDistanceNb,
-            isSmallScale,
-        },
+    `;
+};
+const getScaleCalculationQuestion = () => {
+    const isSmallScale = coinFlip();
+    const scale = isSmallScale ? randint(1, 5) * 10 : randint(5, 100) * 1000;
+    const fakeDistanceNb = isSmallScale ? randint(5, 100) : randint(1, 100);
+    const identifiers = {
+        scale,
+        fakeDistance: fakeDistanceNb,
+        isSmallScale,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        identifiers,
     };
     return question;
 };
@@ -76,9 +106,7 @@ export const scaleCalculation = {
     id: "scaleCalculation",
     connector: "=",
     label: "Calculer une échelle",
-    levels: [],
     isSingleStep: true,
-    sections: [],
     generator: (nb) => getDistinctQuestions(getScaleCalculationQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -86,4 +114,6 @@ export const scaleCalculation = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
+    getQuestionFromIdentifiers,
 };

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

@@ -7,7 +7,7 @@ import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
 const getHint = ({ coeff, affine1, affine2 }) => {
-    return `Choisis deux facteurs de ce produit et multiplie les entre eux. Puis, multiplier le résultat obtenu par le troisième terme.`;
+    return `Choisis deux facteurs de ce produit et multiplie les entre eux. Puis multiplie le résultat obtenu par le troisième terme.`;
 };
 const getCorrection = (identifiers) => {
     const affine1 = new Affine(identifiers.affine1[1], identifiers.affine1[0]);
@@ -18,7 +18,7 @@ const getCorrection = (identifiers) => {
     
 ${alignTex(`${statement} = ${new MultiplyNode(affine1.times(identifiers.coeff).toTree(), affine2.toTree()).toTex()}`)}
 
-Puis, on utilise la double distributivité : 
+Puis on utilise la double distributivité : 
 
 ${alignTex([
         ["", "", new MultiplyNode(affine3.toTree(), affine2.toTree()).toTex()],

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

@@ -44,7 +44,7 @@ $$
 };
 const getHint = (identifiers) => {
     const affine = new Affine(identifiers.a, 0);
-    return `Multiplie chaque terme dans la parenthèse par $${affine
+    return `Multiplie chaque terme de la parenthèse par $${affine
         .toTree()
         .toTex()}$.`;
 };

package/lib/exercises/math/calculLitteral/equation/choseOperationToSolveEquation.js

@@ -128,23 +128,23 @@ const getHint = (identifiers) => {
             //ax = b tous entiers
             return `L'écriture $ax$ signifie $a$ multiplié par $x$. 
       
-Quelle opération permet d'annuler une multiplication ?`;
+Quelle est l'opération contraire d'une multiplication ?`;
         case 2:
             // ax + b = c tous entiers
-            return `Quelle opération permet d'annuler une addition ?`;
+            return `Quelle est l'opération contraire d'une addition ?`;
         case 3:
             //ax-b = c tous entiers
-            return `Quelle opération permet d'annuler une soustraction ?`;
+            return `Quelle est l'opération contraire d'une soustraction ?`;
         case 4:
             //x/a = b tous entiers
-            return `Quelle opération permet d'annuler une division ?`;
+            return `Quelle est l'opération contraire d'une division ?`;
         case 5:
             //x+a = b
-            return `Quelle opération permet d'annuler une addition ?`;
+            return `Quelle est l'opération contraire d'une addition ?`;
         case 6:
         default:
             //x-a = b
-            return `Quelle opération permet d'annuler une soustraction ?`;
+            return `Quelle est l'opération contraire d'une soustraction ?`;
     }
 };
 const getCorrection = (identifiers) => {
@@ -154,33 +154,33 @@ const getCorrection = (identifiers) => {
             //ax = b tous entiers
             return `$${multiply(a, "x").toTex()}$ est une multiplication de $${a}$ par $x$. 
       
-Pour isoler $x$, il faut donc diviser par $${a}$.`;
+Pour isoler $x$, il faut donc diviser les deux membres de l'équation par $${a}$.`;
         case 2:
             // ax + b = c tous entiers
-            return `Pour isoler $x$, on commence par passer $${b}$ à droite de l'équation. 
+            return `Pour isoler $x$, on commence par regrouper les termes sans $x$ dans le membre de droite. 
       
-Pour cela, il faut soustraire par $${b}$.`;
+Pour cela, il faut soustraire les deux membres de l'équation par $${b}$.`;
         case 3:
             //ax-b = c tous entiers
-            return `Pour isoler $x$, on commence par passer $${-b}$ à droite de l'équation. 
+            return `Pour isoler $x$, on commence par regrouper les termes sans $x$ dans le membre de droite.
       
-Pour cela, il faut additionner par $${b}$.`;
+Pour cela, il faut additionner les deux membres de l'équation par $${b}$.`;
         case 4:
             //x/a = b tous entiers
-            return `Pour isoler $x$, on doit "annuler" la division par $${a}$. 
+            return `Pour isoler $x$, on commence par regrouper les termes sans $x$ dans le membre de droite.  
 
-Pour cela, on multiplie par $${a}$.`;
+Pour cela, on multiplie les deux membres de l'équation par $${a}$.`;
         case 5:
             //x+a = b
-            return `Pour isoler $x$, il faut faire passer $${a}$ à droite de l'équation. 
+            return `Pour isoler $x$, on commence par regrouper les termes sans $x$ dans le membre de droite.  
       
-Pour cela, il faut soustraire par $${a}$.`;
+Pour cela, il faut soustraire les deux membres de l'équation par $${a}$.`;
         case 6:
         default:
             //x-a = b
-            return `Pour isoler $x$, il faut faire passer $${-a}$ à droite de l'équation. 
+            return `Pour isoler $x$, on commence par regrouper les termes sans $x$ dans le membre de droite.  
       
-Pour cela, il faut additionner par $${a}$.`;
+Pour cela, il faut additionner les deux membres de l'équation par $${a}$.`;
     }
 };
 const getQuestionFromIdentifiers = (identifiers) => {

package/lib/exercises/math/calculLitteral/equation/equa1.js

@@ -28,7 +28,7 @@ const getAnswer = (identifiers) => {
 };
 const getHint = (identifiers) => {
     const { a, b } = identifiers;
-    return `Il faut isoler $x$ à gauche. Pour cela, effectue l'opération des deux côtés de l'équation qui permet de supprimer le terme $${a < 0 ? "" : "+"}${a}$.`;
+    return `Il faut isoler $x$ à gauche. Pour cela, effectue des deux côtés de l'équation l'opération qui permet de supprimer le terme $${a < 0 ? "" : "+"}${a}$.`;
 };
 const getCorrection = (identifiers) => {
     const { a, b } = identifiers;

package/lib/exercises/math/calculLitteral/equation/equa2.js

@@ -44,7 +44,7 @@ const getHint = (identifiers) => {
     const { a, b, isXRight, aNumberType } = identifiers;
     const aTree = reifyAlgebraic(a);
     const bTree = reifyAlgebraic(b);
-    return `Il faut isoler $x$ à ${isXRight ? "droite" : "gauche"}. Pour cela, effectue l'opération des deux côtés de l'équation qui permet de supprimer la multiplication par $${aTree.toTex()}$.`;
+    return `Il faut isoler $x$ à ${isXRight ? "droite" : "gauche"}. Pour cela, effectue des deux côtés de l'équation l'opération qui permet de supprimer la multiplication par $${aTree.toTex()}$.`;
 };
 const getCorrection = (identifiers) => {
     const { a, b, isXRight, aNumberType } = identifiers;

package/lib/exercises/math/calculLitteral/equation/equa3.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equa3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equa3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAsBvD,CAAC"}
+{"version":3,"file":"equa3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equa3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAsBvD,CAAC"}

package/lib/exercises/math/calculLitteral/equation/equa3.js

@@ -26,15 +26,13 @@ ${getStatementNode(identifiers).toTex()}
 $$`;
 };
 const getHint = (identifiers) => {
-    return "Isolez le terme $x$ dans la partie gauche de l'équation.";
+    return "Isole le terme $x$ dans le membre gauche de l'équation.";
 };
 const getCorrection = (identifiers) => {
     const { a, b, c } = identifiers;
     const statementTex = getStatementNode(identifiers).toTex();
     const answer = getAnswer(identifiers);
-    return `Commencer par soustraire $${b}$ des deux côtés de l'équation pour 
-    l'éliminer du côté gauche. Ensuite, diviser les deux côtés de l'équation par 
-    $${a}$ pour isoler $x$, ce qui donne : 
+    return `On commence par soustraire $${b}$ des deux côtés de l'équation pour l'éliminer du côté gauche. Ensuite, on divise les deux côtés de l'équation par $${a}$ pour isoler $x$. 
     
 ${alignTex([
         [

package/lib/exercises/math/calculLitteral/equation/equa4.js

@@ -59,7 +59,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
     return question;
 };
 const getHint = (identifiers) => {
-    return `Commence par regrouper les termes en $x$ d'un même côté de l'équation. Puis, isole $x$ en effectuant les bonnes opérations.`;
+    return `Commence par regrouper les termes en $x$ d'un même côté de l'équation. Puis isole $x$ en effectuant les bonnes opérations.`;
 };
 const getCorrection = (identifiers) => {
     const { a, b, c, d } = identifiers;

package/lib/exercises/math/calculLitteral/equation/equationFromSentenceExercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationFromSentenceExercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromSentenceExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,YAAY,CAAC;CACpB,CAAC;AASF,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAkOF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}
+{"version":3,"file":"equationFromSentenceExercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromSentenceExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,YAAY,CAAC;CACpB,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AA2PF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAY9D,CAAC"}

package/lib/exercises/math/calculLitteral/equation/equationFromSentenceExercise.js

@@ -12,17 +12,85 @@ import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 const x = new VariableNode("x");
 const twoNode = new NumberNode(2);
+const getInstruction = (identifiers) => {
+    const { type, vars } = identifiers;
+    const { flip, resultNb, randAdd, op2 } = vars;
+    let instruction = `On appelle $x$ le nombre à trouver. 
+      Traduire par une équation la phrase suivante : 
+      
+`;
+    switch (type) {
+        case 1:
+            return (instruction +
+                `"${flip ? `Le double` : `La moitié`} du nombre à trouver vaut $${resultNb}$".`);
+        case 2:
+            return (instruction +
+                `"${flip ? `La somme` : `La différence`} du nombre à trouver et de $${randAdd}$ a pour résultat $${resultNb}$".`);
+        case 3:
+        default:
+            return (instruction +
+                `"${flip ? `Le double` : `La moitié`} du nombre à trouver ${flip ? op2 : op2 + "e"} de $${randAdd}$ vaut $${resultNb}$".`);
+    }
+};
+const getAnswerNode = (identifiers) => {
+    const { type, vars } = identifiers;
+    const randAddNode = vars.randAdd
+        ? new NumberNode(vars.randAdd)
+        : new NumberNode(0);
+    switch (type) {
+        case 1:
+            return new EqualNode(vars.flip
+                ? new MultiplyNode(x, twoNode).simplify()
+                : new FractionNode(x, twoNode).simplify(), new NumberNode(vars.resultNb));
+        case 2:
+            return new EqualNode(vars.flip
+                ? new AddNode(x, randAddNode)
+                : new SubstractNode(x, randAddNode), new NumberNode(vars.resultNb));
+        case 3:
+            return new EqualNode(vars.op2 === "augmenté"
+                ? new AddNode(vars.flip
+                    ? new MultiplyNode(twoNode, x).simplify()
+                    : new FractionNode(x, twoNode).simplify(), randAddNode)
+                : new SubstractNode(vars.flip
+                    ? new MultiplyNode(twoNode, x).simplify()
+                    : new FractionNode(x, twoNode).simplify(), randAddNode), new NumberNode(vars.resultNb));
+    }
+    return new EqualNode(x, x);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
 const getEquationFromSentenceExerciseQuestion = () => {
-    const exercise = generateExercise();
+    const type = randint(1, 4);
+    const flip = coinFlip();
+    const resultNb = randint(1, 51) * 2;
+    let randAdd;
+    let op2;
+    switch (type) {
+        case 1:
+            break;
+        case 2:
+            randAdd = randint(1, 11);
+            break;
+        case 3:
+            randAdd = randint(1, 11);
+            op2 = coinFlip() ? `augmenté` : `diminué`;
+            break;
+    }
+    const vars = { randAdd, resultNb, op2, flip };
+    const identifiers = {
+        type,
+        vars,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: exercise.answer.toTex(),
-        instruction: exercise.instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["x", "equal"],
         answerFormat: "tex",
-        identifiers: {
-            type: exercise.type,
-            vars: exercise.vars,
-        },
+        identifiers,
     };
     return question;
 };
@@ -37,8 +105,8 @@ const getPropositions = (n, { answer, type, vars }) => {
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { type, vars }) => {
-    const correctAnswer = getCorrectAnswer(type, vars);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const correctAnswer = getAnswerNode(identifiers);
     return correctAnswer.toAllValidTexs().includes(ans);
 };
 const generateProposition = (type, vars) => {
@@ -90,68 +158,15 @@ const getSecondProposition = (type, vars, randAddNode, resultNode) => {
     }
     return new EqualNode(x, x);
 };
-const getCorrectAnswer = (type, vars) => {
-    const randAddNode = vars.randAdd
-        ? new NumberNode(vars.randAdd)
-        : new NumberNode(0);
-    switch (type) {
-        case 1:
-            return new EqualNode(vars.flip
-                ? new MultiplyNode(x, twoNode).simplify()
-                : new FractionNode(x, twoNode).simplify(), new NumberNode(vars.resultNb));
-        case 2:
-            return new EqualNode(vars.flip
-                ? new AddNode(x, randAddNode)
-                : new SubstractNode(x, randAddNode), new NumberNode(vars.resultNb));
-        case 3:
-            return new EqualNode(vars.op2 === "augmenté"
-                ? new AddNode(vars.flip
-                    ? new MultiplyNode(twoNode, x).simplify()
-                    : new FractionNode(x, twoNode).simplify(), randAddNode)
-                : new SubstractNode(vars.flip
-                    ? new MultiplyNode(twoNode, x).simplify()
-                    : new FractionNode(x, twoNode).simplify(), randAddNode), new NumberNode(vars.resultNb));
-    }
-    return new EqualNode(x, x);
-};
-const generateExercise = () => {
-    const type = randint(1, 4);
-    const flip = coinFlip();
-    const resultNb = randint(1, 51) * 2;
-    let randAdd;
-    let op2;
-    let instruction = "";
-    switch (type) {
-        case 1:
-            instruction = `On appelle $x$ le nombre à trouver. 
-      Traduire par une équation la phrase "${flip ? `Le double` : `La moitié`} du nombre à trouver vaut $${resultNb}$".`;
-            break;
-        case 2:
-            randAdd = randint(1, 11);
-            instruction = `On appelle $x$ le nombre à trouver. 
-      Traduire par une équation la phrase "${flip ? `La somme` : `La différence`} du nombre à trouver et de $${randAdd}$ a pour résultat $${resultNb}$".`;
-            break;
-        case 3:
-            randAdd = randint(1, 11);
-            op2 = coinFlip() ? `augmenté` : `diminué`;
-            instruction = `On appelle $x$ le nombre à trouver. 
-      Traduire par une équation la phrase "${flip ? `Le double` : `La moitié`} du nombre à trouver ${flip ? op2 : op2 + "e"} de $${randAdd}$ vaut $${resultNb}$".`;
-            break;
-    }
-    const vars = { randAdd, resultNb, op2, flip };
-    const answer = getCorrectAnswer(type, vars);
-    return { type, instruction, answer, vars };
-};
 export const equationFromSentenceExericse = {
     id: "equationFromSentenceExercise",
     label: "Traduire une phrase en une équation mathématique",
-    levels: ["5ème"],
     isSingleStep: true,
-    sections: ["Calcul littéral"],
     generator: (nb) => getDistinctQuestions(getEquationFromSentenceExerciseQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/calculLitteral/equation/firstDegreeEquation.js

@@ -13,14 +13,14 @@ const getInstruction = (identifiers) => {
     const { a, b } = identifiers;
     const frac = new FractionNode(a.toTree(), "x".toTree());
     const statement = new EqualNode(frac, b.toTree()).toTex();
-    return `Résoudre l'équation suivante : 
+    return `Résoudre l'équation suivante, où $x\\neq 0$ : 
  
 $$
 ${statement}
 $$`;
 };
 const getHint = (identifiers) => {
-    return `Multiplie les deux côtés de l'équation par $x$, puis isole $x$ dans la partie droite de l'équation.`;
+    return `Multiplie les deux membres de l'équation par $x$, puis isole $x$ dans le membre de droite de l'équation.`;
 };
 const getAnswer = (identifiers) => {
     const { a, b } = identifiers;
@@ -32,7 +32,7 @@ const getCorrection = (identifiers) => {
     const frac = new FractionNode(a.toTree(), "x".toTree());
     const statement = new EqualNode(frac, b.toTree()).toTex();
     const answer = getAnswer(identifiers);
-    return `On multiplie les deux côtés de l'équation par $x$, puis on divise par $${b}$ : 
+    return `On multiplie les deux membres de l'équation par $x$ (qui est bien différent de $0$), puis on divise par $${b}$ : 
     
 ${alignTex([
         ["", `${statement}`],