math-exercises 3.0.99 → 3.0.101

package/lib/exercises/math/geometry/areas/calculateAreaFromCodedShape.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    shape: number;
+    height: number;
+    width: number;
+};
+export declare const calculateAreaFromCodedShape: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=calculateAreaFromCodedShape.d.ts.map

package/lib/exercises/math/geometry/areas/calculateAreaFromCodedShape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateAreaFromCodedShape.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/calculateAreaFromCodedShape.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA8KF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAsB7D,CAAC"}

package/lib/exercises/math/geometry/areas/calculateAreaFromCodedShape.js

@@ -0,0 +1,156 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+const getPropositions = (n, { answer, height, shape, width }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, (height * width).frenchify());
+    tryToAddWrongProp(propositions, ((height * width) / 2).frenchify());
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, ((3 / 4) * height * width + randint(-3, 3, [0])).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return multiply(0.75, identifiers.height * identifiers.width)
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    return `On considère la figure ci-dessous.
+    
+Quelle est l'aire de la surface colorée ?`;
+};
+const getHint = (identifiers) => {
+    return `L'aire de la surface colorée est égale à l'aire du rectangle $ABCD$ moins l'aire du triangle $CED$.`;
+};
+const getCorrection = (identifiers) => {
+    //rectangle - triangle
+    //moitié rectangle + triangle
+    //moitié reactangle + moitié moitié reactalge
+    const { height, shape, width } = identifiers;
+    return `Pour calculer l'aire de la surface colorée, on remarque qu'elle est égale à l'aire du rectangle $ABCD$ moins l'aire du triangle $CED$.
+  
+L'aire du rectangle $ABCD$ est égale à :
+
+$$
+${multiply(height, width).toTex({ forceNoSimplification: true })}=${(height * width).frenchify()}
+$$
+
+On calcule ensuite l'aire du triangle $CED$. Puisqu'il est rectangle en $D$, son aire vaut : 
+
+$$
+${frac(multiply("CD", "DE"), 2).toTex({ forceTimesSign: true })}
+$$
+
+Or $CD = ${height.frenchify()}$ et $DE = ${(width / 2).frenchify()}$. L'aire de $CED$ vaut donc : 
+
+$$
+${frac(multiply(height, width / 2), 2).toTex()}=${((height * width) /
+        4).frenchify()}
+$$
+
+L'aire de la surface colorée vaut donc : 
+
+$$
+${substract(height * width, (height * width) / 4).toTex()} = ${getAnswer(identifiers)}
+$$
+
+
+
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { height, shape, width } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `B = (0,0)`,
+            `C = (${width},0)`,
+            `D = (${width},${height})`,
+            `A = (0,${height})`,
+            `E = (${width / 2},${height})`,
+            ...["A", "B", "C", "D", "E"].flatMap((e) => [
+                `SetVisibleInView(${e},1, false)`,
+                `SetFixed(${e}, true)`,
+            ]),
+            `Segment(E, C)`,
+            `Segment(D, C)`,
+            `se1 = Segment(A, E)`,
+            `se2 = Segment(E,D)`,
+            `SetDecoration(se1, 2)`,
+            `SetDecoration(se2, 2)`,
+            `a = Angle(C,B,A)`,
+            `ShowLabel(a, false)`,
+            `b = Angle(B,A,D)`,
+            `ShowLabel(b, false)`,
+            `c = Angle(A,D,C)`,
+            `ShowLabel(c, false)`,
+            `P = Polygon(B,A,E,C)`,
+            `SetFixed(P, true)`,
+            `Text("$\\scriptsize B$", (0, -0.1*${height}), true, true, 0, 0)`,
+            `Text("$\\scriptsize C$", (${width}, -0.1*${height}), true, true, 0, 0)`,
+            `Text("$\\scriptsize D$", (${width}, ${height}+0.3+${Math.min(1, 0.1 * height)}), true, true, 0, 0)`,
+            `Text("$\\scriptsize E$", (${width / 2}, ${height}+0.3+${Math.min(1, 0.1 * height)}), true, true, 0, 0)`,
+            `Text("$\\scriptsize A$", (0, ${height}+0.3+${Math.min(1, 0.1 * height)}), true, true, 0, 0)`,
+            `Text("$\\scriptsize ${height}$", (-0.4, ${height / 2}), true, true, 0, 0)`,
+            `Text("$\\scriptsize ${width}$", (${width / 2}, -0.1*${height}), true, true, 0, 0)`,
+        ],
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: [-1, width + 1, -1.5, height + 1.5],
+    });
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getCalculateAreaFromCodedShapeQuestion = (opts) => {
+    const width = randint(3, 11);
+    const height = randint(1, width);
+    const identifiers = {
+        shape: 1,
+        height,
+        width,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const calculateAreaFromCodedShape = {
+    id: "calculateAreaFromCodedShape",
+    label: "Calculer l'aire d'une figure codée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateAreaFromCodedShapeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/areas/index.d.ts

@@ -7,4 +7,5 @@ export * from "./triangleAreaV2.js";
 export * from "./squareSideFromArea.js";
 export * from "./rectangleSideFromArea.js";
 export * from "./circleRadiusFromArea.js";
+export * from "./calculateAreaFromCodedShape.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/areas/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/areas/index.ts"],"names":[],"mappings":"AAAA,cAAc,iBAAiB,CAAC;AAChC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,kCAAkC,CAAC"}

package/lib/exercises/math/geometry/areas/index.js

@@ -7,3 +7,4 @@ export * from "./triangleAreaV2.js";
 export * from "./squareSideFromArea.js";
 export * from "./rectangleSideFromArea.js";
 export * from "./circleRadiusFromArea.js";
+export * from "./calculateAreaFromCodedShape.js";

package/lib/exercises/math/geometry/euclidian/index.d.ts

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

package/lib/exercises/math/geometry/euclidian/index.d.ts.map

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

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

@@ -1 +1,2 @@
 export * from "./pythagoreOrThales.js";
+export * from "./orthogonalProjectFromPicture.js";

package/lib/exercises/math/geometry/euclidian/orthogonalProjectFromPicture.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    point: string;
+    line: string;
+};
+export declare const orthogonalProjectFromPicture: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=orthogonalProjectFromPicture.d.ts.map

package/lib/exercises/math/geometry/euclidian/orthogonalProjectFromPicture.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orthogonalProjectFromPicture.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidian/orthogonalProjectFromPicture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAkMF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}

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

@@ -0,0 +1,197 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPoints = () => {
+    const points = [
+        new Point("A", 0, 0),
+        new Point("B", 4, 0),
+        new Point("C", 4, 4),
+        new Point("D", 0, 4),
+        new Point("E", 0, 2),
+        new Point("F", 4, 2),
+        new Point("G", 2, 4),
+        new Point("H", 2, 0),
+        new Point("I", 1, 3),
+        new Point("J", 3, 1),
+        new Point("K", 1, 1),
+        new Point("L", 3, 3),
+        new Point("P", 2, 2),
+    ];
+    return points;
+};
+const getNames = () => {
+    const names = [
+        "A",
+        "B",
+        "C",
+        "D",
+        "E",
+        "F",
+        "G",
+        "H",
+        "I",
+        "J",
+        "K",
+        "L",
+        "P",
+    ];
+    return names;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const names = getNames();
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, random(names));
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const projs = [
+        { line: "AB", A: ["A", "E", "D"], H: ["G", "P", "H"], B: ["C", "F", "B"] },
+        { line: "EF", E: ["A", "E", "D"], P: ["G", "P", "H"], F: ["C", "F", "B"] },
+        { line: "DC", D: ["A", "E", "D"], G: ["G", "P", "H"], C: ["C", "F", "B"] },
+        { line: "DA", A: ["A", "H", "B"], E: ["E", "P", "F"], D: ["D", "G", "C"] },
+        { line: "GH", H: ["A", "H", "B"], P: ["E", "P", "F"], G: ["D", "G", "C"] },
+        { line: "CB", B: ["A", "H", "B"], F: ["E", "P", "F"], C: ["D", "G", "C"] },
+        {
+            line: "DB",
+            D: ["D"],
+            I: ["E", "I", "G"],
+            P: ["A", "K", "P", "L", "C"],
+            J: ["H", "J", "F"],
+            B: ["B"],
+        },
+        {
+            line: "AC",
+            C: ["C"],
+            K: ["E", "K", "H"],
+            P: ["D", "I", "P", "J", "B"],
+            L: ["G", "L", "F"],
+            A: ["A"],
+        },
+        {
+            line: "EH",
+            E: ["E", "I", "G"],
+            H: ["H", "J", "F"],
+            K: ["A", "K", "P", "L", "C"],
+        },
+        {
+            line: "GF",
+            G: ["E", "I", "G"],
+            F: ["H", "J", "F"],
+            L: ["A", "K", "P", "L", "C"],
+        },
+        {
+            line: "EG",
+            E: ["E", "K", "H"],
+            G: ["G", "L", "F"],
+            I: ["D", "I", "P", "J", "B"],
+        },
+        {
+            line: "HF",
+            H: ["E", "K", "H"],
+            F: ["G", "L", "F"],
+            J: ["D", "I", "P", "J", "B"],
+        },
+    ];
+    const dataSet = projs.find((e) => e.line === identifiers.line);
+    for (const [key, value] of Object.entries(dataSet)) {
+        if (key === "line")
+            continue;
+        if (value.includes(identifiers.point)) {
+            return key;
+        }
+    }
+    return "";
+};
+const getInstruction = (identifiers) => {
+    const { line, point } = identifiers;
+    return `On considère le carré $ABCD$ ci-dessous :
+  
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/pointsOnSquare.png)
+
+Quel est le projeté orthogonal de $${point}$ sur la droite $\\left(${line}\\right)$ ?
+`;
+};
+const getHint = (identifiers) => {
+    return `- Si $A$ est un point sur une droite $d$, alors le projeté orthogonal de $A$ sur $d$ est $A$.
+  
+- Si $A$ n'appartient pas à la droite $d$, alors le projeté orthogonal de $A$ sur $d$ est le point $H$ sur $d$ tel que la droite $(AH)$ est perpendiculaire à $d$.`;
+};
+const getCorrection = (identifiers) => {
+    const { line, point } = identifiers;
+    //si point sur droite
+    //sinon
+    const points = getPoints();
+    const pointAnswer = getAnswer(identifiers);
+    const pointObj = points.find((e) => e.name === point);
+    const linePoints = points.filter((e) => line.includes(e.name));
+    const isOnLine = pointObj.isAligned(linePoints[0], linePoints[1]);
+    if (isOnLine) {
+        return `Puisque $${point}$ appartient à la droite $\\left(${line}\\right)$, le projeté orthogonal de $${point}$ sur $\\left(${line}\\right)$ est $${point}$.`;
+    }
+    else {
+        return `Les droites $\\left(${line}\\right)$ et $\\left(${point}${pointAnswer}\\right)$ sont perpendiculaires. De plus, le point $${pointAnswer}$ appartient à la droite $${line}$. Le projeté orthogonal de $${point}$ sur $\\left(${line}\\right)$ est donc $${pointAnswer}$.`;
+    }
+};
+const getKeys = (identifiers) => {
+    const names = getNames();
+    return names;
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getOrthogonalProjectFromPictureQuestion = (ops) => {
+    const data = [
+        { lines: ["AB", "EF", "DC"], excludes: ["I", "J", "K", "L"] },
+        { lines: ["DA", "GH", "CB"], excludes: ["I", "J", "K", "L"] },
+        { lines: ["DB", "AC"], excludes: [] },
+        { lines: ["EH", "GF"], excludes: ["B", "D"] },
+        { lines: ["EG", "HF"], excludes: ["A", "C"] },
+    ];
+    const names = getNames();
+    const dataSet = random(data);
+    const line = random(dataSet.lines);
+    const point = random(names, dataSet.excludes);
+    const identifiers = {
+        line,
+        point,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const orthogonalProjectFromPicture = {
+    id: "orthogonalProjectFromPicture",
+    label: "Identifier le projeté orthogonal d'un point sur une figure codée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getOrthogonalProjectFromPictureQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointImageFromTranslation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AA0IF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBpE,CAAC"}
+{"version":3,"file":"pointImageFromTranslation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AAqKF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBpE,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.js

@@ -1,6 +1,7 @@
 import { GeneratorOptionType, GeneratorOptionTarget, } from "../../../../exercises/exercise.js";
 import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { red } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { approxEqual } from "../../../../geogebra/parsers/approxEqual.js";
 import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
@@ -23,14 +24,40 @@ const getEndPoint = (identifiers) => {
     const end = vector.getEndPoint(startPoint, identifiers.startPoint + "'");
     return end;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {};
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getHint = (identifiers, opts) => {
+    const { points, startPoint, translationPoints } = identifiers;
+    const useVector = opts?.useVector;
+    if (useVector) {
+        const vector = translationPoints[0] + translationPoints[1];
+        return `Trace le vecteur $\\overrightarrow{${vector}}$ à partir du point $${startPoint}$.`;
+    }
+    else {
+        const vector = translationPoints[0] + translationPoints[1];
+        return `À partir du point $${startPoint}$, déplace toi de la même façon que le déplacement de $${translationPoints[0]}$ vers $${translationPoints[1]}$.`;
+    }
+};
+const getCorrection = (identifiers, opts) => {
+    const { points, startPoint, translationPoints } = identifiers;
+    const useVector = opts?.useVector;
+    if (useVector) {
+        const vector = translationPoints[0] + translationPoints[1];
+        return `On se place à partir du point $${startPoint}$. On trace le vecteur $\\overrightarrow{${vector}}$. Le point d'arrivée est le point recherché.`;
+    }
+    else {
+        return `On se place à partir du point $${startPoint}$. On se déplace de la même façon que le déplacement de $${translationPoints[0]}$ vers $${translationPoints[1]}$. Le point d'arrivée est le point recherché.`;
+    }
+};
 const getGGBAnswer = (identifiers) => {
-    return getEndPoint(identifiers).toGGBCommand();
+    const { points, startPoint, translationPoints } = identifiers;
+    const endPoint = getEndPoint(identifiers);
+    return [
+        ...endPoint.toGGBCommand(),
+        `a = Vector(${startPoint}, ${endPoint.name})`,
+        `SetColor(a, "${red}")`,
+    ];
 };
 const getStudentGGBOptions = (identifiers) => {
     const points = identifiers.points.map((p) => PointConstructor.fromIdentifiers(p));
-    const end = getEndPoint(identifiers);
     const ggb = new GeogebraConstructor({
         hideAxes: true,
         isGridSimple: true,
@@ -39,15 +66,11 @@ const getStudentGGBOptions = (identifiers) => {
             size: 3,
             style: 1,
         })),
+        fontSize: 16,
     });
-    const [endX, endY] = [end.x.evaluate(), end.y.evaluate()];
+    const endPoint = getEndPoint(identifiers);
     return ggb.getOptions({
-        coords: [
-            Math.min(endX - 2, -7),
-            Math.max(endX + 2, 7),
-            Math.min(endY - 2, -7),
-            Math.max(endY + 2, 7),
-        ],
+        coords: ggb.getCoordsForPoints([...points, endPoint]),
     });
 };
 const isGGBAnswerValid = (ans, { ggbAnswer }) => {
@@ -66,7 +89,7 @@ const getPointImageFromTranslationQuestion = (opts) => {
     const points = [];
     for (let i = 0; i < 4; i++) {
         const name = String.fromCharCode(65 + i);
-        const newPoint = doWhile(() => PointConstructor.random(name, -4, 5), (p) => points.some((p2) => p.distanceTo(p2) < 2));
+        const newPoint = doWhile(() => PointConstructor.random(name, -3, 4), (p) => points.some((p2) => p.distanceTo(p2) < 2));
         points.push(newPoint);
     }
     const startPoint = random(points).name;
@@ -74,8 +97,11 @@ const getPointImageFromTranslationQuestion = (opts) => {
         random(points.filter((p) => p.name !== startPoint)).name,
     ];
     translationPoints.push(random(points.filter((p) => p.name !== translationPoints[0])).name);
+    const pointsUsed = [startPoint, ...translationPoints];
     const identifiers = {
-        points: points.map((p) => p.toIdentifiers()),
+        points: points
+            .filter((p) => pointsUsed.includes(p.name))
+            .map((p) => p.toIdentifiers()),
         startPoint,
         translationPoints,
     };
@@ -87,8 +113,8 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         instruction: getInstruction(identifiers, opts),
         studentGgbOptions: getStudentGGBOptions(identifiers, opts),
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -98,6 +124,7 @@ const options = [
         label: 'Utiliser le terme "translation de vecteur"',
         type: GeneratorOptionType.checkbox,
         target: GeneratorOptionTarget.instruction,
+        defaultValue: false,
     },
 ];
 export const pointImageFromTranslation = {
@@ -108,11 +135,12 @@ export const pointImageFromTranslation = {
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",
-    // getHint,
-    // getCorrection,
+    getHint,
+    getCorrection,
     getGGBAnswer,
     getStudentGGBOptions,
     answerType: "GGB",
     options,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    shape: "square" | "rectangle";
+    side: number;
+    side2?: number;
+};
+export declare const calculateDiagonalFromSides: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=calculateDiagonalFromSides.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"calculateDiagonalFromSides.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/calculateDiagonalFromSides.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,QAAQ,GAAG,WAAW,CAAC;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAqJF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}