math-exercises 2.1.21 → 2.1.23

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

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rightTriangleArea = 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 shuffle_1 = require("../../../utils/shuffle");
-const getRightTriangleArea = () => {
-    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.4, maxRapport: 1.6, names: vertices });
-    const sidesLength = [Math.round(triangle.getSideBnumber() / 2), Math.round(triangle.getSideCnumber() / 2)];
-    const commands = [
-        ...triangle.generateCommands({
-            showLabels: [triangle.getSideBName(), triangle.getSideCName()],
-            setCaptions: [sidesLength[0] + '', sidesLength[1] + ''],
-        }),
-    ];
-    const answer = ((sidesLength[0] * sidesLength[1]) / 2 + '').replace('.', ',');
-    const question = {
-        instruction: `Calculer l'aire du triangle ${triangle.getTriangleName()} rectangle en ${triangle.getRightAngle()} sachant que ${triangle.getSideBName()} = $${sidesLength[0]}$ cm et ${triangle.getSideCName()} = $${sidesLength[1]}$ cm.`,
-        answer,
-        keys: [...vertices, 'equal', 'cm2'],
-        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) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, ((0, randint_1.randint)(2, 12) * (0, randint_1.randint)(2, 12)) / 2 + '');
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-exports.rightTriangleArea = {
-    id: 'rightTriangleArea',
-    connector: '=',
-    label: "Calculer l'aire d'un triangle rectangle",
-    levels: ['4ème', '3ème', '2nde'],
-    isSingleStep: false,
-    sections: ['Géométrie euclidienne'],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRightTriangleArea, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-};

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"squareArea.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/squareArea.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;AAyBnB,eAAO,MAAM,UAAU,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAYvD,CAAC"}

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

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.squareArea = 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 getSquareArea = () => {
-    const side = (0, randint_1.randint)(1, 21);
-    const answer = side ** 2 + '';
-    const question = {
-        instruction: `Calculer l'aire d'un carré de $${side}$ cm de côté.`,
-        answer: side ** 2 + '',
-        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)(1, 13) ** 2 + '');
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-exports.squareArea = {
-    id: 'squareArea',
-    connector: '=',
-    label: "Calculer l'aire d'un carré",
-    levels: ['4ème', '3ème', '2nde'],
-    isSingleStep: false,
-    sections: ['Géométrie euclidienne'],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSquareArea, nb, 20),
-    qcmTimer: 60,
-    freeTimer: 60,
-    maxAllowedQuestions: 20,
-    getPropositions,
-};

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"squarePerimeter.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/squarePerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AA0BnB,eAAO,MAAM,eAAe,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAY5D,CAAC"}

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

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.squarePerimeter = 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 getSquarePerimeter = () => {
-    const side = (0, randint_1.randint)(1, 21);
-    const answer = side * 4 + '';
-    const question = {
-        instruction: `Calculer le périmètre d'un carré de $${side}$ cm de côté.`,
-        answer,
-        answerFormat: 'tex',
-        keys: [],
-        qcmGeneratorProps: { answer, side },
-    };
-    return question;
-};
-const getPropositions = (n, { answer, side }) => {
-    const propositions = [];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    while (propositions.length < n) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, side * 4 + (0, randint_1.randint)(-side * 4 + 1, 14, [0]) + '');
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-exports.squarePerimeter = {
-    id: 'squarePerimeter',
-    connector: '=',
-    label: "Calculer le périmètre d'un carré",
-    levels: ['4ème', '3ème', '2nde'],
-    isSingleStep: false,
-    sections: ['Géométrie euclidienne'],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSquarePerimeter, nb, 20),
-    qcmTimer: 60,
-    freeTimer: 60,
-    maxAllowedQuestions: 20,
-    getPropositions,
-};

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

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

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

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

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

@@ -1,95 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.thales = 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 getThales = () => {
-    const vertices = [];
-    const code = 65 + (0, randint_1.randint)(0, 22); // Générer un code de caractère majuscule aléatoire (A-Z)
-    for (let i = 0; i < 5; i++)
-        vertices.push(String.fromCharCode(code + i));
-    const [xA, yA] = [(0, randint_1.randint)(-10, 11), (0, randint_1.randint)(-10, 11)];
-    let xB, yB, xC, yC;
-    let d1, d2; // distance entre le point A et B
-    let theta = 0; // angle entre AB et AC
-    do {
-        [xB, yB, xC, yC] = [(0, randint_1.randint)(-10, 11), (0, randint_1.randint)(-10, 11), (0, randint_1.randint)(-10, 11), (0, randint_1.randint)(-10, 11)];
-        d1 = Math.hypot(xB - xA, yB - yA); // Calculer la distance entre A et B
-        d2 = Math.hypot(xC - xA, yC - yA); // Calculer la distance entre A et C
-        theta = Math.acos(((xB - xA) * (xC - xA) + (yB - yA) * (yC - yA)) / (d1 * d2));
-    } while (!theta || theta < 0.35 || theta > 2.1 || d1 / d2 > 1.3 || d1 / d2 < 0.7);
-    const factor = (0, randint_1.randint)(-5, 6, [-2, -1, 0, 1, 2]) / 10; // facteur = AB/AE, Pour que l'affichage soit acceptable, les valeurs de factor sont +- 0.5 0.4 0.3
-    const [xD, yD] = [xA + factor * (xB - xA), yA + factor * (yB - yA)];
-    const [xE, yE] = [xA + factor * (xC - xA), yA + factor * (yC - yA)];
-    const xMin = Math.min(xA, xB, xC, xD, xE);
-    const xMax = Math.max(xA, xB, xC, xD, xE);
-    const yMin = Math.min(yA, yB, yC, yD, yE);
-    const yMax = Math.max(yA, yB, yC, yD, yE);
-    const commands = [
-        `${vertices[0]} = Point({${xA}, ${yA}})`,
-        `${vertices[1]} = Point({${xB}, ${yB}})`,
-        `${vertices[2]} = Point({${xC}, ${yC}})`,
-        `${vertices[3]} = Point(${vertices[0]}, Vector(${factor}Vector(${vertices[0]},${vertices[1]})))`,
-        `${vertices[4]} = Intersect(Line(${vertices[3]}, Line(${vertices[1]}, ${vertices[2]})) , Line(${vertices[0]}, ${vertices[2]}))`,
-        `l = Segment(${vertices[0]}, ${vertices[1]})`,
-        `i = Segment(${vertices[0]}, ${vertices[2]})`,
-        `j = Segment(${vertices[1]}, ${vertices[2]})`,
-        `k = Segment(${vertices[3]}, ${vertices[4]})`,
-        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[3]}))`,
-        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[4]}))`,
-        `ShowAxes(false)`,
-        `ShowGrid(false)`,
-        `ShowLabel(${vertices[0]}, true)`,
-        `ShowLabel(${vertices[1]}, true)`,
-        `ShowLabel(${vertices[2]}, true)`,
-        `ShowLabel(${vertices[3]}, true)`,
-        `ShowLabel(${vertices[4]}, true)`,
-    ];
-    const answer = `\\frac{${vertices[0]}${vertices[3]}}{${vertices[0]}${vertices[1]}}=\\frac{${vertices[0]}${vertices[4]}}{${vertices[0]}${vertices[2]}}=\\frac{${vertices[3]}${vertices[4]}}{${vertices[1]}${vertices[2]}}`;
-    const question = {
-        instruction: `En utilisant le théoreme de Thalès, Écrire l'égalité des quotients sachant que :$\\\\$ (${vertices[3]}${vertices[4]})//(${vertices[1]}${vertices[2]})`,
-        answer,
-        keys: [...vertices, 'equal'],
-        commands,
-        coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
-        answerFormat: 'tex',
-        qcmGeneratorProps: { answer, vertices },
-    };
-    return question;
-};
-const getPropositions = (n, { answer, vertices }) => {
-    const propositions = [];
-    const wrongQuotients = [
-        vertices[0] + vertices[3],
-        vertices[0] + vertices[1],
-        vertices[0] + vertices[4],
-        vertices[0] + vertices[2],
-        vertices[3] + vertices[4],
-        vertices[1] + vertices[2],
-        vertices[1] + vertices[3],
-        vertices[2] + vertices[4],
-    ];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    const indexRange = Array.from({ length: 8 }, (_, i) => i);
-    while (propositions.length < n) {
-        const rands = (0, shuffle_1.shuffle)(indexRange).slice(0, 6);
-        (0, exercise_1.tryToAddWrongProp)(propositions, `\\frac{${wrongQuotients[rands[0]]}}{${wrongQuotients[rands[1]]}} = 
-    \\frac{${wrongQuotients[rands[2]]}}{${wrongQuotients[rands[3]]}} = 
-    \\frac{${wrongQuotients[rands[4]]}}{${wrongQuotients[rands[5]]}}`);
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-exports.thales = {
-    id: 'thales',
-    connector: '=',
-    label: "Ecrire l'égalité de Thalès",
-    levels: ['5ème', '4ème', '3ème', '2nde'],
-    isSingleStep: false,
-    sections: ['Géométrie euclidienne'],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getThales, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-};

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"thalesCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/thalesCalcul.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;AAmInB,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWzD,CAAC"}

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

@@ -1,118 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.thalesCalcul = void 0;
-const exercise_1 = require("../../../exercises/exercise");
-const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const randint_1 = require("../../../math/utils/random/randint");
-const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
-const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
-const simplify_1 = require("../../../tree/parsers/simplify");
-const coinFlip_1 = require("../../../utils/coinFlip");
-const shuffle_1 = require("../../../utils/shuffle");
-const getThales = () => {
-    const vertices = [];
-    const code = 65 + (0, randint_1.randint)(0, 22); // Générer un code de caractère majuscule aléatoire (A-Z)
-    for (let i = 0; i < 5; i++)
-        vertices.push(String.fromCharCode(code + i));
-    const [xA, yA] = [(0, randint_1.randint)(-10, 11), (0, randint_1.randint)(-10, 11)];
-    let xB, yB, xC, yC;
-    let d1, d2, d3; // distance entre le point A et B
-    let theta = 0; // angle entre AB et AC
-    do {
-        [xB, yB, xC, yC] = [(0, randint_1.randint)(-10, 11), (0, randint_1.randint)(-10, 11), (0, randint_1.randint)(-10, 11), (0, randint_1.randint)(-10, 11)];
-        d1 = Math.hypot(xB - xA, yB - yA); // Calculer la distance entre A et B
-        d2 = Math.hypot(xC - xA, yC - yA); // Calculer la distance entre A et C
-        theta = Math.acos(((xB - xA) * (xC - xA) + (yB - yA) * (yC - yA)) / (d1 * d2));
-    } while (!theta || theta < 0.35 || theta > 2.1 || d1 / d2 > 1.3 || d1 / d2 < 0.7);
-    d3 = Math.sqrt(d1 ** 2 + d2 ** 2 - 2 * d1 * d2 * Math.cos(theta)); // Calculer la distance entre C et B
-    // CB² = AB² * AC² - 2*AB*AC*cos(theta)  : pythagore généralisé
-    const factor = (0, randint_1.randint)(-5, 6, [-2, -1, 0, 1, 2]) / 10; // facteur = AB/AE, Pour que l'affichage soit acceptable, les valeurs de factor sont +- 0.5 0.4 0.3
-    const [xD, yD] = [xA + factor * (xB - xA), yA + factor * (yB - yA)];
-    const [xE, yE] = [xA + factor * (xC - xA), yA + factor * (yC - yA)];
-    const xMin = Math.min(xA, xB, xC, xD, xE);
-    const xMax = Math.max(xA, xB, xC, xD, xE);
-    const yMin = Math.min(yA, yB, yC, yD, yE);
-    const yMax = Math.max(yA, yB, yC, yD, yE);
-    // AB AC BC AD AE
-    const sides = [
-        `${vertices[0]}${vertices[1]}`,
-        `${vertices[0]}${vertices[3]}`,
-        `${vertices[0]}${vertices[2]}`,
-        `${vertices[0]}${vertices[4]}`,
-        `${vertices[1]}${vertices[2]}`,
-        `${vertices[3]}${vertices[4]}`,
-    ];
-    // round pour avoir des valeurs dans N tout en gardant les proportions pour que ça soit cohérent. sides[i] a pour longueur sideLengths[i]
-    const sideLengths = [d1, factor * d1, d2, factor * d2, d3, factor * d3].map((el) => Math.round(Math.abs(el)));
-    const rand = (0, randint_1.randint)(0, 3);
-    let rand2 = (0, randint_1.randint)(0, 3, [rand]);
-    if (sideLengths[2 * rand] === sideLengths[2 * rand2])
-        rand2 = (0, randint_1.randint)(0, 3, [rand, rand2]); // condition pour pas prendre 2 longueurs identiques
-    let instruction = `Dans la figure ci-dessous, nous avons (${vertices[3]}${vertices[4]})//(${vertices[1]}${vertices[2]}), `;
-    let statement;
-    let startStatement;
-    if ((0, coinFlip_1.coinFlip)()) {
-        // a/b = c/d on cherche c
-        instruction += `${sides[2 * rand]} = $${sideLengths[2 * rand]}$, ${sides[2 * rand + 1]} = $${sideLengths[2 * rand + 1]}$, ${sides[2 * rand2]} = $${sideLengths[2 * rand2]}$.$\\\\$Déterminer ${sides[2 * rand2 + 1]}`;
-        startStatement = `${sides[2 * rand2 + 1]}`;
-        statement = (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(sideLengths[2 * rand2] * sideLengths[2 * rand + 1]), new numberNode_1.NumberNode(sideLengths[2 * rand])));
-    }
-    else {
-        // a/b = c/d on cherche d
-        instruction += `${sides[2 * rand]} = $${sideLengths[2 * rand]}$, ${sides[2 * rand + 1]} = $${sideLengths[2 * rand + 1]}$, ${sides[2 * rand2 + 1]} = $${sideLengths[2 * rand2 + 1]}$.$\\\\$Déterminer ${sides[2 * rand2]}`;
-        startStatement = `${sides[2 * rand2]}`;
-        statement = (0, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new numberNode_1.NumberNode(sideLengths[2 * rand2 + 1] * sideLengths[2 * rand]), new numberNode_1.NumberNode(sideLengths[2 * rand + 1])));
-    }
-    const commands = [
-        `${vertices[0]} = Point({${xA}, ${yA}})`,
-        `${vertices[1]} = Point({${xB}, ${yB}})`,
-        `${vertices[2]} = Point({${xC}, ${yC}})`,
-        `${vertices[3]} = Point(${vertices[0]}, Vector(${factor}Vector(${vertices[0]},${vertices[1]})))`,
-        `${vertices[4]} = Intersect(Line(${vertices[3]}, Line(${vertices[1]}, ${vertices[2]})) , Line(${vertices[0]}, ${vertices[2]}))`,
-        `l = Segment(${vertices[0]}, ${vertices[1]})`,
-        `i = Segment(${vertices[0]}, ${vertices[2]})`,
-        `j = Segment(${vertices[1]}, ${vertices[2]})`,
-        `k = Segment(${vertices[3]}, ${vertices[4]})`,
-        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[3]}))`,
-        `If(${factor} < 0, Segment(${vertices[0]}, ${vertices[4]}))`,
-        `ShowAxes(false)`,
-        `ShowGrid(false)`,
-        `ShowLabel(${vertices[0]}, true)`,
-        `ShowLabel(${vertices[1]}, true)`,
-        `ShowLabel(${vertices[2]}, true)`,
-        `ShowLabel(${vertices[3]}, true)`,
-        `ShowLabel(${vertices[4]}, true)`,
-    ];
-    const answer = statement.toTex();
-    const question = {
-        instruction,
-        startStatement,
-        answer,
-        keys: [],
-        commands,
-        coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
-        answerFormat: 'tex',
-        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, simplify_1.simplifyNode)(new fractionNode_1.FractionNode(new numberNode_1.NumberNode((0, randint_1.randint)(2, 30)), new numberNode_1.NumberNode((0, randint_1.randint)(2, 30)))).toTex());
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-exports.thalesCalcul = {
-    id: 'thalesCalcul',
-    connector: '=',
-    label: 'Utiliser le théoreme de Thalès pour faire des calculs',
-    levels: ['5ème', '4ème', '3ème', '2nde'],
-    isSingleStep: false,
-    sections: ['Géométrie euclidienne'],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getThales, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-};

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"triangleArea.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/triangleArea.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;AA6DnB,eAAO,MAAM,YAAY,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWzD,CAAC"}

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

@@ -1,66 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.triangleArea = 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 shuffle_1 = require("../../../utils/shuffle");
-const getTriangleArea = () => {
-    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.createRandomTriangle({ minAngle: 0.69, maxAngle: 1.5, names: vertices });
-    const sides = [triangle.getSideAName(), triangle.getSideBName(), triangle.getSideCName()];
-    const sidesLength = [triangle.getSideAnumber(), triangle.getSideBnumber(), triangle.getSideCnumber()].map((el) => Math.round(el / 2));
-    const angles = [triangle.getAngleA(), triangle.getAngleB(), triangle.getAngleC()];
-    const randoms = (0, shuffle_1.shuffle)([0, 1, 2]);
-    const height = Math.round(sidesLength[randoms[1]] * Math.sin(angles[randoms[2]]));
-    const commands = [
-        ...triangle.generateCommands({
-            showLabels: [sides[randoms[0]]],
-            setCaptions: [sidesLength[randoms[0]] + ''],
-        }),
-        `poi = Intersect(PerpendicularLine(${vertices[randoms[0]]},${sides[randoms[0]]}),${sides[randoms[0]]})`,
-        `ShowLabel(poi, true)`,
-        `SetCaption(poi, "${String.fromCharCode(code + 3)}")`,
-        `seg = Segment(${vertices[randoms[0]]}, poi)`,
-        `ShowLabel(seg, true)`,
-        `SetCaption(seg, "${height}")`,
-        `SetLineStyle(seg, 1)`,
-        `alpha = Angle(${vertices[randoms[0]]},poi ,${vertices[randoms[1]]}, Line(${vertices[randoms[0]]},poi))`,
-        `ShowLabel(alpha, false)`,
-    ];
-    const answer = ((sidesLength[randoms[0]] * height) / 2 + '').replace('.', ',');
-    const question = {
-        instruction: `Calculer l'aire du triangle ${triangle.getTriangleName()} sachant que ${sides[randoms[0]]} = $${sidesLength[randoms[0]]}$ cm et la hauteur ${vertices[randoms[0]]}${String.fromCharCode(code + 3)} = $${height}$ cm.`,
-        answer,
-        keys: [...vertices, 'equal', 'cm2'],
-        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) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, ((0, randint_1.randint)(2, 12) * (0, randint_1.randint)(2, 12)) / 2 + '');
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-exports.triangleArea = {
-    id: 'triangleArea',
-    connector: '=',
-    label: "Calculer l'aire d'un triangle (avec figure)",
-    levels: ['5ème', '4ème', '3ème', '2nde'],
-    isSingleStep: false,
-    sections: ['Géométrie euclidienne'],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTriangleArea, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-};

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"triangleAreaV2.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/triangleAreaV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AAgDnB,eAAO,MAAM,cAAc,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAY3D,CAAC"}

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

@@ -1,61 +0,0 @@
-"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 question = {
-        instruction: `Calculer l'aire du triangle rectangle qui a pour côtés: $${sides[randomSide][0]}$ cm, $${sides[randomSide][1]}$ cm et $${sides[randomSide][2]}$ cm.`,
-        answer,
-        answerFormat: 'tex',
-        keys: [],
-        qcmGeneratorProps: { answer, randomSide },
-    };
-    return question;
-};
-const getPropositions = (n, { answer, randomSide }) => {
-    const propositions = [];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    const area = Number(answer);
-    (0, exercise_1.tryToAddWrongProp)(propositions, sides[randomSide][0] + sides[randomSide][1] + sides[randomSide][2] + '');
-    while (propositions.length < n) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, area + (0, randint_1.randint)(-area + 1, 14, [0]) + '');
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-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: ['Géométrie euclidienne'],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTriangleAreaV2, nb, 16),
-    qcmTimer: 60,
-    freeTimer: 60,
-    maxAllowedQuestions: 16,
-    getPropositions,
-};

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"trianglePerimeter.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/trianglePerimeter.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;AA2BnB,eAAO,MAAM,iBAAiB,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAW9D,CAAC"}

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

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.trianglePerimeter = 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 getTrianglePerimeter = () => {
-    const sides = [(0, randint_1.randint)(1, 13), (0, randint_1.randint)(1, 13), (0, randint_1.randint)(1, 13)];
-    const answer = sides[0] + sides[1] + sides[2] + '';
-    const question = {
-        instruction: `Calculer le périmètre d'un triangle qui a pour côtés: $${sides[0]}$ cm, $${sides[1]}$ cm et $${sides[2]}$ cm.`,
-        answer,
-        answerFormat: 'tex',
-        keys: [],
-        qcmGeneratorProps: { answer },
-    };
-    return question;
-};
-const getPropositions = (n, { answer }) => {
-    const propositions = [];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    const perimeter = Number(answer);
-    while (propositions.length < n) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, perimeter + (0, randint_1.randint)(-perimeter + 1, 14, [0]) + '');
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-exports.trianglePerimeter = {
-    id: 'trianglePerimeter',
-    connector: '=',
-    label: "Calculer le périmètre d'un triangle",
-    levels: ['5ème', '4ème', '3ème', '2nde'],
-    isSingleStep: false,
-    sections: ['Géométrie euclidienne'],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrianglePerimeter, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-};

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

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

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

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