math-exercises 3.0.68 → 3.0.70

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

@@ -3,91 +3,89 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { random } from "../../../utils/alea/random.js";
-const getTypeOfAccelerationQuestion = () => {
-    const exo = generateExo();
-    const question = {
-        answer: exo.answer,
-        instruction: exo.instruction,
-        ggbOptions: exo.ggb.object.getOptions({
-            coords: exo.ggb.coords,
-        }),
-        keys: [],
-        answerFormat: "raw",
-        identifiers: {
-            typeOfAcceleration: exo.typeOfAcceleration,
-            ggbCommands: exo.ggb.object.commands,
-        },
-    };
-    return question;
-};
-const getPropositions = (n, { answer }) => {
-    const propositions = [];
-    addValidProp(propositions, answer, "raw");
-    tryToAddWrongProp(propositions, "Mouvement accéléré", "raw");
-    tryToAddWrongProp(propositions, "Mouvement ralenti", "raw");
-    tryToAddWrongProp(propositions, "Mouvement constant", "raw");
-    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
-    return shuffleProps(propositions, n);
-};
-const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
-};
-const generateExo = () => {
-    const typeOfAcceleration = random([
-        "Mouvement accéléré",
-        "Mouvement ralenti",
-        "Mouvement constant",
-    ]);
-    const ggb = generateGgb(typeOfAcceleration);
-    const instruction = `D'après le graphique ci-dessous qui représente la position d'un objet en fonction du temps, 
+const getInstruction = (identifiers) => {
+    const instruction = `Le graphique ci-dessous qui représente la position d'un objet en fonction du temps.
   
-  déterminez si l'objet est en mouvement accéléré, en mouvement ralenti ou en mouvement constant.`;
-    return {
-        instruction,
-        answer: typeOfAcceleration,
-        ggb,
-        typeOfAcceleration,
-    };
+L'objet est-il en mouvement accéléré, en mouvement ralenti ou en mouvement constant ?`;
+    return instruction;
 };
-const generateGgb = (typeOfAcceleration) => {
-    const points = getPoints(typeOfAcceleration);
-    return {
-        object: new GeogebraConstructor({
-            commands: points.points,
-            hideAxes: true,
-            hideGrid: true,
-        }),
-        coords: points.coords,
-    };
+const getAnswer = (identifiers) => {
+    const { typeOfAcceleration } = identifiers;
+    return typeOfAcceleration;
 };
-const getPoints = (typeOfAcceleration) => {
+const getGGBOptions = (identifiers) => {
+    const { typeOfAcceleration, step } = identifiers;
     const points = [];
     let coords = [];
     let n = 0;
     let x = 0;
-    let step = randint(3, 14);
     let variation = 1;
     if (typeOfAcceleration === "Mouvement accéléré")
         variation = 1.3;
     if (typeOfAcceleration === "Mouvement ralenti") {
-        step = randint(10, 21);
         variation = 0.8;
     }
+    let trueStep = step;
     while (n < 10) {
         points.push(`Point({${x},4})`);
-        x = x + step;
-        step = step * variation;
+        x = x + trueStep;
+        trueStep = trueStep * variation;
         n++;
     }
     coords = [-2, x + 5, -2, 20];
-    return { points, coords };
+    const ggb = new GeogebraConstructor({
+        commands: points,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: coords,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+const getTypeOfAccelerationQuestion = () => {
+    const typeOfAcceleration = random([
+        "Mouvement accéléré",
+        "Mouvement ralenti",
+        "Mouvement constant",
+    ]);
+    let step = randint(3, 14);
+    if (typeOfAcceleration === "Mouvement ralenti") {
+        step = randint(10, 21);
+    }
+    const identifiers = {
+        typeOfAcceleration: typeOfAcceleration,
+        // ggbCommands: ggb.object.commands!,
+        step,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Mouvement accéléré", "raw");
+    tryToAddWrongProp(propositions, "Mouvement ralenti", "raw");
+    tryToAddWrongProp(propositions, "Mouvement constant", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
 };
 export const typeOfAcceleration = {
     id: "typeOfAcceleration",
     label: "Déterminer le type d'accélération du mouvement d'un objet.",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Mécanique"],
     generator: (nb) => getDistinctQuestions(getTypeOfAccelerationQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -96,4 +94,5 @@ export const typeOfAcceleration = {
     hasGeogebra: true,
     answerType: "QCU",
     subject: "Physique",
+    getQuestionFromIdentifiers,
 };

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"typeOfMovement.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfMovement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAkHF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"typeOfMovement.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/motion/typeOfMovement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyGF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}

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

@@ -1,55 +1,27 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
-import { AffineConstructor } from "../../../math/polynomials/affine.js";
+import { Affine, AffineConstructor } from "../../../math/polynomials/affine.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { random } from "../../../utils/alea/random.js";
-const getTypeOfMovementQuestion = () => {
-    const exo = generateExercise();
-    const ggb = exo.ggb;
-    const question = {
-        answer: exo.answer,
-        instruction: exo.instruction,
-        ggbOptions: ggb.getOptions({
-            coords: exo.coords,
-        }),
-        keys: [],
-        answerFormat: "raw",
-        identifiers: { movementType: exo.answer, ggbCommands: ggb.commands },
-    };
-    return question;
-};
-const getPropositions = (n, { answer }) => {
-    const propositions = [];
-    addValidProp(propositions, answer, "raw");
-    tryToAddWrongProp(propositions, "Rectiligne", "raw");
-    tryToAddWrongProp(propositions, "Circulaire", "raw");
-    tryToAddWrongProp(propositions, "Curviligne", "raw");
-    tryToAddWrongProp(propositions, "On ne peut pas savoir.", "raw");
-    return shuffleProps(propositions, n);
-};
-const generateExercise = () => {
-    const movementType = random(["Rectiligne", "Circulaire", "Curviligne"]);
-    const ggb = getGgb(movementType);
-    const instruction = `Soit le graphique ci-dessous, représentant la position d'un objet en fonction du temps. \n \\
+const getInstruction = (identifiers) => {
+    const instruction = `Soit le graphique ci-dessous, représentant la position d'un objet en fonction du temps.
+
 Déterminer le type de mouvement de l'objet.`;
-    return {
-        instruction,
-        answer: movementType,
-        movementType,
-        ggb: ggb.ggb,
-        coords: ggb.coords,
-    };
+    return instruction;
 };
-const getGgb = (movementType) => {
+const getAnswer = (identifiers) => {
+    const { movementType } = identifiers;
+    return movementType;
+};
+const getGGBOptions = (identifiers) => {
+    const { movementType, a, b } = identifiers;
     let commands = [];
     let coords = [];
     let point1;
     let point2;
     switch (movementType) {
         case "Circulaire":
-            const a = randint(1, 5);
-            const b = randint(6, 9);
             commands = [
                 `Semicircle((${a},4),(${b},8))`,
                 `Point({${a},4})`,
@@ -59,46 +31,74 @@ const getGgb = (movementType) => {
             coords = [-2, 10, -2, 10];
             break;
         case "Rectiligne":
-            const affine = AffineConstructor.random({ min: 1, max: 4 }, { min: 1, max: 4 });
+            const affine = new Affine(a, b);
             point1 = `(2,${affine.calculate(2)})`;
             point2 = `(8,${affine.calculate(8)})`;
-            commands = [`Segment(${point1},${point2})`].concat(getPoints(movementType, { affine }));
+            commands = [`Segment(${point1},${point2})`];
+            for (let x = 3; x < 8; x++) {
+                commands.push(`Point({${x},${affine.calculate(x)}})`);
+            }
             coords = [-2, 10, -2, affine.calculate(8) + 5];
             break;
         case "Curviligne":
-            const random = randint(10, 21);
-            const bRand = randint(1, 5);
-            commands = [`Function(e^sin(x)+${bRand},0,${random})`].concat(getPoints(movementType, { bRand: bRand }));
+            commands = [`Function(e^sin(x)+${b},0,${a})`];
+            for (let x = 1; x < 9; x++) {
+                commands.push(`Point({${x},${Math.exp(Math.sin(x)) + b}})`);
+            }
             coords = [-2, 10, -2, 10];
             break;
     }
-    return {
-        ggb: new GeogebraConstructor({ commands }),
+    const ggb = new GeogebraConstructor({ commands });
+    return ggb.getOptions({
         coords,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
     };
+    return question;
 };
-const getPoints = (movementType, options) => {
-    const commands = [];
+const getTypeOfMovementQuestion = () => {
+    const movementType = random(["Rectiligne", "Circulaire", "Curviligne"]);
+    let a, b;
     switch (movementType) {
+        case "Circulaire":
+            a = randint(1, 5);
+            b = randint(6, 9);
+            break;
         case "Rectiligne":
-            for (let x = 3; x < 8; x++) {
-                commands.push(`Point({${x},${options.affine.calculate(x)}})`);
-            }
+            const affine = AffineConstructor.random({ min: 1, max: 4 }, { min: 1, max: 4 });
+            a = affine.a;
+            b = affine.b;
             break;
         case "Curviligne":
-            for (let x = 1; x < 9; x++) {
-                commands.push(`Point({${x},${Math.exp(Math.sin(x)) + options.bRand}})`);
-            }
+        default:
+            a = randint(10, 21);
+            b = randint(1, 5);
             break;
     }
-    return commands;
+    const identifiers = { movementType, a, b };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Rectiligne", "raw");
+    tryToAddWrongProp(propositions, "Circulaire", "raw");
+    tryToAddWrongProp(propositions, "Curviligne", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir.", "raw");
+    return shuffleProps(propositions, n);
 };
 export const typeOfMovement = {
     id: "typeOfMovement",
     label: "Déterminer le type de mouvement",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Mécanique"],
     generator: (nb) => getDistinctQuestions(getTypeOfMovementQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -106,4 +106,5 @@ export const typeOfMovement = {
     answerType: "QCU",
     subject: "Physique",
     hasGeogebra: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/orderOfMagnitude.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orderOfMagnitude.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/orderOfMagnitude.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA4DF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAalD,CAAC"}
+{"version":3,"file":"orderOfMagnitude.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/orderOfMagnitude.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAkEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAYlD,CAAC"}

package/lib/exercises/pc/orderOfMagnitude.js

@@ -7,17 +7,35 @@ import { Measure } from "../../pc/measure/measure.js";
 import { NumberNode } from "../../tree/nodes/numbers/numberNode.js";
 import { PowerNode } from "../../tree/nodes/operators/powerNode.js";
 const ten = new NumberNode(10);
-const getOrderOfMagnitudeQuestion = () => {
-    const exercise = generateExercise();
+const getInstruction = (identifiers) => {
+    const { order, multiplier } = identifiers;
+    const diameter = new Measure(multiplier, order, DistanceUnit.m);
+    const instruction = `Supposons qu'on ait un atome de diamètre $${diameter.toTex()}$. Indiquez l'ordre de grandeur du diamètre de cet atome.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { order, multiplier } = identifiers;
+    const answer = multiplier > 5
+        ? new PowerNode(ten, (order + 1).toTree())
+        : new PowerNode(ten, order.toTree());
+    return answer.toTex();
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: `${exercise.answer.toTex()}`,
-        instruction: exercise.instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { order: exercise.order, multiplier: exercise.multiplier },
+        identifiers,
     };
     return question;
 };
+const getOrderOfMagnitudeQuestion = () => {
+    const order = randint(-15, -10);
+    const multiplier = +randfloat(1, 11).toFixed(1);
+    const identifiers = { order: order, multiplier: multiplier };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, order, multiplier }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -34,32 +52,15 @@ const generatePropositions = (order, multiplier) => {
     const third = new PowerNode(ten, correctAnswer.toTree()).toTex();
     return [first, second, third];
 };
-const generateExercise = () => {
-    const order = randint(-15, -10);
-    const multiplier = +randfloat(1, 11).toFixed(1);
-    const diameter = new Measure(multiplier, order, DistanceUnit.m);
-    const answer = multiplier > 5
-        ? new PowerNode(ten, (order + 1).toTree())
-        : new PowerNode(ten, order.toTree());
-    const instruction = `Supposons qu'on ait un atome de diamètre $${diameter.toTex()}$. Indiquez l'ordre de grandeur du diamètre de cet atome.`;
-    return {
-        answer,
-        order,
-        diameter,
-        multiplier,
-        instruction,
-    };
-};
 export const orderOfMagnitude = {
     id: "orderOfMagnitude",
     label: "Calcul d'ordre de grandeur",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Chimie organique"],
     generator: (nb) => getDistinctQuestions(getOrderOfMagnitudeQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    getQuestionFromIdentifiers,
     subject: "Chimie",
 };

package/lib/exercises/pc/pH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pH.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/pH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAkDF,eAAO,MAAM,EAAE,EAAE,QAAQ,CAAC,WAAW,CAcpC,CAAC"}
+{"version":3,"file":"pH.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/pH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA2EF,eAAO,MAAM,EAAE,EAAE,QAAQ,CAAC,WAAW,CAapC,CAAC"}

package/lib/exercises/pc/pH.js

@@ -4,29 +4,51 @@ import { frenchify } from "../../math/utils/latex/frenchify.js";
 import { randint } from "../../math/utils/random/randint.js";
 import { round } from "../../math/utils/round.js";
 import { shuffle } from "../../utils/alea/shuffle.js";
-const getpH = () => {
-    const randomNumber = randint(1, 10);
-    const randomTenPower = randint(2, 10);
+const getInstruction = (identifiers) => {
+    const { randomNumber, randomTenPower } = identifiers;
+    const instruction = `Calculer le pH d'une solution ayant une concentration en ions hydrogène ($H^+$) de $${randomNumber} \\times 10^{-${randomTenPower}} \\ \\textrm{mol}/\\textrm{L}$.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { randomNumber, randomTenPower } = identifiers;
     const concentrationHydrogene = randomNumber * 10 ** -randomTenPower;
-    const instruction = `Calculer le pH d'une solution ayant une concentration en ions hydrogène ($H^+$) de $${randomNumber} \\times 10^{-${randomTenPower}}$ mol/L.`;
     const answer = frenchify(round(-Math.log10(concentrationHydrogene), 1));
-    const hint = "Utilisez la formule du pH : $\\text{pH} = -\\log[H^+]$.";
-    const correction = `Pour calculer le pH, on utilise la formule $\\text{pH} = -\\log[H^+]$ :
-  \n$1$. La concentration en ions hydrogène est $${randomNumber} \\times 10^{-${randomTenPower}}$ mol/L.
-  \n$2$. En appliquant la formule, on obtient $\\text{pH} = -\\log(${randomNumber} \\times 10^{-${randomTenPower}})$.
-  \n$3$. Le résultat est $${answer}$.`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    const hint = "Utilise la formule du pH : $\\text{pH} = -\\log[H^+]$.";
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { randomNumber, randomTenPower } = identifiers;
+    const correction = `Pour calculer le pH, on utilise la formule $\\textrm{pH} = -\\log[H^+]$.
+  
+La concentration en ions hydrogène est $${randomNumber} \\times 10^{-${randomTenPower}}\\ \\textrm{mol}/\\textrm{L}$.
+
+En appliquant la formule, on obtient $\\textrm{pH} = -\\log(${randomNumber} \\times 10^{-${randomTenPower}})$.
+
+Le résultat est $${getAnswer(identifiers)}$.`;
+    return correction;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction,
+        instruction: getInstruction(identifiers),
         startStatement: `pH`,
-        answer,
-        hint,
-        correction,
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: ["logBrackets"],
         answerFormat: "tex",
-        identifiers: { randomNumber, randomTenPower },
+        identifiers,
     };
     return question;
 };
+const getpH = () => {
+    const randomNumber = randint(1, 10);
+    const randomTenPower = randint(2, 10);
+    const identifiers = { randomNumber, randomTenPower };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -46,8 +68,6 @@ export const pH = {
     id: "pH",
     connector: "=",
     label: "Calculer le pH d'une solution",
-    levels: ["4ème", "3ème", "2nde"],
-    sections: ["Acide / Base"],
     subject: "Chimie",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getpH, nb),
@@ -56,4 +76,5 @@ export const pH = {
     getPropositions,
     isAnswerValid,
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/perceivedFrequency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"perceivedFrequency.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/perceivedFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EACT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAmDF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}
+{"version":3,"file":"perceivedFrequency.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/perceivedFrequency.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EAIT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAsEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAYpD,CAAC"}

package/lib/exercises/pc/perceivedFrequency.js

@@ -6,24 +6,38 @@ import { round } from "../../math/utils/round.js";
 import { shuffle } from "../../utils/alea/shuffle.js";
 const soundSpeed = 340; // Vitesse du son dans l'air en m/s
 const observerSpeed = 0; // La vitesse de l'observateur est supposée être nulle (observateur immobile)
-const getPerceivedFrequency = () => {
-    const frequencyEmitted = randint(200, 1500); // Fréquence émise en Hz
-    const ambulanceSpeed = Math.floor(Math.random() * 40 + 10); // Vitesse de l'ambulance entre 10 et 50 m/s
+const getInstruction = (identifiers) => {
+    const { frequencyEmitted, ambulanceSpeed } = identifiers;
+    return `Une ambulance émet un son d'une fréquence de $${frequencyEmitted}\\ \\textrm{Hz}$ lorsqu'elle
+  s'approche d'un observateur à une vitesse de $${ambulanceSpeed} \\ \\textrm{m}/\\textrm{s}$. 
+  
+La vitesse du son dans l'air est de $340 \\ \\textrm{m}/\\textrm{s}$. 
+  
+Calculer la fréquence perçue par l'observateur.`;
+};
+const getAnswer = (identifiers) => {
+    const { frequencyEmitted, ambulanceSpeed } = identifiers;
     const perceivedFrequency = (frequencyEmitted * (soundSpeed + observerSpeed)) /
         (soundSpeed - ambulanceSpeed);
-    const instruction = `Une ambulance émet un son d'une fréquence de $${frequencyEmitted}$ Hz lorsqu'elle
-  s'approche d'un observateur à une vitesse de $${ambulanceSpeed}$ m/s. Si la vitesse du son
-  dans l'air est de $340$ m/s, calculer la fréquence perçue par l'observateur.`;
-    const answer = `${frenchify(round(perceivedFrequency, 0))} \\ Hz`;
+    const answer = `${frenchify(round(perceivedFrequency, 0))}\\text{Hz}`;
+    return answer;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction,
-        answer,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: ["Hz"],
         answerFormat: "tex",
-        identifiers: { ambulanceSpeed, frequencyEmitted },
+        identifiers,
     };
     return question;
 };
+const getPerceivedFrequency = () => {
+    const frequencyEmitted = randint(200, 1500); // Fréquence émise en Hz
+    const ambulanceSpeed = Math.floor(Math.random() * 40 + 10); // Vitesse de l'ambulance entre 10 et 50 m/s
+    const identifiers = { ambulanceSpeed, frequencyEmitted };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, ambulanceSpeed, frequencyEmitted }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -31,7 +45,7 @@ const getPropositions = (n, { answer, ambulanceSpeed, frequencyEmitted }) => {
         (soundSpeed - ambulanceSpeed);
     while (propositions.length < n) {
         tryToAddWrongProp(propositions, frenchify(round(perceivedFrequency * (0.3 + Math.random() * 1.5), 0)) +
-            " \\ Hz");
+            " \\text{Hz}");
     }
     return shuffle(propositions);
 };
@@ -42,8 +56,6 @@ export const perceivedFrequency = {
     id: "perceivedFrequency",
     connector: "\\iff",
     label: "Calculer une fréquence perçue par un observateur",
-    levels: ["4ème", "3ème", "2nde"],
-    sections: ["Ondes"],
     subject: "Physique",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getPerceivedFrequency, nb),
@@ -51,4 +63,5 @@ export const perceivedFrequency = {
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/potentialEnergy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"potentialEnergy.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/potentialEnergy.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EACT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAwDF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"potentialEnergy.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/potentialEnergy.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,QAAQ,EAIT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAuEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}

package/lib/exercises/pc/potentialEnergy.js

@@ -8,31 +8,44 @@ import { DistanceUnit } from "../../pc/units/distanceUnits.js";
 import { EnergyUnit } from "../../pc/units/energyUnit.js";
 import { MassUnit } from "../../pc/units/massUnits.js";
 import { shuffle } from "../../utils/alea/shuffle.js";
-const getPotentialEnergy = () => {
-    const mass = Math.floor(Math.random() * 10 + 1); // Masse de l'objet entre 1 et 11 kg
+const getInstruction = (identifiers) => {
+    const { mass, height } = identifiers;
     const massMeasure = new Measure(mass, 0, MassUnit.kg);
-    const height = Math.floor(Math.random() * 50 + 1); // Hauteur par rapport à la référence entre 1 et 51 m
     const heightMeasure = new Measure(height, 0, DistanceUnit.m);
-    const potentialEnergy = mass * 9.81 * height;
     const instruction = `Un objet de masse $${massMeasure.toTex({
         notScientific: true,
     })}$ est suspendu à une hauteur de $${heightMeasure.toTex({
         notScientific: true,
     })}$. Il est ensuite relâché et tombe librement.
-  $\\\\$ Calculer l'énergie potentielle de l'objet. (Supposons que l'accélération due à la gravité est de $${earthGravityAcceleration.measure
+  
+Calculer l'énergie potentielle de l'objet (on suppose que l'accélération due à la gravité est de $${earthGravityAcceleration.measure
         .toSignificant(2)
-        .toTex()}$)`;
+        .toTex()}$).`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { mass, height } = identifiers;
+    const potentialEnergy = mass * 9.81 * height;
     const answer = `${frenchify(round(potentialEnergy, 2))}${EnergyUnit.J.toTex()}`;
+    return answer;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction,
+        instruction: getInstruction(identifiers),
         startStatement: "Ep",
-        answer,
+        answer: getAnswer(identifiers),
         keys: ["J"],
         answerFormat: "tex",
-        identifiers: { height, mass },
+        identifiers,
     };
     return question;
 };
+const getPotentialEnergy = () => {
+    const mass = Math.floor(Math.random() * 10 + 1); // Masse de l'objet entre 1 et 11 kg
+    const height = Math.floor(Math.random() * 50 + 1); // Hauteur par rapport à la référence entre 1 et 51 m
+    const identifiers = { height, mass };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, height, mass }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -50,8 +63,6 @@ export const potentialEnergy = {
     id: "potentialEnergy",
     connector: "=",
     label: "Calculer l'énergie potentielle",
-    levels: ["4ème", "3ème", "2nde"],
-    sections: ["Mécanique"],
     subject: "Physique",
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getPotentialEnergy, nb),
@@ -59,4 +70,5 @@ export const potentialEnergy = {
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    getQuestionFromIdentifiers,
 };