math-exercises 3.0.56 → 3.0.58

package/lib/exercises/math/calculLitteral/systems/basicSystemResolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basicSystemResolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/basicSystemResolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAKtE,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,EAAE,CAAC;CAIhC,CAAC;AA6EF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAgBvD,CAAC"}
+{"version":3,"file":"basicSystemResolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/basicSystemResolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAMtE,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,EAAE,CAAC;CAIhC,CAAC;AAoGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}

package/lib/exercises/math/calculLitteral/systems/basicSystemResolution.js

@@ -34,6 +34,26 @@ const getBasicSystemResolutionQuestion = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    return `On peut utilise la méthode par substitution ou bien celle par combinaison : 
+  
+- Si une des variables est facile à isoler dans une des équations, alors on utilise la méthode par substitution : on isole cette variable, puis on injecte le résultat obtenu dans l'autre équation.
+
+- Sinon, on utilise la méthode par combinaison : on multiple une (ou les deux) équation(s) par un nombre, afin que lorsqu'on additionne les deux équations, une des variables disparaisse.`;
+};
+const getCorrection = (identifiers) => {
+    const sys = GeneralSystemConstructor.fromIdentifiers(identifiers);
+    let corr = "";
+    corr += sys.toCorrectionTex();
+    corr += `
+  
+La solution du système est donc le couple :
+
+$$
+${getAnswer(identifiers)}
+$$`;
+    return corr;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -41,6 +61,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -82,4 +104,5 @@ export const basicSystemResolution = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     rebuildIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/calculLitteral/systems/verifySystemSolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"verifySystemSolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/verifySystemSolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,wBAAwB,EACzB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IAGjB,MAAM,EAAE,wBAAwB,CAAC;IACjC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}
+{"version":3,"file":"verifySystemSolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/verifySystemSolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,wBAAwB,EACzB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IAGjB,MAAM,EAAE,wBAAwB,CAAC;IACjC,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAgBtD,CAAC"}

package/lib/exercises/math/calculLitteral/systems/verifySystemSolution.js

@@ -44,11 +44,59 @@ const getVerifySystemSolutionQuestion = () => {
     const identifiers = { sysIds: sys.toIdentifiers(), x, y };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    return `On remplace $x$ par $${identifiers.x}$ et $y$ par $${identifiers.y}$ dans les deux équations.
+  
+Si les deux égalités sont vraies, alors le couple est bien une solution du système. Sinon, ce n'en est pas une.`;
+};
+const getCorrection = (identifiers) => {
+    const { sysIds, x, y } = identifiers;
+    const sys = GeneralSystemConstructor.fromIdentifiers(sysIds);
+    const equas = sys.getEqualNodes();
+    const equasDetailed = equas.map((e) => e.toDetailedEvaluation({
+        x: x.toTree(),
+        y: y.toTree(),
+    }));
+    const equasDetailedSimp = equasDetailed.map((e) => e.simplify());
+    const firstIsTrue = equasDetailedSimp[0].isVerified();
+    const secondIsTrue = equasDetailedSimp[1].isVerified();
+    return `On remplace $x$ par $${x}$ et $y$ par $${y}$ dans les deux équations :
+  
+$$
+${equasDetailed[0].leftChild.toTex()} = ${equasDetailedSimp[0].leftChild.toTex()}
+$$
+
+${firstIsTrue
+        ? "La première équation est donc bien vérifiée."
+        : "La première équation n'est donc pas vérifiée : le couple n'est donc pas une solution du système."}
+
+${firstIsTrue
+        ? `
+  
+On vérifie maintenant la deuxième équation : 
+
+$$
+${equasDetailed[1].leftChild.toTex()} = ${equasDetailedSimp[1].leftChild.toTex()}
+$$
+
+${secondIsTrue
+            ? "La deuxième équation est donc bien vérifiée."
+            : "La deuxième équation n'est donc pas vérifiée : le couple n'est donc pas une solution du système."}
+`
+        : ""}
+
+${firstIsTrue && secondIsTrue
+        ? "Les deux équations sont donc bien vérifiées : le couple est bien une solution du système."
+        : ""}
+`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         answerFormat: "raw",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -77,4 +125,5 @@ export const verifySystemSolution = {
     answerType: "QCU",
     getQuestionFromIdentifiers,
     rebuildIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/conversion/capacityConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capacityConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/capacityConversion.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAQT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA0DF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}
+{"version":3,"file":"capacityConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/capacityConversion.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA0HF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}

package/lib/exercises/math/conversion/capacityConversion.js

@@ -1,7 +1,10 @@
 import { Decimal, DecimalConstructor, } from "../../../math/numbers/decimals/decimal.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 import { doWhile } from "../../../utils/doWhile.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 import { addValidProp, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
 const units = ["mL", "cL", "dL", "L", "daL", "hL", "kL"];
@@ -9,19 +12,72 @@ const getCapacityConversion = () => {
     const randomUnitIndex = randint(0, 7);
     const randomUnitInstructionIndex = randint(0, 7, [randomUnitIndex]);
     const randomCapacity = doWhile(() => DecimalConstructor.random(0, 1000, randint(0, 4)), (x) => x.value === 0);
-    const answer = (randomCapacity.multiplyByPowerOfTen(randomUnitIndex - randomUnitInstructionIndex).value + "").replace(".", ",");
+    const identifiers = {
+        randomCapacity: randomCapacity.value,
+        randomUnitIndex,
+        randomUnitInstructionIndex,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getInstruction = (identifiers) => {
+    const { randomCapacity, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    return `Compléter : 
+
+$$
+${randomCapacity.frenchify()} \\textrm{${units[randomUnitIndex]}} = \\ldots \\textrm{${units[randomUnitInstructionIndex]}}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { randomCapacity, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const answer = new Decimal(randomCapacity)
+        .multiplyByPowerOfTen(randomUnitIndex - randomUnitInstructionIndex)
+        .value.frenchify();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const unit = units[randomUnitIndex];
+    const target = units[randomUnitInstructionIndex];
+    const space = randomUnitIndex - randomUnitInstructionIndex;
+    return `On rappelle que :
+  
+$$
+1 \\ \\textrm{${unit}} = ${space > 0 ? Math.pow(10, space) : frac(1, Math.pow(10, -space)).toTex()} \\ \\textrm{${target}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { randomCapacity, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const unit = units[randomUnitIndex];
+    const target = units[randomUnitInstructionIndex];
+    const space = randomUnitIndex - randomUnitInstructionIndex;
+    const coeff = space > 0 ? Math.pow(10, space).toTree() : frac(1, Math.pow(10, -space));
+    return `On sait que :
+  
+$$
+1 \\ \\textrm{${unit}} = ${coeff.toTex()} \\ \\textrm{${target}}
+$$
+
+Il suffit alors de multiplier $${randomCapacity.frenchify()}$ par $${coeff.toTex()}$ :
+
+${alignTex([
+        [
+            `${randomCapacity.frenchify()} \\textrm{${unit}} `,
+            "=",
+            `${multiply(coeff, randomCapacity).toTex()}\\ \\textrm{${target}}`,
+        ],
+        ["", "=", `${getAnswer(identifiers)}\\ \\textrm{${target}}`],
+    ])}
+`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Compléter : $${randomCapacity.value
-            .toString()
-            .replace(".", ",")} \\textrm{${units[randomUnitIndex]}} = \\ldots \\textrm{${units[randomUnitInstructionIndex]}}$`,
-        answer,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: {
-            randomCapacity: randomCapacity.value,
-            randomUnitIndex,
-            randomUnitInstructionIndex,
-        },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -46,12 +102,12 @@ export const capacityConversion = {
     connector: "=",
     getPropositions,
     label: "Conversion de capacités",
-    levels: ["6ème", "5ème", "CAP", "2ndPro"],
-    sections: ["Conversions"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getCapacityConversion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/conversion/hoursToDecimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hoursToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/hoursToDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAwEF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"hoursToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/hoursToDecimal.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAwIF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

package/lib/exercises/math/conversion/hoursToDecimal.js

@@ -3,28 +3,88 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { DecimalConstructor, } from "../../../math/numbers/decimals/decimal.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { round } from "../../../math/utils/round.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
-const getHoursToDecimalQuestion = () => {
-    const isDecimalToHours = coinFlip();
-    const dec = DecimalConstructor.random(0, 3, 2);
-    const hours = Math.floor(dec.value);
-    const mins = round((dec.value - hours) * 100 * 0.6, 0);
-    const decTex = dec.toTree().toTex();
+import { approxOrEqual } from "../../../utils/latex/approxOrEqual.js";
+const getInstruction = (identifiers) => {
+    const { dec, isDecimalToHours } = identifiers;
+    const hours = Math.floor(dec);
+    const mins = round((dec - hours) * 100 * 0.6, 0);
+    const decTex = dec.frenchify();
     const durationTex = isDecimalToHours
-        ? decTex + "\\text{h}"
-        : `${hours}\\text{h}${mins}\\text{min}`;
+        ? decTex + "\\ \\textrm{h}"
+        : `${hours}\\ \\textrm{h}\\ ${mins}\\ \\textrm{min}`;
+    return `Convertir la durée suivante en ${isDecimalToHours ? "heures et minutes" : "$\\ \\textrm{h}$ (nombre décimal)"} : 
+  
+$$
+${durationTex}
+$$ 
+
+Arrondir ${isDecimalToHours ? "à la minute près" : "au centième près"}.`;
+};
+const getAnswer = (identifiers) => {
+    const { dec, isDecimalToHours } = identifiers;
+    const hours = Math.floor(dec);
+    const mins = round((dec - hours) * 100 * 0.6, 0);
     const answer = isDecimalToHours
         ? `${hours}\\text{h}${mins}\\text{min}`
         : `${hours},${round((mins / 60) * 100, 0)}\\text{h}`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { dec, isDecimalToHours } = identifiers;
+    const hours = Math.floor(dec);
+    const mins = round((dec - hours) * 100 * 0.6, 0);
+    if (isDecimalToHours) {
+        return `Dans $1\\ \\text{h}$, il y a $60$ minutes. Un calcul de proportionnalité permet donc de déterminer combien y a-t-il de minutes dans $${dec.frenchify()} \\text{h}$.`;
+    }
+    return `$60$ minutes correspondent à $1 \\ \\text{h}$. Un calcul de proportionnalité permet donc de convertir $${mins} \\ \\text{min}$ en heures.`;
+};
+const getCorrection = (identifiers) => {
+    const { dec, isDecimalToHours } = identifiers;
+    const hours = Math.floor(dec);
+    const mins = round((dec - hours) * 100 * 0.6, 0);
+    const fracDec = round(dec - Math.floor(dec), 2);
+    if (isDecimalToHours) {
+        return `Dans $1\\ \\text{h}$, il y a $60$ minutes. Un calcul de proportionnalité permet donc de déterminer combien y a-t-il de minutes dans $${fracDec.frenchify()} \\text{h}$ : 
+    
+$$
+${multiply(fracDec, 60).toTex()} ${approxOrEqual(fracDec * 60, 0).join("")}
+$$
+
+$${dec.frenchify()}\\ \\text{h}$ correspond donc à $${getAnswer(identifiers)}$.`;
+    }
+    return `$60$ minutes correspondent à $1 \\ \\text{h}$. Un calcul de proportionnalité permet donc de convertir $${mins} \\ \\text{min}$ en heures :
+
+$$
+${frac(mins, 60).toTex()} ${approxOrEqual(mins / 60, 2).join("")}
+$$
+
+Le résultat attendu est donc :
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer,
-        instruction: `Convertir la durée suivante en ${isDecimalToHours ? "heures et minutes" : "$\\text{h}$ (nombre décimal)"} : $${durationTex}$ (arrondir ${isDecimalToHours ? "à la minute près" : "au centième près"})`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["hours", "minutes"],
         answerFormat: "tex",
-        identifiers: { isDecimalToHours, dec: dec.value },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getHoursToDecimalQuestion = () => {
+    const isDecimalToHours = coinFlip();
+    const dec = DecimalConstructor.random(0, 3, 2);
+    const identifiers = { isDecimalToHours, dec: dec.value };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, isDecimalToHours, dec }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -49,8 +109,6 @@ const getPropositions = (n, { answer, isDecimalToHours, dec }) => {
 const isAnswerValid = (ans, { answer, isDecimalToHours, dec }) => {
     if (isDecimalToHours)
         return ans === answer;
-    // const hours = Math.floor(dec);
-    // const mins = round((dec - hours) * 100 * 0.6, 0);
     const texs = [answer, answer.replace("\\text{h}", "")];
     return texs.includes(ans);
 };
@@ -58,13 +116,13 @@ export const hoursToDecimal = {
     id: "hoursToDecimal",
     connector: "=",
     label: "Convertir une durée en nombre décimal et inversement",
-    levels: ["2nde", "2ndPro", "3ème"],
     isSingleStep: true,
-    sections: ["Conversions"],
     generator: (nb) => getDistinctQuestions(getHoursToDecimalQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/conversion/lengthConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lengthConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/lengthConversion.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AACF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAuHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB3D,CAAC"}
+{"version":3,"file":"lengthConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/lengthConversion.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,QAAQ,EAgBT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AACF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AA2KF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB3D,CAAC"}

package/lib/exercises/math/conversion/lengthConversion.js

@@ -3,9 +3,12 @@ import { Decimal, DecimalConstructor, } from "../../../math/numbers/decimals/dec
 import { randint } from "../../../math/utils/random/randint.js";
 import { Measure } from "../../../pc/measure/measure.js";
 import { DistanceUnit } from "../../../pc/units/distanceUnits.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
 import { random } from "../../../utils/alea/random.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 import { doWhile } from "../../../utils/doWhile.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
 const units = ["mm", "cm", "dm", "m", "dam", "hm", "km"];
@@ -18,11 +21,50 @@ const unitsObj = [
     DistanceUnit.hm,
     DistanceUnit.km,
 ];
+const getHint = (identifiers) => {
+    const { randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const unit = units[randomUnitIndex];
+    const target = units[randomUnitInstructionIndex];
+    const space = randomUnitIndex - randomUnitInstructionIndex;
+    return `On rappelle que :
+  
+$$
+1 \\ \\textrm{${unit}} = ${space > 0 ? Math.pow(10, space) : frac(1, Math.pow(10, -space)).toTex()} \\ \\textrm{${target}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { randomLength, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const unit = units[randomUnitIndex];
+    const target = units[randomUnitInstructionIndex];
+    const space = randomUnitIndex - randomUnitInstructionIndex;
+    const coeff = space > 0 ? Math.pow(10, space).toTree() : frac(1, Math.pow(10, -space));
+    return `On sait que :
+  
+$$
+1 \\ \\textrm{${unit}} = ${coeff.toTex()} \\ \\textrm{${target}}
+$$
+
+Il suffit alors de multiplier $${randomLength.frenchify()}$ par $${coeff.toTex()}$ :
+
+${alignTex([
+        [
+            `${randomLength.frenchify()} \\textrm{${unit}} `,
+            "=",
+            `${multiply(coeff, randomLength).toTex()}\\ \\textrm{${target}}`,
+        ],
+        ["", "=", `${getAnswer(identifiers)}\\ \\textrm{${target}}`],
+    ])}
+`;
+};
 const getInstruction = (identifiers, options) => {
     const measure = new Measure(identifiers.randomLength, 0, unitsObj[identifiers.randomUnitIndex]);
-    return `Compléter : $${measure.toTex({
+    return `Compléter :
+  
+$$
+${measure.toTex({
         notScientific: true,
-    })} = \\ldots  ${unitsObj[identifiers.randomUnitInstructionIndex].toTex()}$`;
+    })} = \\ldots  ${unitsObj[identifiers.randomUnitInstructionIndex].toTex()}
+$$`;
 };
 const getAnswer = (identifiers, options) => {
     const measure = new Measure(identifiers.randomLength, 0, unitsObj[identifiers.randomUnitIndex]);
@@ -31,12 +73,12 @@ const getAnswer = (identifiers, options) => {
         .toTex({ notScientific: true, hideUnit: true });
     return answer;
 };
-const getLengthConversion = (options) => {
+const getLengthConversion = (opts) => {
     // if (options && !validateOptions(options).valid)
     //   throw Error("options invalides, gen lengthConversion");
     const availableUnitsIndexes = units
         .map((e, i) => i)
-        .filter((i) => !options?.units?.length || options.units.includes(units[i]));
+        .filter((i) => !opts?.units?.length || opts.units.includes(units[i]));
     const randomUnitIndex = random(availableUnitsIndexes);
     const randomUnitInstructionIndex = random(availableUnitsIndexes, [
         randomUnitIndex,
@@ -47,12 +89,17 @@ const getLengthConversion = (options) => {
         randomUnitIndex,
         randomUnitInstructionIndex,
     };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        instruction: getInstruction(identifiers, options),
-        answer: getAnswer(identifiers, options),
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -107,4 +154,6 @@ export const lengthConversion = {
     getInstruction,
     options,
     validateOptions,
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/conversion/massConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"massConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/massConversion.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,QAAQ,EAQT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA8DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}
+{"version":3,"file":"massConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/massConversion.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA6HF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}

package/lib/exercises/math/conversion/massConversion.js

@@ -1,31 +1,87 @@
 import { Decimal, DecimalConstructor, } from "../../../math/numbers/decimals/decimal.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
 import { numberParser } from "../../../tree/parsers/numberParser.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 import { doWhile } from "../../../utils/doWhile.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
 import { addValidProp, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
 const units = ["mg", "cg", "dg", "g", "dag", "hg", "kg"];
-const getMassConversion = () => {
-    const randomUnitIndex = randint(0, 7);
-    const randomUnitInstructionIndex = randint(0, 7, [randomUnitIndex]);
-    const randomMass = doWhile(() => DecimalConstructor.random(0, 1000, randint(0, 4)), (x) => x.value === 0);
-    const answer = (randomMass.multiplyByPowerOfTen(randomUnitIndex - randomUnitInstructionIndex).value + "").replace(".", ",");
+const getHint = (identifiers) => {
+    const { randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const unit = units[randomUnitIndex];
+    const target = units[randomUnitInstructionIndex];
+    const space = randomUnitIndex - randomUnitInstructionIndex;
+    return `On rappelle que :
+  
+$$
+1 \\ \\textrm{${unit}} = ${space > 0 ? Math.pow(10, space) : frac(1, Math.pow(10, -space)).toTex()} \\ \\textrm{${target}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { randomMass, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const unit = units[randomUnitIndex];
+    const target = units[randomUnitInstructionIndex];
+    const space = randomUnitIndex - randomUnitInstructionIndex;
+    const coeff = space > 0 ? Math.pow(10, space).toTree() : frac(1, Math.pow(10, -space));
+    return `On sait que :
+  
+$$
+1 \\ \\textrm{${unit}} = ${coeff.toTex()} \\ \\textrm{${target}}
+$$
+
+Il suffit alors de multiplier $${randomMass.frenchify()}$ par $${coeff.toTex()}$ :
+
+${alignTex([
+        [
+            `${randomMass.frenchify()} \\textrm{${unit}} `,
+            "=",
+            `${multiply(coeff, randomMass).toTex()}\\ \\textrm{${target}}`,
+        ],
+        ["", "=", `${getAnswer(identifiers)}\\ \\textrm{${target}}`],
+    ])}
+`;
+};
+const getInstruction = (identifiers) => {
+    const { randomMass, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    return `Compléter : 
+  
+$$
+${randomMass.frenchify()} \\textrm{${units[randomUnitIndex]}} = \\ldots \\textrm{${units[randomUnitInstructionIndex]}}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { randomMass, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const answer = new Decimal(randomMass)
+        .multiplyByPowerOfTen(randomUnitIndex - randomUnitInstructionIndex)
+        .value.frenchify();
+    return answer;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Compléter : $${randomMass.value
-            .toString()
-            .replace(".", ",")} \\textrm{${units[randomUnitIndex]}} = \\ldots \\textrm{${units[randomUnitInstructionIndex]}}$`,
-        answer,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: {
-            randomMass: randomMass.value,
-            randomUnitIndex,
-            randomUnitInstructionIndex,
-        },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getMassConversion = () => {
+    const randomUnitIndex = randint(0, 7);
+    const randomUnitInstructionIndex = randint(0, 7, [randomUnitIndex]);
+    const randomMass = doWhile(() => DecimalConstructor.random(0, 1000, randint(0, 4)), (x) => x.value === 0);
+    const identifiers = {
+        randomMass: randomMass.value,
+        randomUnitIndex,
+        randomUnitInstructionIndex,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, randomMass, randomUnitIndex, randomUnitInstructionIndex }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -49,8 +105,6 @@ export const massConversion = {
     id: "massConversion",
     connector: "=",
     label: "Conversion de masses",
-    levels: ["6ème", "5ème", "CAP", "2ndPro"],
-    sections: ["Conversions"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getMassConversion, nb),
     getPropositions,
@@ -58,4 +112,6 @@ export const massConversion = {
     qcmTimer: 60,
     freeTimer: 60,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/conversion/volumeConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"volumeConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeConversion.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAQT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AA+DF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}
+{"version":3,"file":"volumeConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeConversion.ts"],"names":[],"mappings":"AAUA,OAAO,EACL,QAAQ,EAaT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAgIF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}