math-exercises 3.0.55 → 3.0.57

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"}

package/lib/exercises/math/conversion/volumeConversion.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 = ["mm", "cm", "dm", "m", "dam", "hm", "km"];
@@ -9,19 +12,76 @@ const getVolumeConversion = () => {
     const randomUnitIndex = randint(0, 7);
     const randomUnitInstructionIndex = randint(Math.max(0, randomUnitIndex - 2), Math.min(7, randomUnitIndex + 3), [randomUnitIndex]);
     const randomVolume = doWhile(() => DecimalConstructor.random(0, 1000, randint(0, 4)), (x) => x.value === 0);
-    const answer = (randomVolume.multiplyByPowerOfTen(3 * (randomUnitIndex - randomUnitInstructionIndex)).value + "").replace(".", ",");
+    const identifiers = {
+        randomUnitIndex,
+        randomUnitInstructionIndex,
+        randomVolume: randomVolume.value,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getInstruction = (identifiers) => {
+    const { randomUnitIndex, randomUnitInstructionIndex, randomVolume } = identifiers;
+    return `Compléter : 
+  
+$$
+${randomVolume.frenchify()} \\textrm{${units[randomUnitIndex]}}^3 = \\ldots \\textrm{${units[randomUnitInstructionIndex]}}^3
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { randomUnitIndex, randomUnitInstructionIndex, randomVolume } = identifiers;
+    const answer = new Decimal(randomVolume)
+        .multiplyByPowerOfTen(3 * (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}}^3 = ${space > 0
+        ? Math.pow(10, space * 3)
+        : frac(1, Math.pow(10, -(space * 3))).toTex()} \\ \\textrm{${target}}^3
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { randomVolume, randomUnitIndex, randomUnitInstructionIndex } = identifiers;
+    const unit = units[randomUnitIndex];
+    const target = units[randomUnitInstructionIndex];
+    const space = randomUnitIndex - randomUnitInstructionIndex;
+    const coeff = space > 0
+        ? Math.pow(10, space * 3).toTree()
+        : frac(1, Math.pow(10, -(space * 3)));
+    return `On sait que :
+  
+$$
+1 \\ \\textrm{${unit}}^3 = ${coeff.toTex()} \\ \\textrm{${target}}^3
+$$
+
+Il suffit alors de multiplier $${randomVolume.frenchify()}$ par $${coeff.toTex()}$ :
+
+${alignTex([
+        [
+            `${randomVolume.frenchify()} \\textrm{${unit}}^3 `,
+            "=",
+            `${multiply(coeff, randomVolume).toTex()}\\ \\textrm{${target}}^3`,
+        ],
+        ["", "=", `${getAnswer(identifiers)}\\ \\textrm{${target}}^3`],
+    ])}
+`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Compléter : $${randomVolume.value
-            .toString()
-            .replace(".", ",")} \\textrm{${units[randomUnitIndex]}}^3 = \\ldots \\textrm{${units[randomUnitInstructionIndex]}}^3$`,
-        answer,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: {
-            randomUnitIndex,
-            randomUnitInstructionIndex,
-            randomVolume: randomVolume.value,
-        },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -45,8 +105,6 @@ export const volumeConversion = {
     id: "volumeConversion",
     connector: "=",
     label: "Conversion de volumes",
-    levels: ["6ème", "5ème", "CAP", "2ndPro"],
-    sections: ["Conversions"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getVolumeConversion, nb),
     getPropositions,
@@ -54,4 +112,6 @@ export const volumeConversion = {
     qcmTimer: 60,
     freeTimer: 60,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/affines/signFunction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/signFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAgIF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAqB9C,CAAC"}
+{"version":3,"file":"signFunction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/signFunction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAoBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AA2IF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAqB9C,CAAC"}

package/lib/exercises/math/functions/affines/signFunction.js

@@ -8,7 +8,7 @@ import { firstDegreeInequationResolutionTex } from "../../../../tree/nodes/inequ
 import { MinusInfinityNode, PlusInfinityNode, } from "../../../../tree/nodes/numbers/infiniteNode.js";
 import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
 import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
-import { intervalParser } from "../../../../tree/parsers/intervalParser.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
@@ -51,10 +51,11 @@ $$
 
 Sur quel intervalle $f$ est-elle ${identifiers.askingPositive ? "positive" : "négative"} ?`;
 };
-const getAnswer = ({ a, b, askingPositive }) => {
+const getAnswerNode = (identifiers) => {
+    const { a, b, askingPositive } = identifiers;
     const root = new Rational(-b, a).simplify().toTree();
-    const toRightInfInterval = new IntervalNode(root, PlusInfinityNode, ClosureType.FO).toTex();
-    const toLeftInfInteral = new IntervalNode(MinusInfinityNode, root, ClosureType.OF).toTex();
+    const toRightInfInterval = new IntervalNode(root, PlusInfinityNode, ClosureType.FO);
+    const toLeftInfInteral = new IntervalNode(MinusInfinityNode, root, ClosureType.OF);
     if (askingPositive) {
         return a > 0 ? toRightInfInterval : toLeftInfInteral;
     }
@@ -62,6 +63,9 @@ const getAnswer = ({ a, b, askingPositive }) => {
         return a > 0 ? toLeftInfInteral : toRightInfInterval;
     }
 };
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
 const getSignFunction = () => {
     const a = randint(-9, 10, [0]);
     const b = randint(-9, 10);
@@ -92,15 +96,23 @@ const getPropositions = (n, { answer }) => {
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { answer, a, b, askingPositive }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
     try {
-        const parsed = intervalParser(ans, {
-            allowCommaInsteadOfSemicolon: true,
-            allowNoBrackets: true,
-        });
-        if (!parsed)
+        //? on accepte les réponses peu importe le sens des crochets, meme pour l'infini
+        const formated = ans
+            .replaceAll("]", "")
+            .replaceAll("[", "")
+            .replaceAll("\\ ", "");
+        const splitted = formated.includes(";")
+            ? formated.split(";")
+            : formated.split(",");
+        if (splitted.length !== 2)
             return false;
-        return parsed.simplify().toTex() === answer;
+        const a = parseAlgebraic(splitted[0]);
+        const b = parseAlgebraic(splitted[1]);
+        const intAnswer = getAnswerNode(identifiers);
+        return (a.simplify().toTex() === intAnswer.a.toTex() &&
+            b.simplify().toTex() === intAnswer.b.toTex());
     }
     catch (err) {
         return handleVEAError(err);

package/lib/exercises/math/functions/basics/imageFunctionGeogebra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"imageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,cAAc;IAMd,UAAU;IAMV,UAAU;IACV,YAAY,EAAE,MAAM,CAAC;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AA0SF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqBhE,CAAC"}
+{"version":3,"file":"imageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/imageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAyBrC,KAAK,WAAW,GAAG;IACjB,cAAc;IAMd,UAAU;IAMV,UAAU;IACV,YAAY,EAAE,MAAM,CAAC;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AA4TF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AACF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBhE,CAAC"}

package/lib/exercises/math/functions/basics/imageFunctionGeogebra.js

@@ -69,6 +69,19 @@ const getAnswer = (identifiers) => {
         return "\\text{Aucun}";
     return y.frenchify();
 };
+const getHint = (identifiers) => {
+    return `L'image d'un nombre $x$ par $f$ est l'ordonnée du point de la courbe de $f$ dont l'abscisse est $x$.`;
+};
+const getCorrection = (identifiers) => {
+    const { x, y } = identifiers;
+    return `On cherche le point sur la courbe de $f$ qui a pour abscisse $${x}$.
+  
+${y === undefined
+        ? `On voit qu'il n'y a pas de tel point. On en conclut que l'image de $x$ par $f$ n'existe pas.`
+        : `On voit que c'est le point de coordonnées $\\left(${x};${y}\\right)$.
+  
+On en conclut que l'image de $${x}$ par $f$ est $${y}$.`}`;
+};
 const getGGBOptions = (identifiers) => {
     const { functionType, otherPoints, wrongY, x, y, functionCommand } = identifiers;
     const allPoints = [...otherPoints];
@@ -180,6 +193,8 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         ggbOptions: getGGBOptions(identifiers, opts),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -298,4 +313,5 @@ export const imageFunctionGeogebra = {
     getQuestionFromIdentifiers,
     getKeys,
     getStartStatement,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/areas/triangleArea.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangleArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/triangleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAOnD,OAAO,EAGL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAKxC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,kBAAkB,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA4GF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAiB9C,CAAC"}
+{"version":3,"file":"triangleArea.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/triangleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAOnD,OAAO,EAGL,kBAAkB,EACnB,MAAM,gCAAgC,CAAC;AAOxC,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,kBAAkB,CAAC;IACtC,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAiJF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAiB9C,CAAC"}