math-exercises 2.1.16 → 2.1.17

package/lib/exercises/exercise.d.ts

@@ -12,6 +12,8 @@ export type Proposition = {
 };
 export interface Question<TIdentifiers = {}> {
     instruction: string;
+    hint?: string;
+    correction?: string;
     startStatement?: string;
     answer: string;
     answerFormat: "tex" | "raw";

package/lib/exercises/exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"exercise.d.ts","sourceRoot":"","sources":["../../src/exercises/exercise.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"exercise.d.ts","sourceRoot":"","sources":["../../src/exercises/exercise.ts"],"names":[],"mappings":"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"}

package/lib/exercises/math/calcul/proportionality/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./proportionalityTable";
+export * from "./proportionalityTableCoefficient";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/proportionality/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC"}

package/lib/exercises/math/calcul/proportionality/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./proportionalityTable"), exports);
+__exportStar(require("./proportionalityTableCoefficient"), exports);

package/lib/exercises/math/calcul/proportionality/proportionalityTableCoefficient.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    xValues: number[];
+    yValues: number[];
+};
+export declare const proportionalityTableCoefficient: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=proportionalityTableCoefficient.d.ts.map

package/lib/exercises/math/calcul/proportionality/proportionalityTableCoefficient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"proportionalityTableCoefficient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/proportionalityTableCoefficient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAoDF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}

package/lib/exercises/math/calcul/proportionality/proportionalityTableCoefficient.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.proportionalityTableCoefficient = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const integer_1 = require("../../../../math/numbers/integer/integer");
+const randint_1 = require("../../../../math/utils/random/randint");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getProportionalityTableCoefficient = () => {
+    const factor = (0, randint_1.randint)(2, 15);
+    const xValues = integer_1.IntegerConstructor.randomDifferents(1, 100 / factor, 3).sort((a, b) => a - b);
+    const yValues = xValues.map((x) => x * factor);
+    let dataTable = `
+| ${xValues.join(" | ")} |
+|-|-|-|
+| ${yValues.map((n) => n.frenchify()).join(" | ")} |
+  `;
+    const instruction = `On considère le tableau de proportionnalité suivant : ${dataTable}
+      
+    \n Calculer le coefficient de proportionnalité.`;
+    const answer = factor.toTree().toTex();
+    const question = {
+        instruction,
+        answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { xValues, yValues },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (Number(answer) + (0, randint_1.randint)(-3, 3, [0])).toString());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.proportionalityTableCoefficient = {
+    id: "proportionalityTableCoefficient",
+    connector: "=",
+    label: "Calculer un coefficient de proportionnalité à partir d'un tableau",
+    levels: ["6ème", "5ème", "4ème", "3ème", "CAP", "2ndPro", "1rePro"],
+    isSingleStep: false,
+    sections: ["Proportionnalité"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getProportionalityTableCoefficient, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/calculLitteral/equation/equationType3Exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationType3Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType3Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAiBlC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkDF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}
+{"version":3,"file":"equationType3Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationType3Exercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAalC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2DF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}

package/lib/exercises/math/calculLitteral/equation/equationType3Exercise.js

@@ -24,6 +24,10 @@ const getEquationType3ExerciseQuestion = () => {
     const answer = answerTree.toTex();
     const question = {
         instruction: `Résoudre : $${statementTree.toTex()}$`,
+        hint: "Isolez le terme $x$ dans la partie gauche de l'equation.",
+        correction: `Commencer par soustraire $${b}$ des deux côtés de l'équation pour 
+    l'éliminer du côté gauche, ensuite, diviser les deux côtés de l'équation par 
+    $${a}$ pour isoler $x$, ce qui donne : $ ${a}x = ${c}${b < 0 ? "+" + Math.abs(b) : "-" + Math.abs(b)} \\Leftrightarrow x=\\frac{${c}${b < 0 ? "+" + Math.abs(b) : "-" + Math.abs(b)}}{${a}} \\Leftrightarrow ${answer}$.`,
         startStatement: statementTree.toTex(),
         answer,
         keys: equationKeys_1.equationKeys,

package/lib/exercises/math/equaDiff/equaDiffGeneralForme.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equaDiffGeneralForme.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/equaDiff/equaDiffGeneralForme.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8DF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"equaDiffGeneralForme.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/equaDiff/equaDiffGeneralForme.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA6EF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}

package/lib/exercises/math/equaDiff/equaDiffGeneralForme.js

@@ -6,18 +6,25 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randint_1 = require("../../../math/utils/random/randint");
 const expNode_1 = require("../../../tree/nodes/functions/expNode");
 const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const equalNode_1 = require("../../../tree/nodes/equations/equalNode");
 const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
-const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
 const shuffle_1 = require("../../../utils/shuffle");
+const substractNode_1 = require("../../../tree/nodes/operators/substractNode");
 const getExponentialEquation = () => {
     const a = (0, randint_1.randint)(-19, 20, [0]);
     const equation = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("y"));
     const answer = new equalNode_1.EqualNode(new variableNode_1.VariableNode("y"), new multiplyNode_1.MultiplyNode(new variableNode_1.VariableNode("C"), new expNode_1.ExpNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("x"))))).toTex();
+    const correctionequation = new equalNode_1.EqualNode(new substractNode_1.SubstractNode(new variableNode_1.VariableNode("y'"), new multiplyNode_1.MultiplyNode(a.toTree(), new variableNode_1.VariableNode("y"))).simplify(), new numberNode_1.NumberNode(0)).toTex();
+    const hint = "Rappelez-vous que la solution générale d'une équation différentielle de la forme $y' = ay$ est de la forme $y = Ce^{ax}$, où $C$ est une constante d'intégration.";
+    const correction = `La solution est $y = Ce^{ax}$, où $C$ est une constante d'intégration.
+  \n Donc, la solution générale de l'équation différentielle $y' = ${a}y$ est $y = Ce^{${a}x}$.`;
     const question = {
         instruction: `Résoudre l'équation différentielle suivante : $y' = ${equation.toTex()}$.`,
         startStatement: `y(x)`,
         answer,
+        hint,
+        correction,
         keys: ["x", "y", "epower", "exp", "C", "equal"],
         answerFormat: "tex",
         identifiers: { a },

package/lib/exercises/math/functions/logarithm/log10PowerSimplifying.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"log10PowerSimplifying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/log10PowerSimplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAsCF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}
+{"version":3,"file":"log10PowerSimplifying.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/logarithm/log10PowerSimplifying.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAmDF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}

package/lib/exercises/math/functions/logarithm/log10PowerSimplifying.js

@@ -20,6 +20,8 @@ const getLog10PowerSimplifyingQuestion = () => {
     const question = {
         answer,
         instruction: `Calculer : $${new log10Node_1.Log10Node(nb).toTex()}$`,
+        hint: getHint(nb),
+        correction: getCorrection(tenthPower, nb),
         keys: [],
         answerFormat: "tex",
         identifiers: { tenthPower, nbTex: nb.toTex() },
@@ -36,6 +38,16 @@ const getPropositions = (n, { answer, tenthPower }) => {
     (0, exercise_1.tryToAddWrongProp)(propositions, tenthPower - 2 + "");
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
+const getHint = (nb) => {
+    return `Pour calculer $log(⁡${nb.toTex()})$, il est utile de transformer le nombre $${nb.toTex()}$ en une puissance de $10$.`;
+};
+const getCorrection = (tenthPower, nb) => {
+    const powerTen = new powerNode_1.PowerNode((10).toTree(), tenthPower.toTree());
+    return `1 . Exprimez $${nb.toTex()}$ en puissance de $10$ : $${powerTen.toTex()}$ \n 
+  2 . Utilisez la propriété des logarithmes qui stipule que $log(a^{b}) = b*log(a) \\Leftrightarrow \\log(${powerTen.toTex()}) = ${tenthPower}*log(10) 
+  \\Leftrightarrow log(${nb.toTex()}) = ${tenthPower}$.
+  `;
+};
 const isAnswerValid = (ans, { answer, tenthPower }) => {
     return ans === answer;
 };

package/lib/exercises/math/geometry/vectors/scalarProductViaCoords.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scalarProductViaCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/scalarProductViaCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA8CF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"scalarProductViaCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/scalarProductViaCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAgDF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/math/geometry/vectors/scalarProductViaCoords.js

@@ -23,6 +23,8 @@ const getScalarProductViaCoordsQuestion = () => {
             uCoords: [u.x.toTex(), u.y.toTex()],
             vCoords: [v.x.toTex(), v.y.toTex()],
         },
+        hint: "Rappelez-vous que le produit scalaire de deux vecteurs se calcule en multipliant les coordonnées correspondantes et en additionnant les résultats.",
+        correction: `Le produit scalaire de $${u.toTex()}$ et $${v.toTex()}$ est calculé comme suit : $(${u.x.toTex()} \\times ${v.x.toTex()}) + (${u.y.toTex()} \\times ${v.y.toTex()}) = ${answer}$.`,
     };
     return question;
 };

package/lib/exercises/math/percent/index.d.ts

@@ -6,4 +6,5 @@ export * from "./reciprocalPercentage";
 export * from "./percentToDecimal";
 export * from "./valuePercent";
 export * from "./findProportion";
+export * from "./isTableProportional";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/percent/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iBAAiB,CAAC;AAChC,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC"}

package/lib/exercises/math/percent/index.js

@@ -22,3 +22,4 @@ __exportStar(require("./reciprocalPercentage"), exports);
 __exportStar(require("./percentToDecimal"), exports);
 __exportStar(require("./valuePercent"), exports);
 __exportStar(require("./findProportion"), exports);
+__exportStar(require("./isTableProportional"), exports);

package/lib/exercises/math/percent/isTableProportional.d.ts

@@ -0,0 +1,5 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {};
+export declare const isTableProportional: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isTableProportional.d.ts.map

package/lib/exercises/math/percent/isTableProportional.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isTableProportional.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/isTableProportional.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG,EAAE,CAAC;AAkEtB,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAerD,CAAC"}

package/lib/exercises/math/percent/isTableProportional.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTableProportional = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const getIsTableProportionalQuestion = () => {
+    const table = generateTable();
+    const question = {
+        answer: table.coeff ? "Oui" : "Non",
+        instruction: `On considere le tableau ci-dessous, est-il proportionnel ?${table.table}`,
+        keys: [],
+        answerFormat: "raw",
+        style: { tableHasNoHeader: true },
+        identifiers: {},
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "On peut pas savoir", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const generateTable = () => {
+    const xValues = [(0, randint_1.randint)(1, 11)];
+    while (xValues.length < 3) {
+        let lastNb = xValues[xValues.length - 1];
+        let random = (0, randint_1.randint)(lastNb, lastNb + 11, [...xValues]);
+        xValues.push(random);
+    }
+    const yValues = generateYValues(xValues);
+    return {
+        table: ` 
+  |${xValues.map((value) => `$${value}$`).join("|")}|
+  |-|-|-|
+  |${yValues.values.map((value) => `$${value}$`).join("|")}|
+    `,
+        coeff: yValues.coeff,
+    };
+};
+const generateYValues = (xValues) => {
+    const flip = (0, coinFlip_1.coinFlip)();
+    const coeff = (0, randint_1.randint)(1, 5);
+    return flip
+        ? {
+            values: xValues.map((value) => value * (0, randint_1.randint)(2, 5)),
+        }
+        : {
+            values: xValues.map((value) => value * coeff),
+            coeff,
+        };
+};
+exports.isTableProportional = {
+    id: "isVTableProportional",
+    label: "Reconnaître si 2 grandeurs sont proportionnelles à partir d'un tableau.",
+    levels: ["5ème"],
+    isSingleStep: true,
+    sections: ["Proportionnalité"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getIsTableProportionalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    answerType: "QCM",
+    subject: "Mathématiques",
+};

package/lib/exercises/math/python/pyWhileLoop1Exercise.js

@@ -89,7 +89,7 @@ const generateType16Instruction = (a, b, op) => {
 const generateType17Instruction = (a, b, op) => {
     const instruction = `Qu’affichera le programme suivant, si l'utilisateur entre ${a} ?
   \`\`\`
-  a=input("Entrez un entiel naturel non nul.")
+  a=input("Entrez un entier naturel non nul.")
   a=int(a)
   n=1
   while n<=a:

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AA4FF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AAiNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/trigonometry/trigonometrySideCalcul.js

@@ -54,6 +54,8 @@ const getTrigonometrySideCalcul = () => {
     const question = {
         instruction: `Le triangle $${triangle.getTriangleName()}$ rectangle en $${triangle.getRightAngle()}$ est tel que $${sides[randSide]} = ${(sideLengths[randSide] + "").replace(".", ",")}$ cm et $\\widehat{${angle[randAngle]}} = ${(angleValue[randAngle] + "").replace(".", ",")}^\\circ$. Calculer $${sides[randSideQuestion]}$ à $0,1$ cm près.`,
         answer,
+        hint: getHint(sides, angle[randAngle]),
+        correction: getCorrection(sides, sideLengths, randSideQuestion, randSide, angle[randAngle], angleValue[randAngle], answer),
         keys: [],
         commands: ggb.commands,
         options: ggb.getOptions(),
@@ -71,6 +73,74 @@ const getPropositions = (n, { answer }) => {
     }
     return (0, shuffle_1.shuffle)(propositions);
 };
+const getHint = (sides, angle) => {
+    const hypothenus = sides[2];
+    const adjacent = sides.filter((value) => value !== hypothenus &&
+        [value.charAt(0), value.charAt(1)].includes(angle))[0];
+    const opposite = sides.filter((value) => value !== hypothenus && value !== adjacent[0])[0];
+    return `Identifier le côté opposé, le côté adjacent et l'hypoténuse, puis utiliesr la bonne formule de trigonométrie.`;
+};
+const getCorrection = (sides, sideLengths, randSideQuestion, randSide, angle, angleValue, answer) => {
+    const hypothenus = { name: sides[2], length: sideLengths[2] };
+    const sidesWithLentgh = sides.map((value, index) => {
+        return { name: value, length: sideLengths[index] };
+    });
+    const adjacent = sidesWithLentgh.filter((value) => value.name !== hypothenus.name &&
+        [value.name.charAt(0), value.name.charAt(1)].includes(angle))[0];
+    const opposite = sidesWithLentgh.filter((value) => value.name !== hypothenus.name && value.name !== adjacent.name)[0];
+    const correctEquations = getCorrectEquations({ name: sides[randSideQuestion], length: sideLengths[randSideQuestion] }, { name: sides[randSide], length: sideLengths[randSide] }, hypothenus, { name: angle, value: angleValue }, adjacent, opposite, answer);
+    return `On utilise la relation $${correctEquations[0]}$, on a donc :
+    $${correctEquations[1]} \\Leftrightarrow ${correctEquations[2]} \\Leftrightarrow ${correctEquations[3]}$ `;
+};
+const getCorrectEquations = (randSideQuestion, randSide, hypothenus, angle, adjacent, opposite, answer) => {
+    let result;
+    switch (randSideQuestion.name) {
+        case adjacent.name:
+            result =
+                randSide.name === opposite.name
+                    ? [
+                        `\\tan(\\widehat{${angle.name}})=\\frac{${opposite.name}}{${adjacent.name}}`,
+                        `\\tan(\\widehat{${angle.value}})=\\frac{${opposite.length}}{${adjacent.name}}`,
+                        `\\frac{${opposite.length}}{\\tan(\\widehat{${angle.value}})}=${adjacent.name}`,
+                    ]
+                    : [
+                        `\\cos(\\widehat{${angle.name}})=\\frac{${adjacent.name}}{${hypothenus.name}}`,
+                        `\\cos(\\widehat{${angle.value}})=\\frac{${adjacent.name}}{${hypothenus.length}}`,
+                        `\\cos(\\widehat{${angle.value}})*${hypothenus.length}=${adjacent.name}`,
+                    ];
+            return result.concat(`${answer}=${adjacent.name}`);
+        case opposite.name:
+            result =
+                randSide.name === adjacent.name
+                    ? [
+                        `\\tan(\\widehat{${angle.name}})=\\frac{${opposite.name}}{${adjacent.name}}`,
+                        `\\tan(\\widehat{${angle.value}})=\\frac{${opposite.name}}{${adjacent.length}}`,
+                        `\\tan(\\widehat{${angle.value}})*${adjacent.length}=${opposite.name}`,
+                    ]
+                    : [
+                        `\\sin(\\widehat{${angle.name}})=\\frac{${opposite.name}}{${hypothenus.name}}`,
+                        `\\sin(\\widehat{${angle.value}})=\\frac{${opposite.name}}{${hypothenus.length}}`,
+                        `\\sin(\\widehat{${angle.value}})*${hypothenus.length}=${opposite.name}`,
+                    ];
+            return result.concat(`${answer}=${opposite.name}`);
+        case hypothenus.name:
+            result =
+                randSide.name === adjacent.name
+                    ? [
+                        `\\cos(\\widehat{${angle.name}})=\\frac{${adjacent.name}}{${hypothenus.name}}`,
+                        `\\cos(\\widehat{${angle.value}})=\\frac{${adjacent.length}}{${hypothenus.name}}`,
+                        `\\frac{${adjacent.length}}{\\cos(${angle.value})}=${hypothenus.name}`,
+                    ]
+                    : [
+                        `\\sin(\\widehat{${angle.name}})=\\frac{${opposite.name}}{${hypothenus.name}}`,
+                        `\\sin(\\widehat{${angle.value}})=\\frac{${opposite.length}}{${hypothenus.name}}`,
+                        `\\frac{${opposite.length}}{\\sin(${angle.value})}=${hypothenus.name}`,
+                    ];
+            return result.concat(`${answer}=${hypothenus.name}`);
+        default:
+            return [];
+    }
+};
 const isAnswerValid = (ans, { answer }) => {
     const answerTree = new numberNode_1.NumberNode(Number(answer.replace(",", ".")));
     const texs = answerTree.toAllValidTexs();

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

@@ -1 +1 @@
-{"version":3,"file":"findAtomicStructureElement.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/findAtomicStructureElement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAKtE,KAAK,sBAAsB,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAQhE,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,WAAW,CAAC;IACxB,aAAa,EAAE,sBAAsB,CAAC;CACvC,CAAC;AAiEF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}
+{"version":3,"file":"findAtomicStructureElement.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalElements/findAtomicStructureElement.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAIlC,OAAO,EAAE,WAAW,EAAE,MAAM,yCAAyC,CAAC;AAKtE,KAAK,sBAAsB,GAAG,QAAQ,GAAG,SAAS,GAAG,UAAU,CAAC;AAQhE,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,WAAW,CAAC;IACxB,aAAa,EAAE,sBAAsB,CAAC;CACvC,CAAC;AAoFF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}

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

@@ -27,6 +27,8 @@ const getFindAtomicStructureElementQuestion = () => {
     const question = {
         answer: `${answer}`,
         instruction,
+        hint: getHint(elementToFind),
+        correction: getCorrection(elementToFind, protonsNumber, neutronsNumber),
         keys: [],
         answerFormat: "tex",
         identifiers: { atomSymbol: atom.symbole, elementToFind },
@@ -53,6 +55,16 @@ const getPropositions = (n, { answer, atomSymbol, elementToFind }) => {
 const isAnswerValid = (ans, { answer }) => {
     return ans === answer;
 };
+const getHint = (elementToFind) => {
+    return elementToFind === "proton"
+        ? `Pour déterminer le nombre de protons d'un atome, vous pouvez utiliser l'écriture conventionnelle du noyau atomique.`
+        : `On rapelle que : Nombre de neutrons $= A - Z$.`;
+};
+const getCorrection = (elementToFind, protonNb, neutronNb) => {
+    return elementToFind === "proton"
+        ? `Le nombre de proton est égal à : $${protonNb}$`
+        : `Le nombre de neutron est égal à : $A - Z=${neutronNb}$`;
+};
 exports.findAtomicStructureElement = {
     id: "findAtomicStructureElement",
     label: "Trouver le nombre de protons, neutrons ou électrons d'un atome",

package/lib/exercises/pc/chemicalReactions/calculateSynthesisEfficiency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateSynthesisEfficiency.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/calculateSynthesisEfficiency.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAqDF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}
+{"version":3,"file":"calculateSynthesisEfficiency.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/chemicalReactions/calculateSynthesisEfficiency.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AA6EF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}

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

@@ -9,11 +9,18 @@ const getCalculateSynthesisEfficiencyQuestion = () => {
     const maxQuantity = (0, randfloat_1.randfloat)(0.2, 0.6, 2);
     const productQuantity = (0, randfloat_1.randfloat)(maxQuantity / 2, maxQuantity * 0.9, 2);
     const efficiency = (0, round_1.round)(productQuantity / maxQuantity, 2);
+    const instruction = `Lors d'une synthèse chimique, $${(0, round_1.roundSignificant)(maxQuantity, 2)}\\ \\text{mol}$ de produit est attendu au maximum, et il se forme au final $${(0, round_1.roundSignificant)(productQuantity, 2)}\\ \\text{mol}$ de produit.
+  Calculer le rendement.`;
+    const hint = "Le rendement est calculé en utilisant la formule : $R = \\frac{n_{produit}}{n_{max}}$, où $n_{produit}$ est la quantité de produit obtenue et $n_{max}$ est la quantité maximale attendue.";
+    const correction = `Pour calculer le rendement :
+  \n1. La quantité maximale de produit attendue est $${(0, round_1.roundSignificant)(maxQuantity, 2)}\\ \\text{mol}$.
+  \n2. La quantité de produit effectivement obtenue est $${(0, round_1.roundSignificant)(productQuantity, 2)}\\ \\text{mol}$.
+  \n3. Le rendement est donné par $R = \\frac{n_{produit}}{n_{max}} = \\frac{${(0, round_1.roundSignificant)(productQuantity, 2)}}{${(0, round_1.roundSignificant)(maxQuantity, 2)}} = ${(0, round_1.roundSignificant)(efficiency, 2)}$.`;
     const question = {
         answer: `${(0, round_1.roundSignificant)(efficiency, 2)}`,
-        instruction: `Lors d'une synthèse chimique, $${(0, round_1.roundSignificant)(maxQuantity, 2)}\\ \\text{mol}$ de produit est attendu au maximum, et il se forme au final $${(0, round_1.roundSignificant)(productQuantity, 2)}\\ \\text{mol}$ de produit.
-    Calculer le rendement.
-    `,
+        instruction,
+        hint,
+        correction,
         keys: [],
         answerFormat: "tex",
         identifiers: { maxQuantity, productQuantity },
@@ -25,10 +32,10 @@ const getPropositions = (n, { answer, maxQuantity, productQuantity }) => {
     (0, exercise_1.addValidProp)(propositions, answer);
     const wrongDivision = maxQuantity / productQuantity;
     const multiplied = maxQuantity * productQuantity;
-    const substracted = maxQuantity - productQuantity;
+    const subtracted = maxQuantity - productQuantity;
     (0, exercise_1.tryToAddWrongProp)(propositions, `${(0, round_1.roundSignificant)(wrongDivision, 2)}`);
     (0, exercise_1.tryToAddWrongProp)(propositions, `${(0, round_1.roundSignificant)(multiplied, 2)}`);
-    (0, exercise_1.tryToAddWrongProp)(propositions, `${(0, round_1.roundSignificant)(substracted, 2)}`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${(0, round_1.roundSignificant)(subtracted, 2)}`);
     while (propositions.length < n) {
         (0, exercise_1.tryToAddWrongProp)(propositions, `${(0, round_1.roundSignificant)((0, randfloat_1.randfloat)(0, 5), 2)}`);
     }

package/lib/exercises/pc/forces/forceWork.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"forceWork.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/forceWork.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAoDF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAa3C,CAAC"}
+{"version":3,"file":"forceWork.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/forces/forceWork.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAoDF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAa3C,CAAC"}

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,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAwCF,eAAO,MAAM,EAAE,EAAE,QAAQ,CAAC,WAAW,CAapC,CAAC"}
+{"version":3,"file":"pH.d.ts","sourceRoot":"","sources":["../../../src/exercises/pc/pH.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAkDF,eAAO,MAAM,EAAE,EAAE,QAAQ,CAAC,WAAW,CAapC,CAAC"}

package/lib/exercises/pc/pH.js

@@ -13,10 +13,17 @@ const getpH = () => {
     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 = (0, frenchify_1.frenchify)((0, round_1.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^+]$ :
+  \n1. La concentration en ions hydrogène est $${randomNumber} \\times 10^{-${randomTenPower}}$ mol/L.
+  \n2. En appliquant la formule, on obtient $\\text{pH} = -\\log(${randomNumber} \\times 10^{-${randomTenPower}})$.
+  \n3. Le résultat est $${answer}$.`;
     const question = {
         instruction,
         startStatement: `pH`,
         answer,
+        hint,
+        correction,
         keys: ["log"],
         answerFormat: "tex",
         identifiers: { randomNumber, randomTenPower },

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,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4EF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}
+{"version":3,"file":"periodicWaveCelerity.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/waves/periodicWaveCelerity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,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,CActD,CAAC"}

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

@@ -6,13 +6,15 @@ const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQues
 const randfloat_1 = require("../../../math/utils/random/randfloat");
 const round_1 = require("../../../math/utils/round");
 const random_1 = require("../../../utils/random");
-// v = lambda / t
+// v = lambda / T
 const getPeriodicWaveCelerityQuestion = () => {
     const varAsked = (0, random_1.random)(["v", "T", "l"]);
     let v;
     let T;
     let l;
     let instruction = "";
+    let hint = "";
+    let correction = "";
     let answer = "";
     switch (varAsked) {
         case "v":
@@ -20,6 +22,8 @@ const getPeriodicWaveCelerityQuestion = () => {
             l = (0, randfloat_1.randfloat)(1, 10, 1);
             v = (0, round_1.round)(l / T, 1);
             instruction = `Une onde périodique a une longueur d'onde de $${(0, round_1.roundSignificant)(l, 1)}\\ \\text{m}$ et une période de $${(0, round_1.roundSignificant)(T, 1)}\\ \\text{s}$. Quelle est sa célérité ?`;
+            hint = "Utilisez la formule de la célérité: $v = \\frac{\\lambda}{T}$";
+            correction = `La célérité est donnée par $v = \\frac{\\lambda}{T} = \\frac{${(0, round_1.roundSignificant)(l, 1)}}{${(0, round_1.roundSignificant)(T, 1)}} = ${(0, round_1.roundSignificant)(v, 1)}$.`;
             answer = (0, round_1.roundSignificant)(v, 1);
             break;
         case "T":
@@ -27,6 +31,8 @@ const getPeriodicWaveCelerityQuestion = () => {
             v = (0, randfloat_1.randfloat)(1, 10, 1);
             T = (0, round_1.round)(l / v, 1);
             instruction = `Une onde périodique a une longueur d'onde de $${(0, round_1.roundSignificant)(l, 1)}\\ \\text{m}$ et une célérité de $${(0, round_1.roundSignificant)(v, 1)}\\ \\text{m}\\cdot\\text{s}^{-1}$. Quelle est sa période ?`;
+            hint = "Utilisez la formule de la période: $T = \\frac{\\lambda}{v}$";
+            correction = `La période est donnée par $T = \\frac{\\lambda}{v} = \\frac{${(0, round_1.roundSignificant)(l, 1)}}{${(0, round_1.roundSignificant)(v, 1)}} = ${(0, round_1.roundSignificant)(T, 1)}$.`;
             answer = (0, round_1.roundSignificant)(T, 1);
             break;
         case "l":
@@ -35,12 +41,17 @@ const getPeriodicWaveCelerityQuestion = () => {
             T = (0, randfloat_1.randfloat)(1, 10, 1);
             l = (0, round_1.round)(v * T, 1);
             instruction = `Une onde périodique a une période de $${(0, round_1.roundSignificant)(T, 1)}\\ \\text{m}$ et une célérité de $${(0, round_1.roundSignificant)(v, 1)}\\ \\text{m}\\cdot\\text{s}^{-1}$. Quelle est sa longueur d'onde ?`;
-            answer = (0, round_1.roundSignificant)(T, 1);
+            hint =
+                "Utilisez la formule de la longueur d'onde: $\\lambda = v \\times T$";
+            correction = `La longueur d'onde est donnée par $\\lambda = v \\times T = ${(0, round_1.roundSignificant)(v, 1)} \\times ${(0, round_1.roundSignificant)(T, 1)} = ${(0, round_1.roundSignificant)(l, 1)}$.`;
+            answer = (0, round_1.roundSignificant)(l, 1);
             break;
     }
     const question = {
         answer,
         instruction,
+        hint,
+        correction,
         keys: [],
         answerFormat: "tex",
         identifiers: { v, T, l },

package/lib/exercises/pc/weight/weightOnTheMoon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"weightOnTheMoon.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/weightOnTheMoon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA+DF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}
+{"version":3,"file":"weightOnTheMoon.d.ts","sourceRoot":"","sources":["../../../../src/exercises/pc/weight/weightOnTheMoon.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA+FF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/pc/weight/weightOnTheMoon.js

@@ -26,6 +26,9 @@ const getWeightOnTheMoonQuestion = () => {
     
 Données : $g_T = ${gt.toTex()}\\ ${gravity_1.earthGravity.unit}$ , $g_L = ${gl.toTex()}\\ ${gravity_1.moonGravity.unit}$
     `,
+        //hint: ` Pour calculer la masse de l'objet sur Terre, utiliser la formule : $m=\\frac{p_T}{g_T}$`,
+        hint: "On rappelle que : $m=\\frac{p_T}{g_T}$ et  $m=\\frac{p_L}{g_L}$",
+        correction: getCorrection(origin, weight, answer, gt, gl),
         keys: ["N"],
         answerFormat: "tex",
         identifiers: { weight, originIsMoon },
@@ -45,6 +48,20 @@ const getPropositions = (n, { answer, originIsMoon, weight }) => {
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
+const getCorrection = (origin, weight, answer, gt, gl) => {
+    switch (origin) {
+        case "Terre":
+            return `1 . Trouver la masse de l'objet en utilisant son poids sur Terre $p_T$ et l'accélération due à la gravité terrestre $g_T$ : \n $m = \\frac{p_T}{g_T} \\Leftrightarrow m=${(0, round_1.round)(weight / gt.evaluate(), 1)}$. \n \\
+      2 . Utiliser la masse trouvée et l'accélération due à la gravité sur la Lune $g_L$ pour calculer le poids sur la Lune $p_L$ : $p_L = m \\ \\cdot g_L \\Leftrightarrow$ $p_L = ${(0, frenchify_1.frenchify)(answer)}$.`;
+        case "Lune":
+            return `1 . Trouver la masse de l'objet en utilisant son poids sur la Lune $p_L$ et l'accélération due à la gravité luanire $g_L$ : 
+      $m = \\frac{p_L}{g_L} \\Leftrightarrow m=${(0, round_1.round)(weight / gl.evaluate(), 1)}$. \n \\
+      2 . Utiliser la masse trouvée et l'accélération due à la gravité sur la Terre $g_T$ pour calculer le poids sur la Terre $p_T$ : 
+      $p_T = m \\ \\cdot g_T \\Leftrightarrow p_T = ${(0, frenchify_1.frenchify)(answer)}$.`;
+        default:
+            return "";
+    }
+};
 const isAnswerValid = (ans, { answer }) => {
     return [answer, answer.replace("N", "")].includes(ans);
 };

package/lib/index.d.ts

@@ -121,6 +121,9 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
     x2: string | number;
     x3: string | number;
     x4: string | number;
+}> | import("./exercises/exercise").Exercise<{
+    xValues: number[];
+    yValues: number[];
 }> | import("./exercises/exercise").Exercise<{
     precisionAsked: number;
     decimal: number;
@@ -955,7 +958,7 @@ declare const mathExercises: (import("./exercises/exercise").Exercise<{
 }> | import("./exercises/exercise").Exercise<{
     total: number;
     lefties: number;
-}> | import("./exercises/exercise").Exercise<{
+}> | import("./exercises/exercise").Exercise<{}> | import("./exercises/exercise").Exercise<{
     int: number;
     power: number;
 }> | import("./exercises/exercise").Exercise<{

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAUA,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAG3D,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;QAC5B,SAAS,EAAE,MAAM,MAAM,CAAC;QACxB,YAAY,EAAE,CAAC,QAAQ,CAAC,EAAE,MAAM,KAAK,aAAa,CAAC;KACpD;CACF;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA+BE;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAjCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAEgD,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,CAAC"}

package/lib/math/polynomials/trinom.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trinom.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/trinom.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"trinom.d.ts","sourceRoot":"","sources":["../../../src/math/polynomials/trinom.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "math-exercises",
-  "version": "2.1.16",
+  "version": "2.1.17",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [