math-exercises 3.0.69 → 3.0.71

package/lib/exercises/math/geometry/shapes/basicShapesNaming.js

@@ -1,36 +1,74 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { LineConstructor } from "../../../../math/geometry/line.js";
-import { RayConstructor } from "../../../../math/geometry/ray.js";
-import { SegmentConstructor } from "../../../../math/geometry/segment.js";
+import { LineConstructor, } from "../../../../math/geometry/line.js";
+import { RayConstructor, } from "../../../../math/geometry/ray.js";
+import { SegmentConstructor, } from "../../../../math/geometry/segment.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-//!!Difficile de rendre cet exo non pur QCM car taper la parenthèse ouvre un environnement left/right ce qui empeche de taper des demi droites [AB)
-//!solutions que je vois :
-//! créer une touche parenthèse qui n'ouvre pas left/right (faisable mais relou)
-//! créer des touches [..], (..) et [..) directement (mais il faut déplacer le curseur vers la gauche dans ce cas)
-const getBasicShapesNamingQuestion = () => {
-    let answer = "";
+const buildObj = (identifiers) => {
+    switch (identifiers.type) {
+        case 1: //segment
+            return SegmentConstructor.fromIdentifiers(identifiers.objIds);
+        case 2: //demi-droite
+            return RayConstructor.fromIdentifiers(identifiers.objIds);
+        case 3: //droite
+        default:
+            return LineConstructor.fromIdentifiers(identifiers.objIds);
+    }
+};
+const getInstruction = (identifiers) => {
+    return `Comment se nomme la figure suivante ?`;
+};
+const getAnswer = (identifiers) => {
+    const obj = buildObj(identifiers);
+    const { type } = identifiers;
+    switch (type) {
+        case 1: //segment
+            return obj.name;
+            break;
+        case 2: //demi-droite
+            return obj.name;
+            break;
+        case 3: //droite
+        default:
+            return obj.toTexNoLeftRight();
+            break;
+    }
+};
+const getHint = (identifiers) => {
+    return `On rappelle que : 
+    
+  - Une longueur se note $AB$ ;
+  - Un segment se note $[AB]$ ;
+  - Une demi-droite d'origine $A$ se note $[AB)$ ;
+  - Une droite se note $(AB)$.
+  `;
+};
+const getCorrection = (identifiers) => {
+    const { type } = identifiers;
+    const obj = buildObj(identifiers);
+    return `La figure tracée est ${type === 1
+        ? "un segment"
+        : type === 2
+            ? `une demi-droite d'origine $${obj.startPoint.name}$`
+            : "une droite"}.
+    
+Cette figure se nomme donc $${getAnswer(identifiers)}$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { type } = identifiers;
     const commands = [];
-    const type = randint(1, 4);
-    let startPointName = "";
+    const obj = buildObj(identifiers);
     switch (type) {
         case 1: //segment
-            const segment = SegmentConstructor.random();
-            commands.push(...segment.toGGBCommands(true));
-            answer = segment.name;
+            commands.push(...obj.toGGBCommands(true));
             break;
         case 2: //demi-droite
-            const ray = RayConstructor.random();
-            commands.push(...ray.toGGBCommands(true));
-            answer = ray.name;
-            startPointName = ray.startPoint.name;
+            commands.push(...obj.toGGBCommands(true));
             break;
         case 3: //droite
         default:
-            const line = LineConstructor.random();
-            commands.push(...line.toGGBCommands(true, { color: "black" }));
-            answer = line.toTexNoLeftRight();
+            commands.push(...obj.toGGBCommands(true, { color: "black" }));
             break;
     }
     const ggb = new GeogebraConstructor({
@@ -38,36 +76,52 @@ const getBasicShapesNamingQuestion = () => {
         hideAxes: true,
         hideGrid: true,
     });
+    return ggb.getOptions({
+        coords: [-15, 15, -15, 15],
+    });
+};
+const getKeys = (identifiers) => {
+    const answer = getAnswer(identifiers);
     const letters = answer.substring(1, answer.length - 1).split("");
+    return ["lbracketNoSpace", "rbracketNoSpace", ...letters];
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer,
-        instruction: `Comment se nomme la figure suivante ?`,
-        keys: ["lbracketNoSpace", "rbracketNoSpace", ...letters],
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
         answerFormat: "tex",
-        identifiers: { type, commands },
-        ggbOptions: ggb.getOptions({
-            coords: [-15, 15, -15, 15],
-        }),
+        identifiers,
+        ggbOptions: getGGBOptions(identifiers),
         keyboardOptions: {
             parenthesisShouldNotProduceLeftRight: true,
         },
-        hint: `On rappelle que : 
-    
-- Une longueur se note $AB$ ;
-- Un segment se note $[AB]$ ;
-- Une demi-droite d'origine $A$ se note $[AB)$ ;
-- Une droite se note $(AB)$.
-`,
-        correction: `La figure tracée est ${type === 1
-            ? "un segment"
-            : type === 2
-                ? `une demi-droite d'origine $${startPointName}$`
-                : "une droite"}.
-    
-Cette figure se nomme donc $${answer}$.`,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getBasicShapesNamingQuestion = () => {
+    const type = randint(1, 4);
+    let objIds;
+    switch (type) {
+        case 1: //segment
+            const segment = SegmentConstructor.random();
+            objIds = segment.toIdentifiers();
+            break;
+        case 2: //demi-droite
+            const ray = RayConstructor.random();
+            objIds = ray.toIdentifiers();
+            break;
+        case 3: //droite
+        default:
+            const line = LineConstructor.random();
+            objIds = line.toIdentifiers();
+            break;
+    }
+    const identifiers = { type, objIds };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -94,9 +148,7 @@ export const basicShapesNaming = {
     id: "basicShapesNaming",
     connector: "=",
     label: "Nommer un segment/une demi-droite/une droite",
-    levels: [],
     isSingleStep: true,
-    sections: [],
     generator: (nb) => getDistinctQuestions(getBasicShapesNamingQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -105,4 +157,5 @@ export const basicShapesNaming = {
     subject: "Mathématiques",
     hasGeogebra: true,
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/geometry/vectors/coordinatesReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"coordinatesReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/coordinatesReading.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAoEF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}
+{"version":3,"file":"coordinatesReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/coordinatesReading.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAuFF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAcpD,CAAC"}

package/lib/exercises/math/geometry/vectors/coordinatesReading.js

@@ -4,15 +4,18 @@ import { randomColor } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { IntegerConstructor } from "../../../../math/numbers/integer/integer.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-const getCoordinatesReadingQuestion = () => {
-    const [xA, yA] = IntegerConstructor.randomDifferents(-5, 6, 2);
-    let xB, yB;
-    do {
-        [xB, yB] = IntegerConstructor.randomDifferents(-5, 6, 2);
-    } while (xA === xB && yA === yB);
+const getInstruction = (identifiers) => {
+    return `Lire les coordonnées du vecteur $\\overrightarrow u$ représenté ci-dessous :`;
+};
+const getAnswer = (identifiers) => {
+    const { xA, xB, yA, yB } = identifiers;
     const xDelta = xB - xA;
     const yDelta = yB - yA;
     const answer = `\\left(${xDelta};${yDelta}\\right)`;
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { xA, xB, yA, yB } = identifiers;
     const commands = [
         `u = Vector((${xA},${yA}), (${xB}, ${yB}))`,
         'SetCaption(u, "$\\overrightarrow u$")',
@@ -27,18 +30,30 @@ const getCoordinatesReadingQuestion = () => {
         commands,
         isGridBold: true,
     });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({ xMax, xMin, yMax, yMin }),
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: answer,
-        instruction: `Lire les coordonnées du vecteur $\\overrightarrow u$ représenté ci-dessous :`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: ["semicolon", "vectorU"],
         answerFormat: "tex",
-        ggbOptions: ggb.getOptions({
-            coords: ggb.getAdaptedCoords({ xMax, xMin, yMax, yMin }),
-        }),
-        identifiers: { xA, xB, yA, yB },
+        ggbOptions: getGGBOptions(identifiers),
+        identifiers,
     };
     return question;
 };
+const getCoordinatesReadingQuestion = () => {
+    const [xA, yA] = IntegerConstructor.randomDifferents(-5, 6, 2);
+    let xB, yB;
+    do {
+        [xB, yB] = IntegerConstructor.randomDifferents(-5, 6, 2);
+    } while (xA === xB && yA === yB);
+    const identifiers = { xA, xB, yA, yB };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, xA, xB, yA, yB }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -58,9 +73,7 @@ export const coordinatesReading = {
     id: "coordinatesReading",
     connector: "=",
     label: "Lire les coordonnées d'un vecteur",
-    levels: ["2nde", "1reESM"],
     isSingleStep: true,
-    sections: ["Vecteurs"],
     generator: (nb) => getDistinctQuestions(getCoordinatesReadingQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -68,4 +81,5 @@ export const coordinatesReading = {
     isAnswerValid,
     hasGeogebra: true,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/geometry/vectors/determinant.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"determinant.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/determinant.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAoDF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAa7C,CAAC"}
+{"version":3,"file":"determinant.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/determinant.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAwFF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAY7C,CAAC"}

package/lib/exercises/math/geometry/vectors/determinant.js

@@ -4,23 +4,38 @@ import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-const getDeterminantQuestion = () => {
-    const u = VectorConstructor.random("u");
-    const v = VectorConstructor.random("v");
+const getInstruction = (identifiers) => {
+    const u = new Vector("u", Number(identifiers.uCoords[0]).toTree(), Number(identifiers.uCoords[1]).toTree());
+    const v = new Vector("v", Number(identifiers.uCoords[0]).toTree(), Number(identifiers.uCoords[1]).toTree());
+    return `Soient les vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. 
+  
+Calculer le déterminant $\\det(\\overrightarrow u;\\overrightarrow v)$.`;
+};
+const getAnswer = (identifiers) => {
+    const u = new Vector("u", Number(identifiers.uCoords[0]).toTree(), Number(identifiers.uCoords[1]).toTree());
+    const v = new Vector("v", Number(identifiers.uCoords[0]).toTree(), Number(identifiers.uCoords[1]).toTree());
     const answer = u.determinant(v).simplify();
-    const answerTex = answer.toTex();
+    return answer.toTex();
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        answer: answerTex,
-        instruction: `Soient les vecteurs $${u.toTexWithCoords()}$ et $${v.toTexWithCoords()}$. Calculer le déterminant $\\det(\\overrightarrow u;\\overrightarrow v)$.`,
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: {
-            uCoords: [u.x.toTex(), u.y.toTex()],
-            vCoords: [v.x.toTex(), v.y.toTex()],
-        },
+        identifiers,
     };
     return question;
 };
+const getDeterminantQuestion = () => {
+    const u = VectorConstructor.random("u");
+    const v = VectorConstructor.random("v");
+    const identifiers = {
+        uCoords: [u.x.toTex(), u.y.toTex()],
+        vCoords: [v.x.toTex(), v.y.toTex()],
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, uCoords, vCoords }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -40,13 +55,12 @@ export const determinant = {
     id: "determinant",
     connector: "=",
     label: "Calculer le déterminant de deux vecteurs",
-    levels: ["2nde", "1reESM", "1reSpé"],
     isSingleStep: true,
-    sections: ["Vecteurs"],
     generator: (nb) => getDistinctQuestions(getDeterminantQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/geometry/vectors/drawAVectorInGGB.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"drawAVectorInGGB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/drawAVectorInGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAIT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkCF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAYlD,CAAC"}
+{"version":3,"file":"drawAVectorInGGB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/drawAVectorInGGB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyDF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAWlD,CAAC"}

package/lib/exercises/math/geometry/vectors/drawAVectorInGGB.js

@@ -5,28 +5,43 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
 import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
 import { approxEqual } from "../../../../geogebra/parsers/approxEqual.js";
-const getDrawAVectorInGgbQuestion = () => {
-    const x = randint(-3, 3);
-    const y = x === 0 ? randint(-3, 3, [0]) : randint(-3, 3);
+const getInstruction = (identifiers) => {
+    const { x, y } = identifiers;
     const vector = new Vector("u", x.toTree(), y.toTree());
+    return `Tracer le vecteur $${vector.toTex()}${vector.toInlineCoordsTex()}$`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { x, y } = identifiers;
+    return [`Vector[(0, 0), (${x}, ${y})]`];
+};
+const getStudentGGBOptions = (identifiers) => {
     const studentGGB = new GeogebraConstructor({
         isGridSimple: true,
         customToolBar: toolBarConstructor({
             vector: true,
         }),
     });
+    return studentGGB.getOptions({
+        coords: [-5, 5, -6, 6],
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
-        ggbAnswer: [`Vector[(0, 0), (${x}, ${y})]`],
-        instruction: `Tracer le vecteur $${vector.toTex()}${vector.toInlineCoordsTex()}$`,
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
         keys: [],
-        studentGgbOptions: studentGGB.getOptions({
-            coords: [-5, 5, -6, 6],
-        }),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
         answerFormat: "tex",
-        identifiers: { x, y },
+        identifiers,
     };
     return question;
 };
+const getDrawAVectorInGgbQuestion = () => {
+    const x = randint(-3, 3);
+    const y = x === 0 ? randint(-3, 3, [0]) : randint(-3, 3);
+    const identifiers = { x, y };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const isGGBAnswerValid = (ans, { ggbAnswer, x, y }) => {
     const parser = new GeogebraParser(ans);
     const vectors = parser.vectors();
@@ -38,12 +53,11 @@ const isGGBAnswerValid = (ans, { ggbAnswer, x, y }) => {
 export const drawAVectorInGGB = {
     id: "drawAVectorInGGB",
     label: "Tracer un vecteur",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Géométrie cartésienne"],
     generator: (nb) => getDistinctQuestions(getDrawAVectorInGgbQuestion, nb),
     ggbTimer: 60,
     answerType: "GGB",
     isGGBAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/geometry/vectors/equalCaracteristicFromGraph.d.ts

@@ -3,6 +3,7 @@ type Identifiers = {
     caracAsked: string;
     uPoints: number[][];
     vPoints: number[][];
+    isTrue: boolean;
 };
 export declare const equalCaracteristicFromGraph: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/geometry/vectors/equalCaracteristicFromGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equalCaracteristicFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/equalCaracteristicFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;CACrB,CAAC;AAuLF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAe7D,CAAC"}
+{"version":3,"file":"equalCaracteristicFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/equalCaracteristicFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IACpB,OAAO,EAAE,MAAM,EAAE,EAAE,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAuNF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAc7D,CAAC"}

package/lib/exercises/math/geometry/vectors/equalCaracteristicFromGraph.js

@@ -9,10 +9,65 @@ import { random } from "../../../../utils/alea/random.js";
  * Soient deux cercles C1 et C2 de rayon 3 et de centres (-4,0) et (4,0)
  * on construit u dans C1 et v dans C2
  */
+const getInstruction = (identifiers) => {
+    let instruction = "";
+    const { caracAsked, uPoints, vPoints } = identifiers;
+    switch (caracAsked) {
+        case "direction":
+            instruction = "avoir la même direction";
+            break;
+        case "norme":
+            instruction = "avoir la même norme";
+            break;
+        case "sens":
+            instruction = "avoir le même sens";
+            break;
+        case "egaux":
+            instruction = "être égaux";
+            break;
+        case "opposes":
+        default:
+            instruction = "être opposés";
+            break;
+    }
+    return `Les vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ suivants semblent-ils ${instruction} ?`;
+};
+const getAnswer = (identifiers) => {
+    const { caracAsked, uPoints, vPoints, isTrue } = identifiers;
+    const answer = isTrue ? "Oui" : "Non";
+    return answer;
+};
+const getGGBOptions = (identifiers) => {
+    const { caracAsked, uPoints, vPoints } = identifiers;
+    const commands = [
+        `u = Vector((${uPoints[0][0]},${uPoints[0][1]}), (${uPoints[1][0]},${uPoints[1][1]}))`,
+        `v = Vector((${vPoints[0][0]},${vPoints[0][1]}), (${vPoints[1][0]},${vPoints[1][1]}))`,
+        'SetCaption(u, "$\\overrightarrow u$")',
+        'SetCaption(v, "$\\overrightarrow v$")',
+        "ShowLabel(u, true)",
+        "ShowLabel(v,true)",
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideAxes: true,
+    });
+    return ggb.getOptions({
+        coords: [-8, 8, -4, 4],
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        ggbOptions: getGGBOptions(identifiers),
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
 const getEqualCaracteristicFromGraphQuestion = () => {
-    let points = [];
     // const caracAsked = random(["sens", "direction", "norme"]);
-    let instruction = "";
     const caracAsked = random(["sens", "norme", "direction", "egaux", "opposes"]);
     const isTrue = coinFlip();
     let uPoints = [];
@@ -31,7 +86,6 @@ const getEqualCaracteristicFromGraphQuestion = () => {
     let rho;
     switch (caracAsked) {
         case "direction":
-            instruction = "avoir la même direction";
             thetaPrime = isTrue
                 ? theta
                 : theta + randfloat(1 / 4, 1 / 3) * Math.PI * 2;
@@ -51,7 +105,6 @@ const getEqualCaracteristicFromGraphQuestion = () => {
                 [uPoints, vPoints] = [vPoints, uPoints];
             break;
         case "norme":
-            instruction = "avoir la même norme";
             sameDirection = coinFlip();
             thetaPrime = sameDirection ? theta : Math.random() * 2 * Math.PI;
             if (isTrue) {
@@ -74,7 +127,6 @@ const getEqualCaracteristicFromGraphQuestion = () => {
                 [uPoints, vPoints] = [vPoints, uPoints];
             break;
         case "sens":
-            instruction = "avoir le même sens";
             sameDirection = coinFlip();
             sameNorm = coinFlip();
             thetaPrime =
@@ -96,7 +148,6 @@ const getEqualCaracteristicFromGraphQuestion = () => {
                 [uPoints, vPoints] = [vPoints, uPoints];
             break;
         case "egaux":
-            instruction = "être égaux";
             sameDirection = isTrue || coinFlip();
             sameNorm = isTrue || coinFlip();
             sameSens = isTrue || (sameDirection && sameNorm ? false : coinFlip());
@@ -118,7 +169,6 @@ const getEqualCaracteristicFromGraphQuestion = () => {
                 [uPoints, vPoints] = [vPoints, uPoints];
             break;
         case "opposes":
-            instruction = "être opposés";
             sameDirection = isTrue || coinFlip();
             sameNorm = isTrue || coinFlip();
             sameSens = !isTrue || (sameDirection && sameNorm ? false : coinFlip());
@@ -140,30 +190,8 @@ const getEqualCaracteristicFromGraphQuestion = () => {
                 [uPoints, vPoints] = [vPoints, uPoints];
             break;
     }
-    const commands = [
-        `u = Vector((${uPoints[0][0]},${uPoints[0][1]}), (${uPoints[1][0]},${uPoints[1][1]}))`,
-        `v = Vector((${vPoints[0][0]},${vPoints[0][1]}), (${vPoints[1][0]},${vPoints[1][1]}))`,
-        'SetCaption(u, "$\\overrightarrow u$")',
-        'SetCaption(v, "$\\overrightarrow v$")',
-        "ShowLabel(u, true)",
-        "ShowLabel(v,true)",
-    ];
-    const ggb = new GeogebraConstructor({
-        commands,
-        hideAxes: true,
-    });
-    const answer = isTrue ? "Oui" : "Non";
-    const question = {
-        answer,
-        instruction: `Les vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ suivants semblent-ils ${instruction} ?`,
-        keys: [],
-        ggbOptions: ggb.getOptions({
-            coords: [-8, 8, -4, 4],
-        }),
-        answerFormat: "raw",
-        identifiers: { caracAsked, uPoints, vPoints },
-    };
-    return question;
+    const identifiers = { caracAsked, uPoints, vPoints, isTrue };
+    return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -178,9 +206,7 @@ const isAnswerValid = (ans, { answer }) => {
 export const equalCaracteristicFromGraph = {
     id: "equalCaracteristicFromGraph",
     label: "Direction, sens, norme, égalité, opposés",
-    levels: ["2nde"],
     isSingleStep: true,
-    sections: ["Vecteurs"],
     generator: (nb) => getDistinctQuestions(getEqualCaracteristicFromGraphQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
@@ -189,4 +215,5 @@ export const equalCaracteristicFromGraph = {
     answerType: "QCU",
     hasGeogebra: true,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/geometry/vectors/fourthParallelogramPoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fourthParallelogramPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/fourthParallelogramPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAwDF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"fourthParallelogramPoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/fourthParallelogramPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4EF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAY1D,CAAC"}

package/lib/exercises/math/geometry/vectors/fourthParallelogramPoint.js

@@ -6,6 +6,29 @@ import { Vector, VectorConstructor } from "../../../../math/geometry/vector.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const A = new Point("A", identifiers.xA, identifiers.yA);
+    const B = new Point("B", identifiers.xB, identifiers.yB);
+    const C = new Point("C", identifiers.xC, identifiers.yC);
+    return `Soient les points $${A.toTexWithCoords()}$, $${B.toTexWithCoords()}$, et $${C.toTexWithCoords()}$. 
+  
+Quelles sont les coordonnées du point $D$ tel que $ABCD$ soit un parallélogramme ?`;
+};
+const getAnswer = (identifiers) => {
+    const D = new Point("D", identifiers.xD, identifiers.yD);
+    const answer = D.toCoords();
+    return answer;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: coordinatesKeys,
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
 const getFourthParallelogramPointQuestion = () => {
     const points = PointConstructor.randomDifferent(2, { names: ["A", "B"] });
     const AB = VectorConstructor.fromPoints(points[0], points[1]);
@@ -14,24 +37,17 @@ const getFourthParallelogramPointQuestion = () => {
         D = PointConstructor.random("D");
     } while (AB.isColinear(VectorConstructor.fromPoints(D, points[0])));
     const C = AB.getEndPoint(D, "C");
-    const answer = D.toCoords();
-    const question = {
-        answer,
-        instruction: `Soient les points $${points[0].toTexWithCoords()}$, $${points[1].toTexWithCoords()}$, et $${C.toTexWithCoords()}$. Quelles sont les coordonnées du point $D$ tel que $ABCD$ soit un parallélogramme ?`,
-        keys: coordinatesKeys,
-        answerFormat: "tex",
-        identifiers: {
-            xA: points[0].x.evaluate({}),
-            xB: points[1].x.evaluate({}),
-            xC: C.x.evaluate({}),
-            xD: D.x.evaluate({}),
-            yA: points[0].y.evaluate({}),
-            yB: points[1].y.evaluate({}),
-            yC: C.y.evaluate({}),
-            yD: D.y.evaluate({}),
-        },
+    const identifiers = {
+        xA: points[0].x.evaluate({}),
+        xB: points[1].x.evaluate({}),
+        xC: C.x.evaluate({}),
+        xD: D.x.evaluate({}),
+        yA: points[0].y.evaluate({}),
+        yB: points[1].y.evaluate({}),
+        yC: C.y.evaluate({}),
+        yD: D.y.evaluate({}),
     };
-    return question;
+    return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer, xA, xB, xC, yA, yB, yC, yD }) => {
     const propositions = [];
@@ -51,13 +67,12 @@ const isAnswerValid = (ans, { answer }) => {
 export const fourthParallelogramPoint = {
     id: "fourthParallelogramPoint",
     label: "Déterminer les coordonnées du quatrième point d'un parallélogramme",
-    levels: ["2nde", "1reSpé"],
     isSingleStep: true,
-    sections: ["Vecteurs", "Droites"],
     generator: (nb) => getDistinctQuestions(getFourthParallelogramPointQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };