math-exercises 3.0.74 → 3.0.75

package/lib/exercises/math/calcul/arithmetics/isInequalityTrue.js

@@ -37,10 +37,10 @@ $$
 ${leftNode.toTex()} ${inequalitySign ? "<" : ">"} ${rightNode.toTex()}
 $$
 
-Cette inéquation est-elle vraie pour pour $x = ${x}$ ?`;
+Cette inéquation est-elle vraie pour $x = ${x}$ ?`;
 };
 const getHint = (identifiers) => {
-    return `Remplacer $x$ par $${identifiers.x}$ dans les deux membres. Ensuite, vérifie si l'inégalité est vraie ou non.`;
+    return `Remplace $x$ par $${identifiers.x}$ dans les deux membres. Ensuite, vérifie si l'inégalité est vraie ou non.`;
 };
 const reverseSign = (sign) => {
     let x = "";

package/lib/exercises/math/calcul/operations/operationsPrioritiesParenthesis.js

@@ -86,7 +86,7 @@ const getOperationsPrioritiesParenthesisQuestion = () => {
             const isAdd2 = coinFlip();
             statement = new (isAdd ? AddNode : SubstractNode)(a.toTree(), new (isAdd2 ? AddNode : SubstractNode)(b.toTree(), new (isDivide ? DivideNode : MultiplyNode)(c.toTree(), d.toTree(), {
                 forceTimesSign: true,
-            }), { forceParenthesis: isAdd }));
+            }), { forceParenthesis: true }));
             break;
     }
     const identifiers = { nodeIds: statement.toIdentifiers(), type };

package/lib/exercises/math/calculLitteral/inequations/squareFunctionInequation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squareFunctionInequation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/squareFunctionInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAY9C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,gBAAgB,CAAC;CACpC,CAAC;AA0FF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"squareFunctionInequation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/squareFunctionInequation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAa9C,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,gBAAgB,EAAE,gBAAgB,CAAC;CACpC,CAAC;AA6GF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}

package/lib/exercises/math/calculLitteral/inequations/squareFunctionInequation.js

@@ -30,6 +30,19 @@ $$
 x^2 ${inequationSymbol} ${k}
 $$`;
 };
+// const getHint: GetHint<Identifiers> = (identifiers) => {
+//   return ``;
+// };
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
+//   const { k, inequationSymbol } = identifiers;
+//   return `On applique la fonction racine carrée à l'inégalité :
+// ${alignTex([
+//   ["x^2", inequationSymbol, k.frenchify()],
+//   ["\\sqrt{x^2}", inequationSymbol, sqrt(k).toTex()],
+//   ["|x|", inequationSymbol, sqrt(k).simplify().toTex()],
+// ])}
+// `;
+// };
 const getSquareFunctionInequationQuestion = () => {
     const k = coinFlip() ? randint(1, 11) ** 2 : randint(1, 100);
     const inequationSymbol = InequationSymbolConstructor.random();
@@ -43,6 +56,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["S", "equal", "lbracket", "rbracket", "semicolon", "infty", "cup"],
         answerFormat: "tex",
         identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
     };
     return question;
 };

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

@@ -1 +1 @@
-{"version":3,"file":"leadingCoefficientCalculV1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoefficientCalculV1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAiHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAc5D,CAAC"}
+{"version":3,"file":"leadingCoefficientCalculV1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoefficientCalculV1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAuKF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAe5D,CAAC"}

package/lib/exercises/math/functions/affines/leadingCoefficientCalculV1.js

@@ -3,6 +3,8 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { Rational } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers, opts) => {
     const { xA, yA, xB, yB } = identifiers;
@@ -42,6 +44,53 @@ const getLeadingCoefficientCalculV1Question = (opts) => {
     const identifiers = { xA, xB, yA, yB };
     return getQuestionFromIdentifiers(identifiers, opts);
 };
+const getHint = (identifiers, opts) => {
+    const { xA, yA, xB, yB } = identifiers;
+    const usePoints = opts?.usePoints;
+    const useLinear = opts?.useLinear;
+    if (useLinear) {
+        if (usePoints) {
+            return `Pour déterminer le coefficient directeur $a$ d'une fonction linéaire à partir d'un point $A(x_A; y_A)$ de sa droite représentative, on utilise la formule : 
+
+$$
+a = \\frac{y_A}{x_A}
+$$`;
+        }
+        return `Pour déterminer le coefficient directeur $a$ d'une fonction linéaire $f$ à partir d'une image $f(x)$, on utilise la formule : 
+
+$$
+a = \\frac{f(x)}{x}
+$$`;
+    }
+    if (usePoints)
+        return `Pour déterminer le coefficient directeur $a$ d'une fonction affine à partir de deux points $A(x_A; y_A)$ et $B(x_B;y_B)$ de sa droite représentative, on utilise la formule : 
+
+$$
+a = \\frac{y_B-y_A}{x_B-x_A}
+$$`;
+    return `Pour déterminer le coefficient directeur $a$ d'une fonction affine $f$ à partir de deux images $f(x_1)$ et $f(x_2)$, on utilise la formule : 
+
+$$
+a = \\frac{f(x_2)-f(x_1)}{x_2-x_1}
+$$`;
+};
+const getCorrection = (identifiers, opts) => {
+    const { xA, yA, xB, yB } = identifiers;
+    const usePoints = opts?.usePoints;
+    const useLinear = opts?.useLinear;
+    if (useLinear) {
+        return `Le coefficient directeur $a$ est égal à :
+
+$$
+a = ${frac(yB, xB).toSimplificationTex()}
+$$`;
+    }
+    return `Le coefficient directeur $a$ est égal à :
+
+$$
+a = ${frac(substract(yB, yA), substract(xB, xA)).toSimplificationTex()}
+$$`;
+};
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         instruction: getInstruction(identifiers, opts),
@@ -50,6 +99,8 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         answerFormat: "tex",
         keys: [],
         identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -97,4 +148,5 @@ export const leadingCoefficientCalculV1 = {
     subject: "Mathématiques",
     options,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/basics/inverseImageFunctionGeogebra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IAEjB,MAAM,EAAE,MAAM,CAAC;IAIf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AAmNF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAkB9D,CAAC"}
+{"version":3,"file":"inverseImageFunctionGeogebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/inverseImageFunctionGeogebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IAEjB,MAAM,EAAE,MAAM,CAAC;IAIf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AA6OF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAmB9D,CAAC"}

package/lib/exercises/math/functions/basics/inverseImageFunctionGeogebra.js

@@ -152,6 +152,27 @@ const getInverseImageFunctionGeogebra = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const { points, yValue } = identifiers;
+    return `Repère, s'il y en a, les points de la courbe qui ont pour ordonnée $${yValue}$. Les antécédents de $${yValue}$ sont alors les abscisses de ces points.`;
+};
+const getCorrection = (identifiers) => {
+    const { points, yValue } = identifiers;
+    const validPoints = points.filter((p) => p[1] === yValue);
+    const pts = validPoints.map((e) => new Point("A", e[0], e[1]));
+    if (!validPoints.length) {
+        return `Aucun point de la courbe n'a pour ordonnée $${yValue}$ : cela signifie que $${yValue}$ n'a pas d'antécédent par $f$.`;
+    }
+    return `On lit les points de la courbe qui ont pour ordonnée $${yValue}$ : ${validPoints.length === 1
+        ? `il n'y a que le point de coordonnées $${pts[0].toCoords()}$`
+        : `ce sont les points de coordonnées $${pts[0].toCoords()}$ et $${pts[1].toCoords()}$`}.
+  
+Les antécédents par $f$ de $${yValue}$ sont donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -160,6 +181,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -218,4 +241,5 @@ export const inverseImageFunctionGeogebra = {
     getGGBOptions,
     getQuestionFromIdentifiers,
     rebuildIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/parity/parityFromAlgebra.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parityFromAlgebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/parity/parityFromAlgebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA0HF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}
+{"version":3,"file":"parityFromAlgebra.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/parity/parityFromAlgebra.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAkLF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAcnD,CAAC"}

package/lib/exercises/math/functions/parity/parityFromAlgebra.js

@@ -9,9 +9,18 @@ import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { doWhile } from "../../../../utils/doWhile.js";
 import { probaFlip } from "../../../../utils/alea/probaFlip.js";
 import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { opposite } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
 const getInstruction = (identifiers) => {
     const fct = identifiers.fctTex;
-    return `Soit $f(x) = ${fct}$. La fonction $f$ est-elle paire, impaire, ou ni paire ni impaire ?`;
+    return `Soit $f$ la fonction définie par : 
+  
+$$
+f(x) = ${fct}
+$$
+
+La fonction $f$ est-elle paire, impaire, ou ni paire ni impaire ?`;
 };
 const getAnswer = (identifiers) => {
     const type = identifiers.type;
@@ -30,8 +39,10 @@ const getQuestionFromIdentifiers = (identifiers) => {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: [],
-        answerFormat: "tex",
+        answerFormat: "raw",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -104,6 +115,49 @@ const getParityFromAlgebraQuestion = () => {
     const identifiers = { type, fctTex: fct };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    return `Une fonction $f$ est paire si pour tout $x$ de son ensemble de définition, on a : $f(-x) = f(x)$.
+  
+Une fonction $f$ est impaire si pour tout $x$ de son ensemble de définition, on a : $f(-x) = -f(x)$.`;
+};
+const getCorrection = (identifiers) => {
+    const type = identifiers.type;
+    const fct = parseAlgebraic(identifiers.fctTex);
+    const fctEv = fct.toDetailedEvaluation({ x: opposite("x") });
+    const fctEvSimp = fctEv.simplify({ calculatePowers: true });
+    const fctEvIsSimplifiable = fctEv.toTex() !== fctEvSimp.toTex();
+    const oppFct = opposite(fct);
+    const oppFctSimp = oppFct.simplify({
+        calculatePowers: true,
+        towardsDistribute: true,
+        forbidFactorize: true,
+    });
+    const oppFctIsSimplifiable = oppFct.toTex() !== oppFctSimp.toTex();
+    return `On exprime $f(-x)$ : 
+
+${alignTex([
+        ["f(-x)", "=", fctEv.toTex()],
+        ["", "=", fctEvSimp.toTex()],
+    ])}
+
+${type === "even"
+        ? "Puisque $f(-x) = f(x)$, la fonction $f$ est paire."
+        : `Puisque $f(-x)\\neq f(x)$, la fonction $f$ n'est pas paire. 
+    
+On calcule alors $-f(x)$ : 
+
+${alignTex([
+            ["-f(x)", "=", oppFct.toTex()],
+            oppFctIsSimplifiable ? ["", "=", oppFctSimp.toTex()] : [],
+        ])}`}
+
+${type === "uneven"
+        ? "Puisque $f(-x) = -f(x)$, la fonction $f$ est impaire."
+        : type === "neither"
+            ? "Puisque $f(-x)\\neq -f(x)$, la fonction $f$ n'est pas impaire. La fonction $f$ n'est donc ni paire, ni impaire."
+            : ""}
+`;
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer, "raw");
@@ -128,4 +182,5 @@ export const parityFromAlgebra = {
     answerType: "QCU",
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/euclidian/pythagoreOrThales.js

@@ -55,37 +55,40 @@ const getInstruction = (identifiers) => {
 
 Pour ${instruction}, il faut utiliser... `;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return `Voici les énoncés des théorèmes de Pythagore et de Thalès, et leurs réciproques :
-// - **Théorème de Pythagore** : Dans un triangle rectangle, le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés.
-// - **Réciproque du théorème de Pythagore** : Si dans un triangle, le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés, alors le triangle est rectangle.
-// - **Théorème de Thalès** : Soit un triangle $ABC$, et $D$ un point sur la droite $(AB)$ et $E$ un point sur la droite $(AC)$. Si les droites $(DE)$ et $(BC)$ sont parallèles, alors :
-// $$
-// \\frac{AD}{AB}=\\frac{AE}{AC}=\\frac{DE}{BC}
-// $$
-// - **Réciproque du théorème de Thalès** :  Soit un triangle $ABC$, et $D$ un point sur la droite $(AB)$ et $E$ un point sur la droite $(AC)$. Si $\\frac{AD}{AB}=\\frac{AE}{AC}$, alors les droites $(AB)$ et $(AC)$ sont parallèles.`;
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   const { isAskingLength, pointsIdentifiers, isSegmentHeight } = identifiers;
-//   const points = pointsIdentifiers.map((p) =>
-//     PointConstructor.fromIdentifiers(p),
-//   );
-//   if (isSegmentHeight) {
-//     if(isAskingLength){
-//       // ("Pythagore");
-//       return ``
-//     } else {
-//       // ("Recip pythagore");
-//     }
-//   } else {
-//     if (isAskingLength) {
-//       // ("Thales");
-//     } else {
-//       // ("Recip thales");
-//     }
-//   }
-//   return ``;
-// };
+const getHint = (identifiers) => {
+    return `Voici les énoncés des théorèmes de Pythagore et de Thalès, et leurs réciproques :
+
+- **Théorème de Pythagore** : Dans un triangle rectangle, le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés.
+- **Réciproque du théorème de Pythagore** : Si dans un triangle, le carré de l'hypoténuse est égal à la somme des carrés des deux autres côtés, alors le triangle est rectangle.
+- **Théorème de Thalès** : Soit un triangle $ABC$, et $D$ un point sur la droite $(AB)$ et $E$ un point sur la droite $(AC)$. Si les droites $(DE)$ et $(BC)$ sont parallèles, alors :
+
+$$
+\\frac{AD}{AB}=\\frac{AE}{AC}=\\frac{DE}{BC}
+$$
+- **Réciproque du théorème de Thalès** :  Soit un triangle $ABC$, et $D$ un point sur la droite $(AB)$ et $E$ un point sur la droite $(AC)$. Si $\\frac{AD}{AB}=\\frac{AE}{AC}$, alors les droites $(AB)$ et $(AC)$ sont parallèles.`;
+};
+const getCorrection = (identifiers) => {
+    const { isAskingLength, pointsIdentifiers, isSegmentHeight } = identifiers;
+    const points = pointsIdentifiers.map((p) => PointConstructor.fromIdentifiers(p));
+    if (isSegmentHeight) {
+        if (isAskingLength) {
+            // ("Pythagore");
+            return ``;
+        }
+        else {
+            // ("Recip pythagore");
+        }
+    }
+    else {
+        if (isAskingLength) {
+            // ("Thales");
+        }
+        else {
+            // ("Recip thales");
+        }
+    }
+    return ``;
+};
 const getGGBOptions = (identifiers) => {
     const { isAskingLength, lengths, pointsIdentifiers, isSegmentHeight } = identifiers;
     const points = pointsIdentifiers.map((p) => PointConstructor.fromIdentifiers(p));

package/lib/exercises/math/geometry/thales/thalesCalcul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"thalesCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thalesCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAsBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAQnD,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAmJF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAqEF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyBvD,CAAC"}
+{"version":3,"file":"thalesCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thalesCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAsBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAanD,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AA2OF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAqEF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CA0BvD,CAAC"}

package/lib/exercises/math/geometry/thales/thalesCalcul.js

@@ -6,9 +6,14 @@ import { Segment } from "../../../../math/geometry/segment.js";
 import { Triangle, TriangleConstructor, } from "../../../../math/geometry/triangles/triangle.js";
 import { VectorConstructor } from "../../../../math/geometry/vector.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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
 import { randomLetter } from "../../../../utils/strings/randomLetter.js";
 const getSubTriangle = ({ triangle, insidePointsNames, ratio, isPapillon, }) => {
     const [A, B, C] = triangle.points;
@@ -25,7 +30,7 @@ const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
     while (propositions.length < n) {
-        tryToAddWrongProp(propositions, randfloat(3, 20, 1).frenchify());
+        tryToAddWrongProp(propositions, randfloat(3, 20, 2).frenchify());
     }
     return shuffleProps(propositions, n);
 };
@@ -65,12 +70,77 @@ On sait de plus que : ${allSides
         .map((e) => `$${e.toLengthTex()}$`)
         .join(" , ")}.
 
-Calculer $${segmentAskedName.slice(1, 3)}$ (arrondir aux dixième).`;
+Calculer $${segmentAskedName.slice(1, 3)}$ (arrondir au centième).`;
+};
+const getHint = (identifiers) => {
+    const { triangleIdentifiers, insidePointsNames, ratio, isPapillon, segmentAskedName, } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames: identifiers.insidePointsNames,
+        ratio,
+        isPapillon: identifiers.isPapillon,
+    });
+    const oppositeSegment = triangle.sides[2].toInsideName();
+    return `Puisque les droites $\\left(${subTriangle.sides[2].toInsideName()}\\right)$ et $\\left(${oppositeSegment}\\right)$ sont parallèles, d'après le théorème de Thalès, on a :
+  
+$$
+\\frac{${triangle.sides[0].toInsideName()}}{${subTriangle.sides[0].toInsideName()}}=\\frac{${triangle.sides[1].toInsideName()}}{${subTriangle.sides[1].toInsideName()}}=\\frac{${triangle.sides[2].toInsideName()}}{${subTriangle.sides[2].toInsideName()}}
+$$
+
+Remplace dans cette égalité les longueurs par les valeurs données dans l'énoncé.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { triangleIdentifiers, insidePointsNames, ratio, isPapillon, segmentAskedName, } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames: identifiers.insidePointsNames,
+        ratio,
+        isPapillon: identifiers.isPapillon,
+    });
+    const oppositeSegment = triangle.sides[2].toInsideName();
+    const ratios = [0, 1, 2].map((i) => [
+        triangle.sides[i],
+        subTriangle.sides[i],
+    ]);
+    const names = ratios.map((arr) => [
+        arr[0].toInsideName(),
+        arr[1].toInsideName(),
+    ]);
+    const lengths = ratios.map((arr) => [
+        arr[0].getLength().frenchify(),
+        arr[1].getLength().frenchify(),
+    ]);
+    const lengthAsked = segmentAskedName.slice(1, 3);
+    const lengthAskedColumn = names.findIndex((e) => e.some((s) => s === lengthAsked));
+    const lengthAskedRow = names[lengthAskedColumn].findIndex((s) => s === lengthAsked);
+    lengths[lengthAskedColumn][lengthAskedRow] = lengthAsked;
+    const chosenSecondColumn = randint(0, 3, [lengthAskedColumn]);
+    const fraction = frac(multiply(lengths[lengthAskedColumn][1 - lengthAskedRow].unfrenchify(), lengths[chosenSecondColumn][lengthAskedRow].unfrenchify()), lengths[chosenSecondColumn][1 - lengthAskedRow].unfrenchify());
+    const fracEv = fraction.evaluate();
+    return `Puisque les droites $\\left(${subTriangle.sides[2].toInsideName()}\\right)$ et $\\left(${oppositeSegment}\\right)$ sont parallèles, d'après le théorème de Thalès, on a :
+  
+$$
+\\frac{${triangle.sides[0].toInsideName()}}{${subTriangle.sides[0].toInsideName()}}=\\frac{${triangle.sides[1].toInsideName()}}{${subTriangle.sides[1].toInsideName()}}=\\frac{${triangle.sides[2].toInsideName()}}{${subTriangle.sides[2].toInsideName()}}
+$$
+
+On remplace les longueurs par les valeurs données dans l'énoncé : 
+
+$$
+${[0, 1, 2].map((i) => `\\frac{${lengths[i][0]}}{${lengths[i][1]}}`).join("=")}
+$$
+
+Pour déterminer $${lengthAsked}$, on peut donc faire le calcul suivant : 
+
+${alignTex([
+        [lengthAsked, "=", fraction.toTex()],
+        ["", ...approxOrEqual(fracEv, 2)],
+    ])}
+
+`;
 };
-// const getHint : GetHint<Identifiers> = (identifiers)=>{
-// }
-// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
-// }
 const getGGBOptions = (identifiers) => {
     const triangle = TriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
     const subTriangle = getSubTriangle({
@@ -164,8 +234,8 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         keys: getKeys(identifiers, opts),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers, opts),
     };
     return question;
@@ -194,4 +264,5 @@ export const thalesCalcul = {
         };
     },
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"paralellismViaColinearity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/paralellismViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAsFF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAY3D,CAAC"}
+{"version":3,"file":"paralellismViaColinearity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/paralellismViaColinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4HF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}

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

@@ -2,9 +2,10 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Line } from "../../../../math/geometry/line.js";
 import { Point, PointConstructor } from "../../../../math/geometry/point.js";
-import { VectorConstructor } from "../../../../math/geometry/vector.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { substract, } from "../../../../tree/nodes/operators/substractNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
@@ -27,6 +28,40 @@ const getAnswer = (identifiers) => {
     const answer = isParallele ? "Oui" : "Non";
     return answer;
 };
+const getHint = (identifiers) => {
+    return `Les droites $(AB)$ et $(CD)$ sont parallèles si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{CD}$ sont colinéaires. Calcule donc les coordonnées puis le déterminant des vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{CD}$.`;
+};
+const getCorrection = (identifiers) => {
+    const A = new Point("A", identifiers.xA, identifiers.yA);
+    const B = new Point("B", identifiers.xB, identifiers.yB);
+    const C = new Point("C", identifiers.xC, identifiers.yC);
+    const D = new Point("D", identifiers.xD, identifiers.yD);
+    const vec1 = new Vector("AB", substract(B.x, A.x), substract(B.y, A.y));
+    const vec2 = new Vector("CD", substract(D.x, C.x), substract(D.y, C.y));
+    const vec1Simp = vec1.simplify();
+    const vec2Simp = vec2.simplify();
+    const det = vec1Simp.determinant(vec2Simp);
+    const isParallel = vec1.isColinear(vec2);
+    return `Les droites $(AB)$ et $(CD)$ sont parallèles si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{CD}$ sont colinéaires. On calcule donc d'abord les coordonnées de ces vecteurs : 
+
+$$
+${vec1.toTexWithCoords()}=${vec1Simp.toBinomCoords().toTex()}
+$$
+
+$$
+${vec2.toTexWithCoords()}=${vec2Simp.toBinomCoords().toTex()}
+$$
+
+Puis, on calcule le déterminant des vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{CD}$ :
+
+$$
+\\det(${vec1.toTex()};${vec2.toTex()})=${det.toTex()}=${det.simplify().toTex()}
+$$
+
+${isParallel
+        ? `Puisque le déterminant est nul, les vecteurs sont colinéaires. Les droites $(AB)$ et $(CD)$ sont donc parallèles.`
+        : `Puisque le déterminant n'est pas nul, les vecteurs ne sont pas colinéaires. Les droites $(AB)$ et $(CD)$ ne sont donc pas parallèles.`}`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -34,6 +69,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "raw",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -92,4 +129,5 @@ export const paralellismViaColinearity = {
     answerType: "QCU",
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"parallelogramViaEqualVectors.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/parallelogramViaEqualVectors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA6EF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAY9D,CAAC"}
+{"version":3,"file":"parallelogramViaEqualVectors.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/parallelogramViaEqualVectors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4GF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}

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

@@ -1,7 +1,8 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Point, PointConstructor } from "../../../../math/geometry/point.js";
-import { VectorConstructor } from "../../../../math/geometry/vector.js";
+import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
+import { substract, } from "../../../../tree/nodes/operators/substractNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
@@ -24,6 +25,33 @@ const getAnswer = (identifiers) => {
     const answer = isParallelogram ? "Oui" : "Non";
     return answer;
 };
+const getHint = (identifiers) => {
+    return `$ABCD$ est un parallélogramme si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux.`;
+};
+const getCorrection = (identifiers) => {
+    const A = new Point("A", identifiers.xA, identifiers.yA);
+    const B = new Point("B", identifiers.xB, identifiers.yB);
+    const C = new Point("C", identifiers.xC, identifiers.yC);
+    const D = new Point("D", identifiers.xD, identifiers.yD);
+    const vec1 = new Vector("AB", substract(B.x, A.x), substract(B.y, A.y));
+    const vec2 = new Vector("DC", substract(C.x, D.x), substract(C.y, D.y));
+    const vec1Simp = vec1.simplify();
+    const vec2Simp = vec2.simplify();
+    const isParallelogram = vec1Simp.equals(vec2Simp);
+    return `$ABCD$ est un parallélogramme si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux. On calcule donc les coordonnées de ces vecteurs : 
+
+$$
+${vec1.toTexWithCoords()}=${vec1Simp.toBinomCoords().toTex()}
+$$
+
+$$
+${vec2.toTexWithCoords()}=${vec2Simp.toBinomCoords().toTex()}
+$$
+
+${isParallelogram
+        ? `Puisque les vecteurs sont égaux, $ABCD$ est un parallélogramme.`
+        : `Puisque les vecteurs ne sont pas égaux, $ABCD$ n'est pas un parallélogramme.`}`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -31,6 +59,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "raw",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -82,4 +112,5 @@ export const parallelogramViaEqualVectors = {
     answerType: "QCU",
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"vectorLinearCombination.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/vectorLinearCombination.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,YAAY,CAAC;IAChB,CAAC,EAAE,YAAY,CAAC;CACjB,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmJF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}
+{"version":3,"file":"vectorLinearCombination.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/vectorLinearCombination.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,YAAY,CAAC;IAChB,CAAC,EAAE,YAAY,CAAC;CACjB,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyMF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

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

@@ -3,8 +3,8 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
-import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply, MultiplyNode, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 const getInstruction = (identifiers) => {
     const { a, b } = identifiers;
@@ -26,6 +26,41 @@ const getAnswer = (identifiers) => {
     const correctAnswer = new Vector("au+bv", aUPlusBv.x, aUPlusBv.y);
     return `${correctAnswer.toInlineCoordsTex()}`;
 };
+const getHint = (identifiers) => {
+    return `Calcule d'abord les coordonnées de chaque vecteur de la somme. Puis, additionne ces coordonnées.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, u, v } = identifiers;
+    const uVec = new Vector("u", u.x.toTree(), u.y.toTree());
+    const coeffedU = new Vector("au", multiply(a, uVec.x), multiply(a, uVec.y));
+    const vVec = new Vector("v", v.x.toTree(), v.y.toTree());
+    const coeffedV = new Vector("bv", multiply(b, vVec.x), multiply(b, vVec.y));
+    const sum = add(multiply(a, "\\overrightarrow{u}"), multiply(b, "\\overrightarrow{v}")).toTex();
+    const sumVec = new Vector("sum", add(coeffedU.x.simplify(), coeffedV.x.simplify()), add(coeffedU.y.simplify(), coeffedV.y.simplify()));
+    return `${a !== 1
+        ? `Les coordonnées du vecteur $${multiply(a, "\\overrightarrow{u}").toTex()}$ sont : 
+  
+$$
+${coeffedU.toCoords()} = ${coeffedU.simplify().toCoords()}
+$$`
+        : ""}
+
+${a !== 1
+        ? `Les coordonnées du vecteur $${multiply(b, "\\overrightarrow{v}").toTex()}$ sont : 
+  
+$$
+${coeffedV.toCoords()} = ${coeffedV.simplify().toCoords()}
+$$`
+        : ""}
+
+En additionnant, on obtient donc les coordonnées du vecteur $${sum}$ :
+
+$$
+${sumVec.toCoords()} = ${sumVec.simplify().toCoords()}
+$$
+
+`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -33,6 +68,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["semicolon"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -112,4 +149,5 @@ export const vectorLinearCombination = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/stats1var/choseReasoningForIndicator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"choseReasoningForIndicator.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/choseReasoningForIndicator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAqHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}
+{"version":3,"file":"choseReasoningForIndicator.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/choseReasoningForIndicator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAgIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAa5D,CAAC"}

package/lib/exercises/math/probaStat/stats1var/choseReasoningForIndicator.js

@@ -38,13 +38,20 @@ La ${indicatorAsked} de cette série est $${avg}$.
 
 Quelle est la justification correcte ?`;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   const { values, indicatorAsked } = identifiers;
-//   return indicatorAsked === "moyenne" ? `La moyenne est la somme des valeurs, divisée par le nombre de valeurs.` : `La médiane est la valeur telle qu'il y a autant de valeurs inférieures à elle que de valeurs supérieures.`;
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   return ``
-// };
+const getHint = (identifiers) => {
+    const { values, indicatorAsked } = identifiers;
+    return indicatorAsked === "moyenne"
+        ? `La moyenne est la somme des valeurs, divisée par le nombre de valeurs.`
+        : `La médiane est la valeur centrale de la série.`;
+};
+const getCorrection = (identifiers) => {
+    const { values, indicatorAsked } = identifiers;
+    return indicatorAsked === "moyenne"
+        ? `La moyenne est la somme des valeurs, divisée par le nombre de valeurs. Ici, ${getAnswer(identifiers).toLocaleLowerCase()}.
+`
+        : `La médiane est la valeur centrale de la série : c'est à dire qu'il y a autant de valeurs inférieures à elle que de valeurs supérieures. Ici, ${getAnswer(identifiers).toLocaleLowerCase()}.
+`;
+};
 const getChoseReasoningForIndicatorQuestion = (ops) => {
     const max = 2 * randint(5, 20);
     const x = max / 2;
@@ -77,8 +84,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         instruction: getInstruction(identifiers),
         answerFormat: "raw",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -93,5 +100,5 @@ export const choseReasoningForIndicator = {
     subject: "Mathématiques",
     answerType: "QCU",
     getQuestionFromIdentifiers,
-    // hasHintAndCorrection: true
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/stats1var/median.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"median.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/median.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAWT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAmFF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}
+{"version":3,"file":"median.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/median.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAaT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAuHF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/math/probaStat/stats1var/median.js

@@ -36,6 +36,38 @@ const getMedianWithTable = () => {
     const identifiers = { randomValues, randomEffectives };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    return `Dresse le tableau des effectifs cumulés croissants. Cela permet de trouver l'effectif total $N$. Puis : 
+  
+- Si $N$ est pair, alors la médiane est la valeur comprise entre la valeur de rang $\\frac{N}{2}$ et celle de rang $\\frac{N}{2}+1$;
+- Si $N$ est impair, alors la médiane est la valeur de rang $\\frac{N+1}{2}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { randomEffectives, randomValues } = identifiers;
+    const eccs = [];
+    let s = 0;
+    for (let i = 0; i < randomEffectives.length; i++) {
+        s += randomEffectives[i];
+        eccs.push(s);
+    }
+    const total = eccs[eccs.length - 1];
+    const rank = total / 2;
+    return `On dresse le tableau des effectifs cumulés croissants (ECC) : 
+  
+${mdTable([
+        ["Valeur", ...randomValues.map((e) => dollarize(e))],
+        ["Effectif", ...randomEffectives.map((e) => dollarize(e))],
+        ["ECC", ...eccs.map((e) => dollarize(e))],
+    ])}
+
+L'effectif total est donc $${total}$. 
+
+Puisque $\\frac{${total}}{2} = ${rank.frenchify()}$, la médiane est ${rank % 1 === 0
+        ? `entre la $${rank}$ème et la $${rank + 1}$ème valeur.`
+        : `la $${Math.ceil(rank)}$ème valeur.`}
+
+La médiane est donc $${getAnswer(identifiers)}$.`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -44,6 +76,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         answerFormat: "tex",
         identifiers,
         style: { tableHasNoHeader: true },
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -70,4 +104,5 @@ export const medianWithTable = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/stats1var/medianList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"medianList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianList.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EAYT,MAAM,sBAAsB,CAAC;AAE9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA+DF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAYhD,CAAC"}
+{"version":3,"file":"medianList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianList.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAE9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAkFF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAahD,CAAC"}

package/lib/exercises/math/probaStat/stats1var/medianList.js

@@ -25,6 +25,21 @@ const getMedianList = () => {
     const identifiers = { sortedValues };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    return `La médiane est la valeur centrale de la série : il y a autant de valeur inférieures à la médiane que de valeurs supérieures à la médiane.`;
+};
+const getCorrection = (identifiers) => {
+    const { sortedValues } = identifiers;
+    const total = sortedValues.length;
+    const rank = total / 2;
+    return `Il y a $${total}$ valeurs dans la liste. 
+  
+Puisque $\\frac{${total}}{2} = ${rank.frenchify()}$, la médiane est ${rank % 1 === 0
+        ? `entre la $${rank}$ème et la $${rank + 1}$ème valeur.`
+        : `la $${Math.ceil(rank)}$ème valeur.`}
+
+La médiane est donc $${getAnswer(identifiers)}$.`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -32,6 +47,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -59,4 +76,5 @@ export const medianWithList = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/stats1var/quartiles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quartiles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartiles.ts"],"names":[],"mappings":"AASA,OAAO,EACL,QAAQ,EAWT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAsFF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAY3C,CAAC"}
+{"version":3,"file":"quartiles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartiles.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,QAAQ,EAaT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA6HF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAa3C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/quartiles.js

@@ -1,5 +1,7 @@
 import { randint } from "../../../../math/utils/random/randint.js";
 import { firstQuartile, thirdQuartile, } from "../../../../math/utils/stats/quartiles.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { dollarize } from "../../../../utils/latex/dollarize.js";
 import { mdTable } from "../../../../utils/markdown/mdTable.js";
@@ -41,6 +43,38 @@ const getQuartiles = () => {
     const identifiers = { randomValues, randomEffectives, randomQuartile };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const { randomEffectives, randomValues, randomQuartile } = identifiers;
+    if (randomQuartile === 0)
+        return `Le premier quartile est la valeur de la série telle qu'au moins un quart des valeurs lui sont inférieures. Dresse le tableau des effectifs cumulés croissants de la série, puis calcule ce que vaut un quart de l'effectif total.`;
+    return `Le troisième quartile est la valeur de la série telle qu'au moins un trois quarts des valeurs lui sont inférieures. Dresse le tableau des effectifs cumulés croissants de la série, puis calcule ce que vaut un trois quarts de l'effectif total.`;
+};
+const getCorrection = (identifiers) => {
+    const { randomEffectives, randomValues, randomQuartile } = identifiers;
+    const eccs = [];
+    let s = 0;
+    for (let i = 0; i < randomEffectives.length; i++) {
+        s += randomEffectives[i];
+        eccs.push(s);
+    }
+    const total = eccs[eccs.length - 1];
+    const rank = randomQuartile === 0 ? frac(total, 4) : frac(multiply(3, total), 4);
+    const rankEv = rank.evaluate();
+    const numeral = randomQuartile === 0 ? "premier" : "troisième";
+    return `On dresse le tableau des effectifs cumulés croissants (ECC) : 
+  
+${mdTable([
+        ["Valeur", ...randomValues.map((e) => dollarize(e))],
+        ["Effectif", ...randomEffectives.map((e) => dollarize(e))],
+        ["ECC", ...eccs.map((e) => dollarize(e))],
+    ])}
+
+L'effectif total est donc $${total}$. 
+
+Puisque $${rank.toTex()} = ${rankEv.frenchify()}$, le ${numeral} quartile est la $${Math.ceil(rankEv)}$-ème valeur.
+
+Le ${numeral} quartile est donc $${getAnswer(identifiers)}$.`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -49,6 +83,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         answerFormat: "tex",
         identifiers,
         style: { tableHasNoHeader: true },
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -75,4 +111,5 @@ export const quartiles = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/stats1var/quartilesList.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quartilesList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartilesList.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAYT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAuEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAY/C,CAAC"}
+{"version":3,"file":"quartilesList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartilesList.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAgGF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAa/C,CAAC"}

package/lib/exercises/math/probaStat/stats1var/quartilesList.js

@@ -1,5 +1,7 @@
 import { randint } from "../../../../math/utils/random/randint.js";
 import { firstQuartile, thirdQuartile, } from "../../../../math/utils/stats/quartiles.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
 import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
 const getInstruction = ({ randomQuartile, randomValues, }) => {
@@ -34,6 +36,24 @@ const getQuartiles = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const { randomValues, randomQuartile } = identifiers;
+    if (randomQuartile === 0)
+        return `Le premier quartile est la valeur de la série telle qu'au moins un quart des valeurs lui sont inférieures. `;
+    return `Le troisième quartile est la valeur de la série telle qu'au moins un trois quarts des valeurs lui sont inférieures.`;
+};
+const getCorrection = (identifiers) => {
+    const { randomValues, randomQuartile } = identifiers;
+    const total = randomValues.length;
+    const rank = randomQuartile === 0 ? frac(total, 4) : frac(multiply(3, total), 4);
+    const rankEv = rank.evaluate();
+    const numeral = randomQuartile === 0 ? "premier" : "troisième";
+    return `Il y a $${total}$ valeurs dans la série. 
+
+Puisque $${rank.toTex()} = ${rankEv.frenchify()}$, le ${numeral} quartile est la $${Math.ceil(rankEv)}$-ème valeur.
+
+Le ${numeral} quartile est donc $${getAnswer(identifiers)}$.`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -41,6 +61,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -71,4 +93,5 @@ export const quartilesList = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.74",
+  "version": "3.0.75",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [