math-exercises 1.3.32 → 1.3.34

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

@@ -1,53 +1,53 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTriangleArea = exports.triangleArea = 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");
-exports.triangleArea = {
-    id: 'triangleArea',
-    connector: '=',
-    instruction: '',
-    label: "Calculer l'aire d'un triangle",
-    levels: ['4', '3', '2'],
-    isSingleStep: false,
-    section: 'Géométrie euclidienne',
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTriangleArea, nb),
-};
-function 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 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: (sidesLength[randoms[0]] * height) / 2 + '',
-        keys: [...vertices, 'equal', 'cm2'],
-        commands,
-        coords: triangle.generateCoords(),
-    };
-    return question;
-}
-exports.getTriangleArea = getTriangleArea;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTriangleArea = exports.triangleArea = 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");
+exports.triangleArea = {
+    id: 'triangleArea',
+    connector: '=',
+    instruction: '',
+    label: "Calculer l'aire d'un triangle",
+    levels: ['4', '3', '2'],
+    isSingleStep: false,
+    section: 'Géométrie euclidienne',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getTriangleArea, nb),
+};
+function 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 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: (sidesLength[randoms[0]] * height) / 2 + '',
+        keys: [...vertices, 'equal', 'cm2'],
+        commands,
+        coords: triangle.generateCoords(),
+    };
+    return question;
+}
+exports.getTriangleArea = getTriangleArea;

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

@@ -1,4 +1,4 @@
-import { Exercise, Question } from '../../../exercises/exercise';
-export declare const pythagore: Exercise;
-export declare function getPythagore(): Question;
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const pythagore: Exercise;
+export declare function getPythagore(): Question;
 //# sourceMappingURL=pythagore.d.ts.map

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

@@ -1,31 +1,31 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPythagore = exports.pythagore = void 0;
-const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const triangles_1 = require("../../../math/geometry/triangles");
-const randint_1 = require("../../../math/utils/random/randint");
-exports.pythagore = {
-    id: 'pythagore',
-    connector: '=',
-    instruction: "Écrire l'égalité de Pythagore pour la figure suivante : ",
-    label: "Ecrire l'égalité de Pythagore",
-    levels: ['4', '3', '2'],
-    isSingleStep: false,
-    section: 'Géométrie euclidienne',
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPythagore, nb),
-};
-function 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 question = {
-        answer: `${triangle.getSideAName()}^2 = ${triangle.getSideBName()}^2 + ${triangle.getSideCName()}^2`,
-        keys: [...vertices, 'equal'],
-        commands: triangle.generateCommands({}),
-        coords: triangle.generateCoords(),
-    };
-    return question;
-}
-exports.getPythagore = getPythagore;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPythagore = exports.pythagore = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const triangles_1 = require("../../../math/geometry/triangles");
+const randint_1 = require("../../../math/utils/random/randint");
+exports.pythagore = {
+    id: 'pythagore',
+    connector: '=',
+    instruction: "Écrire l'égalité de Pythagore pour la figure suivante : ",
+    label: "Ecrire l'égalité de Pythagore",
+    levels: ['4', '3', '2'],
+    isSingleStep: false,
+    section: 'Géométrie euclidienne',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPythagore, nb),
+};
+function 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 question = {
+        answer: `${triangle.getSideAName()}^2 = ${triangle.getSideBName()}^2 + ${triangle.getSideCName()}^2`,
+        keys: [...vertices, 'equal'],
+        commands: triangle.generateCommands({}),
+        coords: triangle.generateCoords(),
+    };
+    return question;
+}
+exports.getPythagore = getPythagore;

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

@@ -1,4 +1,4 @@
-import { Exercise, Question } from '../../../exercises/exercise';
-export declare const pythagoreCalcul: Exercise;
-export declare function getPythagoreCalcul(): Question;
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const pythagoreCalcul: Exercise;
+export declare function getPythagoreCalcul(): Question;
 //# sourceMappingURL=pythagoreCalcul.d.ts.map

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

@@ -1,60 +1,60 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getPythagoreCalcul = exports.pythagoreCalcul = 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 coinFlip_1 = require("../../../utils/coinFlip");
-const shuffle_1 = require("../../../utils/shuffle");
-exports.pythagoreCalcul = {
-    id: 'pythagoreCalcul',
-    connector: '=',
-    instruction: '',
-    label: 'Utiliser le théoreme de Pythagore pour faire des calculs',
-    levels: ['3', '2'],
-    isSingleStep: false,
-    section: 'Géométrie euclidienne',
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPythagoreCalcul, nb),
-};
-function 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]],
-        }),
-    ];
-    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: answer + '',
-        keys: [...vertices, 'equal'],
-        commands,
-        coords: triangle.generateCoords(),
-    };
-    return question;
-}
-exports.getPythagoreCalcul = getPythagoreCalcul;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPythagoreCalcul = exports.pythagoreCalcul = 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 coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+exports.pythagoreCalcul = {
+    id: 'pythagoreCalcul',
+    connector: '=',
+    instruction: '',
+    label: 'Utiliser le théoreme de Pythagore pour faire des calculs',
+    levels: ['3', '2'],
+    isSingleStep: false,
+    section: 'Géométrie euclidienne',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPythagoreCalcul, nb),
+};
+function 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]],
+        }),
+    ];
+    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: answer + '',
+        keys: [...vertices, 'equal'],
+        commands,
+        coords: triangle.generateCoords(),
+    };
+    return question;
+}
+exports.getPythagoreCalcul = getPythagoreCalcul;

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

@@ -1,4 +1,4 @@
-import { Exercise, Question } from '../../../exercises/exercise';
-export declare const rightTriangleArea: Exercise;
-export declare function getRightTriangleArea(): Question;
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const rightTriangleArea: Exercise;
+export declare function getRightTriangleArea(): Question;
 //# sourceMappingURL=rightTriangleArea.d.ts.map

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

@@ -1,39 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRightTriangleArea = exports.rightTriangleArea = void 0;
-const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const triangles_1 = require("../../../math/geometry/triangles");
-const randint_1 = require("../../../math/utils/random/randint");
-exports.rightTriangleArea = {
-    id: 'rightTriangleArea',
-    connector: '=',
-    instruction: '',
-    label: "Calculer l'aire d'un triangle rectangle",
-    levels: ['4', '3', '2'],
-    isSingleStep: false,
-    section: 'Géométrie euclidienne',
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRightTriangleArea, nb),
-};
-function 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 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: (sidesLength[0] * sidesLength[1]) / 2 + '',
-        keys: [...vertices, 'equal', 'cm2'],
-        commands,
-        coords: triangle.generateCoords(),
-    };
-    return question;
-}
-exports.getRightTriangleArea = getRightTriangleArea;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRightTriangleArea = exports.rightTriangleArea = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const triangles_1 = require("../../../math/geometry/triangles");
+const randint_1 = require("../../../math/utils/random/randint");
+exports.rightTriangleArea = {
+    id: 'rightTriangleArea',
+    connector: '=',
+    instruction: '',
+    label: "Calculer l'aire d'un triangle rectangle",
+    levels: ['4', '3', '2'],
+    isSingleStep: false,
+    section: 'Géométrie euclidienne',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRightTriangleArea, nb),
+};
+function 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 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: (sidesLength[0] * sidesLength[1]) / 2 + '',
+        keys: [...vertices, 'equal', 'cm2'],
+        commands,
+        coords: triangle.generateCoords(),
+    };
+    return question;
+}
+exports.getRightTriangleArea = getRightTriangleArea;

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

@@ -1,4 +1,4 @@
-import { Exercise, Question } from '../../../exercises/exercise';
-export declare const thales: Exercise;
-export declare function getThales(): Question;
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const thales: Exercise;
+export declare function getThales(): Question;
 //# sourceMappingURL=thales.d.ts.map

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

@@ -1,67 +1,67 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getThales = exports.thales = void 0;
-const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
-const randint_1 = require("../../../math/utils/random/randint");
-exports.thales = {
-    id: 'thales',
-    connector: '=',
-    instruction: '',
-    label: "Ecrire l'égalité de Thalès",
-    levels: ['5', '4', '3', '2'],
-    isSingleStep: false,
-    section: 'Géométrie euclidienne',
-    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getThales, nb),
-};
-function 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 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: `\\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]}}`,
-        keys: [...vertices, 'equal'],
-        commands,
-        coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
-    };
-    return question;
-}
-exports.getThales = getThales;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThales = exports.thales = void 0;
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+exports.thales = {
+    id: 'thales',
+    connector: '=',
+    instruction: '',
+    label: "Ecrire l'égalité de Thalès",
+    levels: ['5', '4', '3', '2'],
+    isSingleStep: false,
+    section: 'Géométrie euclidienne',
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getThales, nb),
+};
+function 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 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: `\\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]}}`,
+        keys: [...vertices, 'equal'],
+        commands,
+        coords: [xMin - 1, xMax + 1, yMin - 1, yMax + 1],
+    };
+    return question;
+}
+exports.getThales = getThales;

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

@@ -1,4 +1,4 @@
-import { Exercise, Question } from '../../../exercises/exercise';
-export declare const thalesCalcul: Exercise;
-export declare function getThales(): Question;
+import { Exercise, Question } from '../../../exercises/exercise';
+export declare const thalesCalcul: Exercise;
+export declare function getThales(): Question;
 //# sourceMappingURL=thalesCalcul.d.ts.map