math-exercises 3.0.68 → 3.0.70

package/lib/exercises/pc/motion/averageSpeed.js

@@ -7,21 +7,79 @@ import { DistanceUnit } from "../../../pc/units/distanceUnits.js";
 import { TimeUnit } from "../../../pc/units/timeUnits.js";
 import { FractionNode } from "../../../tree/nodes/operators/fractionNode.js";
 import { VariableNode } from "../../../tree/nodes/variables/variableNode.js";
-const timeUnits = [TimeUnit.h, TimeUnit.mi];
-const distanceUnitValues = [DistanceUnit.km, DistanceUnit.m];
-const getAverageSpeedQuestion = () => {
-    const exo = generateExercise();
+const getInstruction = (identifiers) => {
+    const { distance, time } = identifiers;
+    const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]);
+    const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]);
+    const instruction = `Soit un objet parcourant $${distanceMeasure.toTex({
+        notScientific: true,
+    })}$ en $${timeMeasure.toTex({ notScientific: true })}$.
+
+
+Caculer la vitesse moyenne de cet objet en $${DistanceUnit.m.toTex()} \\cdot ${TimeUnit.s.toTex()}^{-1}$.
+  `;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { distance, time } = identifiers;
+    const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]);
+    const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]);
+    const answer = distanceMeasure
+        .convert("m")
+        .divide(timeMeasure.convert("s"))
+        .toSignificant(2);
+    return answer.toTex();
+};
+const getHint = (identifiers) => {
+    return `La vitesse moyenne est donnée par : 
+  
+$$
+\\frac{\\text{distance}}{\\text{temps}} \\ \\textrm{m} \\cdot \\textrm{s}^{-1}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { distance, time } = identifiers;
+    let correction = ``;
+    let step = 1;
+    const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]).convert("m");
+    const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]).convert("s");
+    const calcul = new FractionNode(new VariableNode(distanceMeasure.toSignificant(2).toTex()), new VariableNode(timeMeasure.toSignificant(2).toTex()));
+    const answer = distanceMeasure.divide(timeMeasure).toSignificant(2).toTex();
+    if (distance.unitIndex === 0)
+        correction = `- On convertit les $\\textrm{km}$ en $\\textrm{m}$ : $1\\ \\textrm{km}=1000\\ \\textrm{m}$.`;
+    switch (time.unitIndex) {
+        case 0:
+            correction = `${correction}
+- On convertit les heures en secondes : $1\\ \\textrm{h} = 3600\\ \\textrm{s}$.`;
+            break;
+        case 1:
+        default:
+            correction = `${correction}
+- On convertit les minutes en secondes : $1\\ \\textrm{m} = 60\\ \\textrm{s}$.`;
+    }
+    return `${correction}
+- On applique la règle de calcul pour la vitesse moyenne : $${calcul.toTex()} = ${answer}$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: exo.answer.toTex(),
-        instruction: exo.instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
-        hint: "Rappel : vitesse moyenne = $\\frac{\\text{distance}}{\\text{temps}}$ $m \\cdot s^{-1}$",
-        correction: exo.correction,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         answerFormat: "tex",
-        identifiers: { distance: exo.distance, time: exo.time },
+        identifiers,
     };
     return question;
 };
+const timeUnits = [TimeUnit.h, TimeUnit.mi];
+const distanceUnitValues = [DistanceUnit.km, DistanceUnit.m];
+const getAverageSpeedQuestion = () => {
+    const distance = { value: randint(70, 151), unitIndex: randint(0, 2) };
+    const time = { value: randint(10, 61), unitIndex: randint(0, 2) };
+    const identifiers = { distance, time };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, distance, time }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -59,56 +117,10 @@ const isAnswerValid = (ans, { answer, distance, time }) => {
             .toTex({ hideUnit: true }),
     ].includes(ans);
 };
-const generateExercise = () => {
-    const distance = { value: randint(70, 151), unitIndex: randint(0, 2) };
-    const time = { value: randint(10, 61), unitIndex: randint(0, 2) };
-    const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]);
-    const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]);
-    const instruction = `Soit un objet parcourant $${distanceMeasure.toTex({
-        notScientific: true,
-    })}$ en $${timeMeasure.toTex({ notScientific: true })}$. \n \\
-  Caculer la vitesse moyenne de cet objet en $${DistanceUnit.m.toTex()} \\cdot ${TimeUnit.s.toTex()}^{-1}$.
-  `;
-    const answer = distanceMeasure
-        .convert("m")
-        .divide(timeMeasure.convert("s"))
-        .toSignificant(2);
-    const correction = getCorrection(distance, time);
-    return {
-        instruction,
-        answer,
-        distance,
-        time,
-        correction,
-    };
-};
-const getCorrection = (distance, time) => {
-    let correction = ``;
-    let step = 1;
-    const distanceMeasure = new Measure(distance.value, 0, distanceUnitValues[distance.unitIndex]).convert("m");
-    const timeMeasure = new Measure(time.value, 0, timeUnits[time.unitIndex]).convert("s");
-    const calcul = new FractionNode(new VariableNode(distanceMeasure.toSignificant(2).toTex()), new VariableNode(timeMeasure.toSignificant(2).toTex()));
-    const answer = distanceMeasure.divide(timeMeasure).toSignificant(2).toTex();
-    if (distance.unitIndex === 0)
-        correction = `${step++}. Convertir les $km$ en $m$ : $1km=1000m$.`;
-    switch (time.unitIndex) {
-        case 0:
-            correction = `${correction}
-${step++}. Convertir les heures en secondes : $1h = 3600s$.`;
-            break;
-        case 1:
-            correction = `${correction}
-${step++}. Convertir les minutes en secondes : $1m = 60s$.`;
-    }
-    return `${correction}
-${step}. Appliquer la règle de calcul pour la vitesse moyenne : $${calcul.toTex()} = ${answer}$`;
-};
 export const averageSpeed = {
     id: "averageSpeed",
     label: "Caclul de vitesse moyenne",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Mécanique"],
     generator: (nb) => getDistinctQuestions(getAverageSpeedQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -116,4 +128,5 @@ export const averageSpeed = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/motion/averageSpeedCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averageSpeedCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeedCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,iBAAiB,GAAG,UAAU,GAAG,OAAO,CAAC;CAClD,CAAC;AA4MF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}
+{"version":3,"file":"averageSpeedCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/averageSpeedCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,iBAAiB,GAAG,UAAU,GAAG,OAAO,CAAC;CAClD,CAAC;AA8PF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/pc/motion/averageSpeedCalculation.js

@@ -7,10 +7,8 @@ import { DivideUnit } from "../../../pc/units/divideUnit.js";
 import { TimeUnit } from "../../../pc/units/timeUnits.js";
 import { DistanceUnit } from "../../../pc/units/distanceUnits.js";
 import { Measure } from "../../../pc/measure/measure.js";
-const getAverageSpeedQuestion = () => {
-    const speed = round(randfloat(900, 1400), 2); // Vitesse en km/h
-    const distance = round(randfloat(100, 2000), 2); // Distance en km
-    const deltaTime = round(distance / speed, 2); // Temps en heures
+const getInstruction = (identifiers) => {
+    const { speed, distance, deltaTime, target } = identifiers;
     const variables = [
         {
             name: "vitesse moyenne",
@@ -28,27 +26,61 @@ const getAverageSpeedQuestion = () => {
             symbol: "\\Delta t",
         },
     ];
-    const randomIndex = randint(0, variables.length);
-    const targetVariable = variables[randomIndex];
-    const knownVariables = variables.filter((_, index) => index !== randomIndex);
+    const targetVariable = variables.find((v) => v.name === target);
+    const knownVariables = variables.filter((v) => v.name !== target);
     const instruction = `Lors d'une mission d'entraînement, un avion de chasse Rafale a été chronométré et mesuré. Voici les données recueillies :
-  - ${knownVariables[0].name.charAt(0).toUpperCase() +
+  
+- ${knownVariables[0].name.charAt(0).toUpperCase() +
         knownVariables[0].name.slice(1)} : $${knownVariables[0].symbol} = ${knownVariables[0].value.toTex({
         notScientific: true,
     })}$
-  - ${knownVariables[1].name.charAt(0).toUpperCase() +
+- ${knownVariables[1].name.charAt(0).toUpperCase() +
         knownVariables[1].name.slice(1)} : $${knownVariables[1].symbol} = ${knownVariables[1].value.toTex({
         notScientific: true,
-    })}$. \n
-  Utilisez ces informations pour calculer ${targetVariable.name === "distance" ||
+    })}$. 
+
+Utilisez ces informations pour calculer ${targetVariable.name === "distance" ||
         targetVariable.name === "vitesse moyenne"
         ? "la"
         : "le"} ${targetVariable.name} en $${targetVariable.value.getUnit().toTex()}$.`;
-    const hint = targetVariable.name === "vitesse moyenne"
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { speed, distance, deltaTime, target } = identifiers;
+    return getAnswerNode(identifiers).toTex({
+        notScientific: true,
+        hideUnit: true,
+    });
+};
+const getHint = (identifiers) => {
+    const { speed, distance, deltaTime, target } = identifiers;
+    const hint = target === "vitesse moyenne"
         ? `Rappelez-vous la formule de la vitesse moyenne : $v = \\frac{d}{\\Delta t}$.`
-        : targetVariable.name === "distance"
+        : target === "distance"
             ? `Rappelez-vous la formule de la distance : $d = v \\times \\Delta t$.`
             : `Rappelez-vous la formule du temps : $\\Delta t = \\frac{d}{v}$.`;
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { speed, distance, deltaTime, target } = identifiers;
+    const variables = [
+        {
+            name: "vitesse moyenne",
+            value: new Measure(speed, 0, new DivideUnit(DistanceUnit.km, TimeUnit.h)),
+            symbol: "v",
+        },
+        {
+            name: "distance",
+            value: new Measure(distance, 0, DistanceUnit.km),
+            symbol: "d",
+        },
+        {
+            name: "temps",
+            value: new Measure(deltaTime, 0, TimeUnit.h),
+            symbol: "\\Delta t",
+        },
+    ];
+    const targetVariable = variables.find((v) => v.name === target);
     const correction = targetVariable.name === "vitesse moyenne"
         ? `La vitesse moyenne est calculée en utilisant la formule $v = \\frac{d}{\\Delta t}$. Donc, $v = \\frac{${round(distance, 2)
             .toTree()
@@ -62,25 +94,63 @@ const getAverageSpeedQuestion = () => {
             : `Le temps est calculé en utilisant la formule $\\Delta t = \\frac{d}{v}$. Donc, $t = \\frac{${round(distance, 2)
                 .toTree()
                 .toTex()}}{${round(speed, 2).toTree().toTex()}} = ${new Measure(round(distance / speed, 2), 0, TimeUnit.h).toTex({ notScientific: true })}$.`;
+    return correction;
+};
+const getAnswerNode = (identifiers) => {
+    const { speed, distance, deltaTime, target } = identifiers;
+    switch (target) {
+        case "distance":
+            return new Measure(round(speed * deltaTime, 2), 0, DistanceUnit.km);
+        case "vitesse moyenne":
+            return new Measure(round(distance / deltaTime, 2), 0, new DivideUnit(DistanceUnit.km, TimeUnit.h));
+        case "temps":
+            return new Measure(round(distance / speed, 2), 0, TimeUnit.h);
+    }
+    return new Measure(0);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: getCorrectAns(targetVariable.name, speed, distance, deltaTime).toTex({
-            notScientific: true,
-            hideUnit: true,
-        }),
-        instruction,
-        hint,
-        correction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: {
-            speed,
-            distance,
-            deltaTime,
-            target: targetVariable.name,
-        },
+        identifiers,
     };
     return question;
 };
+const getAverageSpeedQuestion = () => {
+    const speed = round(randfloat(900, 1400), 2); // Vitesse en km/h
+    const distance = round(randfloat(100, 2000), 2); // Distance en km
+    const deltaTime = round(distance / speed, 2); // Temps en heures
+    const variables = [
+        {
+            name: "vitesse moyenne",
+            value: new Measure(speed, 0, new DivideUnit(DistanceUnit.km, TimeUnit.h)),
+            symbol: "v",
+        },
+        {
+            name: "distance",
+            value: new Measure(distance, 0, DistanceUnit.km),
+            symbol: "d",
+        },
+        {
+            name: "temps",
+            value: new Measure(deltaTime, 0, TimeUnit.h),
+            symbol: "\\Delta t",
+        },
+    ];
+    const randomIndex = randint(0, variables.length);
+    const targetVariable = variables[randomIndex];
+    const identifiers = {
+        speed,
+        distance,
+        deltaTime,
+        target: targetVariable.name,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, speed, distance, deltaTime, target }) => {
     const propositions = [];
     addValidProp(propositions, answer, "tex");
@@ -116,23 +186,10 @@ const getPropositions = (n, { answer, speed, distance, deltaTime, target }) => {
 const isAnswerValid = (ans, { answer }) => {
     return ans === answer;
 };
-const getCorrectAns = (targetVariable, speed, distance, deltaTime) => {
-    switch (targetVariable) {
-        case "distance":
-            return new Measure(round(speed * deltaTime, 2), 0, DistanceUnit.km);
-        case "vitesse moyenne":
-            return new Measure(round(distance / deltaTime, 2), 0, new DivideUnit(DistanceUnit.km, TimeUnit.h));
-        case "temps":
-            return new Measure(round(distance / speed, 2), 0, TimeUnit.h);
-    }
-    return new Measure(0);
-};
 export const AverageSpeedCalculationExercise = {
     id: "averageSpeedCalculation",
     label: "Calculer la vitesse moyenne, la distance ou le temps d'un objet en mouvement",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Mécanique"],
     generator: (nb) => getDistinctQuestions(getAverageSpeedQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -140,4 +197,5 @@ export const AverageSpeedCalculationExercise = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/motion/characteristicsOfVelocityVector.d.ts

@@ -1,6 +1,9 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
-    norm: number;
+    delta: number;
+    constant: number;
+    step: number;
+    speedVectorX1: number;
 };
 export declare const characteristicsOfVelocityVector: Exercise<Identifiers>;
 export {};

package/lib/exercises/pc/motion/characteristicsOfVelocityVector.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"characteristicsOfVelocityVector.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/characteristicsOfVelocityVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAoFF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}
+{"version":3,"file":"characteristicsOfVelocityVector.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/characteristicsOfVelocityVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAwFF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/pc/motion/characteristicsOfVelocityVector.js

@@ -3,22 +3,64 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
-const getCharacteristicsOfVelocityVectorQuestion = () => {
-    const exo = generateExercise();
+const getInstruction = (identifiers) => {
+    const { delta } = identifiers;
+    const instruction = `Un objet en mouvement rectiligne uniforme est suivi par une chronographie. 
+
+Les points marqués par la chronographie sur la bande de papier sont espacés uniformément en temps, avec un intervalle de $${delta}$ seconde entre chaque point. 
+
+Calculer la norme du vecteur vitesse $\\overrightarrow{M}$.
+  `;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { step, delta } = identifiers;
+    return round(step / delta, 2).frenchify();
+};
+const getGGBOptions = (identifiers) => {
+    const { delta, constant, step, speedVectorX1 } = identifiers;
+    const commands = [];
+    for (let x = 0; x < 4 * step; x += step) {
+        commands.push(`Point({${x},${constant}})`);
+    }
+    commands.push(` M = Vector((${speedVectorX1},${constant}),(${speedVectorX1 + step},${constant}))`, `Text("$\\overrightarrow{\\mathit{M}}$",(${speedVectorX1},${constant + 2}),false,true)`);
+    const ggb = new GeogebraConstructor({ commands });
+    return ggb.getOptions({ coords: [-1, Math.max(step * 5, 20), -2, 10] });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: exo.answer.frenchify(),
-        instruction: exo.instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
-        ggbOptions: exo.ggb.getOptions({ coords: exo.ggbCoords }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: { norm: exo.answer },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, norm }) => {
+const getCharacteristicsOfVelocityVectorQuestion = () => {
+    const delta = randint(2, 11);
+    const constant = randint(3, 8);
+    const step = randint(3, 8);
+    let speedVectorX1 = null;
+    for (let x = 0; x < 4 * step; x += step) {
+        if ((speedVectorX1 === null && coinFlip()) || x === 2 * step)
+            speedVectorX1 = x;
+    }
+    const identifiers = {
+        delta,
+        constant,
+        step,
+        speedVectorX1: speedVectorX1,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, delta, step }) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    const norm = round(step / delta, 2);
     while (propositions.length < n) {
         let random = randfloat(norm - 3, norm + 4, 2, [norm]);
         tryToAddWrongProp(propositions, random.frenchify());
@@ -28,51 +70,10 @@ const getPropositions = (n, { answer, norm }) => {
 const isAnswerValid = (ans, { answer }) => {
     return ans === answer;
 };
-const generateExercise = () => {
-    const delta = randint(2, 11);
-    const ggb = getGgb(delta);
-    const instruction = `
-  Un objet en mouvement rectiligne uniforme est suivi par une chronographie. \n \\
-  Les points marqués par la chronographie sur la bande de papier sont espacés uniformément en temps, avec un intervalle de $${delta}$ seconde entre chaque point. \n \\
-  Calculer la norme du vecteur vitesse $\\overrightarrow{M}$
-  `;
-    const answer = ggb.speedVector.norm;
-    return {
-        instruction,
-        ggb: new GeogebraConstructor({ commands: ggb.commands }),
-        ggbCoords: ggb.coords,
-        answer,
-    };
-};
-const getGgb = (delta) => {
-    const commands = [];
-    const constant = randint(3, 8);
-    const step = randint(3, 8);
-    let speedVector = null;
-    for (let x = 0; x < 4 * step; x += step) {
-        if ((speedVector === null && coinFlip()) || x === 2 * step)
-            speedVector = {
-                x1: x,
-                y1: constant,
-                x2: x + step,
-                y2: constant,
-                norm: +(step / delta).toFixed(2),
-            };
-        commands.push(`Point({${x},${constant}})`);
-    }
-    commands.push(` M = Vector((${speedVector.x1},${speedVector.y1}),(${speedVector.x2},${speedVector.y2}))`, `Text("$\\overrightarrow{\\mathit{M}}$",(${speedVector.x1},${speedVector.y1 + 2}),false,true)`);
-    return {
-        commands,
-        speedVector,
-        coords: [-1, Math.max(step * 5, 20), -2, 10],
-    };
-};
 export const characteristicsOfVelocityVector = {
     id: "characteristicsOfVelocityVector",
-    label: "calculer la norme d'un vecteur vitesse",
-    levels: ["2nde"],
+    label: "Calculer la norme d'un vecteur vitesse",
     isSingleStep: true,
-    sections: ["Mécanique"],
     generator: (nb) => getDistinctQuestions(getCharacteristicsOfVelocityVectorQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -80,4 +81,5 @@ export const characteristicsOfVelocityVector = {
     isAnswerValid,
     subject: "Physique",
     hasGeogebra: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/motion/motionReference.d.ts

@@ -3,6 +3,7 @@ type Identifiers = {
     object1: string;
     object2: string;
     reference: "à l'autre" | "au sol";
+    isAskingObject1: boolean;
 };
 export declare const MotionReferenceExercise: Exercise<Identifiers>;
 export {};

package/lib/exercises/pc/motion/motionReference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"motionReference.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/motionReference.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,WAAW,GAAG,QAAQ,CAAC;CACnC,CAAC;AA0LF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAgBzD,CAAC"}
+{"version":3,"file":"motionReference.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/motionReference.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,WAAW,GAAG,QAAQ,CAAC;IAClC,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA0NF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}

package/lib/exercises/pc/motion/motionReference.js

@@ -100,42 +100,64 @@ const determineCorrectAnswer = (situation, reference) => {
     }
     return "On ne peut pas savoir";
 };
-const getMotionReferenceQuestion = () => {
-    const situationIndex = randint(0, situations.length);
-    const situation = situations[situationIndex];
-    const referenceIndex = randint(0, references.length);
-    const reference = references[referenceIndex];
-    const objectToCheckIndex = coinFlip();
-    const objectToCheck = objectToCheckIndex
-        ? situation.object1
-        : situation.object2;
+const getInstruction = (identifiers) => {
+    const { object1, object2, reference, isAskingObject1 } = identifiers;
+    const situation = situations.find((s) => s.object1 === object1 && s.object2 === object2);
+    const objectToCheck = isAskingObject1 ? situation.object1 : situation.object2;
     const otherObject = situation.object1 === objectToCheck ? situation.object2 : situation.object1;
-    const referenceText = reference === "à l'autre" ? otherObject : "sol";
-    const isMasculine = objectToCheckIndex
+    const isMasculine = isAskingObject1
         ? situation.gender1 === "masculin"
         : situation.gender2 === "masculin";
     const genderPronoun = isMasculine ? "il" : "elle";
-    const instruction = `Considérez la situation suivante :\n
-  ${situation.context}\n
-  ${requiresApostropheBefore(objectToCheck) ? "L'" : "Le "}${objectToCheck} est-${genderPronoun} en mouvement par rapport ${requiresApostropheBefore(referenceText) ? "à l'" : "au "}${referenceText} ?`;
-    const correctAnswer = determineCorrectAnswer(situation, reference);
+    const referenceText = reference === "à l'autre" ? otherObject : "sol";
+    const instruction = `${situation.context}
+
+${requiresApostropheBefore(objectToCheck) ? "L'" : "Le "}${objectToCheck} est-${genderPronoun} en mouvement par rapport ${requiresApostropheBefore(referenceText) ? "à l'" : "au "}${referenceText} ?`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { object1, object2, reference } = identifiers;
+    const situation = situations.find((s) => s.object1 === object1 && s.object2 === object2);
+    return determineCorrectAnswer(situation, reference);
+};
+const getHint = (identifiers) => {
+    const { object1, object2, reference } = identifiers;
+    const situation = situations.find((s) => s.object1 === object1 && s.object2 === object2);
     const hint = situation.hints[reference];
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { object1, object2, reference } = identifiers;
+    const situation = situations.find((s) => s.object1 === object1 && s.object2 === object2);
     const correction = situation.corrections[reference];
+    return correction;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: correctAnswer,
-        instruction,
-        hint,
-        correction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: [],
         answerFormat: "raw",
-        identifiers: {
-            object1: situation.object1,
-            object2: situation.object2,
-            reference,
-        },
+        identifiers,
     };
     return question;
 };
+const getMotionReferenceQuestion = () => {
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const referenceIndex = randint(0, references.length);
+    const reference = references[referenceIndex];
+    const isAskingObject1 = coinFlip();
+    const identifiers = {
+        object1: situation.object1,
+        object2: situation.object2,
+        reference,
+        isAskingObject1,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer, "raw");
@@ -150,9 +172,7 @@ const isAnswerValid = (ans, { answer }) => {
 export const MotionReferenceExercise = {
     id: "motionReference",
     label: "Déterminer le mouvement relatif entre deux objets",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Mécanique"],
     answerType: "QCU",
     generator: (nb) => getDistinctQuestions(getMotionReferenceQuestion, nb, 10),
     qcmTimer: 60,
@@ -162,4 +182,5 @@ export const MotionReferenceExercise = {
     subject: "Physique",
     maxAllowedQuestions: 10,
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/motion/typeOfAcceleration.d.ts

@@ -1,7 +1,7 @@
 import { Exercise } from "../../../exercises/exercise.js";
 type Identifiers = {
     typeOfAcceleration: string;
-    ggbCommands: string[];
+    step: number;
 };
 export declare const typeOfAcceleration: Exercise<Identifiers>;
 export {};

package/lib/exercises/pc/motion/typeOfAcceleration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typeOfAcceleration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfAcceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAwFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}
+{"version":3,"file":"typeOfAcceleration.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfAcceleration.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,MAAM,CAAC;IAC3B,IAAI,EAAE,MAAM,CAAC;CAEd,CAAC;AA2FF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}