math-exercises 3.0.68 → 3.0.70

package/lib/exercises/pc/waves/lightDistanceConversion.js

@@ -5,112 +5,141 @@ import { randint } from "../../../math/utils/random/randint.js";
 import { lightSpeed } from "../../../pc/constants/mechanics/waves.js";
 import { Measure } from "../../../pc/measure/measure.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
-const getLightDistanceConversionQuestion = () => {
-    const lightYear = randfloat(10, 1000, 2);
-    const speed = lightSpeed.measure;
-    const secondsInAYear = 365.25 * 24 * 3600;
-    const lightDistanceTravelled = speed.times(secondsInAYear);
-    const distanceFromEarthMeters = lightDistanceTravelled.times(lightYear);
-    const isLightYearToMeters = coinFlip();
+const getInstruction = (identifiers) => {
+    const { lightYear, distanceMeters, isLightYearToMeters } = identifiers;
+    return isLightYearToMeters
+        ? `Une planète se trouve à $${lightYear.frenchify()}$ années-lumières de nous. 
+    
+Calculer à quelle distance de la Terre se trouve la planète en mètres (en écriture scientifique avec $2$ chiffres significatifs).`
+        : `Une planète se trouve à $${distanceMeters
+            .toSignificant(2)
+            .toTex()}\\ \\textrm{m}$ de nous. 
+        
+Calculer à quelle distance en années-lumières se trouve la planète de la Terre (en écriture scientifique avec $2$ chiffres significatifs).`;
+};
+const getAnswer = (identifiers) => {
+    const { lightYear, distanceMeters, isLightYearToMeters } = identifiers;
     const answer = isLightYearToMeters
-        ? distanceFromEarthMeters.toSignificant(2).toTex()
+        ? distanceMeters.toSignificant(2).toTex()
         : lightYear.toScientific(2).toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { lightYear, distanceMeters, isLightYearToMeters } = identifiers;
     const hint = isLightYearToMeters
         ? `Pour convertir des années-lumière en mètres, utilisez les relations suivantes :
-  - Une année-lumière est la distance parcourue par la lumière en une année.
-  - La vitesse de la lumière est $c = 3 \\times 10^8 \\text{ m/s}$.
-  - Il y a $365.25 \\text{ jours} \\times 24 \\text{ heures/jour} \\times 3600 \\text{ secondes/heure}$ secondes dans une année (Le 0.25 compte pour la moyenne sur quatres années dont une bissextile).
-  
-  La distance parcourue par la lumière en une année est :
-  $$
-  c \\times \\text{secondes par année}
-  $$
   
-  Pour convertir des années-lumière en mètres, multipliez la distance en années-lumière par la distance parcourue par la lumière en une année.`
-        : `Pour convertir une distance en mètres en années-lumières, utilisez les relations suivantes :
-  - Une année-lumière est la distance parcourue par la lumière en une année.
-  - La vitesse de la lumière est $c = 3 \\times 10^8 \\text{ m/s}$.
-  - Il y a $365.25 \\text{ jours} \\times 24 \\text{ heures/jour} \\times 3600 \\text{ secondes/heure}$ secondes dans une année (Le 0.25 compte pour la moyenne sur quatres années dont une bissextile).
+- Une année-lumière est la distance parcourue par la lumière en une année.
+- La vitesse de la lumière est $c = 3 \\times 10^8 \\ \\textrm{m}/\\textrm{s}$.
+- Il y a $365,25 \\text{jours} \\times 24 \\text{heures/jour} \\times 3600 \\text{ secondes/heure}$ secondes dans une année (le $0,25$ compte pour la moyenne sur quatres années dont une bissextile).
   
-  La distance parcourue par la lumière en une année est :
+La distance parcourue par la lumière en une année est :
+
+$$
+c \\times \\text{secondes par année}
+$$
   
-  $$
-  c \\times \\text{secondes par année}
-  $$
+Pour convertir des années-lumière en mètres, multipliez la distance en années-lumière par la distance parcourue par la lumière en une année.`
+        : `Pour convertir une distance en mètres en années-lumières, utilisez les relations suivantes :
 
-  Pour convertir des mètres en années-lumière, divisez la distance en mètres par la distance parcourue par la lumière en une année.`;
+- Une année-lumière est la distance parcourue par la lumière en une année.
+- La vitesse de la lumière est $c = 3 \\times 10^8 \\textrm{m/s}$.
+- Il y a $365,25 \\text{ jours} \\times 24 \\text{heures/jour} \\times 3600 \\text{ secondes/heure}$ secondes dans une année (Le $0,25$ compte pour la moyenne sur quatres années dont une bissextile).
+
+La distance parcourue par la lumière en une année est :
+
+$$
+c \\times \\text{secondes par année}
+$$
+
+Pour convertir des mètres en années-lumière, divisez la distance en mètres par la distance parcourue par la lumière en une année.`;
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { lightYear, distanceMeters, isLightYearToMeters } = identifiers;
     const correction = isLightYearToMeters
         ? `La distance parcourue par la lumière en une année est donnée par :
-  
-  $$
-  c \\times \\text{secondes par année} = 3 \\times 10^8 \\text{ m/s} \\times 365.25 \\times 24 \\times 3600 \\text{ s}
-  $$
 
-  En simplifiant, nous obtenons :
-  
-  $$
-  3 \\times 10^8 \\text{ m/s} \\times 31,557,600 \\text{ s} = 9.46728 \\times 10^{15} \\text{ m}
-  $$
+$$
+c \\times \\text{secondes par année} = 3 \\times 10^8 \\text{ m/s} \\times 365.25 \\times 24 \\times 3600 \\text{ s}
+$$
 
-  Pour convertir des années-lumière en mètres, nous utilisons la relation suivante :
-  
-  $$
-  \\text{distance en années-lumière} \\times 9.46728 \\times 10^{15} \\text{ m}
-  $$
+En simplifiant, nous obtenons :
+
+$$
+3 \\times 10^8 \\text{ m/s} \\times 31,557,600 \\text{ s} = 9.46728 \\times 10^{15} \\text{ m}
+$$
+
+Pour convertir des années-lumière en mètres, nous utilisons la relation suivante :
 
-  En appliquant cette relation avec la valeur donnée de ${lightYear} années-lumière, nous obtenons :
+$$
+\\text{distance en années-lumière} \\times 9.46728 \\times 10^{15} \\text{ m}
+$$
 
-  $$
-  \\text{distance en mètres} = ${lightYear} \\times 9.46728 \\times 10^{15} = ${distanceFromEarthMeters
+En appliquant cette relation avec la valeur donnée de $${lightYear}$ années-lumière, nous obtenons :
+
+$$
+\\text{distance en mètres} = ${lightYear} \\times 9.46728 \\times 10^{15} = ${distanceMeters
             .toSignificant(2)
             .toTex()} \\text{ m}
-  $$`
+$$`
         : `La distance parcourue par la lumière en une année est donnée par :
-  
-    $$
-  c \\times \\text{secondes par année} = 3 \\times 10^8 \\text{ m/s} \\times 365.25 \\times 24 \\times 3600 \\text{ s}
-  $$
 
-  En simplifiant, nous obtenons :
+$$
+c \\times \\text{secondes par année} = 3 \\times 10^8 \\text{ m/s} \\times 365.25 \\times 24 \\times 3600 \\text{ s}
+$$
 
-  $$
-  3 \\times 10^8 \\text{ m/s} \\times 31,557,600 \\text{ s} = 9.46728 \\times 10^{15} \\text{ m}
-  $$
+En simplifiant, nous obtenons :
 
-  Pour convertir des mètres en années-lumière, nous utilisons la relation suivante :
+$$
+3 \\times 10^8 \\text{ m/s} \\times 31,557,600 \\text{ s} = 9.46728 \\times 10^{15} \\text{ m}
+$$
 
-  $$
-  \\frac{\\text{distance en mètres}}{9.46728 \\times 10^{15} \\text{ m}}
-  $$
+Pour convertir des mètres en années-lumière, nous utilisons la relation suivante :
 
-  En appliquant cette relation avec la valeur donnée de $${distanceFromEarthMeters
+$$
+\\frac{\\text{distance en mètres}}{9.46728 \\times 10^{15} \\text{ m}}
+$$
+
+En appliquant cette relation avec la valeur donnée de $${distanceMeters
             .toSignificant(2)
             .toTex()} \\text{m}$, nous obtenons :
 
-  $$
-  \\frac{${distanceFromEarthMeters
+$$
+\\frac{${distanceMeters
             .toSignificant(2)
-            .toTex()}}{9.46728 \\times 10^{15}} = ${lightYear.toScientific(2).toTex()}
-  $$`;
+            .toTex()}}{9.46728 \\times 10^{15}} = ${lightYear
+            .toScientific(2)
+            .toTex()}
+$$`;
+    return correction;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: answer,
-        instruction: isLightYearToMeters
-            ? `Une planète se trouve à $${lightYear.frenchify()}$ années-lumières de nous. Calculer à quelle distance de la Terre se trouve la planète en mètres (en écriture scientifique avec 2 chiffres significatifs).`
-            : `Une planète se trouve à $${distanceFromEarthMeters
-                .toSignificant(2)
-                .toTex()}\\ \\text{m}$ de nous. Calculer à quelle distance en années-lumières se trouve la planète de la Terre (en écriture scientifique avec 2 chiffres significatifs).`,
-        hint,
-        correction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: ["timesTenPower"],
         answerFormat: "tex",
-        identifiers: {
-            lightYear,
-            distanceMeters: distanceFromEarthMeters,
-            isLightYearToMeters,
-        },
+        identifiers,
     };
     return question;
 };
+const getLightDistanceConversionQuestion = () => {
+    const lightYear = randfloat(10, 1000, 2);
+    const speed = lightSpeed.measure;
+    const secondsInAYear = 365.25 * 24 * 3600;
+    const lightDistanceTravelled = speed.times(secondsInAYear);
+    const distanceFromEarthMeters = lightDistanceTravelled.times(lightYear);
+    const isLightYearToMeters = coinFlip();
+    const identifiers = {
+        lightYear,
+        distanceMeters: distanceFromEarthMeters,
+        isLightYearToMeters,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, lightYear, distanceMeters, isLightYearToMeters }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -154,9 +183,7 @@ const isAnswerValid = (ans, { answer, lightYear, distanceMeters, isLightYearToMe
 export const lightDistanceConversion = {
     id: "lightDistanceConversion",
     label: "Conversion entre années-lumière et distance en mètres",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Ondes"],
     generator: (nb) => getDistinctQuestions(getLightDistanceConversionQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -164,4 +191,5 @@ export const lightDistanceConversion = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/waves/periodicWaveCelerity.d.ts

@@ -1,5 +1,6 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
+    varAsked: string;
     v: number;
     l: number;
     T: number;

package/lib/exercises/pc/waves/periodicWaveCelerity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"periodicWaveCelerity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/periodicWaveCelerity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoGF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAetD,CAAC"}
+{"version":3,"file":"periodicWaveCelerity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/periodicWaveCelerity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2KF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/pc/waves/periodicWaveCelerity.js

@@ -4,6 +4,84 @@ import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { round, roundSignificant } from "../../../math/utils/round.js";
 import { random } from "../../../utils/alea/random.js";
 // v = lambda / T
+const getInstruction = (identifiers) => {
+    const { varAsked, v, l, T } = identifiers;
+    switch (varAsked) {
+        case "v":
+            return `Une onde périodique a une longueur d'onde de $${roundSignificant(l, 1)}\\ \\textrm{m}$ et une période de $${roundSignificant(T, 1)}\\ \\textrm{s}$. 
+      
+Quelle est sa célérité ?`;
+            break;
+        case "T":
+            return `Une onde périodique a une longueur d'onde de $${roundSignificant(l, 1)}\\ \\textrm{m}$ et une célérité de $${roundSignificant(v, 1)}\\ \\textrm{m}\\cdot\\textrm{s}^{-1}$. 
+      
+Quelle est sa période ?`;
+            break;
+        case "l":
+        default:
+            return `Une onde périodique a une période de $${roundSignificant(T, 1)}\\ \\textrm{m}$ et une célérité de $${roundSignificant(v, 1)}\\ \\textrm{m}\\cdot\\textrm{s}^{-1}$. 
+      
+Quelle est sa longueur d'onde ?`;
+            break;
+    }
+};
+const getAnswer = (identifiers) => {
+    const { varAsked, v, l, T } = identifiers;
+    switch (varAsked) {
+        case "v":
+            return roundSignificant(v, 1);
+            break;
+        case "T":
+            return roundSignificant(T, 1);
+            break;
+        case "l":
+        default:
+            return roundSignificant(l, 1);
+            break;
+    }
+};
+const getHint = (identifiers) => {
+    const { varAsked, v, l, T } = identifiers;
+    switch (varAsked) {
+        case "v":
+            return "Utilisez la formule de la célérité: $v = \\frac{\\lambda}{T}$";
+            break;
+        case "T":
+            return "Utilisez la formule de la période: $T = \\frac{\\lambda}{v}$";
+            break;
+        case "l":
+        default:
+            return "Utilisez la formule de la longueur d'onde: $\\lambda = v \\times T$";
+            break;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { varAsked, v, l, T } = identifiers;
+    switch (varAsked) {
+        case "v":
+            return `La célérité est donnée par $v = \\frac{\\lambda}{T} = \\frac{${roundSignificant(l, 1)}}{${roundSignificant(T, 1)}} = ${roundSignificant(v, 1)}$.`;
+            break;
+        case "T":
+            return `La période est donnée par $T = \\frac{\\lambda}{v} = \\frac{${roundSignificant(l, 1)}}{${roundSignificant(v, 1)}} = ${roundSignificant(T, 1)}$.`;
+            break;
+        case "l":
+        default:
+            return `La longueur d'onde est donnée par $\\lambda = v \\times T = ${roundSignificant(v, 1)} \\times ${roundSignificant(T, 1)} = ${roundSignificant(l, 1)}$.`;
+            break;
+    }
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
 const getPeriodicWaveCelerityQuestion = () => {
     const varAsked = random(["v", "T", "l"]);
     let v;
@@ -18,42 +96,21 @@ const getPeriodicWaveCelerityQuestion = () => {
             T = randfloat(1, 10, 1);
             l = randfloat(1, 10, 1);
             v = round(l / T, 1);
-            instruction = `Une onde périodique a une longueur d'onde de $${roundSignificant(l, 1)}\\ \\text{m}$ et une période de $${roundSignificant(T, 1)}\\ \\text{s}$. Quelle est sa célérité ?`;
-            hint = "Utilisez la formule de la célérité: $v = \\frac{\\lambda}{T}$";
-            correction = `La célérité est donnée par $v = \\frac{\\lambda}{T} = \\frac{${roundSignificant(l, 1)}}{${roundSignificant(T, 1)}} = ${roundSignificant(v, 1)}$.`;
-            answer = roundSignificant(v, 1);
             break;
         case "T":
             l = randfloat(1, 10, 1);
             v = randfloat(1, 10, 1);
             T = round(l / v, 1);
-            instruction = `Une onde périodique a une longueur d'onde de $${roundSignificant(l, 1)}\\ \\text{m}$ et une célérité de $${roundSignificant(v, 1)}\\ \\text{m}\\cdot\\text{s}^{-1}$. Quelle est sa période ?`;
-            hint = "Utilisez la formule de la période: $T = \\frac{\\lambda}{v}$";
-            correction = `La période est donnée par $T = \\frac{\\lambda}{v} = \\frac{${roundSignificant(l, 1)}}{${roundSignificant(v, 1)}} = ${roundSignificant(T, 1)}$.`;
-            answer = roundSignificant(T, 1);
             break;
         case "l":
         default:
             v = randfloat(1, 10, 1);
             T = randfloat(1, 10, 1);
             l = round(v * T, 1);
-            instruction = `Une onde périodique a une période de $${roundSignificant(T, 1)}\\ \\text{m}$ et une célérité de $${roundSignificant(v, 1)}\\ \\text{m}\\cdot\\text{s}^{-1}$. Quelle est sa longueur d'onde ?`;
-            hint =
-                "Utilisez la formule de la longueur d'onde: $\\lambda = v \\times T$";
-            correction = `La longueur d'onde est donnée par $\\lambda = v \\times T = ${roundSignificant(v, 1)} \\times ${roundSignificant(T, 1)} = ${roundSignificant(l, 1)}$.`;
-            answer = roundSignificant(l, 1);
             break;
     }
-    const question = {
-        answer,
-        instruction,
-        hint,
-        correction,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: { v, T, l },
-    };
-    return question;
+    const identifiers = { varAsked, v, T, l };
+    return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -70,9 +127,7 @@ export const periodicWaveCelerity = {
     id: "periodicWaveCelerity",
     connector: "=",
     label: "Célérité d'une onde periodique",
-    levels: ["1reSpé"],
     isSingleStep: true,
-    sections: ["Ondes"],
     generator: (nb) => getDistinctQuestions(getPeriodicWaveCelerityQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -80,4 +135,5 @@ export const periodicWaveCelerity = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/weight/calculateWeight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/calculateWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA8DF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}
+{"version":3,"file":"calculateWeight.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/calculateWeight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAiGF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/pc/weight/calculateWeight.js

@@ -4,19 +4,66 @@ import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { earthGravity } from "../../../pc/constants/gravity.js";
 const g = +earthGravity.measure.significantPart.toFixed(2);
-const getCalculateWeightQuestion = () => {
-    const exo = generateExercise();
+const getInstruction = (identifiers) => {
+    const { mass } = identifiers;
+    const instruction = `Soit un objet avec une masse de $${mass}\\ \\textrm{kg}$.
+  
+Calculer le poids de cet objet.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { mass } = identifiers;
+    const answer = (mass * g).toScientific(2);
+    return answer.toTex();
+};
+const getHint = (identifiers) => {
+    const { mass } = identifiers;
+    const hint = `Le poids $P$ se calcule en utilisant la formule :
+  
+$$
+P=m \\cdot g
+$$
+
+où
+
+- m est la masse de l'objet (en $\\textrm{kg}$).
+
+- g est l'accélération due à la gravité (en $\\textrm{m} \\cdot \\textrm{s}^${-1}$).`;
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { mass } = identifiers;
+    const answer = getAnswer(identifiers);
+    const correction = `Pour calculer le poids de l'objet, on utilise la formule : 
+  
+$$
+P=m \\cdot g
+$$
+
+On a : 
+
+$$
+P = ${mass.frenchify()} \\times ${g.frenchify()} \\Rightarrow P=${answer}\\ \\textrm{N}
+$$`;
+    return correction;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: exo.answer.toTex(),
-        instruction: exo.instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
-        hint: exo.hint,
-        correction: exo.correction,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         answerFormat: "tex",
-        identifiers: { mass: exo.mass },
+        identifiers,
     };
     return question;
 };
+const getCalculateWeightQuestion = () => {
+    const mass = randint(30, 151);
+    const identifiers = { mass: mass };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, mass }) => {
     const propositions = [];
     const weight = mass * g;
@@ -37,29 +84,10 @@ const generatePropositions = (mass) => {
     const second = (randfloat(weight - 100, weight + 100, 2, [weight]) / 10).toScientific(2);
     return [first.toTex(), second.toTex()];
 };
-const generateExercise = () => {
-    const mass = randint(30, 151);
-    const instruction = `Soit un objet avec une masse de $${mass}$ $kg$. Calculer le poids de cet objet.`;
-    const answer = (mass * g).toScientific(2);
-    const hint = `Rappel : le poids $P$ se calcule en utilisant la formule $P=m \\cdot g$. \n \\
-    - m est la masse de l'objet (en kilogrammes, $kg$).\n \\
-    - g est l'accélération due à la gravité (en $m \\cdot s^${-1}$).`;
-    const correction = `Pour calculer le poids de l'objet, on utilise la formule : $P=m \\cdot g$. \n \\
-  $P = ${mass.frenchify()} \\times ${g.frenchify()}$ $\\Rightarrow$ $P=${answer.toTex()}$ $N$`;
-    return {
-        instruction,
-        answer,
-        hint,
-        correction,
-        mass,
-    };
-};
 export const calculateWeight = {
     id: "calculateWeight",
     label: "Calculer le poids d'un objet",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Forces"],
     generator: (nb) => getDistinctQuestions(getCalculateWeightQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -67,4 +95,5 @@ export const calculateWeight = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/weight/weightOnTheMoon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"weightOnTheMoon.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/weightOnTheMoon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA6FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}
+{"version":3,"file":"weightOnTheMoon.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/weightOnTheMoon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA6HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/pc/weight/weightOnTheMoon.js

@@ -1,37 +1,87 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
-import { frenchify } from "../../../math/utils/latex/frenchify.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { round } from "../../../math/utils/round.js";
 import { earthGravity, moonGravity, } from "../../../pc/constants/mechanics/gravitational.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
-const getWeightOnTheMoonQuestion = () => {
-    const originIsMoon = coinFlip();
+const getInstruction = (identifiers) => {
+    const { weight, originIsMoon } = identifiers;
     const origin = originIsMoon ? "Lune" : "Terre";
     const destination = originIsMoon ? "Terre" : "Lune";
-    const weight = round(randfloat(2, 30), 1);
     const gl = moonGravity.measure.toSignificant(1);
     const gt = earthGravity.measure.toSignificant(1);
-    //Pt = m gt  = Pl/gl gt
-    //Pl = m gl  = Pt/gt gl
+    return `Un objet a un poids de $${weight.frenchify()}\\ \\text{N}$ sur la ${origin}. Quel est son poids sur la ${destination} ?
+    
+Données : $g_T = ${gt.toTex()}$, $g_L = ${gl.toTex()}$
+    `;
+};
+const getAnswer = (identifiers) => {
+    const { weight, originIsMoon } = identifiers;
+    const gl = moonGravity.measure.toSignificant(1);
+    const gt = earthGravity.measure.toSignificant(1);
     const answer = round(originIsMoon
         ? (weight / gl.evaluate()) * gt.evaluate()
-        : (weight / gt.evaluate()) * gl.evaluate(), 1) + "N";
-    const question = {
-        answer: frenchify(answer),
-        instruction: `Un objet a un poids de $${weight.frenchify()}\\ \\text{N}$ sur la ${origin}. Quel est son poids sur la ${destination} ?
+        : (weight / gt.evaluate()) * gl.evaluate(), 1).frenchify() + "N";
+    return answer;
+};
+const getHint = (identifiers) => {
+    return "On rappelle que : $m=\\frac{p_T}{g_T}$ et  $m=\\frac{p_L}{g_L}$";
+};
+const getCorrection = (identifiers) => {
+    const { weight, originIsMoon } = identifiers;
+    const gl = moonGravity.measure.toSignificant(1);
+    const gt = earthGravity.measure.toSignificant(1);
+    const answer = getAnswer(identifiers);
+    if (originIsMoon) {
+        return `- Trouver la masse de l'objet en utilisant son poids sur la Lune $p_L$ et l'accélération due à la gravité luanire $g_L$ : 
     
-Données : $g_T = ${gt.toTex()}$, $g_L = ${gl.toTex()}$
-    `,
-        //hint: ` Pour calculer la masse de l'objet sur Terre, utiliser la formule : $m=\\frac{p_T}{g_T}$`,
-        hint: "On rappelle que : $m=\\frac{p_T}{g_T}$ et  $m=\\frac{p_L}{g_L}$",
-        correction: getCorrection(origin, weight, answer, gt, gl),
+$$
+m = \\frac{p_L}{g_L} \\Leftrightarrow m=${round(weight / gl.evaluate(), 1)}\\textrm{kg}
+$$
+
+- Utiliser la masse trouvée et l'accélération due à la gravité sur la Terre $g_T$ pour calculer le poids sur la Terre $p_T$ : 
+
+$$
+p_T = m \\ \\cdot g_T \\Leftrightarrow p_T = ${answer}
+$$`;
+    }
+    return `- Trouver la masse de l'objet en utilisant son poids sur Terre $p_T$ et l'accélération due à la gravité terrestre $g_T$ : 
+      
+$$
+m = \\frac{p_T}{g_T} \\Leftrightarrow m=${round(weight / gt.evaluate(), 1)}\\textrm{kg}
+$$
+
+- Utiliser la masse trouvée et l'accélération due à la gravité sur la Lune $g_L$ pour calculer le poids sur la Lune $p_L$ : 
+
+$$
+p_L = m \\ \\cdot g_L \\Leftrightarrow
+$$
+
+$$
+p_L = ${answer}
+$$
+`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: ["N"],
         answerFormat: "tex",
-        identifiers: { weight, originIsMoon },
+        identifiers,
     };
     return question;
 };
+const getWeightOnTheMoonQuestion = () => {
+    const originIsMoon = coinFlip();
+    const weight = round(randfloat(2, 30), 1);
+    //Pt = m gt  = Pl/gl gt
+    //Pl = m gl  = Pt/gt gl
+    const identifiers = { weight, originIsMoon };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, originIsMoon, weight }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -45,20 +95,6 @@ const getPropositions = (n, { answer, originIsMoon, weight }) => {
     }
     return shuffleProps(propositions, n);
 };
-const getCorrection = (origin, weight, answer, gt, gl) => {
-    switch (origin) {
-        case "Terre":
-            return `1 . Trouver la masse de l'objet en utilisant son poids sur Terre $p_T$ et l'accélération due à la gravité terrestre $g_T$ : \n $m = \\frac{p_T}{g_T} \\Leftrightarrow m=${round(weight / gt.evaluate(), 1)}\\text{kg}$. \n \\
-      2 . Utiliser la masse trouvée et l'accélération due à la gravité sur la Lune $g_L$ pour calculer le poids sur la Lune $p_L$ : $p_L = m \\ \\cdot g_L \\Leftrightarrow$ $p_L = ${frenchify(answer)}$.`;
-        case "Lune":
-            return `1 . Trouver la masse de l'objet en utilisant son poids sur la Lune $p_L$ et l'accélération due à la gravité luanire $g_L$ : 
-      $m = \\frac{p_L}{g_L} \\Leftrightarrow m=${round(weight / gl.evaluate(), 1)}\\text{kg}$. \n \\
-      2 . Utiliser la masse trouvée et l'accélération due à la gravité sur la Terre $g_T$ pour calculer le poids sur la Terre $p_T$ : 
-      $p_T = m \\ \\cdot g_T \\Leftrightarrow p_T = ${frenchify(answer)}$.`;
-        default:
-            return "";
-    }
-};
 const isAnswerValid = (ans, { answer }) => {
     return [answer, answer.replace("N", "")].includes(ans);
 };
@@ -66,9 +102,7 @@ export const weightOnTheMoon = {
     id: "weightOnTheMoon",
     connector: "=",
     label: "Passer du poids sur la Lune au poids sur la Terre",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Forces"],
     generator: (nb) => getDistinctQuestions(getWeightOnTheMoonQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -76,4 +110,5 @@ export const weightOnTheMoon = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };