math-exercises 2.1.25 → 2.1.26-beta.2

package/lib/exercises/geometry/areas/triangleAreaV2.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.triangleAreaV2 = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const shuffle_1 = require("../../../utils/shuffle");
+const sides = [
+    [3, 4, 5],
+    [5, 12, 13],
+    [8, 15, 17],
+    [7, 24, 25],
+    [20, 21, 29],
+    [12, 35, 37],
+    [9, 40, 41],
+    [28, 45, 53],
+    [11, 60, 61],
+    [16, 63, 65],
+    [33, 56, 65],
+    [48, 55, 73],
+    [13, 84, 85],
+    [36, 77, 85],
+    [39, 80, 89],
+    [65, 72, 97],
+];
+const getTriangleAreaV2 = () => {
+    const randomSide = (0, randint_1.randint)(0, sides.length);
+    const area = (sides[randomSide][0] * sides[randomSide][1]) / 2;
+    const answer = area + "";
+    const answerTex = answer + "\\text{cm}^2";
+    const question = {
+        instruction: `Calculer l'aire du triangle rectangle dont les côtés mesurent : $${sides[randomSide][0]}$ cm, $${sides[randomSide][1]}$ cm et $${sides[randomSide][2]}$ cm.`,
+        answer: answerTex,
+        answerFormat: "tex",
+        keys: ["cm", "cm2"],
+        identifiers: { randomSide },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, randomSide }) => {
+    console.log("props", answer, randomSide);
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const area = Number(answer.split("\\text")[0]);
+    (0, exercise_1.tryToAddWrongProp)(propositions, sides[randomSide][0] +
+        sides[randomSide][1] +
+        sides[randomSide][2] +
+        "\\text{cm}^2");
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, area + (0, randint_1.randint)(-area + 1, 14, [0]) + "\\text{cm}^2");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const texs = [answer, answer.split("\\text")[0]];
+    return texs.includes(ans);
+};
+exports.triangleAreaV2 = {
+    id: "triangleAreaV2",
+    connector: "=",
+    label: "Calculer l'aire d'un triangle (sans figure)",
+    levels: ["5ème", "4ème", "3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Aires", "Géométrie euclidienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTriangleAreaV2, nb, 16),
+    qcmTimer: 60,
+    freeTimer: 60,
+    maxAllowedQuestions: 16,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/geometry/cartesian/distanceBetweenTwoPoints.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    coords1: number[];
+    coords2: number[];
+};
+export declare const distanceBetweenTwoPoints: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=distanceBetweenTwoPoints.d.ts.map

package/lib/exercises/geometry/cartesian/distanceBetweenTwoPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"distanceBetweenTwoPoints.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/cartesian/distanceBetweenTwoPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAiHF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAa9D,CAAC"}

package/lib/exercises/geometry/cartesian/distanceBetweenTwoPoints.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.distanceBetweenTwoPoints = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const point_1 = require("../../../math/geometry/point");
+const real_1 = require("../../../math/numbers/reals/real");
+const randTupleInt_1 = require("../../../math/utils/random/randTupleInt");
+const round_1 = require("../../../math/utils/round");
+const sqrtNode_1 = require("../../../tree/nodes/functions/sqrtNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const getDistanceBetweenTwoPoints = () => {
+    const [coords1, coords2] = (0, randTupleInt_1.distinctRandTupleInt)(2, 2, { from: -9, to: 10 });
+    let A = new point_1.Point("A", new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords1[1]));
+    let B = new point_1.Point("B", new numberNode_1.NumberNode(coords2[0]), new numberNode_1.NumberNode(coords2[1]));
+    const answer = new real_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0))
+        .simplify()
+        .toTree()
+        .toTex();
+    const question = {
+        instruction: `Soit $${A.toTexWithCoords()}$ et $${B.toTexWithCoords()}$. Calculer la distance $AB$.`,
+        startStatement: "AB",
+        answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { coords1, coords2 },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, coords1, coords2 }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const xA = new numberNode_1.NumberNode(coords1[0]);
+    const xB = new numberNode_1.NumberNode(coords1[1]);
+    const yA = new numberNode_1.NumberNode(coords2[0]);
+    const yB = new numberNode_1.NumberNode(coords2[1]);
+    let A, B;
+    A = new point_1.Point("A", xA, xB);
+    B = new point_1.Point("B", new numberNode_1.NumberNode(-coords2[0]), new numberNode_1.NumberNode(-coords2[1]));
+    let wrongStatement = new real_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0))
+        .simplify()
+        .toTree()
+        .toTex();
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongStatement);
+    A = new point_1.Point("A", xB, xA);
+    B = new point_1.Point("B", yA, yB);
+    wrongStatement = new real_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0))
+        .simplify()
+        .toTree()
+        .toTex();
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongStatement);
+    A = new point_1.Point("A", xA, yA);
+    B = new point_1.Point("B", xB, yB);
+    wrongStatement = new real_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0))
+        .simplify()
+        .toTree()
+        .toTex();
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongStatement);
+    while (propositions.length < n) {
+        const [tempCoords1, tempsCoords2] = (0, randTupleInt_1.distinctRandTupleInt)(2, 2, {
+            from: -9,
+            to: 10,
+        });
+        const A = new point_1.Point("A", new numberNode_1.NumberNode(tempCoords1[0]), new numberNode_1.NumberNode(tempCoords1[1]));
+        const B = new point_1.Point("B", new numberNode_1.NumberNode(tempsCoords2[0]), new numberNode_1.NumberNode(tempsCoords2[1]));
+        (0, exercise_1.tryToAddWrongProp)(propositions, new real_1.SquareRoot((0, round_1.round)(A.distanceTo(B) ** 2, 0))
+            .simplify()
+            .toTree()
+            .toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { coords1, coords2 }) => {
+    const A = new point_1.Point("A", new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords1[1]));
+    const B = new point_1.Point("B", new numberNode_1.NumberNode(coords2[0]), new numberNode_1.NumberNode(coords2[1]));
+    const answer = new sqrtNode_1.SqrtNode(new numberNode_1.NumberNode((0, round_1.round)(A.distanceTo(B) ** 2, 0)), {
+        allowSimplifySqrt: true,
+    });
+    const texs = answer.toAllValidTexs();
+    console.log(ans, texs);
+    return texs.includes(ans);
+};
+exports.distanceBetweenTwoPoints = {
+    id: "distanceBetweenTwoPoints",
+    connector: "=",
+    label: "Distance entre deux points",
+    levels: ["2nde", "1reESM"],
+    sections: ["Géométrie cartésienne"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDistanceBetweenTwoPoints, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/geometry/cartesian/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./distanceBetweenTwoPoints";
+export * from "./midpoint";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/geometry/cartesian/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/cartesian/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,YAAY,CAAC"}

package/lib/exercises/geometry/cartesian/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./distanceBetweenTwoPoints"), exports);
+__exportStar(require("./midpoint"), exports);

package/lib/exercises/geometry/cartesian/midpoint.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    coordsA: number[];
+    coordsB: number[];
+};
+export declare const midpoint: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=midpoint.d.ts.map

package/lib/exercises/geometry/cartesian/midpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"midpoint.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/cartesian/midpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAuEF,eAAO,MAAM,QAAQ,EAAE,YAAY,CAAC,WAAW,CAY9C,CAAC"}

package/lib/exercises/geometry/cartesian/midpoint.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.midpoint = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const point_1 = require("../../../math/geometry/point");
+const randTupleInt_1 = require("../../../math/utils/random/randTupleInt");
+const pointNode_1 = require("../../../tree/nodes/geometry/pointNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getMidpointQuestion = () => {
+    const [coords1, coords2] = (0, randTupleInt_1.distinctRandTupleInt)(2, 2, { from: -9, to: 10 });
+    const A = new point_1.Point("A", new numberNode_1.NumberNode(coords1[0]), new numberNode_1.NumberNode(coords1[1]));
+    const B = new point_1.Point("B", new numberNode_1.NumberNode(coords2[0]), new numberNode_1.NumberNode(coords2[1]));
+    const answer = A.midpoint(B).toTexWithCoords();
+    const question = {
+        instruction: `Soit $${A.toTexWithCoords()}$ et $${B.toTexWithCoords()}$. Quelles sont les coordonnées du milieu $I$ de $[AB]$ ?`,
+        startStatement: "I",
+        answer,
+        keys: ["I", "semicolon"],
+        answerFormat: "tex",
+        identifiers: { coordsA: coords1, coordsB: coords2 },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const [tempCoords1, tempsCoords2] = (0, randTupleInt_1.distinctRandTupleInt)(2, 2, {
+            from: -9,
+            to: 10,
+        });
+        const temps1 = new point_1.Point("A", new numberNode_1.NumberNode(tempCoords1[0]), new numberNode_1.NumberNode(tempCoords1[1]));
+        const temps2 = new point_1.Point("B", new numberNode_1.NumberNode(tempsCoords2[0]), new numberNode_1.NumberNode(tempsCoords2[1]));
+        const wrongAnswer = temps1.midpoint(temps2);
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTexWithCoords());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { coordsA, coordsB }) => {
+    const A = new point_1.Point("A", new numberNode_1.NumberNode(coordsA[0]), new numberNode_1.NumberNode(coordsA[1]));
+    const B = new point_1.Point("B", new numberNode_1.NumberNode(coordsB[0]), new numberNode_1.NumberNode(coordsB[1]));
+    const answer = new pointNode_1.PointNode(A.midpoint(B), {
+        allowFractionToDecimal: true,
+    });
+    const texs = answer.toAllValidTexs();
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.midpoint = {
+    id: "midpoint",
+    connector: "=",
+    label: "Coordonnées du milieu",
+    levels: ["3ème", "2nde"],
+    isSingleStep: false,
+    sections: ["Géométrie cartésienne"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getMidpointQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/geometry/euclidean/circleArea.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from '../../../exercises/exercise';
+type QCMProps = {
+    answer: string;
+};
+type VEAProps = {};
+export declare const circleArea: MathExercise<QCMProps, VEAProps>;
+export {};
+//# sourceMappingURL=circleArea.d.ts.map

package/lib/exercises/geometry/euclidean/circleArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circleArea.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/circleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAOlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AA8BnB,eAAO,MAAM,UAAU,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWvD,CAAC"}

package/lib/exercises/geometry/euclidean/circleArea.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circleArea = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getCircleArea = () => {
+    const radius = (0, randint_1.randint)(1, 13);
+    const diametre = (0, randint_1.randint)(1, 21);
+    const coin = (0, coinFlip_1.coinFlip)();
+    const answerNb = coin ? (0, round_1.round)(Math.PI * radius ** 2, 2) : (0, round_1.round)(Math.PI * (diametre / 2) ** 2, 2);
+    const answer = (answerNb + '').replace('.', ',');
+    const question = {
+        instruction: `Calculer l'aire d'un cercle de ${coin ? 'rayon ' + radius : 'diamètre ' + diametre} cm.`,
+        answer,
+        answerFormat: 'tex',
+        keys: [],
+        qcmGeneratorProps: { answer },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(Math.random() * 100, 2) + '');
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.circleArea = {
+    id: 'circleArea',
+    connector: '=',
+    label: "Calculer l'aire d'un cercle",
+    levels: ['4ème', '3ème', '2nde'],
+    isSingleStep: false,
+    sections: ['Géométrie euclidienne'],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCircleArea, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+};

package/lib/exercises/geometry/euclidean/circleCircumference.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from '../../../exercises/exercise';
+type QCMProps = {
+    answer: string;
+};
+type VEAProps = {};
+export declare const circleCircumference: MathExercise<QCMProps, VEAProps>;
+export {};
+//# sourceMappingURL=circleCircumference.d.ts.map

package/lib/exercises/geometry/euclidean/circleCircumference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"circleCircumference.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/circleCircumference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAMlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AA8BnB,eAAO,MAAM,mBAAmB,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWhE,CAAC"}

package/lib/exercises/geometry/euclidean/circleCircumference.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.circleCircumference = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getCircleCircumference = () => {
+    const radius = (0, randint_1.randint)(1, 13);
+    const diametre = (0, randint_1.randint)(1, 21);
+    const coin = (0, coinFlip_1.coinFlip)();
+    const answerNb = coin ? (0, round_1.round)(2 * Math.PI * radius, 2) : (0, round_1.round)(Math.PI * diametre, 2);
+    const answer = (answerNb + '').replace('.', ',');
+    const question = {
+        instruction: `Calculer la circonférence d'un cercle de ${coin ? 'rayon ' + radius : 'diamètre ' + diametre} cm.`,
+        answer: answer,
+        answerFormat: 'tex',
+        keys: [],
+        qcmGeneratorProps: { answer },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, round_1.round)(Math.random() * 100, 2) + '');
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.circleCircumference = {
+    id: 'circleCircumference',
+    connector: '=',
+    label: "Calculer la circonférence d'un cercle",
+    levels: ['4ème', '3ème', '2nde'],
+    isSingleStep: false,
+    sections: ['Géométrie euclidienne'],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCircleCircumference, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+};

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

@@ -0,0 +1,11 @@
+import { MathExercise } from '../../../exercises/exercise';
+type QCMProps = {
+    answer: string;
+    sideA: string;
+    sideB: string;
+    sideC: string;
+};
+type VEAProps = {};
+export declare const pythagore: MathExercise<QCMProps, VEAProps>;
+export {};
+//# sourceMappingURL=pythagore.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pythagore.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/pythagore.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IAEd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AAqCnB,eAAO,MAAM,SAAS,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWtD,CAAC"}

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

@@ -0,0 +1,51 @@
+"use strict";
+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 randint_1 = require("../../../math/utils/random/randint");
+const getPythagore = () => {
+    const vertices = [];
+    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({ minRapport: 0.7, maxRapport: 1.3, names: vertices });
+    const sideA = triangle.getSideAName();
+    const sideB = triangle.getSideBName();
+    const sideC = triangle.getSideCName();
+    const answer = `${sideA}^2=${sideB}^2+${sideC}^2`;
+    const question = {
+        instruction: "Écrire l'égalité de Pythagore pour la figure suivante : ",
+        answer,
+        keys: [...vertices, 'equal'],
+        commands: triangle.generateCommands({}),
+        coords: triangle.generateCoords(),
+        answerFormat: 'tex',
+        qcmGeneratorProps: { answer, sideA, sideB, sideC },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, sideA, sideB, sideC }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideA} = ${sideB} + ${sideC}`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideA}^2 = ${sideB}^2 - ${sideC}^2`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideB}^2 = ${sideA}^2 + ${sideC}^2`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideC}^2 = ${sideA}^2 + ${sideB}^2`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideA}^2 = ${sideB} + ${sideC}^2`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${sideA}^2 = ${sideB}^2 + ${sideC}`);
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+exports.pythagore = {
+    id: 'pythagore',
+    connector: '=',
+    label: "Écrire l'égalité de Pythagore",
+    levels: ['4ème', '3ème', '2nde'],
+    isSingleStep: false,
+    sections: ['Géométrie euclidienne'],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPythagore, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+};

package/lib/exercises/geometry/euclidean/pythagoreCalcul.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from '../../../exercises/exercise';
+type QCMProps = {
+    answer: string;
+};
+type VEAProps = {};
+export declare const pythagoreCalcul: MathExercise<QCMProps, VEAProps>;
+export {};
+//# sourceMappingURL=pythagoreCalcul.d.ts.map

package/lib/exercises/geometry/euclidean/pythagoreCalcul.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pythagoreCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/pythagoreCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAUlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AAyEnB,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAW5D,CAAC"}

package/lib/exercises/geometry/euclidean/pythagoreCalcul.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythagoreCalcul = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const triangles_1 = require("../../../math/geometry/triangles");
+const real_1 = require("../../../math/numbers/reals/real");
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getPythagoreCalcul = () => {
+    const vertices = [];
+    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({ minRapport: 0.7, maxRapport: 1.3, names: vertices });
+    const sides = [triangle.getSideCName(), triangle.getSideBName(), triangle.getSideAName()];
+    const sideLengths = [triangle.getSideCnumber(), triangle.getSideBnumber(), triangle.getSideAnumber()].map((el) => Math.round(el / 2));
+    const zeroOrOne = (0, shuffle_1.shuffle)([0, 1]);
+    const randoms = (0, coinFlip_1.coinFlip)() ? [...zeroOrOne, 2] : [2, ...zeroOrOne];
+    // le but est d'avoir une chance sur 2 d'avoir un hépoténus et une 1 chance sur 2 d'avoir un a des 2 autres cote
+    let answer;
+    if (randoms[2] === 2) {
+        // cas de l'hypoténus
+        answer = Math.hypot(sideLengths[0], sideLengths[1]);
+        answer = Math.round(answer) === answer ? answer : `\\sqrt{${sideLengths[0] ** 2 + sideLengths[1] ** 2}}`;
+    }
+    else {
+        // les deux autres cotés
+        answer = Math.sqrt(Math.abs(sideLengths[randoms[0]] ** 2 - sideLengths[randoms[1]] ** 2));
+        answer =
+            Math.round(answer) === answer
+                ? answer
+                : `\\sqrt{${Math.abs(sideLengths[randoms[0]] ** 2 - sideLengths[randoms[1]] ** 2)}}`;
+    }
+    const commands = [
+        ...triangle.generateCommands({
+            showLabels: [...sides, sides[randoms[2]]],
+            setCaptions: [...sideLengths.map((el) => el + ''), '?'],
+            highlightedSide: sides[randoms[2]],
+        }),
+    ];
+    answer = answer + '';
+    const question = {
+        instruction: `Dans le triangle ${triangle.getTriangleName()} ci-dessous rectangle en ${triangle.getRightAngle()}, on sait que ${sides[randoms[0]]} = $${sideLengths[randoms[0]]}$ et que ${sides[randoms[1]]} = $${sideLengths[randoms[1]]}$.$\\\\$Calculer la longueur exacte ${sides[randoms[2]]}`,
+        answer,
+        keys: [...vertices, 'equal'],
+        commands,
+        coords: triangle.generateCoords(),
+        answerFormat: 'tex',
+        qcmGeneratorProps: { answer },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const temp = (0, randint_1.randint)(2, 300);
+        const squareRoot = new real_1.SquareRoot(temp);
+        const wrongAnswer = Math.sqrt(temp) === Math.floor(Math.sqrt(temp)) ? Math.sqrt(temp).toString() : squareRoot.toTree().toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.pythagoreCalcul = {
+    id: 'pythagoreCalcul',
+    connector: '=',
+    label: 'Utiliser le théoreme de Pythagore pour faire des calculs',
+    levels: ['4ème', '3ème', '2nde'],
+    isSingleStep: false,
+    sections: ['Géométrie euclidienne'],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPythagoreCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+};

package/lib/exercises/geometry/euclidean/rectangleArea.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from '../../../exercises/exercise';
+type QCMProps = {
+    answer: string;
+};
+type VEAProps = {};
+export declare const rectangleArea: MathExercise<QCMProps, VEAProps>;
+export {};
+//# sourceMappingURL=rectangleArea.d.ts.map

package/lib/exercises/geometry/euclidean/rectangleArea.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rectangleArea.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/rectangleArea.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAIlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AA2BnB,eAAO,MAAM,aAAa,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAW1D,CAAC"}

package/lib/exercises/geometry/euclidean/rectangleArea.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rectangleArea = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const shuffle_1 = require("../../../utils/shuffle");
+const getRectangleArea = () => {
+    const length = (0, randint_1.randint)(3, 13);
+    const width = (0, randint_1.randint)(1, length);
+    const answer = length * width + '';
+    const question = {
+        instruction: `Calculer l'aire d'un rectangle de $${length}$ cm de longueur et de $${width}$ cm de largeur.`,
+        answer,
+        answerFormat: 'tex',
+        keys: [],
+        qcmGeneratorProps: { answer },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(3, 13) * (0, randint_1.randint)(3, 13) + '');
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.rectangleArea = {
+    id: 'rectangleArea',
+    connector: '=',
+    label: "Calculer l'aire d'un rectangle",
+    levels: ['4ème', '3ème', '2nde'],
+    isSingleStep: false,
+    sections: ['Géométrie euclidienne'],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRectangleArea, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+};

package/lib/exercises/geometry/euclidean/rectanglePerimeter.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from '../../../exercises/exercise';
+type QCMProps = {
+    answer: string;
+};
+type VEAProps = {};
+export declare const rectanglePerimeter: MathExercise<QCMProps, VEAProps>;
+export {};
+//# sourceMappingURL=rectanglePerimeter.d.ts.map

package/lib/exercises/geometry/euclidean/rectanglePerimeter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rectanglePerimeter.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/rectanglePerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AA2BnB,eAAO,MAAM,kBAAkB,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAW/D,CAAC"}