math-exercises 2.0.11 → 2.0.13

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

@@ -1,54 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.triangleAreaV2 = void 0;
-const exercise_1 = require("../../../exercises/exercise");
+exports.getTriangleAreaV2 = exports.triangleAreaV2 = void 0;
 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);
-};
+const uuid_1 = require("uuid");
 exports.triangleAreaV2 = {
     id: 'triangleAreaV2',
     connector: '=',
+    instruction: '',
     label: "Calculer l'aire d'un triangle (sans figure)",
     levels: ['5ème', '4ème', '3ème', '2nde'],
     isSingleStep: false,
@@ -57,5 +17,65 @@ exports.triangleAreaV2 = {
     qcmTimer: 60,
     freeTimer: 60,
     maxAllowedQuestions: 16,
-    getPropositions,
 };
+function getTriangleAreaV2() {
+    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 randomSide = (0, randint_1.randint)(0, sides.length);
+    const area = (sides[randomSide][0] * sides[randomSide][1]) / 2;
+    const getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)() + '',
+            statement: area + '',
+            isRightAnswer: true,
+            format: 'tex',
+        });
+        res.push({
+            id: (0, uuid_1.v4)() + '',
+            statement: sides[randomSide][0] + sides[randomSide][1] + sides[randomSide][2] + '',
+            isRightAnswer: false,
+            format: 'tex',
+        });
+        for (let i = 0; i < n - 2; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                proposition = {
+                    id: (0, uuid_1.v4)() + '',
+                    statement: area + (0, randint_1.randint)(-area + 1, 14, [0]) + '',
+                    isRightAnswer: false,
+                    format: 'tex',
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, shuffle_1.shuffle)(res);
+    };
+    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: area + '',
+        getPropositions,
+        answerFormat: 'tex',
+        keys: [],
+    };
+    return question;
+}
+exports.getTriangleAreaV2 = getTriangleAreaV2;

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

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

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"trianglePerimeter.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/trianglePerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAe,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAM/E,eAAO,MAAM,iBAAiB,EAAE,YAW/B,CAAC;AAEF,wBAAgB,oBAAoB,IAAI,QAAQ,CA4C/C"}

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

@@ -1,34 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trianglePerimeter = void 0;
-const exercise_1 = require("../../../exercises/exercise");
+exports.getTrianglePerimeter = exports.trianglePerimeter = void 0;
 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);
-};
+const uuid_1 = require("uuid");
 exports.trianglePerimeter = {
     id: 'trianglePerimeter',
     connector: '=',
+    instruction: '',
     label: "Calculer le périmètre d'un triangle",
     levels: ['5ème', '4ème', '3ème', '2nde'],
     isSingleStep: false,
@@ -36,5 +16,41 @@ exports.trianglePerimeter = {
     generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrianglePerimeter, nb),
     qcmTimer: 60,
     freeTimer: 60,
-    getPropositions,
 };
+function getTrianglePerimeter() {
+    const sides = [(0, randint_1.randint)(1, 13), (0, randint_1.randint)(1, 13), (0, randint_1.randint)(1, 13)];
+    const perimeter = sides[0] + sides[1] + sides[2];
+    const getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)() + '',
+            statement: perimeter + '',
+            isRightAnswer: true,
+            format: 'tex',
+        });
+        for (let i = 0; i < n - 1; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                proposition = {
+                    id: (0, uuid_1.v4)() + '',
+                    statement: perimeter + (0, randint_1.randint)(-perimeter + 1, 14, [0]) + '',
+                    isRightAnswer: false,
+                    format: 'tex',
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, shuffle_1.shuffle)(res);
+    };
+    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: sides[0] + sides[1] + sides[2] + '',
+        getPropositions,
+        answerFormat: 'tex',
+        keys: [],
+    };
+    return question;
+}
+exports.getTrianglePerimeter = getTrianglePerimeter;

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

@@ -1,11 +1,4 @@
-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 {};
+import { MathExercise, Question } from '../../../exercises/exercise';
+export declare const trigonometry: MathExercise;
+export declare function getTrigonometry(): Question;
 //# sourceMappingURL=trigonometry.d.ts.map

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

@@ -1 +1 @@
-{"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"}
+{"version":3,"file":"trigonometry.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/trigonometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAe,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAQ/E,eAAO,MAAM,YAAY,EAAE,YAW1B,CAAC;AAEF,wBAAgB,eAAe,IAAI,QAAQ,CA0F1C"}

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

@@ -1,20 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trigonometry = void 0;
-const exercise_1 = require("../../../exercises/exercise");
+exports.getTrigonometry = exports.trigonometry = void 0;
 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 getTrigonometry = () => {
+const uuid_1 = require("uuid");
+exports.trigonometry = {
+    id: 'trigonometry',
+    connector: '=',
+    instruction: '',
+    label: "Écrire le quotient égal au cosinus, au sinus ou à la tangente d'un angle dans un triangle rectangle",
+    levels: ['4ème', '3ème', '2nde'],
+    isSingleStep: false,
+    sections: ['Géométrie euclidienne'],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometry, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+};
+function getTrigonometry() {
     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 trigo = ['le cosinus', 'le sinus', 'la tangente'];
     const randTrigo = (0, randint_1.randint)(0, 3);
     const angle = [triangle.vertexB.name, triangle.vertexC.name];
@@ -22,57 +31,69 @@ const getTrigonometry = () => {
     let quotient;
     switch (randAngle) {
         case 0:
-            quotient = [`\\frac{${sideC}}{${sideA}}`, `\\frac{${sideB}}{${sideA}}`, `\\frac{${sideB}}{${sideC}}`];
+            quotient = [
+                `\\frac{${triangle.getSideCName()}}{${triangle.getSideAName()}}`,
+                `\\frac{${triangle.getSideBName()}}{${triangle.getSideAName()}}`,
+                `\\frac{${triangle.getSideBName()}}{${triangle.getSideCName()}}`,
+            ];
             break;
         case 1:
-            quotient = [`\\frac{${sideB}}{${sideA}}`, `\\frac{${sideC}}{${sideA}}`, `\\frac{${sideC}}{${sideB}}`];
+            quotient = [
+                `\\frac{${triangle.getSideBName()}}{${triangle.getSideAName()}}`,
+                `\\frac{${triangle.getSideCName()}}{${triangle.getSideAName()}}`,
+                `\\frac{${triangle.getSideCName()}}{${triangle.getSideBName()}}`,
+            ];
             break;
         default:
             quotient = [''];
     }
-    const answer = quotient[randTrigo];
+    const getPropositions = (n) => {
+        const res = [];
+        const wrongQuotients = [
+            `\\frac{${triangle.getSideCName()}}{${triangle.getSideAName()}}`,
+            `\\frac{${triangle.getSideBName()}}{${triangle.getSideAName()}}`,
+            `\\frac{${triangle.getSideBName()}}{${triangle.getSideCName()}}`,
+            `\\frac{${triangle.getSideBName()}}{${triangle.getSideAName()}}`,
+            `\\frac{${triangle.getSideCName()}}{${triangle.getSideAName()}}`,
+            `\\frac{${triangle.getSideCName()}}{${triangle.getSideBName()}}`,
+            `\\frac{${triangle.getSideAName()}}{${triangle.getSideCName()}}`,
+            `\\frac{${triangle.getSideAName()}}{${triangle.getSideBName()}}`,
+            `\\frac{${triangle.getSideCName()}}{${triangle.getSideBName()}}`,
+            `\\frac{${triangle.getSideAName()}}{${triangle.getSideBName()}}`,
+            `\\frac{${triangle.getSideAName()}}{${triangle.getSideCName()}}`,
+            `\\frac{${triangle.getSideBName()}}{${triangle.getSideCName()}}`,
+        ];
+        res.push({
+            id: (0, uuid_1.v4)() + '',
+            statement: quotient[randTrigo],
+            isRightAnswer: true,
+            format: 'tex',
+        });
+        for (let i = 0; i < n - 1; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                proposition = {
+                    id: (0, uuid_1.v4)() + '',
+                    statement: wrongQuotients[(0, randint_1.randint)(0, 12)],
+                    isRightAnswer: false,
+                    format: 'tex',
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, shuffle_1.shuffle)(res);
+    };
     const question = {
         instruction: `À quel quotient est égal ${trigo[randTrigo]} de l'angle $\\widehat{${angle[randAngle]}}$?`,
-        answer,
+        answer: quotient[randTrigo],
         keys: [...vertices, 'equal'],
         commands: [...triangle.generateCommands({ highlightedAngle: angle[randAngle] })],
         coords: triangle.generateCoords(),
+        getPropositions,
         answerFormat: 'tex',
-        qcmGeneratorProps: { answer, sideA, sideB, sideC },
     };
     return question;
-};
-const getPropositions = (n, { answer, sideA, sideB, sideC }) => {
-    const propositions = [];
-    (0, exercise_1.addValidProp)(propositions, answer);
-    const wrongQuotients = [
-        `\\frac{${sideC}}{${sideA}}`,
-        `\\frac{${sideB}}{${sideA}}`,
-        `\\frac{${sideB}}{${sideC}}`,
-        `\\frac{${sideB}}{${sideA}}`,
-        `\\frac{${sideC}}{${sideA}}`,
-        `\\frac{${sideC}}{${sideB}}`,
-        `\\frac{${sideA}}{${sideC}}`,
-        `\\frac{${sideA}}{${sideB}}`,
-        `\\frac{${sideC}}{${sideB}}`,
-        `\\frac{${sideA}}{${sideB}}`,
-        `\\frac{${sideA}}{${sideC}}`,
-        `\\frac{${sideB}}{${sideC}}`,
-    ];
-    while (propositions.length < n) {
-        (0, exercise_1.tryToAddWrongProp)(propositions, wrongQuotients[(0, randint_1.randint)(0, 12)]);
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-exports.trigonometry = {
-    id: 'trigonometry',
-    connector: '=',
-    label: "Écrire le quotient égal au cosinus, au sinus ou à la tangente d'un angle dans un triangle rectangle",
-    levels: ['4ème', '3ème', '2nde'],
-    isSingleStep: false,
-    sections: ['Géométrie euclidienne'],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometry, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-};
+}
+exports.getTrigonometry = getTrigonometry;

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

@@ -1,8 +1,4 @@
-import { MathExercise } from '../../../exercises/exercise';
-type QCMProps = {
-    answer: string;
-};
-type VEAProps = {};
-export declare const trigonometryAngleCalcul: MathExercise<QCMProps, VEAProps>;
-export {};
+import { MathExercise, Question } from '../../../exercises/exercise';
+export declare const trigonometryAngleCalcul: MathExercise;
+export declare function getTrigonometryAngleCalcul(): Question;
 //# sourceMappingURL=trigonometryAngleCalcul.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AASlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AAqDnB,eAAO,MAAM,uBAAuB,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWpE,CAAC"}
+{"version":3,"file":"trigonometryAngleCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/trigonometryAngleCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAe,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAS/E,eAAO,MAAM,uBAAuB,EAAE,YAWrC,CAAC;AAEF,wBAAgB,0BAA0B,IAAI,QAAQ,CAqErD"}

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

@@ -1,13 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trigonometryAngleCalcul = void 0;
-const exercise_1 = require("../../../exercises/exercise");
+exports.getTrigonometryAngleCalcul = exports.trigonometryAngleCalcul = void 0;
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const triangles_1 = require("../../../math/geometry/triangles");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
 const shuffle_1 = require("../../../utils/shuffle");
-const getTrigonometryAngleCalcul = () => {
+const uuid_1 = require("uuid");
+exports.trigonometryAngleCalcul = {
+    id: 'trigonometryAngleCalcul',
+    connector: '=',
+    instruction: '',
+    label: 'Utiliser la trigonométrie pour calculer un angle',
+    levels: ['4ème', '3ème', '2nde'],
+    isSingleStep: false,
+    sections: ['Géométrie euclidienne'],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometryAngleCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+};
+function getTrigonometryAngleCalcul() {
     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++)
@@ -21,35 +33,39 @@ const getTrigonometryAngleCalcul = () => {
     const answer = randAngle === 0
         ? Math.round((Math.acos(sideLengths[0] / sideLengths[2]) * 180) / Math.PI)
         : Math.round((Math.acos(sideLengths[1] / sideLengths[2]) * 180) / Math.PI);
-    const answerTex = answer + '°';
+    const getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)() + '',
+            statement: answer + '°',
+            isRightAnswer: true,
+            format: 'tex',
+        });
+        for (let i = 0; i < n - 1; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                proposition = {
+                    id: (0, uuid_1.v4)() + '',
+                    statement: (0, randint_1.randint)(20, 80) + '°',
+                    isRightAnswer: false,
+                    format: 'tex',
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, shuffle_1.shuffle)(res);
+    };
     const question = {
         instruction: `Le triangle ${triangle.getTriangleName()} rectangle en ${triangle.getRightAngle()} est tel que ${sides[randSides[0]]} = $${sideLengths[randSides[0]]}$ cm et ${sides[randSides[1]]} = $${sideLengths[randSides[1]]}$ cm.$\\\\$ Calculer $\\widehat{${angle[randAngle]}}$ à 1° près.`,
-        answer: answerTex,
+        answer: answer + '°',
         keys: [...vertices, 'equal', 'degree', 'cos', 'sin', 'tan', 'arccos', 'arcsin', 'arctan'],
         commands: [...triangle.generateCommands({ highlightedAngle: angle[randAngle] })],
         coords: triangle.generateCoords(),
+        getPropositions,
         answerFormat: 'tex',
-        qcmGeneratorProps: { answer: answerTex },
     };
     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)(20, 80) + '°');
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-exports.trigonometryAngleCalcul = {
-    id: 'trigonometryAngleCalcul',
-    connector: '=',
-    label: 'Utiliser la trigonométrie pour calculer un angle',
-    levels: ['4ème', '3ème', '2nde'],
-    isSingleStep: false,
-    sections: ['Géométrie euclidienne'],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometryAngleCalcul, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-};
+}
+exports.getTrigonometryAngleCalcul = getTrigonometryAngleCalcul;

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

@@ -1,8 +1,4 @@
-import { MathExercise } from '../../../exercises/exercise';
-type QCMProps = {
-    answer: string;
-};
-type VEAProps = {};
-export declare const trigonometrySideCalcul: MathExercise<QCMProps, VEAProps>;
-export {};
+import { MathExercise, Question } from '../../../exercises/exercise';
+export declare const trigonometrySideCalcul: MathExercise;
+export declare function getTrigonometrySideCalcul(): Question;
 //# sourceMappingURL=trigonometrySideCalcul.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAOb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AACF,KAAK,QAAQ,GAAG,EAAE,CAAC;AAgEnB,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,QAAQ,EAAE,QAAQ,CAWnE,CAAC"}
+{"version":3,"file":"trigonometrySideCalcul.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/euclidean/trigonometrySideCalcul.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAe,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAS/E,eAAO,MAAM,sBAAsB,EAAE,YAWpC,CAAC;AAEF,wBAAgB,yBAAyB,IAAI,QAAQ,CAgFpD"}

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

@@ -1,13 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.trigonometrySideCalcul = void 0;
-const exercise_1 = require("../../../exercises/exercise");
+exports.getTrigonometrySideCalcul = exports.trigonometrySideCalcul = void 0;
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const triangles_1 = require("../../../math/geometry/triangles");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
 const shuffle_1 = require("../../../utils/shuffle");
-const getTrigonometrySideCalcul = () => {
+const uuid_1 = require("uuid");
+exports.trigonometrySideCalcul = {
+    id: 'trigonometrySideCalcul',
+    connector: '=',
+    instruction: '',
+    label: 'Utiliser la trigonométrie pour calculer un côté',
+    levels: ['4ème', '3ème', '2nde'],
+    isSingleStep: false,
+    sections: ['Géométrie euclidienne'],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometrySideCalcul, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+};
+function getTrigonometrySideCalcul() {
     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++)
@@ -32,35 +44,39 @@ const getTrigonometrySideCalcul = () => {
             highlightedSide: sides[randsideQuestion],
         }),
     ];
-    const answer = `${((0, round_1.round)(sideLengths[randsideQuestion], 1) + '').replace('.', ',')}`;
+    const getPropositions = (n) => {
+        const res = [];
+        res.push({
+            id: (0, uuid_1.v4)() + '',
+            statement: `${(0, round_1.round)(sideLengths[randsideQuestion], 1)}`,
+            isRightAnswer: true,
+            format: 'tex',
+        });
+        for (let i = 0; i < n - 1; i++) {
+            let isDuplicate;
+            let proposition;
+            do {
+                proposition = {
+                    id: (0, uuid_1.v4)() + '',
+                    statement: `${(0, round_1.round)((0, randint_1.randint)(11, 100) / 10, 1)}`,
+                    isRightAnswer: false,
+                    format: 'tex',
+                };
+                isDuplicate = res.some((p) => p.statement === proposition.statement);
+            } while (isDuplicate);
+            res.push(proposition);
+        }
+        return (0, shuffle_1.shuffle)(res);
+    };
     const question = {
         instruction: `Le triangle ${triangle.getTriangleName()} rectangle en ${triangle.getRightAngle()} tel que ${sides[randside]} = $${sideLengths[randside]}$ cm et $\\widehat{${angle[randAngle]}}$ = $${angleValue[randAngle]}$°.$\\\\$ Calculer ${sides[randsideQuestion]} à $0,1$ cm près.`,
-        answer,
+        answer: `${(0, round_1.round)(sideLengths[randsideQuestion], 1)}`,
         keys: [...vertices, 'equal', 'degree', 'cos', 'sin', 'tan', 'arccos', 'arcsin', 'arctan'],
         commands,
         coords: triangle.generateCoords(),
+        getPropositions,
         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, round_1.round)((0, randint_1.randint)(11, 100) / 10, 1)}`);
-    }
-    return (0, shuffle_1.shuffle)(propositions);
-};
-exports.trigonometrySideCalcul = {
-    id: 'trigonometrySideCalcul',
-    connector: '=',
-    label: 'Utiliser la trigonométrie pour calculer un côté',
-    levels: ['4ème', '3ème', '2nde'],
-    isSingleStep: false,
-    sections: ['Géométrie euclidienne'],
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTrigonometrySideCalcul, nb),
-    qcmTimer: 60,
-    freeTimer: 60,
-    getPropositions,
-};
+}
+exports.getTrigonometrySideCalcul = getTrigonometrySideCalcul;

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

@@ -1,7 +1,7 @@
-export * from "./areas";
-export * from "./cartesian";
-export * from "./perimeters";
-export * from "./pythagore";
-export * from "./thales";
-export * from "./vectors";
+export * from "./areas";
+export * from "./cartesian";
+export * from "./perimeters";
+export * from "./pythagore";
+export * from "./thales";
+export * from "./vectors";
 //# sourceMappingURL=index.d.ts.map