math-exercises 3.0.53 → 3.0.54

package/lib/exercises/math/geometry/perimeters/rectanglePerimeter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectanglePerimeter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/rectanglePerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAkCF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAWpD,CAAC"}
+{"version":3,"file":"rectanglePerimeter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/rectanglePerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAwEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/math/geometry/perimeters/rectanglePerimeter.js

@@ -2,20 +2,51 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getRectanglePerimeter = () => {
-    const length = randint(3, 13);
-    const width = randint(1, length);
+const getInstruction = (identifiers) => {
+    const { width, length } = identifiers;
+    return `Calculer le périmètre d'un rectangle de $${length}$ cm de longueur et de $${width}$ cm de largeur.`;
+};
+const getAnswer = (identifiers) => {
+    const { width, length } = identifiers;
     const answer = (length + width) * 2 + "";
     const answerTex = answer + "\\text{cm}";
+    return answerTex;
+};
+const getHint = (identifiers) => {
+    return `Le périmètre d'un rectangle est la somme des longueurs de ses quatre côtés.`;
+};
+const getCorrection = (identifiers) => {
+    const { width, length } = identifiers;
+    return `Puisque les côtés opposés d'un rectangle sont égaux, le périmètre d'un rectangle est : 
+  
+$$
+P = 2\\times \\text{Longueur} + 2\\times \\text{largeur}
+$$
+
+Ici, le périmètre du rectangle est donc : 
+
+$$
+P = 2\\times ${width} + 2\\times ${length} = ${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Calculer le périmètre d'un rectangle de $${length}$ cm de longueur et de $${width}$ cm de largeur.`,
-        answer: answerTex,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         answerFormat: "tex",
         keys: ["cm", "cm2"],
-        identifiers: { length, width },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getRectanglePerimeter = () => {
+    const length = randint(3, 13);
+    const width = randint(1, length);
+    const identifiers = { length, width };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -39,4 +70,6 @@ export const rectanglePerimeter = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/perimeters/squarePerimeter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"squarePerimeter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/squarePerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAiCF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAYjD,CAAC"}
+{"version":3,"file":"squarePerimeter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/squarePerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAwEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/math/geometry/perimeters/squarePerimeter.js

@@ -2,16 +2,49 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getSquarePerimeter = () => {
-    const side = randint(1, 21);
+const getInstruction = (identifiers) => {
+    const { side } = identifiers;
+    return `Calculer le périmètre d'un carré de $${side}$ cm de côté.`;
+};
+const getAnswer = (identifiers) => {
+    const { side } = identifiers;
     const answer = side * 4 + "";
     const answerTex = answer + "\\text{cm}";
+    return answerTex;
+};
+const getHint = (identifiers) => {
+    return "Le périmètre d'un carré est la somme des longueurs de ses côtés.";
+};
+const getCorrection = (identifiers) => {
+    const { side } = identifiers;
+    return `Puisque tous les côtés d'un carré sont égaux, le périmètre d'un carré est égal à :
+
+$$
+P = 4\\times \\text{longueur d'un côté}
+$$
+
+Ici, la longueur d'un côté du carré est $${side}\\ \\text{cm}$.
+
+Le périmètre est donc égal à :
+
+$$
+P = 4\\times ${side} = ${getAnswer(identifiers)}
+$$`;
+};
+const getSquarePerimeter = () => {
+    const side = randint(1, 21);
+    const identifiers = { side };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Calculer le périmètre d'un carré de $${side}$ cm de côté.`,
-        answer: answerTex,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         answerFormat: "tex",
         keys: ["cm", "cm2"],
-        identifiers: { side },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -39,4 +72,6 @@ export const squarePerimeter = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/perimeters/trianglePerimeter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trianglePerimeter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/trianglePerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAiCF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}
+{"version":3,"file":"trianglePerimeter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/trianglePerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAkEF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAanD,CAAC"}

package/lib/exercises/math/geometry/perimeters/trianglePerimeter.js

@@ -2,19 +2,46 @@ import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getTrianglePerimeter = () => {
-    const sides = [randint(1, 13), randint(1, 13), randint(1, 13)];
+const getInstruction = (identifiers) => {
+    const { sides } = identifiers;
+    return `Calculer le périmètre d'un triangle dont les côtés mesurent : $${sides[0]}$ cm, $${sides[1]}$ cm et $${sides[2]}$ cm.`;
+};
+const getAnswer = (identifiers) => {
+    const { sides } = identifiers;
     const answer = sides[0] + sides[1] + sides[2] + "";
     const answerTex = answer + "\\text{cm}";
+    return answerTex;
+};
+const getHint = (identifiers) => {
+    return `Le périmètre d'un triangle est la somme des longueurs de ses $3$ côtés.`;
+};
+const getCorrection = (identifiers) => {
+    const { sides } = identifiers;
+    return `Le périmètre d'un triangle est la somme des longueurs de ses $3$ côtés. 
+  
+Ici, le périmètre est donc : 
+
+$$
+P = ${sides.join("+")} = ${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Calculer le périmètre d'un triangle dont les côtés mesurent : $${sides[0]}$ cm, $${sides[1]}$ cm et $${sides[2]}$ cm.`,
-        answer: answerTex,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         answerFormat: "tex",
         keys: ["cm", "cm2"],
-        identifiers: { sides },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getTrianglePerimeter = () => {
+    const sides = [randint(1, 13), randint(1, 13), randint(1, 13)];
+    const identifiers = { sides };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -32,13 +59,13 @@ export const trianglePerimeter = {
     id: "trianglePerimeter",
     connector: "=",
     label: "Calculer le périmètre d'un triangle",
-    levels: ["5ème", "4ème", "3ème", "2nde"],
     isSingleStep: false,
-    sections: ["Périmètres", "Géométrie euclidienne"],
     generator: (nb) => getDistinctQuestions(getTrianglePerimeter, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/pythagore/pythagore.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pythagore.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/pythagore.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAUnD,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA8DF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}
+{"version":3,"file":"pythagore.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/pythagore.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAUnD,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA8GF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}

package/lib/exercises/math/geometry/pythagore/pythagore.js

@@ -6,29 +6,65 @@ import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
 import { SquareNode } from "../../../../tree/nodes/operators/powerNode.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { RightTriangleConstructor } from "../../../../math/geometry/triangles/rightTriangle.js";
-const getPythagore = () => {
-    const triangle = RightTriangleConstructor.randomNiceSides({
-        randomName: true,
-    });
-    const triangleIdentifiers = triangle.toIdentifiers();
+const getInstruction = (identifiers) => {
+    return "Écrire l'égalité de Pythagore pour le triangle rectangle suivant : ";
+};
+const getAnswer = (identifiers) => {
+    const triangle = RightTriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
+    const answer = triangle.getPythagorianTex();
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const triangle = RightTriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
     const ggb = new GeogebraConstructor({
         commands: triangle.commands,
         hideAxes: true,
         hideGrid: true,
     });
-    const answer = triangle.getPythagorianTex();
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getHint = (identifiers) => {
+    return "D'après le 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.";
+};
+const getCorrection = (identifiers) => {
+    const triangle = RightTriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
+    return `Le triangle $${triangle.name}$ est rectangle en $${triangle.points[0].name}$.
+
+L'hypoténuse dans ce triangle est donc le côté $${triangle.sides[0].toTex()}$.
+  
+D'après le théorème de Pythagore, on a donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = (identifiers) => {
+    const triangle = RightTriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
+    return [...triangle.points.map((p) => p.name), "equal"];
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: "Écrire l'égalité de Pythagore pour le triangle rectangle suivant : ",
-        answer,
-        keys: [...triangle.points.map((p) => p.name), "equal"],
-        ggbOptions: ggb.getOptions({
-            coords: triangle.generateCoords(),
-        }),
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: { triangleIdentifiers },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getPythagore = () => {
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    const triangleIdentifiers = triangle.toIdentifiers();
+    const identifiers = { triangleIdentifiers };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, triangleIdentifiers }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -53,9 +89,7 @@ export const pythagore = {
     id: "pythagore",
     connector: "=",
     label: "Écrire l'égalité de Pythagore",
-    levels: ["4ème", "3ème", "2nde"],
     isSingleStep: false,
-    sections: ["Théorème de Pythagore", "Géométrie euclidienne"],
     generator: (nb) => getDistinctQuestions(getPythagore, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -63,4 +97,6 @@ export const pythagore = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/pythagore/pythagoreCalcul.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pythagoreCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/pythagoreCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAiBnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA+EF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}
+{"version":3,"file":"pythagoreCalcul.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/pythagoreCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAcnD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AA8LF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

package/lib/exercises/math/geometry/pythagore/pythagoreCalcul.js

@@ -5,38 +5,128 @@ import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { random } from "../../../../utils/alea/random.js";
 import { RightTriangleConstructor } from "../../../../math/geometry/triangles/rightTriangle.js";
 import { sqrtVEA } from "../../../../exercises/vea/sqrtVEA.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { square } from "../../../../tree/nodes/operators/powerNode.js";
 import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { round } from "../../../../math/utils/round.js";
-const getPythagoreCalcul = () => {
-    const triangle = RightTriangleConstructor.randomNiceSides({
-        randomName: true,
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+const getInstruction = (identifiers) => {
+    const { sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    return `Dans le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$, on sait que $${triangle.sides[(sideAsked + 1) % 3].toLengthTex()}$ et que $${triangle.sides[(sideAsked + 2) % 3].toLengthTex()}$. 
+    
+Calculer la longueur exacte $${triangle.sides[sideAsked].toInsideName()}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const answer = triangle.sides[sideAsked].getLengthNode().toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    return `Le triangle $${triangle.name}$ est rectangle en $${triangle.points[0].name}$.
+  
+D'après le théorème de Pythagore, on a donc : 
+
+$$
+${triangle.getPythagorianTex()}
+$$
+
+Remplace les valeurs données dans l'énoncé dans cette égalité. Puis, isole le côté recherché. Enfin, utilise la racine carrée.`;
+};
+const getCorrection = (identifiers) => {
+    const { sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    const sidesNames = triangle.sides.map((e) => e.toInsideName());
+    const sidesSquared = sidesNames.map((e) => square(e));
+    const equality = new EqualNode(sidesSquared[0], add(sidesSquared[1], sidesSquared[2]));
+    const isolated = sideAsked === 0
+        ? equality
+        : new EqualNode(sidesSquared[sideAsked], substract(sidesSquared[0], sidesSquared[3 - sideAsked]));
+    const detailed = isolated.toDetailedEvaluation({
+        ...(sideAsked !== 0 && {
+            [sidesNames[0]]: triangle.sides[0].getLengthNode(),
+        }),
+        ...(sideAsked !== 1 && {
+            [sidesNames[1]]: triangle.sides[1].getLengthNode(),
+        }),
+        ...(sideAsked !== 2 && {
+            [sidesNames[2]]: triangle.sides[2].getLengthNode(),
+        }),
     });
-    //une chance sur deux d'avoir hypoténuse
-    const sideIndexAsked = random([0, random([1, 2])]);
-    const answer = triangle.sides[sideIndexAsked].getLengthNode().toTex();
-    triangle.showSidesLength([sideIndexAsked]);
+    const rightSimp = detailed.rightChild.simplify();
+    return `Le triangle $${triangle.name}$ est rectangle en $${triangle.points[0].name}$.
+  
+D'après le théorème de Pythagore, on a donc : 
+
+$$
+${equality.toTex()}
+$$
+
+${sideAsked === 0
+        ? ""
+        : `On isole le côté recherché : 
+  
+$$
+${isolated.toTex()}
+$$`}
+
+On remplace par les valeurs données dans l'énoncé : 
+
+$$
+${detailed.toTex()} = ${rightSimp.toTex()}
+$$
+
+
+
+On applique enfin la racine carrée pour obtenir la valeur recherchée :
+
+$$
+${sidesNames[sideAsked]} = ${sqrt(rightSimp).toTex()} = ${getAnswer(identifiers)}
+$$
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { sideAsked, triangleIdentifiers } = identifiers;
+    const triangle = RightTriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    triangle.showSidesLength([sideAsked]);
     const commands = [...triangle.commands];
     const ggb = new GeogebraConstructor({
         commands,
         hideAxes: true,
         hideGrid: true,
     });
-    const triangleIdentifiers = triangle.toIdentifiers();
+    return ggb.getOptions({
+        coords: triangle.generateCoords(),
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        instruction: `Dans le triangle $${triangle.name}$ rectangle en $${triangle.points[0].name}$, on sait que $${triangle.sides[(sideIndexAsked + 1) % 3].toLengthTex()}$ et que $${triangle.sides[(sideIndexAsked + 2) % 3].toLengthTex()}$. 
-    
-Calculer la longueur exacte $${triangle.sides[sideIndexAsked].toInsideName()}$.`,
-        answer,
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
-        ggbOptions: ggb.getOptions({
-            coords: triangle.generateCoords(),
-        }),
+        ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: { sideAsked: sideIndexAsked, triangleIdentifiers },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getPythagoreCalcul = () => {
+    const triangle = RightTriangleConstructor.randomNiceSides({
+        randomName: true,
+    });
+    //une chance sur deux d'avoir hypoténuse
+    const sideIndexAsked = random([0, random([1, 2])]);
+    const triangleIdentifiers = triangle.toIdentifiers();
+    const identifiers = { sideAsked: sideIndexAsked, triangleIdentifiers };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, triangleIdentifiers, sideAsked }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -59,10 +149,8 @@ const isAnswerValid = (ans, { answer, sideAsked, triangleIdentifiers }) => {
 export const pythagoreCalcul = {
     id: "pythagoreCalcul",
     connector: "=",
-    label: "Utiliser le théoreme de Pythagore pour calculer un côté",
-    levels: ["4ème", "3ème", "2nde"],
+    label: "Utiliser le théorème de Pythagore pour calculer un côté",
     isSingleStep: false,
-    sections: ["Théorème de Pythagore", "Géométrie euclidienne"],
     generator: (nb) => getDistinctQuestions(getPythagoreCalcul, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -70,4 +158,6 @@ export const pythagoreCalcul = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"thales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAuBnD,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAyFF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAoIF,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBjD,CAAC"}
+{"version":3,"file":"thales.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/thales/thales.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAuBnD,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAyFF,KAAK,OAAO,GAAG;IACb,iBAAiB,EAAE,MAAM,CAAC;CAC3B,CAAC;AAoLF,eAAO,MAAM,MAAM,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBjD,CAAC"}

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

@@ -106,17 +106,46 @@ const getThales = (opts) => {
         isPapillon,
         ratio,
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getHint = (identifiers) => {
+    const triangle = TriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
+    const subTriangle = getSubTriangle({
+        triangle,
+        insidePointsNames: identifiers.insidePointsNames,
+        ratio: identifiers.ratio,
+        isPapillon: identifiers.isPapillon,
+    });
+    return `Puisque les droites $\\left(${identifiers.insidePointsNames.join("")}\\right)$ et $\\left(${triangle.sides[2].toInsideName()}\\right)$ sont parallèles, les triangles $${triangle.name}$ et $${subTriangle.name}$ sont semblables. Leurs côtés sont donc proportionnels deux à deux.`;
+};
+const getCorrection = (identifiers) => {
+    const { triangleIdentifiers, insidePointsNames } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(triangleIdentifiers);
+    return `Puisque les droites $\\left(${insidePointsNames.join("")}\\right)$ et $\\left(${triangle.sides[2].toInsideName()}\\right)$ sont parallèles, d'après le théorème de Thalès, on a : 
+  
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = (identifiers) => {
+    const { triangleIdentifiers, insidePointsNames, isPapillon, ratio } = identifiers;
+    const triangle = TriangleConstructor.fromIdentifiers(identifiers.triangleIdentifiers);
+    return [
+        "equal",
+        ...triangle.points.map((p) => p.name),
+        ...insidePointsNames,
+    ];
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         answer: getAnswer(identifiers),
-        keys: [
-            "equal",
-            ...triangle.points.map((p) => p.name),
-            ...[dName, eName],
-        ],
+        keys: getKeys(identifiers),
         ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -195,4 +224,6 @@ export const thales = {
     getInstruction,
     getGGBOptions,
     options,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/geometry/triangles/triangleNature.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"triangleNature.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/triangleNature.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAKnD,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAqJF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAkBhD,CAAC"}
+{"version":3,"file":"triangleNature.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/triangles/triangleNature.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAKnD,KAAK,WAAW,GAAG;IACjB,mBAAmB,EAAE,mBAAmB,CAAC;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAoLF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAoBhD,CAAC"}

package/lib/exercises/math/geometry/triangles/triangleNature.js

@@ -39,8 +39,40 @@ const getInstruction = (identifiers) => {
   
 D'après les informations données sur la figure, quelle est la nature du triangle $${triangle.name}$ ? `;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = (identifiers) => {
+    const { triangleIdentifiers, type, useAngles } = identifiers;
+    return `Voici quelques rappels : 
+  
+- un triangle qui a un angle droit est un triangle rectangle ;
+- un triangle qui a deux côtés égaux (ou deux angles égaux) est un triangle isocèle ;
+- un triangle qiu a trois côtés égaux (ou trois angles égaux) est un triangle équilatéral.`;
+};
+const getCorrection = (identifiers) => {
+    const { triangleIdentifiers, type, useAngles } = identifiers;
+    switch (type) {
+        case 0:
+            return "Il n'y a aucune information donnée par la figure sur les longueurs des côtés où les mesures des angles du triangle. On en conclut donc que ce triangle est quelconque.";
+        case 1:
+            if (useAngles) {
+                return `Le triangle possède deux angles égaux : c'est donc un triangle isocèle.`;
+            }
+            else {
+                return `Le triangle possède deux côtés égaux : c'est donc un triangle isocèle.`;
+            }
+        case 2:
+            if (useAngles) {
+                return `Le triangle possède trois angles égaux : c'est donc un triangle équilatéral.`;
+            }
+            else {
+                return `Le triangle possède trois côtés égaux : c'est donc un triangle équilatéral.`;
+            }
+        case 3:
+            return `Le triangle possède un angle droit : c'est donc un triangle rectangle.`;
+        case 4:
+        default:
+            return `Le triangle possède un angle droit : il est donc rectangle. De plus, il possède ${useAngles ? "deux angles égaux" : "deux côtés égaux"} : il est donc également isocèle. `;
+    }
+};
 const getGGBOptions = (identifiers) => {
     const { triangleIdentifiers, type, useAngles } = identifiers;
     let triangle;
@@ -84,12 +116,6 @@ const getGGBOptions = (identifiers) => {
         coords: triangle.generateCoords(),
     });
 };
-const getKeys = (identifiers) => {
-    return [];
-};
-const isAnswerValid = (ans, { answer }) => {
-    throw Error("VEA not implemented");
-};
 const getTriangleNatureQuestion = (opts) => {
     // const type = random(["scalène","isocèle","équilatéral", "rectangle", "rectangle et isocèle"]);
     const type = randint(0, 5);
@@ -129,13 +155,16 @@ const getTriangleNatureQuestion = (opts) => {
         type,
         useAngles,
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
-        keys: getKeys(identifiers),
+        // keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
         ggbOptions: getGGBOptions(identifiers),
     };
     return question;
@@ -148,13 +177,15 @@ export const triangleNature = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
+    // isAnswerValid,
     subject: "Mathématiques",
-    // getHint,
-    // getCorrection,
+    getHint,
+    getCorrection,
     getInstruction,
     getGGBOptions,
     hasGeogebra: true,
     answerType: "QCM",
     isQCM: true,
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/geometry/vectors/colinearity.d.ts

@@ -1,9 +1,10 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
-    xu: number;
-    yu: number;
-    xv: number;
-    yv: number;
+    xu: NodeIdentifiers;
+    yu: NodeIdentifiers;
+    xv: NodeIdentifiers;
+    yv: NodeIdentifiers;
 };
 export declare const colinearity: Exercise<Identifiers>;
 export {};