math-exercises 3.0.65 → 3.0.67

package/lib/exercises/pc/chemicalReactions/titrationEquivalenceRelation.js

@@ -71,102 +71,138 @@ const titrationReactions = [
         coeff: [1, 1],
     },
 ];
-const getTitrationEquivalenceRelationQuestion = () => {
-    const exo = generateExo();
-    const question = {
-        answer: exo.answer.toTex(),
-        instruction: exo.instruction,
-        keys: [],
-        hint: exo.hint,
-        correction: exo.correction,
-        answerFormat: "tex",
-        identifiers: {
-            a: exo.a,
-            b: exo.b,
-            vA: exo.vA.getValueAsNumber(),
-            vB: exo.vB.getValueAsNumber(),
-            cB: exo.cB.getValueAsNumber(),
-        },
-    };
-    return question;
-};
-const getPropositions = (n, { answer, a, b, vA, vB, cB }) => {
-    const propositions = [];
-    addValidProp(propositions, answer);
-    const correctAns = round((b * vB * cB) / (a * vA), 2);
-    const unit = new DivideUnit(AmountOfSubstance.mol, VolumeUnit.mL);
-    let random;
-    while (propositions.length < n) {
-        random = randfloat(correctAns - 1, correctAns + 2, 2, [correctAns]);
-        tryToAddWrongProp(propositions, new Measure(Math.abs(random), 0, unit).toTex());
-    }
-    return shuffleProps(propositions, n);
-};
-const isAnswerValid = (ans, { answer, a, b, vA, vB, cB }) => {
-    const correctAns = round((b * vB * cB) / (a * vA), 2);
-    const unit = new DivideUnit(AmountOfSubstance.mol, VolumeUnit.mL);
-    return [
-        answer,
-        frenchify(correctAns),
-        answer.replace(`\\ ${unit.toTex()}`, ""),
-    ].includes(ans);
-};
-const generateExo = () => {
-    const reaction = random(titrationReactions);
-    const vA = new Measure(5 * randint(2, 11), 0, VolumeUnit.mL);
-    const cB = new Measure(random([0.05, 0.1, 0.2, 0.25, 0.5, 0.75, 1.0]), 0, new DivideUnit(AmountOfSubstance.mol, VolumeUnit.mL));
-    const vB = new Measure(5 * randint(1, 11), 0, VolumeUnit.mL);
+const getInstruction = (identifiers) => {
+    const { reactionProduct, vA, vB, cB } = identifiers;
+    const reaction = titrationReactions.find((r) => r.produit === reactionProduct);
+    const vAMeasure = new Measure(vA, 0, VolumeUnit.mL);
+    const cBMeasure = new Measure(cB, 0, new DivideUnit(AmountOfSubstance.mol, VolumeUnit.mL));
+    const vBMeasure = new Measure(vB, 0, VolumeUnit.mL);
     const reactionString = `${reaction.coeff[0] !== 1 ? reaction.coeff[0] : ""}${reaction.titré.symbol} + ${reaction.coeff[1] !== 1 ? reaction.coeff[1] : ""}${reaction.titrant.symbol} \\Rightarrow ${reaction.produit}`;
-    const hint = `Rappel : Au point d'équivalence, les quantités de matière $${reaction.titré.name}$ et $${reaction.titrant.name}$ sont égales , c'est-à-dire :
-
-- $${reaction.coeff[0]} \\times n(${reaction.titré.symbol}) = ${reaction.coeff[1]} \\times n(${reaction.titrant.symbol})$`;
     const instruction = `On réalise un titrage entre une solution ${reaction.titré.name}$(${reaction.titré.symbol})$ et une solution ${reaction.titrant.name}$(${reaction.titrant.symbol})$.
   
-- On prélève un volume de $V_A=${vA.toTex({
+- On prélève un volume de $V_A=${vAMeasure.toTex({
         notScientific: true,
     })}$ de la solution ${reaction.titré.name} de concentration inconnue $C_A$ 
-- On ajoute progressivement une solution ${reaction.titrant.name} de concentration connue $C_B=${cB.toTex({ notScientific: true })}$
-- Le volume ${reaction.titrant.name} nécessaire pour atteindre le point d'équivalence est $V_B=${vB.toTex({
+
+- On ajoute progressivement une solution ${reaction.titrant.name} de concentration connue $C_B=${cBMeasure.toTex({ notScientific: true })}$
+
+- Le volume ${reaction.titrant.name} nécessaire pour atteindre le point d'équivalence est $V_B=${vBMeasure.toTex({
         notScientific: true,
     })}$
+
 - Réaction : $${reactionString}$
 
 Calculer la concentration $C_A$ de (${reaction.titré.name}), arrondie au centiéme.
 `;
-    const answer = cB
-        .times(vB)
+    return instruction;
+};
+const getAnswerNode = (identifiers) => {
+    const { reactionProduct, vA, vB, cB } = identifiers;
+    const reaction = titrationReactions.find((r) => r.produit === reactionProduct);
+    const vAMeasure = new Measure(vA, 0, VolumeUnit.mL);
+    const cBMeasure = new Measure(cB, 0, new DivideUnit(AmountOfSubstance.mol, VolumeUnit.mL));
+    const vBMeasure = new Measure(vB, 0, VolumeUnit.mL);
+    const answer = cBMeasure
+        .times(vBMeasure)
         .times(reaction.coeff[1])
-        .divide(vA.times(reaction.coeff[0]))
+        .divide(vAMeasure.times(reaction.coeff[0]))
         .toSignificant(2);
-    const correction = `Utiliser la relation d'équivalence du titrage : 
+    return answer;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { reactionProduct, vA, vB, cB } = identifiers;
+    const reaction = titrationReactions.find((r) => r.produit === reactionProduct);
+    const hint = `Au point d'équivalence, les quantités de matière $${reaction.titré.name}$ et $${reaction.titrant.name}$ sont égales , c'est-à-dire :
   
+$$
+${reaction.coeff[0]} \\times n(${reaction.titré.symbol}) = ${reaction.coeff[1]} \\times n(${reaction.titrant.symbol})
+$$`;
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { reactionProduct, vA, vB, cB } = identifiers;
+    const reaction = titrationReactions.find((r) => r.produit === reactionProduct);
+    const vAMeasure = new Measure(vA, 0, VolumeUnit.mL);
+    const cBMeasure = new Measure(cB, 0, new DivideUnit(AmountOfSubstance.mol, VolumeUnit.mL));
+    const vBMeasure = new Measure(vB, 0, VolumeUnit.mL);
+    const correction = `On utilise la relation d'équivalence du titrage. 
+    
 Au point d'équivalence, les quantités de matière ${reaction.titré.name}  et ${reaction.titrant.name} sont égales , c'est-à-dire :
+
 - $${reaction.coeff[0]} \\times n(${reaction.titré.symbol}) = ${reaction.coeff[1]} \\times n(${reaction.titrant.symbol})$
+
 - Or, la quantité de matière est donnée par : $n=C \\times V$
+
 - Donc à l'équivalence : $a \\times C_A \\times V_A =b \\times C_B \\times V_B$
-- Ce qui donne : $C_A = \\frac{b \\times C_B \\times V_B}{a \\times V_A} \\Rightarrow C_A = \\frac{${reaction.coeff[1]} \\times ${cB.toTex({ notScientific: true })} \\times ${vB.toTex({
+
+- Ce qui donne : $C_A = \\frac{b \\times C_B \\times V_B}{a \\times V_A} \\Rightarrow C_A = \\frac{${reaction.coeff[1]} \\times ${cBMeasure.toTex({
         notScientific: true,
-    })}}{${reaction.coeff[0]} \\times ${vA.toTex({
+    })} \\times ${vBMeasure.toTex({
         notScientific: true,
-    })}} \\Rightarrow C_A = ${answer.toTex({ notScientific: true })}$`;
-    return {
-        instruction,
-        answer,
-        hint,
-        correction,
+    })}}{${reaction.coeff[0]} \\times ${vAMeasure.toTex({
+        notScientific: true,
+    })}} \\Rightarrow C_A = ${getAnswerNode(identifiers).toTex({
+        notScientific: true,
+    })}$`;
+    return correction;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getTitrationEquivalenceRelationQuestion = () => {
+    const reaction = random(titrationReactions);
+    const vA = 5 * randint(2, 11);
+    const cB = random([0.05, 0.1, 0.2, 0.25, 0.5, 0.75, 1.0]);
+    const vB = 5 * randint(1, 11);
+    const identifiers = {
+        reactionProduct: reaction.produit,
         vA,
         vB,
         cB,
-        a: reaction.coeff[0],
-        b: reaction.coeff[1],
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer, reactionProduct, vA, vB, cB }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const reaction = titrationReactions.find((r) => r.produit === reactionProduct);
+    const [a, b] = reaction.coeff;
+    const correctAns = round((b * vB * cB) / (a * vA), 2);
+    const unit = new DivideUnit(AmountOfSubstance.mol, VolumeUnit.mL);
+    let random;
+    while (propositions.length < n) {
+        random = randfloat(correctAns - 1, correctAns + 2, 2, [correctAns]);
+        tryToAddWrongProp(propositions, new Measure(Math.abs(random), 0, unit).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, reactionProduct, vA, vB, cB }) => {
+    const reaction = titrationReactions.find((r) => r.produit === reactionProduct);
+    const [a, b] = reaction.coeff;
+    const correctAns = round((b * vB * cB) / (a * vA), 2);
+    const unit = new DivideUnit(AmountOfSubstance.mol, VolumeUnit.mL);
+    return [
+        answer,
+        frenchify(correctAns),
+        answer.replace(`\\ ${unit.toTex()}`, ""),
+    ].includes(ans);
 };
 export const titrationEquivalenceRelation = {
     id: "titrationEquivalenceRelation",
     label: "Calculer la concentration d'un element titré à l'aide d'une équation de réaction d'un mélange stœchiométrique.",
-    levels: ["1reSpé"],
     isSingleStep: true,
-    sections: ["Réaction chimique"],
     generator: (nb) => getDistinctQuestions(getTitrationEquivalenceRelationQuestion, nb, 10),
     qcmTimer: 60,
     freeTimer: 60,
@@ -175,4 +211,5 @@ export const titrationEquivalenceRelation = {
     maxAllowedQuestions: 10,
     subject: "Physique",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/dosage/beerLambertRandomValue.d.ts

@@ -5,7 +5,7 @@ type Identifiers = {
     molarAbsorptivity: number;
     pathLength: number;
     absorbance: number;
-    randomIndex: number;
+    targetVariableName: string;
 };
 export declare const BeerLambertRandomValueExercise: Exercise<Identifiers>;
 export {};

package/lib/exercises/pc/dosage/beerLambertRandomValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"beerLambertRandomValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/beerLambertRandomValue.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA0NF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAchE,CAAC"}
+{"version":3,"file":"beerLambertRandomValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/beerLambertRandomValue.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,aAAa,EAAE,MAAM,CAAC;IACtB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAqOF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAahE,CAAC"}

package/lib/exercises/pc/dosage/beerLambertRandomValue.js

@@ -5,31 +5,24 @@ import { round } from "../../../math/utils/round.js";
 import { random } from "../../../utils/alea/random.js";
 import { requiresApostropheBefore } from "../../../utils/strings/requiresApostropheBefore.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
-import { randint } from "../../../math/utils/random/randint.js";
 import { molecules } from "../../../pc/constants/molecularChemistry/molecule.js";
-const getBeerLambertRandomValueQuestion = () => {
-    const molecule = random(molecules);
-    const concentration = round(randfloat(0.01, 0.1), 2); // Concentration in mol/L
-    const molarAbsorptivity = round(randfloat(10, 100), 1); // Molar absorptivity in L·mol^-1·cm^-1
-    const pathLength = round(randfloat(1, 5), 1); // Path length in cm
-    const absorbance = round(concentration * molarAbsorptivity * pathLength, 2); // Absorbance
+const getInstruction = (identifiers) => {
+    const { moleculeName, concentration, molarAbsorptivity, pathLength, absorbance, targetVariableName, } = identifiers;
     const variables = [
         {
             name: "concentration",
             value: concentration,
-            unit: "\\text{mol} \\cdot \\text{L}^{-1}",
+            unit: "\\textrm{mol} \\cdot \\textrm{L}^{-1}",
         },
         {
             name: "molarAbsorptivity",
             value: molarAbsorptivity,
-            unit: "\\text{L} \\cdot \\text{mol}^{-1} \\cdot \\text{cm}^{-1}",
+            unit: "\\textrm{L} \\cdot \\textrm{mol}^{-1} \\cdot \\textrm{cm}^{-1}",
         },
-        { name: "pathLength", value: pathLength, unit: "\\text{cm}" },
+        { name: "pathLength", value: pathLength, unit: "\\textrm{cm}" },
         { name: "absorbance", value: absorbance, unit: "" },
     ];
-    const randomIndex = randint(0, variables.length);
-    const targetVariable = variables[randomIndex];
-    const knownVariables = variables.filter((_, index) => index !== randomIndex);
+    const knownVariables = variables.filter((v) => v.name !== targetVariableName);
     const knownVariablesText = knownVariables
         .map((v) => `${v.name === "concentration"
         ? "- Concentration"
@@ -45,82 +38,121 @@ const getBeerLambertRandomValueQuestion = () => {
                 ? "$\\ell$"
                 : "$A$"} = $${frenchify(v.value)}\\ ${v.unit}$`)
         .join(",\n");
-    const instruction = `Vous êtes en train de réaliser l'étalonnage d'une solution ${requiresApostropheBefore(molecule.name.toLowerCase()) ? "d'" : "de "}${molecule.name.toLowerCase()} en utilisant une solution étalon. Vous avez mesuré les données suivantes :\n
+    const instruction = `Vous êtes en train de réaliser l'étalonnage d'une solution ${requiresApostropheBefore(moleculeName.toLowerCase()) ? "d'" : "de "}${moleculeName.toLowerCase()} en utilisant une solution étalon. Vous avez mesuré les données suivantes :\n
   ${knownVariablesText}.\n 
   
-À partir de ces données, déterminez ${targetVariable.name === "concentration"
+À partir de ces données, déterminez ${targetVariableName === "concentration"
         ? "la concentration en $\\text{mol} \\cdot \\text{L}^{-1}$"
-        : targetVariable.name === "molarAbsorptivity"
+        : targetVariableName === "molarAbsorptivity"
             ? "le coefficient d'absorption molaire en $\\text{L} \\cdot \\text{mol}^{-1} \\cdot \\text{cm}^{-1}$"
-            : targetVariable.name === "pathLength"
+            : targetVariableName === "pathLength"
                 ? "la longueur du trajet optique en $\\text{cm}$"
                 : "l'absorbance"} de cette solution.`;
-    const hint = `Rappelez-vous la loi de Beer-Lambert : $A = \\varepsilon \\cdot C \\cdot \\ell$. Voici les éléments de cette formule :
-- $A$ : l'absorbance
-- $\\varepsilon$ : le coefficient d'absorption molaire en $\\text{L} \\cdot \\text{mol}^{-1} \\cdot \\text{cm}^{-1}$
-- $C$ : la concentration en $\\text{mol} \\cdot \\text{L}^{-1}$
-- $\\ell$ : la longueur du trajet optique en $\\text{cm}$ 
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { targetVariableName } = identifiers;
+    const value = identifiers[targetVariableName];
+    return Number(value).frenchify();
+};
+const getHint = (identifiers) => {
+    const hint = `La loi de Beer-Lambert est la suivante : 
+  
+$$
+A = \\varepsilon \\cdot C \\cdot \\ell
+$$
+
+où : 
+
+- $A$ est l'absorbance
+
+- $\\varepsilon$ est le coefficient d'absorption molaire en $\\textrm{L} \\cdot \\textrm{mol}^{-1} \\cdot \\textrm{cm}^{-1}$
+
+- $C$ est la concentration en $\\textrm{mol} \\cdot \\textrm{L}^{-1}$
+
+- $\\ell$ : la longueur du trajet optique en $\\textrm{cm}$ 
   
 Réorganisez cette formule pour isoler la variable à trouver.`;
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { moleculeName, concentration, molarAbsorptivity, pathLength, absorbance, targetVariableName, } = identifiers;
+    let formula;
+    let calcul;
+    switch (targetVariableName) {
+        case "concentration":
+            formula = "C = \\frac{A}{\\varepsilon \\cdot \\ell}";
+            calcul = `C = \\frac{${frenchify(absorbance)}}{${frenchify(molarAbsorptivity)} \\cdot ${frenchify(pathLength)}} = ${frenchify(round(absorbance / (molarAbsorptivity * pathLength), 2))}\\ \\text{mol} \\cdot \\text{L}^{-1}`;
+            break;
+        case "molarAbsorptivity":
+            formula = "\\varepsilon = \\frac{A}{C \\cdot \\ell}";
+            calcul = `\\varepsilon = \\frac{${frenchify(absorbance)}}{${frenchify(concentration)} \\cdot ${frenchify(pathLength)}} = ${frenchify(round(absorbance / (concentration * pathLength), 1))}\\ \\text{L} \\cdot \\text{mol}^{-1} \\cdot \\text{cm}^{-1}`;
+            break;
+        case "pathLength":
+            formula = "\\ell = \\frac{A}{\\varepsilon \\cdot C}";
+            calcul = `\\ell = \\frac{${frenchify(absorbance)}}{${frenchify(molarAbsorptivity)} \\cdot ${frenchify(concentration)}} = ${frenchify(round(absorbance / (molarAbsorptivity * concentration), 1))}\\ \\text{cm}`;
+            break;
+        case "absorbance":
+        default:
+            formula = "A = \\varepsilon \\cdot C \\cdot \\ell";
+            calcul = `A = ${frenchify(molarAbsorptivity)} \\cdot ${frenchify(concentration)} \\cdot ${frenchify(pathLength)} = ${frenchify(absorbance)}`;
+            break;
+    }
     const correction = `La loi de Beer-Lambert est donnée par :
 
 $$
 A = \\varepsilon \\cdot \\ell \\cdot C
 $$
+  
+Pour résoudre le problème, nous devons réorganiser la formule pour isoler la variable inconnue. En utilisant les valeurs fournies pour $\\varepsilon$, $C$, et $\\ell$, nous pouvons résoudre pour trouver la variable manquante.
 
-  Pour résoudre le problème, nous devons réorganiser la formule pour isoler la variable inconnue. En utilisant les valeurs fournies pour $\\varepsilon$, $C$, et $\\ell$, nous pouvons résoudre pour trouver la variable manquante.
-
-  Si $A$ est l'absorbance, $\\varepsilon$ est le coefficient d'absorption molaire, $C$ est la concentration et $\\ell$ est la longueur du trajet optique, alors:
+Si $A$ est l'absorbance, $\\varepsilon$ est le coefficient d'absorption molaire, $C$ est la concentration et $\\ell$ est la longueur du trajet optique, alors:
 
 $$
-${targetVariable.name === "concentration"
-        ? "C = \\frac{A}{\\varepsilon \\cdot \\ell}"
-        : ""}
-${targetVariable.name === "molarAbsorptivity"
-        ? "\\varepsilon = \\frac{A}{C \\cdot \\ell}"
-        : ""}
-${targetVariable.name === "pathLength"
-        ? "\\ell = \\frac{A}{\\varepsilon \\cdot C}"
-        : ""}
-${targetVariable.name === "absorbance"
-        ? "A = \\varepsilon \\cdot C \\cdot \\ell"
-        : ""}
+${formula}
 $$
-
-  En appliquant les valeurs:
-
+  
+En appliquant les valeurs:
+  
 $$
-${targetVariable.name === "concentration"
-        ? `C = \\frac{${frenchify(absorbance)}}{${frenchify(molarAbsorptivity)} \\cdot ${frenchify(pathLength)}} = ${frenchify(round(absorbance / (molarAbsorptivity * pathLength), 2))}\\ \\text{mol} \\cdot \\text{L}^{-1}`
-        : ""}
-${targetVariable.name === "molarAbsorptivity"
-        ? `\\varepsilon = \\frac{${frenchify(absorbance)}}{${frenchify(concentration)} \\cdot ${frenchify(pathLength)}} = ${frenchify(round(absorbance / (concentration * pathLength), 1))}\\ \\text{L} \\cdot \\text{mol}^{-1} \\cdot \\text{cm}^{-1}`
-        : ""}
-${targetVariable.name === "pathLength"
-        ? `\\ell = \\frac{${frenchify(absorbance)}}{${frenchify(molarAbsorptivity)} \\cdot ${frenchify(concentration)}} = ${frenchify(round(absorbance / (molarAbsorptivity * concentration), 1))}\\ \\text{cm}`
-        : ""}
-${targetVariable.name === "absorbance"
-        ? `A = ${frenchify(molarAbsorptivity)} \\cdot ${frenchify(concentration)} \\cdot ${frenchify(pathLength)} = ${frenchify(absorbance)}`
-        : ""}
+${calcul}
 $$`;
+    return correction;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: targetVariable.value.toTree().toTex(),
-        instruction,
-        hint,
-        correction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: {
-            moleculeName: molecule.name.toLowerCase(),
-            concentration,
-            molarAbsorptivity,
-            pathLength,
-            absorbance,
-            randomIndex,
-        },
+        identifiers,
     };
     return question;
 };
+const getBeerLambertRandomValueQuestion = () => {
+    const molecule = random(molecules);
+    const concentration = round(randfloat(0.01, 0.1), 2); // Concentration in mol/L
+    const molarAbsorptivity = round(randfloat(10, 100), 1); // Molar absorptivity in L·mol^-1·cm^-1
+    const pathLength = round(randfloat(1, 5), 1); // Path length in cm
+    const absorbance = round(concentration * molarAbsorptivity * pathLength, 2); // Absorbance
+    const targetVariableName = random([
+        "concentration",
+        "molarAbsorptivity",
+        "pathLength",
+        "absorbance",
+    ]);
+    const identifiers = {
+        moleculeName: molecule.name.toLowerCase(),
+        concentration,
+        molarAbsorptivity,
+        pathLength,
+        absorbance,
+        targetVariableName,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, concentration, molarAbsorptivity, pathLength, absorbance }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -133,31 +165,15 @@ const getPropositions = (n, { answer, concentration, molarAbsorptivity, pathLeng
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, randomIndex, concentration, molarAbsorptivity, pathLength, absorbance, }) => {
-    const variables = [
-        {
-            name: "concentration",
-            value: concentration,
-            unit: "\\text{mol} \\cdot \\text{L}^{-1}",
-        },
-        {
-            name: "molarAbsorptivity",
-            value: molarAbsorptivity,
-            unit: "\\text{L} \\cdot \\text{mol}^{-1} \\cdot \\text{cm}^{-1}",
-        },
-        { name: "pathLength", value: pathLength, unit: "\\text{cm}" },
-        { name: "absorbance", value: absorbance, unit: "" },
-    ];
-    const validAnswer = variables[randomIndex].value;
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const validAnswer = getAnswer(identifiers).unfrenchify();
     const latexs = validAnswer.toTree().toAllValidTexs();
     return latexs.includes(ans);
 };
 export const BeerLambertRandomValueExercise = {
     id: "beerLambertRandomValue",
     label: "Utiliser la loi de Beer-Lambert",
-    levels: ["1reSpé"],
     isSingleStep: true,
-    sections: ["Spectrophotométrie"],
     generator: (nb) => getDistinctQuestions(getBeerLambertRandomValueQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -165,4 +181,5 @@ export const BeerLambertRandomValueExercise = {
     isAnswerValid,
     subject: "Chimie",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/dosage/concentrationCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"concentrationCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/concentrationCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;CAC3B,CAAC;AA6IF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}
+{"version":3,"file":"concentrationCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/concentrationCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;CAC3B,CAAC;AA6KF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}

package/lib/exercises/pc/dosage/concentrationCalculation.js

@@ -4,61 +4,91 @@ import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuesti
 import { round } from "../../../math/utils/round.js";
 import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
-const getConcentrationCalculationQuestion = () => {
-    const concentration = round(randfloat(0.1, 2), 2); // Concentration en mol/L
-    const quantity = round(randfloat(0.1, 5), 2); // Quantité de matière en mol
-    const volume = round(randfloat(0.1, 2), 2); // Volume en L
-    const variableIndex = randint(0, 3);
-    const variables = ["C", "n", "V"];
-    const variable = variables[variableIndex];
-    let questionText, answer;
+const getInstruction = (identifiers) => {
+    const { concentration, quantity, volume, variable } = identifiers;
     switch (variable) {
         case "C":
-            questionText = `Vous avez une solution contenant une quantité de matière $n = ${frenchify(quantity)}\\ \\text{mol}$ dissoute dans un volume $V = ${frenchify(volume)}\\ \\text{L}$. Déterminez la concentration $[X_i]$ en $\\text{mol.L}^{-1}$ de cette solution.`;
-            answer = round(quantity / volume, 2);
-            break;
+            return `Vous avez une solution contenant une quantité de matière $n = ${frenchify(quantity)}\\ \\textrm{mol}$ dissoute dans un volume $V = ${frenchify(volume)}\\ \\textrm{L}$. 
+      
+Déterminez la concentration $[X_i]$ en $\\textrm{mol.L}^{-1}$ de cette solution.`;
         case "n":
-            questionText = `Vous avez une solution de concentration $[X_i] = ${frenchify(concentration)}\\ \\text{mol.L}^{-1}$ dans un volume $V = ${frenchify(volume)}\\ \\text{L}$. Déterminez la quantité de matière $n$ en $\\text{mol}$ de cette solution.`;
-            answer = round(concentration * volume, 2);
-            break;
+            return `Vous avez une solution de concentration $[X_i] = ${frenchify(concentration)}\\ \\textrm{mol.L}^{-1}$ dans un volume $V = ${frenchify(volume)}\\ \\textrm{L}$. 
+      
+Déterminez la quantité de matière $n$ en $\\text{mol}$ de cette solution.`;
         case "V":
-            questionText = `Vous avez une solution de concentration $[X_i] = ${frenchify(concentration)}\\ \\text{mol.L}^{-1}$ contenant une quantité de matière $n = ${frenchify(quantity)}\\ \\text{mol}$. Déterminez le volume $V$ en $\\text{L}$ de cette solution.`;
-            answer = round(quantity / concentration, 2);
+            return `Vous avez une solution de concentration $[X_i] = ${frenchify(concentration)}\\ \\textrm{mol.L}^{-1}$ contenant une quantité de matière $n = ${frenchify(quantity)}\\ \\textrm{mol}$. 
+      
+Déterminez le volume $V$ en $\\textrm{L}$ de cette solution.`;
             break;
     }
+};
+const getAnswer = (identifiers) => {
+    const { concentration, quantity, volume, variable } = identifiers;
+    switch (variable) {
+        case "C":
+            return round(quantity / volume, 2).frenchify();
+        case "n":
+            return round(concentration * volume, 2).frenchify();
+        case "V":
+        default:
+            return round(quantity / concentration, 2).frenchify();
+    }
+};
+const getHint = (identifiers) => {
     const hint = `La concentration en quantité de matière $[X_i]$ d'une espèce chimique en solution est le quotient de la quantité de matière $n$ de soluté par le volume $V_{\\text{solution}}$ de la solution :
-    $$
-    [X_i] = \\frac{n}{V_{\\text{solution}}}
-    $$
-    Réarrangez cette formule pour isoler la variable à trouver.`;
+
+$$
+[X_i] = \\frac{n}{V_{\\text{solution}}}
+$$
+
+Réarrange cette formule pour isoler la variable à trouver.`;
+    return hint;
+};
+const getCorrection = (identifiers) => {
+    const { concentration, quantity, volume, variable } = identifiers;
+    const answer = getAnswer(identifiers);
     const correction = `La formule de la concentration est :
-    $$
-    [X_i] = \\frac{n}{V}
-    $$
-  
+
+$$
+[X_i] = \\frac{n}{V}
+$$
+
 Pour résoudre ce problème, nous devons réorganiser la formule pour isoler la variable inconnue.
-  
+
 ${variable === "C"
-        ? `$$[X_i] = \\frac{n}{V} = \\frac{${frenchify(quantity)}}{${frenchify(volume)}} = ${frenchify(answer)}\\ \\text{mol.L}^{-1}$$`
+        ? `$$[X_i] = \\frac{n}{V} = \\frac{${frenchify(quantity)}}{${frenchify(volume)}} = ${answer}\\ \\text{mol.L}^{-1}$$`
         : variable === "n"
-            ? `$$n = [X_i] \\times V = ${frenchify(concentration)} \\times ${frenchify(volume)} = ${frenchify(answer)}\\ \\text{mol}$$`
-            : `$$V = \\frac{n}{[X_i]} = \\frac{${frenchify(quantity)}}{${frenchify(concentration)}} = ${frenchify(answer)}\\ \\text{L}$$`}`;
+            ? `$$n = [X_i] \\times V = ${frenchify(concentration)} \\times ${frenchify(volume)} = ${answer}\\ \\text{mol}$$`
+            : `$$V = \\frac{n}{[X_i]} = \\frac{${frenchify(quantity)}}{${frenchify(concentration)}} = ${answer}\\ \\text{L}$$`}`;
+    return correction;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: answer.toTree().toTex(),
-        instruction: questionText,
-        hint,
-        correction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: ["C", "n", "V"],
         answerFormat: "tex",
-        identifiers: {
-            concentration,
-            quantity,
-            volume,
-            variable,
-        },
+        identifiers,
     };
     return question;
 };
+const getConcentrationCalculationQuestion = () => {
+    const concentration = round(randfloat(0.1, 2), 2); // Concentration en mol/L
+    const quantity = round(randfloat(0.1, 5), 2); // Quantité de matière en mol
+    const volume = round(randfloat(0.1, 2), 2); // Volume en L
+    const variableIndex = randint(0, 3);
+    const variables = ["C", "n", "V"];
+    const variable = variables[variableIndex];
+    const identifiers = {
+        concentration,
+        quantity,
+        volume,
+        variable,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, concentration, quantity, volume, variable }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -103,9 +133,7 @@ const isAnswerValid = (ans, { answer, variable, concentration, quantity, volume
 export const concentrationCalculation = {
     id: "concentrationCalculation",
     label: "Calculer la concentration d'un élément dans une solution",
-    levels: ["1reSpé"],
     isSingleStep: true,
-    sections: ["Chimie des solutions"],
     generator: (nb) => getDistinctQuestions(getConcentrationCalculationQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -113,4 +141,5 @@ export const concentrationCalculation = {
     isAnswerValid,
     subject: "Chimie",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/dosage/concentrationFromMassCalculation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"concentrationFromMassCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/concentrationFromMassCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;CAC3B,CAAC;AA2IF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAelE,CAAC"}
+{"version":3,"file":"concentrationFromMassCalculation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/dosage/concentrationFromMassCalculation.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;CAC3B,CAAC;AAkLF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAclE,CAAC"}