math-exercises 2.2.56 → 2.2.58

package/lib/exercises/math/functions/trinoms/coefficientsIdentification.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor";
+type Identifiers = {
+    aIdentifiers: NodeIdentifiers;
+    bIdentifiers: NodeIdentifiers;
+    cIdentifiers: NodeIdentifiers;
+    isAsking: string;
+};
+export declare const coefficientsIdentification: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=coefficientsIdentification.d.ts.map

package/lib/exercises/math/functions/trinoms/coefficientsIdentification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coefficientsIdentification.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/coefficientsIdentification.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAEL,eAAe,EAChB,MAAM,kCAAkC,CAAC;AAO1C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,eAAe,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAmIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAgB5D,CAAC"}

package/lib/exercises/math/functions/trinoms/coefficientsIdentification.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coefficientsIdentification = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../../../math/numbers/rationals/rational");
+const generalTrinom_1 = require("../../../../math/polynomials/generalTrinom");
+const randint_1 = require("../../../../math/utils/random/randint");
+const nodeConstructor_1 = require("../../../../tree/nodes/nodeConstructor");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../../tree/nodes/operators/powerNode");
+const latexParser_1 = require("../../../../tree/parsers/latexParser");
+const random_1 = require("../../../../utils/alea/random");
+const getPropositions = (n, { answer, aIdentifiers, bIdentifiers, cIdentifiers, isAsking }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const trinom = new generalTrinom_1.GeneralTrinom(nodeConstructor_1.NodeConstructor.fromIdentifiers(aIdentifiers), nodeConstructor_1.NodeConstructor.fromIdentifiers(bIdentifiers), nodeConstructor_1.NodeConstructor.fromIdentifiers(cIdentifiers));
+    if (answer === "1") {
+        (0, exercise_1.tryToAddWrongProp)(propositions, "0");
+    }
+    if (answer === "0") {
+        (0, exercise_1.tryToAddWrongProp)(propositions, "1");
+    }
+    if (answer === "-1") {
+        (0, exercise_1.tryToAddWrongProp)(propositions, "-");
+    }
+    const askedNode = isAsking === "a" ? trinom.a : isAsking === "b" ? trinom.b : trinom.c;
+    if ((0, fractionNode_1.isFractionNode)(askedNode)) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, askedNode.leftChild.toTex());
+    }
+    // si frac ajouter que le num
+    const monom = isAsking === "a"
+        ? (0, multiplyNode_1.multiply)(trinom.a, (0, powerNode_1.square)("x")).simplify()
+        : isAsking === "b"
+            ? (0, multiplyNode_1.multiply)(trinom.b, "x").simplify()
+            : trinom.c;
+    (0, exercise_1.tryToAddWrongProp)(propositions, monom.toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 10) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIdentifiers, bIdentifiers, cIdentifiers, isAsking } = identifiers;
+    return isAsking === "a"
+        ? nodeConstructor_1.NodeConstructor.fromIdentifiers(aIdentifiers).toTex()
+        : isAsking === "b"
+            ? nodeConstructor_1.NodeConstructor.fromIdentifiers(bIdentifiers).toTex()
+            : nodeConstructor_1.NodeConstructor.fromIdentifiers(cIdentifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const trinom = new generalTrinom_1.GeneralTrinom(nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.aIdentifiers), nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.bIdentifiers), nodeConstructor_1.NodeConstructor.fromIdentifiers(identifiers.cIdentifiers));
+    return `Soit $f$ la fonction polynôme de degré $2$ définie sur $\\mathbb{R}$ par :
+  
+$$
+f(x)=${trinom
+        .toTree()
+        .simplify({
+        // forceDistributeFractions: true,
+        forbidFactorize: true,
+        towardsDistribute: true,
+    })
+        .toTex()}
+$$
+  
+Quelle est la valeur du coefficient $${identifiers.isAsking}$ de $f$ ?`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    const parsed = (0, latexParser_1.parseAlgebraic)(ans);
+    if (!parsed)
+        return false;
+    return parsed.simplify().toTex() === answer;
+};
+const getCoefficientsIdentificationQuestion = () => {
+    const a = (0, random_1.random)([
+        (-1).toTree(),
+        (1).toTree(),
+        (0, randint_1.randint)(-10, 11, [-1, 0, 1]).toTree(),
+        rational_1.RationalConstructor.randomIrreductible().toTree(),
+    ]);
+    const b = (0, random_1.random)([
+        (-1).toTree(),
+        (1).toTree(),
+        (0).toTree(),
+        (0, randint_1.randint)(-10, 10, [-1, 1, 0]).toTree(),
+        rational_1.RationalConstructor.randomIrreductible().toTree(),
+    ]);
+    const c = (0, random_1.random)([
+        (0).toTree(),
+        (0, randint_1.randint)(-10, 11, [0]).toTree(),
+        rational_1.RationalConstructor.randomIrreductible().toTree(),
+    ]);
+    const isAsking = (0, random_1.random)(["a", "b", "c"]);
+    const identifiers = {
+        aIdentifiers: a.toIdentifiers(),
+        bIdentifiers: b.toIdentifiers(),
+        cIdentifiers: c.toIdentifiers(),
+        isAsking,
+    };
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.coefficientsIdentification = {
+    id: "coefficientsIdentification",
+    connector: "=",
+    label: "Reconnaître les coefficients d'un trinôme exprimé sous forme développée",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCoefficientsIdentificationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getAnswer,
+};

package/lib/exercises/math/functions/trinoms/index.d.ts

@@ -18,4 +18,5 @@ export * from "./trinomialMeanValue";
 export * from "./solveSecondDegreeEquationByFactorisation";
 export * from "./solveSecondDegreeEquationFromCano";
 export * from "./trinomSignFromRoots";
+export * from "./coefficientsIdentification";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/trinoms/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,4CAA4C,CAAC;AAC3D,cAAc,qCAAqC,CAAC;AACpD,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,4CAA4C,CAAC;AAC3D,cAAc,qCAAqC,CAAC;AACpD,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC"}

package/lib/exercises/math/functions/trinoms/index.js

@@ -34,3 +34,4 @@ __exportStar(require("./trinomialMeanValue"), exports);
 __exportStar(require("./solveSecondDegreeEquationByFactorisation"), exports);
 __exportStar(require("./solveSecondDegreeEquationFromCano"), exports);
 __exportStar(require("./trinomSignFromRoots"), exports);
+__exportStar(require("./coefficientsIdentification"), exports);

package/lib/exercises/math/functions/trinoms/summitAbscissFromDevForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"summitAbscissFromDevForm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/summitAbscissFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8CF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAe1D,CAAC"}
+{"version":3,"file":"summitAbscissFromDevForm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/trinoms/summitAbscissFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgFF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAkB1D,CAAC"}

package/lib/exercises/math/functions/trinoms/summitAbscissFromDevForm.js

@@ -6,10 +6,15 @@ const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQ
 const rational_1 = require("../../../../math/numbers/rationals/rational");
 const trinom_1 = require("../../../../math/polynomials/trinom");
 const randint_1 = require("../../../../math/utils/random/randint");
+const oppositeNode_1 = require("../../../../tree/nodes/functions/oppositeNode");
+const fractionNode_1 = require("../../../../tree/nodes/operators/fractionNode");
+const multiplyNode_1 = require("../../../../tree/nodes/operators/multiplyNode");
+const alignTex_1 = require("../../../../utils/latex/alignTex");
 const getSummitAbscissFromDevFormQuestion = () => {
     const trinom = trinom_1.TrinomConstructor.random();
     const alpha = trinom.getAlphaNode();
     const answer = alpha.toTex();
+    const identifiers = { a: trinom.a, b: trinom.b, c: trinom.c };
     const question = {
         answer,
         instruction: `Soit $f(x) = ${trinom
@@ -17,7 +22,9 @@ const getSummitAbscissFromDevFormQuestion = () => {
             .toTex()}$ une fonction polynôme du second degré. Quelle est l'abscisse du sommet de la parabole représentant $f$ ?`,
         keys: [],
         answerFormat: "tex",
-        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -31,6 +38,34 @@ const getPropositions = (n, { answer, a, b, c }) => {
     }
     return (0, exercise_1.shuffleProps)(propositions, n);
 };
+const getHint = (identifiers) => {
+    return `L'abscisse $\\alpha$ du sommet d'une parabole s'obtient à partir de la forme développée $f(x) = ax^2 + bx +c$ via la formule : 
+  
+$$
+\\alpha = \\frac{-b}{2a}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const alpha = (0, fractionNode_1.frac)((0, oppositeNode_1.opposite)(b), (0, multiplyNode_1.multiply)(2, a), {
+        allowMinusAnywhereInFraction: true,
+    });
+    return `On sait que l'abscisse  $\\alpha$ du sommet de la parabole vaut :
+  
+$$
+\\alpha = \\frac{-b}{2a}
+$$
+
+Ici, $a=${a}$ et $b=${b}$.
+
+Donc, 
+
+${(0, alignTex_1.alignTex)([
+        ["\\alpha", "=", alpha.toTex()],
+        ["", "=", alpha.simplify().toTex()],
+    ])}
+`;
+};
 const isAnswerValid = (ans, { a, b, c }) => {
     const node = new rational_1.Rational(-b, 2 * a).simplify().toTree();
     const texs = node.toAllValidTexs({
@@ -51,5 +86,8 @@ exports.summitAbscissFromDevForm = {
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
+    hasHintAndCorrection: true,
+    getHint,
+    getCorrection,
     subject: "Mathématiques",
 };

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

@@ -4,7 +4,7 @@ exports.rightTriangleArea = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
-const triangles_1 = require("../../../../math/geometry/triangles");
+const triangle_1 = require("../../../../math/geometry/triangle");
 const rational_1 = require("../../../../math/numbers/rationals/rational");
 const randint_1 = require("../../../../math/utils/random/randint");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
@@ -13,7 +13,7 @@ const getRightTriangleArea = () => {
     const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
     for (let i = 0; i < 3; i++)
         vertices.push(String.fromCharCode(code + i));
-    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+    const triangle = triangle_1.TriangleConstructor.createRandomRightTriangle({
         minRapport: 0.4,
         maxRapport: 1.6,
         names: vertices,

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

@@ -4,7 +4,7 @@ exports.triangleArea = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
-const triangles_1 = require("../../../../math/geometry/triangles");
+const triangle_1 = require("../../../../math/geometry/triangle");
 const rational_1 = require("../../../../math/numbers/rationals/rational");
 const randint_1 = require("../../../../math/utils/random/randint");
 const randomLetter_1 = require("../../../../utils/strings/randomLetter");
@@ -14,7 +14,7 @@ const getTriangleArea = () => {
     const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
     for (let i = 0; i < 3; i++)
         vertices.push(String.fromCharCode(code + i));
-    const triangle = triangles_1.TriangleConstructor.createRandomTriangle({
+    const triangle = triangle_1.TriangleConstructor.createRandomTriangle({
         minAngle: 0.69,
         maxAngle: 1.5,
         names: vertices,

package/lib/exercises/math/geometry/euclidianConstructions/buildTriangleWithSizes.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    lengths: number[];
+};
+export declare const buildTriangleWithSizes: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=buildTriangleWithSizes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildTriangleWithSizes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/buildTriangleWithSizes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAuGF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

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

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTriangleWithSizes = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const parseGGBPoints_1 = require("../../../../geogebra/parsers/parseGGBPoints");
+const point_1 = require("../../../../math/geometry/point");
+const segment_1 = require("../../../../math/geometry/segment");
+const randfloat_1 = require("../../../../math/utils/random/randfloat");
+const round_1 = require("../../../../math/utils/round");
+const arrayEqual_1 = require("../../../../utils/arrays/arrayEqual");
+const getInstruction = (identifiers) => {
+    return `Construire un triangle dont les côtés mesurent $${identifiers.lengths[0].frenchify()}$ cm, $${identifiers.lengths[1].frenchify()}$ cm et $${identifiers.lengths[2].frenchify()}$ cm.`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return [
+        `A=(0,0)`,
+        `B=Point(Circle(A,${identifiers.lengths[0]}))`,
+        `C_1 = Circle(B,${identifiers.lengths[1]})`,
+        `C_2 = Circle(A,${identifiers.lengths[2]})`,
+        `C = Intersect(C_1,C_2,1)`,
+        `Polygon(A,B,C)`,
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands: [],
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({
+            point: true,
+            intersect: true,
+            circleRadius: true,
+            // circleTwoPoints: true,
+            // segment: true,
+            segmentFixed: true,
+            polygon: true,
+        }),
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: [-8, 8, -8, 8],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, lengths }) => {
+    let points = [];
+    const polygone = ans.find((c) => c.includes("Polygon"));
+    if (polygone) {
+        const names = polygone
+            .split("=")[1]
+            .replace("(", "")
+            .replace(")", "")
+            .replace("[", "")
+            .replace("]", "")
+            .replace("Polygon", "")
+            .replaceAll(" ", "")
+            .split(",");
+        points = names.map((n) => {
+            const command = ans.find((c) => c.startsWith(n + "="));
+            if (!command)
+                throw Error("Point not found");
+            return (0, ggbPointToCoords_1.ggbPointToCoords)(command.split("=")[1]);
+        });
+    }
+    else {
+        points = (0, parseGGBPoints_1.parseGGBPoints)(ans).map((c) => (0, ggbPointToCoords_1.ggbPointToCoords)(c));
+    }
+    if (points.length !== 3) {
+        return false;
+    }
+    const pointsNode = points.map((p, i) => new point_1.Point("P" + i, p.x.toTree(), p.y.toTree()));
+    const lengthsAns = pointsNode
+        .map((p, i) => new segment_1.Segment(p, pointsNode[(i + 1) % 3]))
+        .map((s) => (0, round_1.round)(s.getLength(), 1))
+        .sort((a, b) => a - b);
+    const sortedExpected = lengths.sort((a, b) => a - b);
+    return (0, arrayEqual_1.arrayEqual)(lengthsAns, sortedExpected);
+};
+const getBuildTriangleWithSizesQuestion = () => {
+    const lengths = [];
+    let a, b, c;
+    do {
+        a = (0, randfloat_1.randfloat)(1, 10, 1);
+        b = (0, randfloat_1.randfloat)(1, 10, 1);
+        c = (0, randfloat_1.randfloat)(1, 10, 1);
+    } while (a + b < c || a + c < b || b + c < a);
+    lengths.push(a, b, c);
+    const identifiers = {
+        lengths,
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.buildTriangleWithSizes = {
+    id: "buildTriangleWithSizes",
+    label: "Construire un triangle en connaissant les longueurs de ses côtés",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getBuildTriangleWithSizesQuestion, nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

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

@@ -1,2 +1,4 @@
 export * from "./buildMediatriceWithCompass";
+export * from "./buildTriangleWithSizes";
+export * from "./pointImageFromTranslation";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC"}

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

@@ -15,3 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./buildMediatriceWithCompass"), exports);
+__exportStar(require("./buildTriangleWithSizes"), exports);
+__exportStar(require("./pointImageFromTranslation"), exports);

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { PointIdentifiers } from "../../../../math/geometry/point";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPoint: string;
+    translationPoints: string[];
+};
+export declare const pointImageFromTranslation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pointImageFromTranslation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pointImageFromTranslation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAMnC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IACnB,iBAAiB,EAAE,MAAM,EAAE,CAAC;CAC7B,CAAC;AAgHF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAc3D,CAAC"}

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pointImageFromTranslation = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const approxEqual_1 = require("../../../../geogebra/parsers/approxEqual");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const point_1 = require("../../../../math/geometry/point");
+const vector_1 = require("../../../../math/geometry/vector");
+const random_1 = require("../../../../utils/alea/random");
+const doWhile_1 = require("../../../../utils/doWhile");
+const getInstruction = (identifiers) => {
+    return `Placer l'image du point $${identifiers.startPoint}$ par la translation qui transforme $${identifiers.translationPoints[0]}$ en $${identifiers.translationPoints[1]}$.`;
+};
+const getEndPoint = (identifiers) => {
+    const translationPoints = [
+        point_1.PointConstructor.fromIdentifiers(identifiers.points.find((p) => p.name === identifiers.translationPoints[0])),
+        point_1.PointConstructor.fromIdentifiers(identifiers.points.find((p) => p.name === identifiers.translationPoints[1])),
+    ];
+    const vector = vector_1.VectorConstructor.fromPoints(translationPoints[0], translationPoints[1]);
+    const startPoint = point_1.PointConstructor.fromIdentifiers(identifiers.points.find((p) => p.name === identifiers.startPoint));
+    const end = vector.getEndPoint(startPoint, "M");
+    return end;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getEndPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const points = identifiers.points.map((p) => point_1.PointConstructor.fromIdentifiers(p));
+    const end = getEndPoint(identifiers);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({ point: true }),
+        commands: points.flatMap((p) => p.toGGBCommand({
+            size: 3,
+            style: 1,
+        })),
+    });
+    const [endX, endY] = [end.x.evaluate(), end.y.evaluate()];
+    return ggb.getOptions({
+        coords: [
+            Math.min(endX - 2, -7),
+            Math.max(endX + 2, 7),
+            Math.min(endY - 2, -7),
+            Math.max(endY + 2, 7),
+        ],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C", "D"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const coords = (0, ggbPointToCoords_1.ggbPointToCoords)(studentAns[0].split("=")[1]);
+    const coordsAns = (0, ggbPointToCoords_1.ggbPointToCoords)(ggbAnswer[0].split("=")[1]);
+    return ((0, approxEqual_1.approxEqual)(coords.x, coordsAns.x, 0.2) &&
+        (0, approxEqual_1.approxEqual)(coords.y, coordsAns.y, 0.2));
+};
+const getPointImageFromTranslationQuestion = () => {
+    const points = [];
+    for (let i = 0; i < 4; i++) {
+        const name = String.fromCharCode(65 + i);
+        const newPoint = (0, doWhile_1.doWhile)(() => point_1.PointConstructor.random(name, -4, 5), (p) => points.some((p2) => p.equals(p2)));
+        points.push(newPoint);
+    }
+    const startPoint = (0, random_1.random)(points).name;
+    const translationPoints = [
+        (0, random_1.random)(points.filter((p) => p.name !== startPoint)).name,
+    ];
+    translationPoints.push((0, random_1.random)(points.filter((p) => p.name !== translationPoints[0])).name);
+    const identifiers = {
+        points: points.map((p) => p.toIdentifiers()),
+        startPoint,
+        translationPoints,
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.pointImageFromTranslation = {
+    id: "pointImageFromTranslation",
+    label: "Placer l'image d'un point par une translation",
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPointImageFromTranslationQuestion, nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

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

@@ -1,8 +1,10 @@
 import { Exercise } from "../../../../exercises/exercise";
+import { TriangleIdentifiers } from "../../../../math/geometry/triangle";
 type Identifiers = {
     sideA: string;
     sideB: string;
     sideC: string;
+    triangleIdentifiers: TriangleIdentifiers;
 };
 export declare const pythagore: Exercise<Identifiers>;
 export {};

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,0BAA0B,CAAC;AAWlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgEF,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,EAST,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAEL,mBAAmB,EACpB,MAAM,8BAA8B,CAAC;AAStC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAiEF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}

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

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pythagore = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
-const triangles_1 = require("../../../../math/geometry/triangles");
+const triangle_1 = require("../../../../math/geometry/triangle");
 const randint_1 = require("../../../../math/utils/random/randint");
 const lengthNode_1 = require("../../../../tree/nodes/geometry/lengthNode");
 const addNode_1 = require("../../../../tree/nodes/operators/addNode");
@@ -15,7 +15,7 @@ const getPythagore = () => {
     const code = 65 + (0, randint_1.randint)(0, 24); // Générer un code de caractère majuscule aléatoire (A-Z)
     for (let i = 0; i < 3; i++)
         vertices.push(String.fromCharCode(code + i));
-    const triangle = triangles_1.TriangleConstructor.createRandomRightTriangle({
+    const triangle = triangle_1.TriangleConstructor.createRandomRightTriangle({
         minRapport: 0.7,
         maxRapport: 1.3,
         names: vertices,
@@ -23,6 +23,7 @@ const getPythagore = () => {
     const sideA = triangle.getSideAName();
     const sideB = triangle.getSideBName();
     const sideC = triangle.getSideCName();
+    const triangleIdentifiers = triangle.toIdentifiers();
     const ggb = new geogebraConstructor_1.GeogebraConstructor({
         commands: triangle.generateCommands({}),
         hideAxes: true,
@@ -37,7 +38,7 @@ const getPythagore = () => {
             coords: triangle.generateCoords(),
         }),
         answerFormat: "tex",
-        identifiers: { sideA, sideB, sideC },
+        identifiers: { sideA, sideB, sideC, triangleIdentifiers },
     };
     return question;
 };

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

@@ -1,7 +1,9 @@
 import { Exercise } from "../../../../exercises/exercise";
+import { TriangleIdentifiers } from "../../../../math/geometry/triangle";
 type Identifiers = {
     square: number;
     sideLengths: number[];
+    triangleIdentifiers: TriangleIdentifiers;
 };
 export declare const pythagoreCalcul: Exercise<Identifiers>;
 export {};

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,0BAA0B,CAAC;AAalC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAmGF,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,EAQT,MAAM,0BAA0B,CAAC;AAGlC,OAAO,EAEL,mBAAmB,EACpB,MAAM,8BAA8B,CAAC;AAUtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,mBAAmB,EAAE,mBAAmB,CAAC;CAC1C,CAAC;AAoGF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}