math-exercises 3.0.126 → 3.0.127

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

@@ -11,6 +11,8 @@ import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { random, randomMany } from "../../../../utils/alea/random.js";
 import { isOperatorNode, OperatorIds, } from "../../../../tree/nodes/operators/operatorNode.js";
 import { parseLatex } from "../../../../tree/parsers/latexParser.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
 class ProblemConstructor {
     static byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays) {
         const shuffleFuncs = shuffleArrays.map((shuffleArray) => {
@@ -70,6 +72,16 @@ class Problem {
                 .filter((node) => !!node);
         });
     }
+    getExplanationString() {
+        const arrArr = Object.values(this.groups).map((group) => [
+            `\\text{${group.getScalarString(this.mysteryVar).replaceAll("$", "")}}`,
+            `:`,
+            `${group
+                .getNode(this.mysteryVar, this.groups, this.shuffleFuncs)
+                .toTex()}`,
+        ]);
+        return alignTex(arrArr, false);
+    }
 }
 class ProblemVarGroup {
     skeleton;
@@ -84,6 +96,9 @@ class ProblemVarGroup {
     getNode(mysteryVar, groups, shuffleFuncs) {
         return this.skeleton.nodeFunc(this, mysteryVar, groups, shuffleFuncs);
     }
+    getScalarString(mysteryVar) {
+        return `${this.skeleton.strToScalar} ${this.toTex(mysteryVar)}`;
+    }
 }
 class ProblemVar {
     skeleton;
@@ -101,12 +116,14 @@ class ProblemVar {
 }
 class ProblemVarSkeletonGroup {
     vars;
+    strToScalar;
     strFunc;
     nodeFunc;
     isCanBeMysteryGroup;
     isComputed;
-    constructor(vars, strFunc, nodeFunc, isCanBeMysteryGroup, isComputed) {
+    constructor(vars, strToScalar, strFunc, nodeFunc, isCanBeMysteryGroup, isComputed) {
         this.vars = vars;
+        this.strToScalar = strToScalar;
         this.strFunc = strFunc;
         this.nodeFunc = nodeFunc;
         this.isCanBeMysteryGroup = isCanBeMysteryGroup;
@@ -154,14 +171,11 @@ const skeletons = [
 Elle a pris trois pâtes à pizza à 1,95 € l’unité et deux pots de sauce tomate. 
 Elle a payé au total 8,37 €. 
 Quel est le prix, noté a, d'un pot de sauce ?`, (_group, mysteryVar, groups, shuffleFuncs) => {
-        const { pizza, sauce, total } = groups;
-        const [gp1, gp2] = shuffleFuncs[0]([pizza, sauce]);
-        return `Clara a acheté des ingrédients pour réaliser des pizzas. 
-Elle a pris ${gp1.toTex(mysteryVar)} et, dans un autre rayon, ${gp2.toTex(mysteryVar)}. 
-Elle a payé au total $${total
+        const { total, ...groupsWithoutTotal } = groups;
+        const [gp1, gp2] = shuffleFuncs[0](Object.values(groupsWithoutTotal));
+        return `Clara a acheté des ingrédients pour réaliser des pizzas. Elle a pris ${gp1.toTex(mysteryVar)} et, dans un autre rayon, ${gp2.toTex(mysteryVar)}. Elle a payé au total $${total
             .getNode(mysteryVar, groups, shuffleFuncs)
-            .toTex()}$ €. 
-${mysteryVar.skeleton.question}`;
+            .toTex()}$ €. ${mysteryVar.skeleton.question}`;
     }, (_group, mysteryVar, groups, shuffleFuncs) => {
         const { pizza, sauce } = groups;
         const [gp1, gp2] = shuffleFuncs[0]([pizza, sauce]);
@@ -184,7 +198,7 @@ ${mysteryVar.skeleton.question}`;
                     return randfloat(0.5, 4, 2, []).toTree();
                 },
             },
-        }, (group, mysteryVar) => {
+        }, "le coût pour", (group, mysteryVar) => {
             switch (mysteryVar?.skeleton.varName) {
                 case "n":
                     return `des pâtes à pizza à $${group.vars.price.value.toTex()}$ € l’unité`;
@@ -223,7 +237,7 @@ ${mysteryVar.skeleton.question}`;
                     return randfloat(0.5, 4, 2, []).toTree();
                 },
             },
-        }, (group, mysteryVar) => {
+        }, "le coût pour", (group, mysteryVar) => {
             switch (mysteryVar?.skeleton.varName) {
                 case "m":
                     return `des boîtes de sauce tomate à $${group.vars.price.value.toTex()}$ € l’unité`;
@@ -251,11 +265,11 @@ ${mysteryVar.skeleton.question}`;
                 str: "le coût total",
                 question: `Quel est le coût total, noté $t$, de ses achats ?`,
             },
-        }, () => {
-            return "le coût total";
+        }, "le", () => {
+            return "coût total";
         }, (_group, _mysteryVar, groups, shuffleFuncs) => {
-            const { pizza, sauce } = groups;
-            const orderedNodes = shuffleFuncs[0]([pizza, sauce]).map((group) => group.getNode());
+            const { total, ...groupsWithoutTotal } = groups;
+            const orderedNodes = shuffleFuncs[0](Object.values(groupsWithoutTotal)).map((group) => group.getNode());
             // console.log(
             //   "orderedNodes[0].leftChild",
             //   (orderedNodes[0] as MultiplyNode).leftChild,
@@ -278,11 +292,34 @@ const getInstruction = (identifiers) => {
     const { problemSkeletonIndex, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays, } = identifiers;
     const skeleton = skeletons[problemSkeletonIndex];
     const problem = ProblemConstructor.byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
-    return `Traduire par une équation le problème suivant : 
-${problem.frenchStr}`;
+    return `${mdTable([[""], [problem.frenchStr]])}
+  
+Parmi les équations suivantes, laquelle modélise cette situation ?`;
+};
+const getHint = (identifiers) => {
+    const { problemSkeletonIndex, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays, } = identifiers;
+    const skeleton = skeletons[problemSkeletonIndex];
+    const problem = ProblemConstructor.byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
+    return `${Object.values(problem.groups).map((group) => `Quel est ${group.getScalarString(problem.mysteryVar)} ?`).join(`
+    
+`)}`;
+};
+const getCorrection = (identifiers) => {
+    const { problemSkeletonIndex, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays, } = identifiers;
+    const skeleton = skeletons[problemSkeletonIndex];
+    const problem = ProblemConstructor.byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
+    return `On peut former les expressions suivantes: 
+${problem.getExplanationString()}
+
+L'équation qui modélise la situation est donc: 
+
+$$
+${getAnswer(identifiers)}
+$$
+
+`;
 };
 const getAnswerNode = (identifiers) => {
-    console.log("getAnswerNode", identifiers);
     const { problemSkeletonIndex, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays, } = identifiers;
     const skeleton = skeletons[problemSkeletonIndex];
     const problem = ProblemConstructor.byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
@@ -333,6 +370,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
@@ -411,4 +450,5 @@ export const equationFromProblem = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     answerType: "QCU",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/calculLitteral/isolate/isolateUInInvXPlusInvYEqualsInvU.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isolateUInInvXPlusInvYEqualsInvU.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/isolate/isolateUInInvXPlusInvYEqualsInvU.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA2FF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAmBlE,CAAC;AAUF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAoBpE,CAAC"}
+{"version":3,"file":"isolateUInInvXPlusInvYEqualsInvU.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/isolate/isolateUInInvXPlusInvYEqualsInvU.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAqEF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAmBlE,CAAC;AAUF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAoBpE,CAAC"}

package/lib/exercises/math/calculLitteral/isolate/isolateUInInvXPlusInvYEqualsInvU.js

@@ -1,6 +1,7 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randomMany } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const { varNames } = identifiers;
     const [x, y, u] = varNames;
@@ -20,33 +21,11 @@ const getHint = (identifiers) => {
 const getCorrection = (identifiers) => {
     const { varNames } = identifiers;
     const [x, y, u] = varNames;
-    return `L'inverse de  $\\frac{1}{${u}}$ est $${u}$. 
-  
-L'inverse de $\\frac{1}{${x}}+\\frac{1}{${y}}$ est $\\frac{1}{\\frac{1}{${x}}+\\frac{1}{${y}}}$. 
-
-Il faut donc mettre ces deux fractions au même dénominateur. 
-
-On obtient :  
-
-$$
-\\frac{1}{\\frac{1}{${x}}+\\frac{1}{${y}}}
-$$
-
-$$
-= \\frac{1}{\\frac{${x}+${y}}{${x}${y}}}
-$$
-
-$$
-= \\frac{${x}${y}}{${x}+${y}}
-$$
-
-Conclusion :
-
-$$
-\\frac{1}{${u}} = \\frac{${x}${y}}{${x}+${y}}
-$$
-
-`;
+    return alignTex([
+        [`${u}`, "=", `\\frac{1}{\\frac{1}{${x}}+\\frac{1}{${y}}}`],
+        [``, "=", `\\frac{1}{\\frac{${x}+${y}}{${x}${y}}}`],
+        [``, "=", `\\frac{${x}${y}}{${x}+${y}}`],
+    ]);
 };
 const getPropositions = (nbProps, { answer, ...identifiers }) => {
     const { varNames } = identifiers;

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareAMinusB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareAMinusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAkMF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAgBhD,CAAC"}
+{"version":3,"file":"compareAMinusB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareAMinusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA+LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAgBhD,CAAC"}

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.js

@@ -12,9 +12,8 @@ $$
 
 alors on peut dire que :`;
 };
-const getHint = (identifiers) => {
-    const { names } = identifiers;
-    return `Il s'agit de comparer  $${names[0]}$ et $${names[1]}$.`;
+const getHint = () => {
+    return `Essaye d’isoler chaque variable de chaque côté de l’inégalité.`;
 };
 const getCorrection = (identifiers) => {
     const { names, texInstruction, texsCorrection } = identifiers;
@@ -67,7 +66,7 @@ const isAnswerValid = (ans, { texsAnswer }) => {
 };
 const getCompareAMinusBQuestion = () => {
     const namesPool = ["a", "b", "c", "d", "r", "s", "t", "u", "v"];
-    let names = randomMany(namesPool, 2);
+    const names = randomMany(namesPool, 2);
     const compareSymbol = random(["inf", "sup", "leq", "geq"]);
     let texsObjectArray = [];
     switch (compareSymbol) {
@@ -144,7 +143,6 @@ const getCompareAMinusBQuestion = () => {
     texInstruction = replaceVarNames(texInstruction);
     texsCorrection = texsCorrection.map((tex) => replaceVarNames(tex));
     texsAnswer = texsAnswer.map((tex) => replaceVarNames(tex));
-    names = order.map((i) => names[i]);
     return getQuestionFromIdentifiers({
         names,
         texInstruction,

package/lib/exercises/math/calculLitteral/ordering/compareFromPiMinusFrac.js

@@ -129,7 +129,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 };
 export const compareFromPiMinusFrac = {
     id: "compareFromPiMinusFrac",
-    label: "Comparer deux nombres (Pi et une fraction approximante) par le calcul de leur différence",
+    label: "Comparer deux nombres ($\\pi$ et une fraction approximante) par le calcul de leur différence",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getCompareFromPiMinusFracQuestion(opts), nb, 30),
     qcmTimer: 60,

package/lib/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"writeLitExpFromFrenchExp.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAmCrC,KAAK,QAAQ,GACT,UAAU,GACV,SAAS,GACT,KAAK,GACL,UAAU,GACV,UAAU,GACV,QAAQ,CAAC;AAoEb,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,QAAQ,CAAC;IACvB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACnB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC/B,wBAAwB,EAAE,OAAO,CAAC;CACnC,CAAC;AAyNF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}
+{"version":3,"file":"writeLitExpFromFrenchExp.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAmCrC,KAAK,QAAQ,GACT,UAAU,GACV,SAAS,GACT,KAAK,GACL,UAAU,GACV,UAAU,GACV,QAAQ,CAAC;AAoEb,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,QAAQ,CAAC;IACvB,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACnB,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAAC;IAC/B,wBAAwB,EAAE,OAAO,CAAC;CACnC,CAAC;AAuRF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAmBxD,CAAC"}

package/lib/exercises/math/calculLitteral/writing/writeLitExpFromFrenchExp.js

@@ -40,27 +40,27 @@ class ExpressionConstructor {
             case "opposite":
                 return {
                     node: opposite(a),
-                    str__french: `L'opposé de $ ${a} $`,
+                    strFrench: `L'opposé de $ ${a} $`,
                 };
             case "inverse":
                 return {
                     node: frac(1, a),
-                    str__french: `L'inverse de $ ${a} $`,
+                    strFrench: `L'inverse de $ ${a} $`,
                 };
             case "add":
                 return {
                     node: add(a, b),
-                    str__french: `La somme de $ ${a} $ et de $ ${b} $`,
+                    strFrench: `La somme de $ ${a} $ et de $ ${b} $`,
                 };
             case "subtract":
                 return {
                     node: substract(a, b),
-                    str__french: `La différence entre $ ${a} $ et $ ${b} $`,
+                    strFrench: `La différence entre $ ${a} $ et $ ${b} $`,
                 };
             case "multiply":
                 return {
                     node: multiply(a, b),
-                    str__french: typeof b === "string" && isUsingFrenchFactorNouns
+                    strFrench: typeof b === "string" && isUsingFrenchFactorNouns
                         ? dictTexFactorToFrenchFactor[a.frenchify()]
                             ? `${dictTexFactorToFrenchFactor[a.frenchify()]} de $ ${b} $`
                             : `Le produit de $ ${a} $ par $ ${b} $`
@@ -69,7 +69,7 @@ class ExpressionConstructor {
             case "divide":
                 return {
                     node: frac(a, b),
-                    str__french: typeof a === "string" && isUsingFrenchFactorNouns
+                    strFrench: typeof a === "string" && isUsingFrenchFactorNouns
                         ? dictTexFactorToFrenchFactor[frac(1, b).toTex()]
                             ? `${dictTexFactorToFrenchFactor[frac(1, b).toTex()]} de $ ${a} $`
                             : `Le quotient de $ ${a} $ par $ ${b} $`
@@ -145,7 +145,7 @@ const getAnswer = (identifiers) => {
     return node.toTex();
 };
 const getInstruction = (identifiers) => {
-    const statementString = ExpressionConstructor.fromIdentifiers(identifiers).str__french;
+    const statementString = ExpressionConstructor.fromIdentifiers(identifiers).strFrench;
     return `Écrire l'expression littérale pour : 
 
 ${statementString}
@@ -157,32 +157,77 @@ const getHint = (identifiers) => {
         case "opposite":
             return `La somme d'un nombre et de son opposé donne $0$.`;
         case "inverse":
-            return `L'inverse de $8$ est $0.25$.`;
+            return `L'inverse de $8$ est $0,25$.`;
         case "add":
-            return `La somme de $8457$ et de $6567$ est $${8457 + 6567}$.`;
+            return `La somme de $8$ et de $6$ est $14$.`;
         case "subtract":
-            return `La différence entre $8457$ est $6567$ est $${8457 - 6567}$.`;
-        case "multiply":
-            return `Le produit de $8457$ par $6567$ est $${8457 * 6567}$ .`;
-        case "divide":
-            return `Le quotient de $200$ par $8$ est $25$.`;
+            return `La différence entre $8$ et $6$ est $2$.`;
+        case "multiply": {
+            const statementString = ExpressionConstructor.fromIdentifiers(identifiers).strFrench;
+            if (!statementString.includes("produit")) {
+                const bHint = randint(2, 10, typeof identifiers.b === "number" ? [identifiers.b] : []);
+                const exprHint1 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    b: "" + bHint,
+                }));
+                const exprHint2 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    b: bHint,
+                }));
+                return `${capitalize(exprHint1.strFrench)} est $${exprHint2.node
+                    .simplify()
+                    .toTex()}$.`;
+            }
+            else {
+                return `Le produit de $8$ par $6$ est $48$.`;
+            }
+        }
+        case "divide": {
+            const statementString = ExpressionConstructor.fromIdentifiers(identifiers).strFrench;
+            if (!statementString.includes("quotient")) {
+                const aHint = randint(2, 10, typeof identifiers.a === "number" ? [identifiers.a] : []);
+                const exprHint1 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    a: "" + aHint,
+                }));
+                const exprHint2 = ExpressionConstructor.fromIdentifiers(Object.assign({}, identifiers, {
+                    a: aHint,
+                }));
+                return `${capitalize(exprHint1.strFrench)} est $${exprHint2.node.toTex()}$.`;
+            }
+            else {
+                return `Le quotient de $200$ par $8$ est $25$.`;
+            }
+        }
     }
 };
 const getCorrection = (identifiers) => {
+    const { a, operatorName, b } = identifiers;
     const expression = ExpressionConstructor.fromIdentifiers(identifiers);
-    const statementString = expression.str__french;
-    let outString = `${capitalize(statementString)} est $ ${getAnswer(identifiers)} $.`;
+    const statementString = expression.strFrench;
     //explain rewriting if needed
     const nodeRaw = expression.node;
     const nodeRefined = nodeRaw.simplify();
-    const texRaw = nodeRaw.toTex({
-        allowDoubleMinus: true,
-        forceTimesSign: true,
-        forceParenthesis: true,
-        forceNoSimplification: true,
-        allowMinusAnywhereInFraction: true,
-    });
+    let texRaw;
+    switch (operatorName) {
+        case "add":
+            {
+                const [texA, texB] = [a, b].map((c) => parseAlgebraic("" + c).toTex());
+                const isWrapWithParenthesis = ("" + b).startsWith("-");
+                texRaw = `${texA}+${isWrapWithParenthesis ? `(${texB})` : `${texB}`}`;
+            }
+            break;
+        default:
+            {
+                texRaw = nodeRaw.toTex({
+                    allowDoubleMinus: true,
+                    forceTimesSign: true,
+                    forceParenthesis: true,
+                    forceNoSimplification: true,
+                    allowMinusAnywhereInFraction: true,
+                });
+            }
+            break;
+    }
     const texRefined = nodeRefined.toTex();
+    let outString = `${capitalize(statementString)} est $ ${texRefined} $.`;
     if (texRaw !== texRefined) {
         outString += `
 
@@ -282,4 +327,5 @@ export const writeLitExprFromFrench = {
     getAnswer,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/conversion/kmPerMinToKmPerHourConversion.d.ts

@@ -3,6 +3,9 @@ type Identifiers = {
     distance: number;
     minutes: number;
 };
-export declare const kmPerMinToKmPerHourConversion: Exercise<Identifiers>;
+type Options = {
+    unitTex: string;
+};
+export declare const kmPerMinToKmPerHourConversion: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=kmPerMinToKmPerHourConversion.d.ts.map

package/lib/exercises/math/conversion/kmPerMinToKmPerHourConversion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kmPerMinToKmPerHourConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/kmPerMinToKmPerHourConversion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAkHF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAiB/D,CAAC"}
+{"version":3,"file":"kmPerMinToKmPerHourConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/kmPerMinToKmPerHourConversion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA2IF,KAAK,OAAO,GAAG;IACb,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAgBF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqBxE,CAAC"}

package/lib/exercises/math/conversion/kmPerMinToKmPerHourConversion.js

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { dividersOf } from "../../../math/utils/arithmetic/dividersOf.js";
 import { randint } from "../../../math/utils/random/randint.js";
@@ -7,85 +7,103 @@ import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
 import { random } from "../../../utils/alea/random.js";
-const getInstruction = (identifiers) => {
+const getInstruction = (identifiers, optsIn) => {
     const { distance, minutes } = identifiers;
-    return `Si on parcourt $${distance.frenchify()}$ km en $${minutes.frenchify()}$ min, 
-quelle est la vitesse moyenne en km/h ( $km.h^{-1}$ ) ?`;
+    const opts = optsIn ?? optsDefault;
+    const { unitTex } = opts;
+    return `Si on parcourt $${distance.frenchify()} \\ \\textrm{km}$ en $${minutes.frenchify()} \\ \\textrm{min}$, 
+quelle est la vitesse moyenne en $${unitTex}$ ?`;
 };
-const getAnswer = (identifiers) => {
+const getAnswer = (identifiers, optsIn) => {
     const { distance, minutes } = identifiers;
+    const opts = optsIn ?? optsDefault;
+    const { unitTex } = opts;
     const nodeAnswer = multiply(distance, frac(60, minutes));
-    return `${nodeAnswer.simplify().toTex()}km.h^{-1}`;
+    return `${nodeAnswer.simplify().toTex()} \\ ${unitTex}`;
 };
 const isAnswerValid = (ans, { distance, minutes }) => {
     const nodeAnswer = multiply(distance, frac(60, minutes));
-    const nodeAns = parseAlgebraic(ans.replace("$km.h^{-1}$", "").replace("km/h", ""));
+    const nodeAns = parseAlgebraic(["\\textrm{km/h}", "\\textrm{km}.\\textrm{h}^{-1}"].reduce((acc, x) => acc.replace(x, ""), ans));
     return substract(nodeAns, nodeAnswer).evaluate() === 0;
 };
 const getHint = () => {
     return `Combien de minutes constituent une heure ?`;
 };
-const getCorrection = (identifiers) => {
+const getCorrection = (identifiers, optsIn) => {
     const { distance, minutes } = identifiers;
-    return `En $60$ minutes, on parcourt $${multiply(distance, frac(60, minutes)).toTex()}$ km 
+    const opts = optsIn ?? optsDefault;
+    const { unitTex } = opts;
+    return `En $60$ minutes, on parcourt $${multiply(distance, frac(60, minutes)).toTex()} \\ \\textrm{km}$ 
 donc la vitesse est de $${multiply(distance, frac(60, minutes).simplify()).toTex()} = ${multiply(distance, frac(60, minutes))
         .simplify()
-        .toTex()}$ $km.h^{-1}$`;
+        .toTex()} \\ ${unitTex}$`;
 };
-const getPropositions = (n, { answer, distance, minutes }) => {
+const getPropositions = (n, { answer, distance, minutes }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { unitTex } = opts;
     const propositions = [];
     addValidProp(propositions, answer);
-    tryToAddWrongProp(propositions, `${multiply(60, minutes).simplify().toTex()}km.h^{-1}`);
-    tryToAddWrongProp(propositions, `${frac(distance, minutes).simplify().toTex()}km.h^{-1}`);
-    tryToAddWrongProp(propositions, `${multiply(3.6, frac(distance, minutes)).simplify().toTex()}km.h^{-1}`);
+    tryToAddWrongProp(propositions, `${multiply(60, minutes).simplify().toTex()} \\ ${unitTex}`);
+    tryToAddWrongProp(propositions, `${frac(distance, minutes).simplify().toTex()} \\ ${unitTex}`);
+    tryToAddWrongProp(propositions, `${multiply(3.6, frac(distance, minutes))
+        .simplify()
+        .toTex()} \\ ${unitTex}`);
     return shuffleProps(propositions, n);
 };
-const getKmPerMinToKmPerHourConversionQuestion = () => {
+const getKmPerMinToKmPerHourConversionQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const distance = randint(1, 101);
     const minutes = random(dividersOf(60));
     const identifiers = {
         distance,
         minutes,
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const question = {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
         keys: [
             {
                 id: "custom",
-                label: "{km}.{h}^{-1}",
+                label: opts.unitTex,
                 labelType: "tex",
                 mathfieldInstructions: {
                     method: "write",
-                    content: "{km}.{h}^{-1}",
-                },
-            },
-            {
-                id: "custom",
-                label: "km/h",
-                labelType: "raw",
-                mathfieldInstructions: {
-                    method: "write",
-                    content: "km/h",
+                    content: opts.unitTex,
                 },
             },
         ],
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
     };
     return question;
 };
+const optsDefault = {
+    unitTex: "\\textrm{km/h}",
+};
+const options = [
+    {
+        id: "unitTex",
+        label: "Unité affichée",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["\\textrm{km/h}", "\\textrm{km}.\\textrm{h}^{-1}"],
+        defaultValue: optsDefault.unitTex,
+    },
+];
 export const kmPerMinToKmPerHourConversion = {
     id: "kmPerMinToKmPerHourConversion",
     connector: "=",
-    label: "Effectuer des conversions de vitesse ( $x$ km en $y$ min donne une vitesse $V$ en km/h)",
+    label: "Effectuer des conversions de vitesse ( $x$ km en $y$ min donne une vitesse $V$ en \\textrm{km/h})",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getKmPerMinToKmPerHourConversionQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getKmPerMinToKmPerHourConversionQuestion(opts), nb),
+    options,
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

package/lib/exercises/math/conversion/prefixToNumber.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefixToNumber.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/prefixToNumber.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAiBT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAsLF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA+EF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBzD,CAAC"}
+{"version":3,"file":"prefixToNumber.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/prefixToNumber.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAiBT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAoMF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA+EF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBzD,CAAC"}

package/lib/exercises/math/conversion/prefixToNumber.js

@@ -92,9 +92,12 @@ const getMdTable = (prefixes, indexBold = -1) => {
     function boldify(str) {
         return `**${str}**`;
     }
+    const isBolded = 0 <= indexBold && indexBold < prefixes.length;
     return mdTable([
         ["Préfixe", "Symbole", "Signification", "Puissance"],
-        ...prefixes.map((prefix, i) => [
+        ...prefixes
+            .filter((_, i) => (isBolded ? i === indexBold : true))
+            .map((prefix, i) => [
             prefix.name,
             `$${prefix.symbol}$`,
             prefix.meaning,
@@ -107,7 +110,7 @@ const getInstruction = (identifiers) => {
     const prefix = prefixes[prefixIndex];
     return `Quelle est la valeur du préfixe ${isFromSymbol ? `$${prefix.symbol}$` : prefix.name} ?
   
-Ecris la réponse sous la forme ${isToPow10 ? `d'une puissance de $10$` : `d'un nombre décimal`}.`;
+Ecrire la réponse sous la forme ${isToPow10 ? `d'une puissance de $10$` : `d'un nombre décimal`}.`;
 };
 const getHint = (identifiers) => {
     const { prefixIndexesPool } = identifiers;
@@ -115,7 +118,8 @@ const getHint = (identifiers) => {
     return getMdTable(prefixPool);
 };
 const getCorrection = (identifiers) => {
-    const { prefixIndexesPool, prefixIndex } = identifiers;
+    const { prefixIndexesPool, prefixIndex, isToPow10 } = identifiers;
+    const prefix = prefixes[prefixIndex];
     const prefixPool = prefixIndexesPool.map((i) => prefixes[i]);
     const indexBold = (() => {
         for (let i = 0; i < prefixIndexesPool.length; i++) {
@@ -123,7 +127,13 @@ const getCorrection = (identifiers) => {
                 return i;
         }
     })();
-    return getMdTable(prefixPool, indexBold);
+    return `Voici un tableau récapitulatif :
+  
+${getMdTable(prefixPool, indexBold)}
+  
+${!isToPow10
+        ? `$${prefix.texPow10}$ correspond à l'écriture décimale $${prefix.texValue}$.`
+        : ``}`;
 };
 const getAnswer = (identifiers) => {
     const { prefixIndex, isToPow10 } = identifiers;

package/lib/exercises/math/conversion/secondsToHours.js

@@ -46,7 +46,7 @@ const isAnswerValid = (ans, { isSecondsToHours, nodeIdsSeconds, nodeIdsHours })
 const getHint = (identifiers) => {
     const { isSecondsToHours } = identifiers;
     if (isSecondsToHours) {
-        return `Combien y-a-t-il d'heures dans $7200$ secondes ?`;
+        return `Combien d'heures font $7200$ secondes ?`;
     }
     else {
         return `Combien y-a-t-il de secondes dans une heure ?`;