math-exercises 3.0.146 → 3.0.148

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

@@ -4,6 +4,7 @@ import { RationalConstructor } from "../../../../math/numbers/rationals/rational
 import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { random } from "../../../../utils/alea/random.js";
@@ -43,8 +44,26 @@ ${mdTable([xTexs.map((v) => dollarize(v)), yTexs.map((v) => dollarize(v))])}
 Quel est le coefficient de proportionnalité ?
   `;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = () => {
+    return `Il y a $2$ lignes. 
+Le coefficient de proportionnalité est le facteur par lequel multiplier les valeurs de la ligne du haut pour obtenir les valeurs de la ligne du bas.`;
+};
+const getCorrection = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const nodeXs = xValues.map((x) => NodeConstructor.fromIdentifiers(x));
+    const nodeYs = yValues.map((y) => NodeConstructor.fromIdentifiers(y));
+    const nodeFrac = frac(nodeYs[0], nodeXs[0]);
+    return `On prend un couple de valeurs "(haut,bas)".
+On prend le couple : $(${nodeXs[0].toTex()};${nodeYs[0].toTex()})$.
+
+On calcule : 
+
+$$
+${nodeFrac.toTex()} = ${nodeFrac.simplify({ fractionsToDecimal: true }).toTex()}
+$$
+
+Le coefficient de proportionnalité est $${nodeFrac.simplify().toTex()}$.`;
+};
 const getKeys = () => {
     return [];
 };
@@ -101,8 +120,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         style: {
             tableHasNoHeader: true,
         },
@@ -138,9 +157,10 @@ export const findCoeffInProportionalTableNonIntegers = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
-    // getHint,
-    // getCorrection,
     getAnswer,
     options,
     getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"rectangleSideAfterReduction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/rectangleSideAfterReduction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CAGnB,CAAC;AA4PF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAoB7D,CAAC"}
+{"version":3,"file":"rectangleSideAfterReduction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/rectangleSideAfterReduction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CAGnB,CAAC;AAwUF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAqB7D,CAAC"}

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

@@ -1,12 +1,11 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile,
-// GetHint,
-// GetCorrection,
- } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
 import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { D3Node } from "d3-node";
 const getPropositions = (n, { answer, ...identifiers }) => {
@@ -125,8 +124,6 @@ ${d3n.svgString()}
 
 Quelle est la ${sideTypeAsked} (en $\\textrm{cm}$) du ${sideIsOnFirstRect ? "premier" : "deuxième"} rectangle ? Arrondir à $0,1\\ \\textrm{cm}$ si nécessaire.`;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
 const getKeys = () => {
     return [];
 };
@@ -138,12 +135,90 @@ const isAnswerValid = (ans, { answer }) => {
         return handleVEAError(err);
     }
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return ``;
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   return ``;
-// };
+const getHint = (identifiers) => {
+    const { lengths } = identifiers;
+    const [big1, big2] = lengths;
+    const isShrink = big1 !== 0 && big2 !== 0;
+    return `Détermine le coefficient ${isShrink ? "de réduction" : "d'agrandissement"} en considérant un côté sur le grand rectangle et son homologue sur le petit rectangle
+dont les longueurs sont données.`;
+};
+const getCorrection = (identifiers) => {
+    const { lengths } = identifiers;
+    const [big1, big2, small1, small2] = lengths;
+    const isShrink = big1 !== 0 && big2 !== 0;
+    if (isShrink) {
+        if (small1 === 0) {
+            const nodeFrac = frac(small2, big2);
+            const nodeLength = multiply(big1, nodeFrac.simplify());
+            return `Le coefficient de réduction est : 
+    
+$$
+${nodeFrac.toSimplificationTex()}
+$$
+
+La longueur recherchée est donc : 
+
+$$
+${nodeLength.toSimplificationTex({ fractionsToDecimal: true })}
+$$
+    
+    `;
+        }
+        else {
+            const nodeFrac = frac(small1, big1);
+            const nodeLength = multiply(big2, nodeFrac.simplify());
+            return `Le coefficient de réduction est : 
+    
+$$
+${nodeFrac.toSimplificationTex()}
+$$
+
+La longueur recherchée est donc : 
+
+$$
+${nodeLength.toSimplificationTex({ fractionsToDecimal: true })}
+$$
+    
+    `;
+        }
+    }
+    else {
+        if (big1 === 0) {
+            const nodeFrac = frac(big2, small2);
+            const nodeLength = multiply(small1, nodeFrac.simplify());
+            return `Le coefficient d'agrandissement est : 
+    
+$$
+${nodeFrac.toSimplificationTex()}
+$$
+
+La longueur recherchée est donc : 
+
+$$
+${nodeLength.toSimplificationTex({ fractionsToDecimal: true })}
+$$
+    
+    `;
+        }
+        else {
+            const nodeFrac = frac(big1, small1);
+            const nodeLength = multiply(small2, nodeFrac.simplify());
+            return `Le coefficient de réduction est : 
+    
+$$
+${nodeFrac.toSimplificationTex()}
+$$
+
+La longueur recherchée est donc : 
+
+$$
+${nodeLength.toSimplificationTex({ fractionsToDecimal: true })}
+$$
+    
+    `;
+        }
+    }
+};
 const getRectangleSideAfterReductionQuestion = () => {
     const askedSize = randint(0, 4);
     let a;
@@ -189,8 +264,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -206,8 +281,9 @@ export const rectangleSideAfterReduction = {
     isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
-    // getHint,
-    // getCorrection,
     getAnswer,
     getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"solveByFactorizingWithIdRmq3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/solveByFactorizingWithIdRmq3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA0LF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAUF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBvE,CAAC"}
+{"version":3,"file":"solveByFactorizingWithIdRmq3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/solveByFactorizingWithIdRmq3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA2LF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AAUF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAsBvE,CAAC"}

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

@@ -124,6 +124,7 @@ const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
     try {
         if (opts?.useSetAsAnswer) {
             const setParsed = discreteSetParser(ans);
+            //!!!TODO
             console.log(setParsed);
             return false;
         }

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

@@ -1 +1 @@
-{"version":3,"file":"volumeCapacityConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeCapacityConversion.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,QAAQ,EAYT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAuGF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"volumeCapacityConversion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/volumeCapacityConversion.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,0BAA0B,EAAE,MAAM,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAoSF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAgB1D,CAAC"}

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

@@ -1,5 +1,8 @@
 import { Decimal, DecimalConstructor, } from "../../../math/numbers/decimals/decimal.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply, MultiplyNode, } from "../../../tree/nodes/operators/multiplyNode.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
 import { coinFlip } from "../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 import { doWhile } from "../../../utils/doWhile.js";
@@ -7,6 +10,26 @@ import { addValidProp, propWhile, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
 const volumeUnits = ["mm", "cm", "dm", "m", "dam", "hm", "km"];
 const capacityUnits = ["mL", "cL", "dL", "L", "daL", "hL", "kL"];
+const getDecimalFactorForPrefix = (prefix) => {
+    switch (prefix) {
+        case "m":
+            return 0.001;
+        case "c":
+            return 0.01;
+        case "d":
+            return 0.1;
+        case "":
+            return 1;
+        case "da":
+            return 10;
+        case "h":
+            return 100;
+        case "k":
+            return 1000;
+        default:
+            throw new Error("unsupported");
+    }
+};
 const getInstruction = (identifiers) => {
     const { randomValue, randomUnitIndex, randomUnitInstructionIndex, isVolumeToCapacity, } = identifiers;
     let instructionUnit;
@@ -40,6 +63,149 @@ const getAnswer = (identifiers) => {
             .toTex();
     }
 };
+const getHint = (identifiers) => {
+    const { randomUnitIndex, randomUnitInstructionIndex, isVolumeToCapacity } = identifiers;
+    let volumeUnit;
+    let capacityUnit;
+    if (isVolumeToCapacity) {
+        volumeUnit = volumeUnits[randomUnitIndex];
+        capacityUnit = capacityUnits[randomUnitInstructionIndex];
+    }
+    else {
+        capacityUnit = capacityUnits[randomUnitIndex];
+        volumeUnit = volumeUnits[randomUnitInstructionIndex];
+    }
+    const prefixVolume = volumeUnit.slice(0, -1);
+    return `Une manière de procéder, très générale, est de convertir les deux unités proposées en $ {\\textrm{m}}^3 $.
+
+${(() => {
+        if (prefixVolume !== "") {
+            return `Pour ce faire, 
+retiens que l'unité qui figure sous l'exposant $ {}^3 $ donne la longueur du côté du cube de référence utilisé pour mesurer le volume.
+
+$$
+1 {\\textrm{${volumeUnit}}}^3 = {1 \\ \\textrm{${volumeUnit}}} \\times {1 \\ \\textrm{${volumeUnit}}} \\times {1 \\ \\textrm{${volumeUnit}}}
+$$
+
+$$
+1 {\\textrm{${volumeUnit}}}^3 
+= 
+{${getDecimalFactorForPrefix(prefixVolume).frenchify()} \\ \\textrm{m}} 
+\\times
+{${getDecimalFactorForPrefix(prefixVolume).frenchify()} \\ \\textrm{m}} 
+\\times
+{${getDecimalFactorForPrefix(prefixVolume).frenchify()} \\ \\textrm{m}}
+$$`;
+        }
+        else {
+            return "";
+        }
+    })()}
+
+Retiens que dans $1 \\ {\\textrm{m}}^3$, il y $1000 \\ \\textrm{L}$ (comme les "tonnes à eau" dans les jardins).
+Convertis donc les $\\textrm{${capacityUnit}}$ en $\\textrm{L}$ puis les $\\textrm{L}$ en $ {\\textrm{m}}^3 $.
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { randomValue, randomUnitIndex, randomUnitInstructionIndex, isVolumeToCapacity, } = identifiers;
+    let instructionUnit;
+    let answerUnit;
+    let volumeUnit;
+    let capacityUnit;
+    if (isVolumeToCapacity) {
+        volumeUnit = volumeUnits[randomUnitIndex];
+        capacityUnit = capacityUnits[randomUnitInstructionIndex];
+        instructionUnit = volumeUnit;
+        answerUnit = capacityUnit;
+    }
+    else {
+        capacityUnit = capacityUnits[randomUnitIndex];
+        volumeUnit = volumeUnits[randomUnitInstructionIndex];
+        instructionUnit = capacityUnit;
+        answerUnit = volumeUnit;
+    }
+    const prefixVolume = volumeUnit.slice(0, -1);
+    const prefixCapacity = capacityUnit.slice(0, -1);
+    const nodeFactorCapacityUnitToL = getDecimalFactorForPrefix(prefixCapacity).toTree();
+    const nodeFactorCapacityUnitToM3 = multiply(nodeFactorCapacityUnitToL, frac(1, 1000));
+    const nodeFactorLengthUnitToM = getDecimalFactorForPrefix(prefixVolume).toTree();
+    const nodeFactorVolumeUnitToM3 = operatorComposition(MultiplyNode, [...Array(3).keys()].map(() => nodeFactorLengthUnitToM));
+    let nodeFraction;
+    if (isVolumeToCapacity) {
+        nodeFraction = frac(nodeFactorVolumeUnitToM3, nodeFactorCapacityUnitToM3);
+    }
+    else {
+        nodeFraction = frac(nodeFactorCapacityUnitToM3, nodeFactorVolumeUnitToM3);
+    }
+    return `Si on nomme $x$ le nombre que l'on recherche, on a :
+
+$$
+${randomValue.frenchify()}\\ \\textrm{${instructionUnit}}${isVolumeToCapacity ? "^3" : ""} = x \\ \\textrm{${answerUnit}}${!isVolumeToCapacity ? "^3" : ""}
+$$
+  
+Quand on calcule avec des unités, l'unité est multipliée de façon implicite :
+
+L'égalité précédente est équivalente à :
+
+$$
+${randomValue.frenchify()}\\ \\times 1 \\ \\textrm{${instructionUnit}}${isVolumeToCapacity ? "^3" : ""} = x \\times 1 \\ \\textrm{${answerUnit}}${!isVolumeToCapacity ? "^3" : ""}
+$$
+  
+Donc :
+
+$$
+${randomValue.frenchify()}\\ \\times 
+\\frac{1 \\ \\textrm{${instructionUnit}}${isVolumeToCapacity ? "^3" : ""}}
+{1 \\textrm{${answerUnit}}${!isVolumeToCapacity ? "^3" : ""}} = x
+$$
+
+On convertit toutes les unités en $ {\\textrm{m}}^3 $ : 
+
+${(() => {
+        if (prefixVolume !== "") {
+            return `
+    
+$$
+1 \\ \\textrm{${volumeUnit}}^3 = ${nodeFactorVolumeUnitToM3.toTex()} \\ {\\textrm{m}}^3
+$$
+
+`;
+        }
+        else {
+            return "";
+        }
+    })()}
+
+${(() => {
+        if (prefixCapacity !== "") {
+            return `
+    
+$$
+1 \\ \\textrm{${capacityUnit}} = ${nodeFactorCapacityUnitToL.toTex()} \\ \\textrm{L} = ${nodeFactorCapacityUnitToM3.toTex()} \\ {\\textrm{m}}^3
+$$
+
+`;
+        }
+        else {
+            return `
+    
+$$
+1 \\ \\textrm{L} = ${nodeFactorCapacityUnitToM3.toTex()} \\ {\\textrm{m}}^3
+$$
+
+`;
+        }
+    })()}
+
+Le nombre recherché est donc :
+
+$$
+x = ${randomValue.frenchify()}\\ \\times ${nodeFraction.toTex()} = ${getAnswer(identifiers)}
+$$
+
+`;
+};
 const getVolumeCapacityConversion = () => {
     const randomUnitInstructionIndex = randint(0, 7);
     const randomUnitIndex = randint(
@@ -62,6 +228,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -90,4 +258,7 @@ export const volumeCapacityConversion = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/dataRepresentations/barChartReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"barChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC;;AAgFF,oBAAoB;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG"}
+{"version":3,"file":"barChartReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAwIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAgBjD,CAAC;;AAgFF,oBAAoB;AACpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmFG"}

package/lib/exercises/math/dataRepresentations/barChartReading.js

@@ -25,12 +25,18 @@ const getInstruction = (identifiers) => {
 Combien de pommes de $${labels[itemAsked]}\\ \\textrm{cm}$ de diamètre le producteur a-t-il récoltées ?
 `;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return "";
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   return "";
-// };
+const getHint = (identifiers) => {
+    const { labels, itemAsked } = identifiers;
+    return `Trouve le bâton qui correspond aux pommes de $${labels[itemAsked]}\\ \\textrm{cm}$ et lis la graduation correspondant à sa hauteur.`;
+};
+const getCorrection = (identifiers) => {
+    const { labels, itemAsked, data } = identifiers;
+    return `Le bâton qui correspond aux pommes de $${labels[itemAsked]}\\ \\textrm{cm}$ est le $${itemAsked + 1}^{\\text{${itemAsked > 0 ? "e" : "er"}}}$ en partant de la gauche.
+La graduation correspondante est $${data[itemAsked].frenchify()}$.
+
+Le producteur a récolté $${data[itemAsked].frenchify()}$ pommes de $${labels[itemAsked]}\\ \\textrm{cm}$.
+`;
+};
 const getKeys = () => {
     return [];
 };
@@ -98,8 +104,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers),
     };
     return question;
@@ -116,6 +122,9 @@ export const barChartReading = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     hasGeogebra: true,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };
 // !signtable
 //  const options = { svg: true };

package/lib/exercises/math/dataRepresentations/functionGraphReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionGraphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/functionGraphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwHF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC;;AAEF,UAAU;AACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGE"}
+{"version":3,"file":"functionGraphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/functionGraphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+MF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAmBtD,CAAC;;AAEF,UAAU;AACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGE"}

package/lib/exercises/math/dataRepresentations/functionGraphReading.js

@@ -1,8 +1,9 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
-import { randomColor } from "../../../geogebra/colors.js";
+import { greenMain, randomColor } from "../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
 import { approxEqual } from "../../../geogebra/parsers/approxEqual.js";
+import { Point } from "../../../math/geometry/point.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { round } from "../../../math/utils/round.js";
 import { valueParser } from "../../../tree/parsers/valueParser.js";
@@ -32,11 +33,94 @@ const getInstruction = (identifiers) => {
     return `La droite $(d_1)$ modélise l'évolution du coût total d'un voyage scolaire en fonction du nombre de participants.
     
 ${isAskingX
-        ? `Si le coût total du voyage est de $${yValue}€$, quel est le nombre de participants ?`
+        ? `Si le coût total du voyage est de $${yValue}\\ \\textrm{€}$, quel est le nombre de participants ?`
         : `Si le nombre de participants est $${xValue}$, quel est le coût total du voyage ?`}`;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = () => {
+    return `Cherche l'axe et la graduation représentant la donnée qui t'est fournie puis utilise la grille pour atteindre la droite et ensuite la graduation correspondante sur l'autre axe.`;
+};
+const getCorrection = (identifiers) => {
+    const { isAskingX, xValue, yValue } = identifiers;
+    if (isAskingX) {
+        return `On part de l'axe des ordonnées, à la graduation $${yValue}$.
+
+On suit la grille horizontalement jusqu'à atteindre la droite.
+
+On suit la grille verticalement jusqu'à atteindre l'axe des abscisses.
+
+On lit la valeur $${getAnswer(identifiers)}$.
+
+Le nombre de participants est donc $${getAnswer(identifiers)}$.`;
+    }
+    else {
+        return `On part de l'axe des abscisses, à la graduation $${xValue}$.
+
+On suit la grille verticalement jusqu'à atteindre la droite.
+
+On suit la grille horizontalement jusqu'à atteindre l'axe des abscisses.
+
+On lit la valeur $${getAnswer(identifiers)}$.
+
+Le coût total du voyage est donc $${getAnswer(identifiers)} \\ \\textrm{€}$.`;
+    }
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { a, b, yValue, xValue, isAskingX } = identifiers;
+    const x = xValue ?? (yValue - b) / a;
+    const y = yValue ?? a * xValue + b;
+    const xText = 4;
+    const yText = a * xText + b;
+    const color = randomColor();
+    const pointX0 = new Point("PX0", x, 0);
+    const point0Y = new Point("P0Y", 0, y);
+    const pointXY = new Point("PXY", x, y);
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `f = Function(${a}*x+${b}, 0, 1000)`,
+            `SetColor(f, "${color}")`,
+            `T = Text("$(d_1)$", (${xText},${yText}), true, true)`,
+            `SetColor(T, "${color}")`,
+            `Text("Nombre \\ de \\ participants", (x(Corner(2)),50), true, true, -1)`,
+            `Text("Coût \\ en \\ €", (1, y(Corner(4))), true, true)`,
+            // `(${xValue},${yValue})`,
+            ...(() => {
+                if (isAskingX) {
+                    return [
+                        `v1 = Vector(${point0Y.toMathString()},${pointXY.toMathString()})`,
+                        `SetColor(v1, "${greenMain}")`,
+                        `v2 = Vector(${pointXY.toMathString()},${pointX0.toMathString()})`,
+                        `SetColor(v2, "${greenMain}")`,
+                    ];
+                }
+                else {
+                    return [
+                        `v1 = Vector(${pointX0.toMathString()},${pointXY.toMathString()})`,
+                        `SetColor(v1, "${greenMain}")`,
+                        `v2 = Vector(${pointXY.toMathString()},${point0Y.toMathString()})`,
+                        `SetColor(v2, "${greenMain}")`,
+                    ];
+                }
+            })(),
+        ],
+        forbidShiftDragZoom: false,
+        gridDistance: [2, 500],
+        lockedAxesRatio: 2 / 500,
+        xAxis: {
+            // label: "$\\math{\\tiny \\text{Nb. de \\\\ participants}}$",
+            steps: 2,
+            showPositive: true,
+        },
+        yAxis: {
+            // label: "y",
+            steps: 500,
+            showPositive: true,
+        },
+        fontSize: 14,
+    });
+    return ggb.getOptions({
+        coords: [-1, x + 6, -100, y + 500],
+    });
+};
 const getGGBOptions = (identifiers) => {
     const { a, b, yValue, xValue } = identifiers;
     const x = xValue ?? (yValue - b) / a;
@@ -111,9 +195,10 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
     };
     return question;
 };
@@ -127,13 +212,14 @@ export const functionGraphReading = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
-    // getHint,
-    // getCorrection,
     getInstruction,
     getAnswer,
     getGGBOptions,
     hasGeogebra: true,
     getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };
 /***SVG */
 /**

package/lib/exercises/math/functions/affines/affineExpressionReading.d.ts

@@ -1,8 +1,13 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+type Options = {
+    isLinear: boolean;
+};
 type Identifiers = {
+    isLinear: boolean;
     b: number;
     secondPoint: number[];
 };
-export declare const affineExpressionReading: Exercise<Identifiers>;
+export declare const affineExpressionReading: Exercise<Identifiers, Options>;
+export declare const linearExpressionReading: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=affineExpressionReading.d.ts.map

package/lib/exercises/math/functions/affines/affineExpressionReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"affineExpressionReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineExpressionReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AA8KF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAezD,CAAC"}
+{"version":3,"file":"affineExpressionReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineExpressionReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAiTF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBlE,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBlE,CAAC"}