math-exercises 3.0.65 → 3.0.67

package/lib/exercises/math/probaStat/binomial/expectedValueOfBinomialProba.js

@@ -1,36 +1,62 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { Rational, RationalConstructor, } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { nX, a, b } = identifiers;
+    const p = new Rational(a, b);
+    return `Soit $X$ une variable aléatoire qui suit une loi binomiale de paramètres $n=${nX}$ et $p=${p
+        .toTree()
+        .simplify()
+        .toTex()}$. 
+  
+Calculez l'espérance de $X$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nX, a, b } = identifiers;
+    const p = new Rational(a, b);
+    const nNode = new NumberNode(nX);
+    const node = new MultiplyNode(nNode, p.toTree().simplify()).simplify();
+    const answer = node.toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `L'espérance d'une variable aléatoire $X$ qui suit une loi binomiale de paramètres $n$ et $p$ est donnée par $E(X) = np$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nX, a, b } = identifiers;
+    const p = new Rational(a, b);
+    return `L'espérance d'une variable aléatoire $X$ qui suit une loi binomiale de paramètres $n$ et $p$ est donnée par $E(X) = np$.
+    
+  Ici, on a donc :
+  
+  ${alignTex([
+        ["E(X)", "=", new MultiplyNode(nX.toTree(), p.toTree()).toTex()],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
 const getExpectedValueOfBinomialProbaQuestion = () => {
     const nX = randint(1, 9);
     const b = randint(2, 11);
     const a = randint(1, b);
-    const p = new Rational(a, b);
-    const node = getCorrectAnswer(nX, p);
-    const answer = node.toTex();
+    const identifiers = { nX, a, b };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer,
-        instruction: `Soit $X$ une variable aléatoire qui suit une loi binomiale de paramètres $n=${nX}$ et $p=${p
-            .toTree()
-            .simplify()
-            .toTex()}$. Calculez l'espérance de $X$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { nX, a, b },
-        hint: `L'espérance d'une variable aléatoire $X$ qui suit une loi binomiale de paramètres $n$ et $p$ est donnée par $E(X) = np$.`,
-        correction: `L'espérance d'une variable aléatoire $X$ qui suit une loi binomiale de paramètres $n$ et $p$ est donnée par $E(X) = np$.
-    
-Ici, on a donc :
-
-${alignTex([
-            ["E(X)", "=", new MultiplyNode(nX.toTree(), p.toTree()).toTex()],
-            ["", "=", answer],
-        ])}`,
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -46,12 +72,13 @@ const getPropositions = (n, { answer, nX, a, b }) => {
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { nX, a, b }) => {
-    const p = new Rational(a, b);
-    const correctAns = getCorrectAnswer(nX, p);
-    return correctAns
-        .toAllValidTexs({ allowFractionToDecimal: true })
-        .includes(ans);
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const generatePropositions = (n, p) => {
     const pTree = p.toTree().simplify();
@@ -66,10 +93,6 @@ const generatePropositions = (n, p) => {
         thirdProposition.toTex(),
     ];
 };
-const getCorrectAnswer = (n, p) => {
-    const nNode = new NumberNode(n);
-    return new MultiplyNode(nNode, p.toTree().simplify()).simplify();
-};
 export const expectedValueOfBinomialProba = {
     id: "expectedValueOfBinomialProba",
     label: "Calcul de l'espérance d'une loi binomiale",
@@ -83,4 +106,5 @@ export const expectedValueOfBinomialProba = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/probaStat/binomial/varianceOfBinomialProba.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"varianceOfBinomialProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/binomial/varianceOfBinomialProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+FF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"varianceOfBinomialProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/binomial/varianceOfBinomialProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqHF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAYzD,CAAC"}

package/lib/exercises/math/probaStat/binomial/varianceOfBinomialProba.js

@@ -1,46 +1,72 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { Rational, RationalConstructor, } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { PowerNode } from "../../../../tree/nodes/operators/powerNode.js";
 import { SubstractNode } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
-const nbOneNode = new NumberNode(1);
-const getVarianceOfBinomialProbaQuestion = () => {
-    const nX = randint(1, 9);
-    const b = randint(2, 11);
-    const a = randint(1, b);
+const getAnswer = (identifiers) => {
+    const { nX, a, b } = identifiers;
     const p = new Rational(a, b);
-    const correctAns = getCorrectAnswer(nX, p);
-    const answer = correctAns.toTex();
-    const question = {
-        answer,
-        instruction: `Soit $X$ une variable aléatoire qui suit une loi binomiale de paramètres $n=${nX}$ et $p=${p
-            .toTree()
-            .simplify()
-            .toTex()}$. Calculez la variance de $X$.`,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: { nX, a, b },
-        hint: `L'espérance d'une variable aléatoire $X$ qui suit une loi binomiale de paramètres $n$ et $p$ est donnée par :
+    const pTree = p.toTree().simplify();
+    const oneMinusP = new SubstractNode((1).toTree(), pTree);
+    return new MultiplyNode(new NumberNode(nX), new MultiplyNode(pTree, oneMinusP).simplify())
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { nX, a, b } = identifiers;
+    const p = new Rational(a, b);
+    return `Soit $X$ une variable aléatoire qui suit une loi binomiale de paramètres $n=${nX}$ et $p=${p
+        .toTree()
+        .simplify()
+        .toTex()}$. Calculez la variance de $X$.`;
+};
+const getHint = (identifiers) => {
+    return `L'espérance d'une variable aléatoire $X$ qui suit une loi binomiale de paramètres $n$ et $p$ est donnée par :
     
-$V(X) = np(1-p)$.`,
-        correction: `L'espérance d'une variable aléatoire $X$ qui suit une loi binomiale de paramètres $n$ et $p$ est donnée par :
+$$
+V(X) = np(1-p)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { nX, a, b } = identifiers;
+    const p = new Rational(a, b);
+    return `L'espérance d'une variable aléatoire $X$ qui suit une loi binomiale de paramètres $n$ et $p$ est donnée par :
     
 $V(X) = np(1-p)$.
     
 Ici, on a donc :
 
 ${alignTex([
-            [
-                "V(X)",
-                "=",
-                new MultiplyNode(nX.toTree(), new MultiplyNode(p.toTree(), new SubstractNode((1).toTree(), p.toTree())), { forceTimesSign: true }).toTex(),
-            ],
-            ["", "=", answer],
-        ])}`,
+        [
+            "V(X)",
+            "=",
+            new MultiplyNode(nX.toTree(), new MultiplyNode(p.toTree(), new SubstractNode((1).toTree(), p.toTree())), { forceTimesSign: true }).toTex(),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}`;
+};
+const getVarianceOfBinomialProbaQuestion = () => {
+    const nX = randint(1, 9);
+    const b = randint(2, 11);
+    const a = randint(1, b);
+    const identifiers = { nX, a, b };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -56,12 +82,13 @@ const getPropositions = (n, { answer, nX, a, b }) => {
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { nX, a, b }) => {
-    const p = new Rational(a, b);
-    const correctAns = getCorrectAnswer(nX, p);
-    return correctAns
-        .toAllValidTexs({ allowFractionToDecimal: true })
-        .includes(ans);
+const isAnswerValid = (ans, { answer, nX, a, b }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
 };
 const generatePropositions = (n, p) => {
     const pTree = p.toTree().simplify();
@@ -70,17 +97,10 @@ const generatePropositions = (n, p) => {
     const secondProposition = new MultiplyNode(nNode, new PowerNode(pTree, new NumberNode(2)).simplify()).simplify();
     return [firstProposition.toTex(), secondProposition.toTex()];
 };
-const getCorrectAnswer = (n, p) => {
-    const pTree = p.toTree().simplify();
-    const oneMinusP = new SubstractNode(nbOneNode, pTree);
-    return new MultiplyNode(new NumberNode(n), new MultiplyNode(pTree, oneMinusP).simplify()).simplify();
-};
 export const varianceOfBinomialProba = {
     id: "varianceOfBinomialProba",
     label: "Calcul de la variance d'une loi binomiale",
-    levels: ["TermTech"],
     isSingleStep: true,
-    sections: ["Probabilités"],
     generator: (nb) => getDistinctQuestions(getVarianceOfBinomialProbaQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,

package/lib/exercises/math/probaStat/diceBasicProbas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"diceBasicProbas.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/diceBasicProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA8IF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAgBjD,CAAC"}
+{"version":3,"file":"diceBasicProbas.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/diceBasicProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;IACxB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA8IF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/math/probaStat/diceBasicProbas.js

@@ -125,9 +125,6 @@ export const diceBasicProbas = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
-    getAnswer,
-    getHint,
-    getInstruction,
-    getCorrection,
+    getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/sequencePlot.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sequencePlot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequencePlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA0FF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAe9C,CAAC"}
+{"version":3,"file":"sequencePlot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequencePlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA0HF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAc9C,CAAC"}

package/lib/exercises/math/sequences/sequencePlot.js

@@ -4,6 +4,54 @@ import { randfloat } from "../../../math/utils/random/randfloat.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
+const getInstruction = (identifiers) => {
+    const { nValue, points, isArithmetic } = identifiers;
+    return `Ci-dessous est tracé un nuage de points représentant les valeurs d'une suite $(u_n)$. Quelle est la valeur de $u_{${nValue}}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nValue, points, isArithmetic } = identifiers;
+    const u_nValue = points[nValue][1];
+    const answer = u_nValue.toString();
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { nValue, points, isArithmetic } = identifiers;
+    const commands = points.map((point, index) => {
+        return `A${index}=(${point[0]},${point[1]})`;
+    });
+    commands.push(...points.map((_, index) => {
+        return `SetFixed(A${index},true)`;
+    }), ...points.map((_, index) => {
+        return `SetLabelMode(A${index},1)`;
+    }));
+    const ggb = new GeogebraConstructor({
+        commands,
+        xAxis: { natural: true },
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: 0,
+            xMax: 10,
+            yMin: Math.min(...points.map((p) => p[1])) - 2,
+            yMax: Math.max(...points.map((p) => p[1])) + 2,
+        }),
+    });
+};
+const getHint = (identifiers) => {
+    const { nValue, points, isArithmetic } = identifiers;
+    return `$u_{${nValue}}$ est l'ordonnée du point d'absicsse $${nValue}$ dans le nuage de points.`;
+};
+const getCorrection = (identifiers) => {
+    const { nValue, points, isArithmetic } = identifiers;
+    return `$u_{${nValue}}$ est l'ordonnée du point d'absicsse $${nValue}$ dans le nuage de points.
+
+On lit donc : 
+
+$$
+u_{${nValue}}=${getAnswer(identifiers)}
+$$
+`;
+};
 const getSequencePlotQuestion = () => {
     const isArithmetic = coinFlip();
     const a = isArithmetic ? randfloat(0.1, 0.5, 1) : randfloat(1.01, 1.1, 2);
@@ -23,39 +71,19 @@ const getSequencePlotQuestion = () => {
         points.push([n, Math.round(u_n)]);
     }
     const nValue = randint(0, nMax);
-    const u_nValue = points[nValue][1];
-    const commands = points.map((point, index) => {
-        return `A${index}=(${point[0]},${point[1]})`;
-    });
-    commands.push(...points.map((_, index) => {
-        return `SetFixed(A${index},true)`;
-    }), ...points.map((_, index) => {
-        return `SetLabelMode(A${index},1)`;
-    }));
-    const ggb = new GeogebraConstructor({
-        commands,
-        xAxis: { natural: true },
-    });
-    const answer = u_nValue.toString();
+    const identifiers = { nValue, points, isArithmetic };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer,
-        instruction: `Ci-dessous est tracé un nuage de points représentant les valeurs d'une suite $(u_n)$. Quelle est la valeur de $u_{${nValue}}$ ?`,
-        ggbOptions: ggb.getOptions({
-            coords: ggb.getAdaptedCoords({
-                xMin: 0,
-                xMax: nMax,
-                yMin: Math.min(...points.map((p) => p[1])) - 2,
-                yMax: Math.max(...points.map((p) => p[1])) + 2,
-            }),
-        }),
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
         keys: [],
         answerFormat: "raw",
-        identifiers: { nValue, points, isArithmetic },
-        hint: `$u_{${nValue}}$ est l'ordonnée du point d'absicsse $${nValue}$ dans le nuage de points.`,
-        correction: `$u_{${nValue}}$ est l'ordonnée du point d'absicsse $${nValue}$ dans le nuage de points.
-
-On lit donc : $u_{${nValue}}=${answer}$.
-    `,
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -75,10 +103,8 @@ const isAnswerValid = (ans, { answer }) => {
 export const sequencePlot = {
     id: "sequencePlot",
     label: "Lire graphiquement un terme d'une suite à partir d'un nuage de points",
-    levels: ["1reSpé"],
     isSingleStep: true,
     hasGeogebra: true,
-    sections: ["Suites"],
     generator: (nb) => getDistinctQuestions(getSequencePlotQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -86,4 +112,5 @@ export const sequencePlot = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/chemicalElements/atomicStructureOfNucleus.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"atomicStructureOfNucleus.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/atomicStructureOfNucleus.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAKnF,KAAK,WAAW,GAAG;IAAE,UAAU,EAAE,WAAW,CAAA;CAAE,CAAC;AAoE/C,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}
+{"version":3,"file":"atomicStructureOfNucleus.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/atomicStructureOfNucleus.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAKnF,KAAK,WAAW,GAAG;IAAE,UAAU,EAAE,WAAW,CAAA;CAAE,CAAC;AA0F/C,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}

package/lib/exercises/pc/chemicalElements/atomicStructureOfNucleus.js

@@ -5,16 +5,33 @@ import { round } from "../../../math/utils/round.js";
 import { atomes } from "../../../pc/constants/molecularChemistry/atome.js";
 import { random } from "../../../utils/alea/random.js";
 import { requiresApostropheBefore } from "../../../utils/strings/requiresApostropheBefore.js";
+const getAnswer = (identifiers) => {
+    const { atomSymbol } = identifiers;
+    const atom = atomes.find((a) => a.symbole === atomSymbol);
+    const mass = round(atom.masseAtomique, 0);
+    return `^{${mass}}_{${atom.numeroAtomique}}${atom.symbole}`;
+};
+const getInstruction = (identifiers) => {
+    const { atomSymbol } = identifiers;
+    const atom = atomes.find((a) => a.symbole === atomSymbol);
+    const mass = round(atom.masseAtomique, 0);
+    const instruction = `Le noyau d'un atome  ${requiresApostropheBefore(atom.name) ? "d'" : "de "}${atom.name} possède $${mass}$ nucléons, $${mass - atom.numeroAtomique}$ neutrons et $${atom.numeroAtomique}$ protons. 
+  
+Quelle est son écriture conventionnelle ?`;
+    return instruction;
+};
 const getAtomicStructureOfNucleusQuestion = () => {
     const atom = random(atomes.slice(0, 50));
-    const mass = round(atom.masseAtomique, 0);
-    const instruction = `Le noyau d'un atome  ${requiresApostropheBefore(atom.name) ? "d'" : "de "}${atom.name} possède $${mass}$ nucléons, $${mass - atom.numeroAtomique}$ neutrons et $${atom.numeroAtomique}$ protons. Quelle est son écriture conventionnelle ?`;
+    const identifiers = { atomSymbol: atom.symbole };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: `^{${mass}}_{${atom.numeroAtomique}}${atom.symbole}`,
-        instruction: instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { atomSymbol: atom.symbole },
+        identifiers,
     };
     return question;
 };
@@ -42,9 +59,7 @@ const isAnswerValid = (ans, { answer }) => {
 export const atomicStructureOfNucleus = {
     id: "atomicStructureOfNucleus",
     label: "Trouver l'écriture conventionnelle d'un atome",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Chimie organique"],
     generator: (nb) => getDistinctQuestions(getAtomicStructureOfNucleusQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -52,4 +67,5 @@ export const atomicStructureOfNucleus = {
     isAnswerValid,
     subject: "Chimie",
     answerType: "QCU",
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/chemicalElements/calculateProtonsNumberFromMass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateProtonsNumberFromMass.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/calculateProtonsNumberFromMass.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAQnF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,WAAW,CAAC;CACzB,CAAC;AA+DF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAahE,CAAC"}
+{"version":3,"file":"calculateProtonsNumberFromMass.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/calculateProtonsNumberFromMass.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAQnF,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,WAAW,CAAC;CACzB,CAAC;AAqFF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAYhE,CAAC"}

package/lib/exercises/pc/chemicalElements/calculateProtonsNumberFromMass.js

@@ -7,22 +7,38 @@ import { atomes } from "../../../pc/constants/molecularChemistry/atome.js";
 import { random } from "../../../utils/alea/random.js";
 import { requiresApostropheBefore } from "../../../utils/strings/requiresApostropheBefore.js";
 import { randint } from "../../../math/utils/random/randint.js";
-const getCalculateProtonsNumberFromMassQuestion = () => {
-    const atom = random(atomes.slice(0, 50));
+const getInstruction = (identifiers) => {
+    const { atomSymbol } = identifiers;
+    const atom = atomes.find((a) => a.symbole === atomSymbol);
     const atomNucleusMass = nucleonMass.value.times(atom.masseAtomique);
     const instruction = `Le noyau d'un atome ${requiresApostropheBefore(atom.name) ? "d'" : "de "}${atom.name} a pour masse $m = ${atomNucleusMass.toTex({
         scientific: 2,
-    })}$ et possède $${round(atom.masseAtomique, 0) - atom.numeroAtomique}$ neutrons. Déterminer le nombre de protons de cet atome.`;
+    })}$ et possède $${round(atom.masseAtomique, 0) - atom.numeroAtomique}$ neutrons. 
+  
+Déterminer le nombre de protons de cet atome.`;
+    return instruction;
+};
+const getAnswer = (identifiers) => {
+    const { atomSymbol } = identifiers;
+    const atom = atomes.find((a) => a.symbole === atomSymbol);
+    return `${atom.numeroAtomique}`;
+};
+const getCalculateProtonsNumberFromMassQuestion = () => {
+    const atom = random(atomes.slice(0, 50));
     // const help = ` $m_{\\text{nucléon}} = ${nucleonMass.value.toTex({
     //   scientific: 2,
     // })}\\ ${nucleonMass.unit}$`;
+    const identifiers = { atomSymbol: atom.symbole };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: `${atom.numeroAtomique}`,
-        instruction: instruction,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         // instruction: instruction + help,
         keys: [],
         answerFormat: "tex",
-        identifiers: { atomSymbol: atom.symbole },
+        identifiers,
     };
     return question;
 };
@@ -48,13 +64,12 @@ const isAnswerValid = (ans, { answer }) => {
 export const calculateProtonsNumberFromMass = {
     id: "calculateProtonsNumberFromMass",
     label: "Déterminer le nombre de protons par la masse",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Chimie organique"],
     generator: (nb) => getDistinctQuestions(getCalculateProtonsNumberFromMassQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Chimie",
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/pc/chemicalElements/calculateVolumetricMass.d.ts

@@ -1,5 +1,10 @@
 import { Exercise } from "../../../exercises/exercise.js";
-type Identifiers = {};
+type Identifiers = {
+    m: number;
+    t: number;
+    v: number;
+    type: number;
+};
 export declare const calculateVolumetricMass: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=calculateVolumetricMass.d.ts.map

package/lib/exercises/pc/chemicalElements/calculateVolumetricMass.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateVolumetricMass.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/calculateVolumetricMass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG,EAAE,CAAC;AAoFtB,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"calculateVolumetricMass.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/calculateVolumetricMass.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC;AA4HrE,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}