math-exercises 3.0.69 → 3.0.70

package/lib/exercises/pc/spectral/spectralEnergy.d.ts

@@ -1,9 +1,7 @@
 import { Exercise } from "../../../exercises/exercise.js";
-import { Measure } from "../../../pc/measure/measure.js";
 type Identifiers = {
-    wavelengths: Measure[];
+    wavelengths: number[];
     targetColor: "bleue" | "verte" | "rouge";
-    energy: Measure;
 };
 export declare const SpectralEnergyExercise: Exercise<Identifiers>;
 export {};

package/lib/exercises/pc/spectral/spectralEnergy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spectralEnergy.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/spectral/spectralEnergy.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAKtD,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,OAAO,EAAE,CAAC;IACvB,WAAW,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;IACzC,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAwJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"spectralEnergy.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/spectral/spectralEnergy.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,WAAW,EAAE,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;CAC1C,CAAC;AA4MF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAaxD,CAAC"}

package/lib/exercises/pc/spectral/spectralEnergy.js

@@ -1,58 +1,83 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
-import { Measure } from "../../../pc/measure/measure.js";
+import { Measure, MeasureConstructor, } from "../../../pc/measure/measure.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { lightSpeed, planckConstant } from "../../../pc/constants/quantic.js";
-const wavelengths = {
+const wavelengthsBounds = {
     bleue: { min: 400, max: 455 },
     verte: { min: 500, max: 560 },
     rouge: { min: 610, max: 660 },
 };
 const h = new Measure(planckConstant.value.significantPart, planckConstant.value.exponent);
 const c = new Measure(lightSpeed.value.significantPart, lightSpeed.value.exponent);
-const images = [
-    `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum1.png`,
-    `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum2.png`,
-    `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum3.png`,
-    `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum4.png`,
-    `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum5.png`,
-];
-const getSpectralEnergyQuestion = () => {
-    const wavelengthBlueNm = randint(wavelengths.bleue.min, wavelengths.bleue.max);
-    const wavelengthGreenNm = randint(wavelengths.verte.min, wavelengths.verte.max);
-    const wavelengthRedNm = randint(wavelengths.rouge.min, wavelengths.rouge.max);
-    const wavelengthBlue = new Measure(wavelengthBlueNm, -9);
-    const wavelengthGreen = new Measure(wavelengthGreenNm, -9);
-    const wavelengthRed = new Measure(wavelengthRedNm, -9);
+// const images = [
+//   `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum1.png`,
+//   `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum2.png`,
+//   `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum3.png`,
+//   `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum4.png`,
+//   `https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/xpliveV2/activities/quizzes/generator/emissionSpectrum5.png`,
+// ];
+const getInstruction = (identifiers) => {
+    const { targetColor, wavelengths } = identifiers;
+    return `Vous travaillez dans un laboratoire de spectroscopie et vous êtes en train de réaliser une analyse des transitions électroniques d'un échantillon. 
+
+Vous avez utilisé un spectromètre pour mesurer les longueurs d'onde des raies d'émission de la lumière émise par l'échantillon. 
+
+Les mesures que vous avez obtenues sont les suivantes :
+
+- Longueur d'onde de la lumière bleue : $\\lambda_{bleue} = ${wavelengths[0]}\\ \\textrm{nm}$,
+- Longueur d'onde de la lumière verte : $\\lambda_{verte} = ${wavelengths[1]}\\ \\textrm{nm}$,
+- Longueur d'onde de la lumière rouge : $\\lambda_{rouge} = ${wavelengths[2]}\\ \\textrm{nm}$.
+
+En utilisant ces données, calculez l'énergie de transition en joules pour la lumière ${targetColor} émise par l'échantillon.`;
+};
+const getAnswer = (identifiers) => {
+    const { targetColor, wavelengths } = identifiers;
+    const wavelengthBlue = new Measure(wavelengths[0], -9);
+    const wavelengthGreen = new Measure(wavelengths[1], -9);
+    const wavelengthRed = new Measure(wavelengths[2], -9);
     const energies = {
         bleue: h.times(c).divide(wavelengthBlue).toSignificant(2),
         verte: h.times(c).divide(wavelengthGreen).toSignificant(2),
         rouge: h.times(c).divide(wavelengthRed).toSignificant(2),
     };
-    const colors = ["bleue", "verte", "rouge"];
-    const targetColor = colors[randint(0, colors.length - 1)];
-    const targetEnergy = energies[targetColor];
-    const instruction = `Vous travaillez dans un laboratoire de spectroscopie et vous êtes en train de réaliser une analyse des transitions électroniques d'un échantillon. \n
-  Vous avez utilisé un spectromètre pour mesurer les longueurs d'onde des raies d'émission de la lumière émise par l'échantillon. \n
-  Les mesures que vous avez obtenues sont les suivantes :
-
-  - Longueur d'onde de la lumière bleue : $\\lambda_{bleue} = ${wavelengthBlueNm}\\ nm$,
-  - Longueur d'onde de la lumière verte : $\\lambda_{verte} = ${wavelengthGreenNm}\\ nm$,
-  - Longueur d'onde de la lumière rouge : $\\lambda_{rouge} = ${wavelengthRedNm}\\ nm$.
-
-  ![](${images[randint(0, images.length)]})
+    const energy = energies[targetColor];
+    return MeasureConstructor.fromIdentifiers(energy).toTex();
+};
+const getHint = (identifiers) => {
+    return `La relation entre l'énergie et la longueur d'onde est : 
+  
+$$
+E = \\frac{hc}{\\lambda}
+$$
 
-  En utilisant ces données, calculez l'énergie de transition en joules pour la lumière ${targetColor} émise par l'échantillon.`;
-    const hint = `La relation entre l'énergie et la longueur d'onde est : $E = \\frac{hc}{\\lambda}$. \n 
 Rappel des constantes : 
+
 - Constante de Planck : $h = ${h.toSignificant(2).toTex()}$
 - Vitesse de la lumière : $c = ${c.toSignificant(2).toTex()}$`;
-    const correction = `La relation entre l'énergie et la longueur d'onde est donnée par :
-  $E = \\frac{hc}{\\lambda}$. 
+};
+const getCorrection = (identifiers) => {
+    const { targetColor, wavelengths } = identifiers;
+    const wavelengthBlue = new Measure(wavelengths[0], -9);
+    const wavelengthGreen = new Measure(wavelengths[1], -9);
+    const wavelengthRed = new Measure(wavelengths[2], -9);
+    const energies = {
+        bleue: h.times(c).divide(wavelengthBlue).toSignificant(2),
+        verte: h.times(c).divide(wavelengthGreen).toSignificant(2),
+        rouge: h.times(c).divide(wavelengthRed).toSignificant(2),
+    };
+    const energy = energies[targetColor];
+    return `La relation entre l'énergie et la longueur d'onde est donnée par :
+
+$$
+E = \\frac{hc}{\\lambda}
+$$ 
   
-  \n En utilisant les valeurs fournies pour $h$, $c$, et $\\lambda_{${targetColor}}$ (en mètres), vous pouvez résoudre pour l'énergie : \n 
-  $E_{${targetColor}} = \\dfrac{${h.toTex({ scientific: 2 })} \\times ${c.toTex({
+En utilisant les valeurs fournies pour $h$, $c$, et $\\lambda_{${targetColor}}$ (en mètres), on peut résoudre pour l'énergie : 
+
+$$
+E_{${targetColor}} = \\dfrac{${h.toTex({ scientific: 2 })} \\times ${c.toTex({
         scientific: 2,
     })}}{${targetColor === "bleue"
         ? wavelengthBlue.toTex({
@@ -60,30 +85,45 @@ Rappel des constantes :
         })
         : targetColor === "rouge"
             ? wavelengthRed.toTex({ scientific: 2 })
-            : wavelengthGreen.toTex({ scientific: 2 })}} = ${targetEnergy.toTex()}\\ J$. \n
-
-  Rappel des constantes : 
-
-  - Constante de Planck : $h = ${h.toSignificant(2).toTex()}$
-  - Vitesse de la lumière : $c = ${c.toSignificant(2).toTex()}$`;
+            : wavelengthGreen.toTex({ scientific: 2 })}} = ${energy.toTex()}\\ \\textrm{J}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: targetEnergy.toTex(),
-        instruction,
-        hint,
-        correction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: {
-            wavelengths: [wavelengthBlue, wavelengthGreen, wavelengthRed],
-            targetColor,
-            energy: targetEnergy,
-        },
+        identifiers,
     };
     return question;
 };
-const getPropositions = (n, { answer, energy }) => {
+const getSpectralEnergyQuestion = () => {
+    const wavelengthBlueNm = randint(wavelengthsBounds.bleue.min, wavelengthsBounds.bleue.max);
+    const wavelengthGreenNm = randint(wavelengthsBounds.verte.min, wavelengthsBounds.verte.max);
+    const wavelengthRedNm = randint(wavelengthsBounds.rouge.min, wavelengthsBounds.rouge.max);
+    const colors = ["bleue", "verte", "rouge"];
+    const targetColor = colors[randint(0, colors.length - 1)];
+    const identifiers = {
+        wavelengths: [wavelengthBlueNm, wavelengthGreenNm, wavelengthRedNm],
+        targetColor,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, targetColor, wavelengths }) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    const wavelengthBlue = new Measure(wavelengths[0], -9);
+    const wavelengthGreen = new Measure(wavelengths[1], -9);
+    const wavelengthRed = new Measure(wavelengths[2], -9);
+    const energies = {
+        bleue: h.times(c).divide(wavelengthBlue).toSignificant(2),
+        verte: h.times(c).divide(wavelengthGreen).toSignificant(2),
+        rouge: h.times(c).divide(wavelengthRed).toSignificant(2),
+    };
+    const energy = energies[targetColor];
     const incorrectValues = [
         new Measure(randfloat(0.1, 10, 2), -19).toSignificant(2),
         energy.times(new Measure(1, -8)),
@@ -97,11 +137,14 @@ const getPropositions = (n, { answer, energy }) => {
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, energy, wavelengths, targetColor }) => {
+const isAnswerValid = (ans, { answer, wavelengths, targetColor }) => {
+    const wavelengthBlue = new Measure(wavelengths[0], -9);
+    const wavelengthGreen = new Measure(wavelengths[1], -9);
+    const wavelengthRed = new Measure(wavelengths[2], -9);
     const energies = {
-        bleue: h.times(c).divide(wavelengths[0]),
-        verte: h.times(c).divide(wavelengths[1]),
-        rouge: h.times(c).divide(wavelengths[2]),
+        bleue: h.times(c).divide(wavelengthBlue).toSignificant(2),
+        verte: h.times(c).divide(wavelengthGreen).toSignificant(2),
+        rouge: h.times(c).divide(wavelengthRed).toSignificant(2),
     };
     const targetEnergy = energies[targetColor];
     const validAnswer1 = targetEnergy.toSignificant(1).toTex();
@@ -114,9 +157,7 @@ const isAnswerValid = (ans, { answer, energy, wavelengths, targetColor }) => {
 export const SpectralEnergyExercise = {
     id: "spectralEnergy",
     label: "Calculer l'énergie d'une lumière à partir de la longueur d'onde",
-    levels: ["TermSpé"],
     isSingleStep: true,
-    sections: ["Quantique"],
     generator: (nb) => getDistinctQuestions(getSpectralEnergyQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -124,4 +165,5 @@ export const SpectralEnergyExercise = {
     isAnswerValid,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"findDistanceFromEarth.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/findDistanceFromEarth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAsEF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}
+{"version":3,"file":"findDistanceFromEarth.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/findDistanceFromEarth.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAuFF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAYvD,CAAC"}

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

@@ -4,25 +4,39 @@ import { Decimal } from "../../../math/numbers/decimals/decimal.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { round } from "../../../math/utils/round.js";
-const getFindDistanceFromEarthQuestion = () => {
-    const lightYear = round(randfloat(4.2, 50), 1);
+const getInstruction = (identifiers) => {
+    const { lightYear } = identifiers;
+    return `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). 
+    `;
+};
+const getAnswer = (identifiers) => {
+    const { lightYear } = identifiers;
     const speed = 300000000;
     const secondsInAYear = 365.25 * 24 * 3600;
     const lightDistanceTravelled = speed * secondsInAYear;
     const lightDistanceTravelledDecimal = new Decimal(lightDistanceTravelled);
     const lightDistanceTravelledDecimalScientificNotation = lightDistanceTravelledDecimal.toScientificNotation(1);
     const distanceFromEarth = lightYear * lightDistanceTravelledDecimalScientificNotation.evaluate({});
-    // Aide : Passer par la distance parcourue par la lumière en une année. L'année-lumière est la distance parcourue par la lumière dans le vide en une année.
+    return `${distanceFromEarth.toScientific(1).toTex({ scientific: 1 })}`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: `${distanceFromEarth.toScientific(1).toTex({ scientific: 1 })}`,
-        instruction: `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). 
-    `,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["timesTenPower"],
         answerFormat: "tex",
-        identifiers: { lightYear },
+        identifiers,
     };
     return question;
 };
+const getFindDistanceFromEarthQuestion = () => {
+    const lightYear = round(randfloat(4.2, 50), 1);
+    // Aide : Passer par la distance parcourue par la lumière en une année. L'année-lumière est la distance parcourue par la lumière dans le vide en une année.
+    const identifiers = { lightYear };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, lightYear }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -51,13 +65,12 @@ const isAnswerValid = (ans, { answer }) => {
 export const findDistanceFromEarth = {
     id: "findDistanceFromEarth",
     label: "Calculer la distance d'une planète à la Terre",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Ondes"],
     generator: (nb) => getDistinctQuestions(getFindDistanceFromEarthQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Physique",
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"lightDistanceConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/lightDistanceConversion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAGtD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AA8KF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"lightDistanceConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/lightDistanceConversion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAAE,OAAO,EAAE,MAAM,6BAA6B,CAAC;AAGtD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,OAAO,CAAC;IACxB,mBAAmB,EAAE,OAAO,CAAC;CAC9B,CAAC;AA8MF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}

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