math-exercises 3.0.99 → 3.0.101

package/lib/exercises/math/geometry/vectors/parallelogram/parallelogramCriterion.js

@@ -0,0 +1,193 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { randomLetter } from "../../../../../utils/strings/randomLetter.js";
+const getPropositions = (n, { answer, isAskingParallelogramName, pointNames }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        if (isAskingParallelogramName) {
+            const reversed = answer.split("").reverse().join("");
+            let fake = "";
+            do {
+                fake = shuffle(pointNames).join("");
+            } while (isParaNameValid(fake, answer));
+            tryToAddWrongProp(propositions, fake);
+        }
+        else {
+            let vec1 = "";
+            let vec2 = "";
+            do {
+                const shuffled = shuffle(pointNames);
+                vec1 = shuffled[0] + shuffled[1];
+                vec2 = shuffled[2] + shuffled[3];
+            } while (isVectorEqualityValid(vec1, vec2, pointNames.join("")));
+            tryToAddWrongProp(propositions, `\\overrightarrow{${vec1}}=\\overrightarrow{${vec2}}`);
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const isParaNameValid = (name, expectedName) => {
+    //exemple ABCDABCD contient bien tous les noms possibles dans un sens, et DCBADCBA dans l'autre
+    const reversed = expectedName.split("").reverse().join("");
+    return ((expectedName + expectedName).includes(name) ||
+        (reversed + reversed).includes(name));
+};
+const isVectorEqualityValid = (vec1, vec2, expectedName) => {
+    const reversed = expectedName.split("").reverse().join("");
+    const name = vec1 + vec2.split("").reverse().join("");
+    return ((expectedName + expectedName).includes(name) ||
+        (reversed + reversed).includes(name));
+};
+const getAnswer = (identifiers) => {
+    const { isAskingParallelogramName, pointNames } = identifiers;
+    if (isAskingParallelogramName) {
+        return pointNames.join("");
+    }
+    else {
+        const vec1 = `\\overrightarrow{${pointNames.slice(0, 2).join("")}}`;
+        const vec2 = `\\overrightarrow{${pointNames
+            .slice(2, 4)
+            .reverse()
+            .join("")}}`;
+        return `${vec1}=${vec2}`;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { isAskingParallelogramName, pointNames } = identifiers;
+    if (isAskingParallelogramName) {
+        const vec1 = `\\overrightarrow{${pointNames.slice(0, 2).join("")}}`;
+        const vec2 = `\\overrightarrow{${pointNames
+            .slice(2, 4)
+            .reverse()
+            .join("")}}`;
+        return `Soient deux vecteurs $${vec1}$ et $${vec2}$ tels que $${vec1} = ${vec2}$.
+    
+Donner le nom du parallélogramme formé par ces vecteurs.`;
+    }
+    return `Soit un parallélogramme $${pointNames.join("")}$. 
+  
+Donner une égalité entre deux vecteurs issus de ce parallélogramme.`;
+};
+const getHint = (identifiers) => {
+    return `$ABCD$ est un parallélogramme si et seulemtne si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux.`;
+};
+const getCorrection = (identifiers) => {
+    const { isAskingParallelogramName, pointNames } = identifiers;
+    if (isAskingParallelogramName) {
+        return `On sait que $ABCD$ est un parallélogramme si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux. 
+    
+Ici, le quadrilatère $${pointNames.join("")}$ est donc un parallélogramme.`;
+    }
+    return `On sait que $ABCD$ est un parallélogramme si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux. 
+
+Ici, les vecteurs $${pointNames.slice(0, 2).join("")}$ et $${pointNames
+        .slice(2, 4)
+        .reverse()
+        .join("")}$ sont donc égaux.
+    `;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { isAskingParallelogramName, pointNames } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [
+            `${pointNames[0]} = (-1, 0)`,
+            `ShowLabel(${pointNames[0]}, true)`,
+            `SetFixed(${pointNames[0]}, true)`,
+            `${pointNames[1]} = (1,2)`,
+            `ShowLabel(${pointNames[1]}, true)`,
+            `SetFixed(${pointNames[1]}, true)`,
+            `${pointNames[2]} = (2, 0)`,
+            `ShowLabel(${pointNames[2]}, true)`,
+            `SetFixed(${pointNames[2]}, true)`,
+            `${pointNames[3]} = (0, -2)`,
+            `ShowLabel(${pointNames[3]}, true)`,
+            `SetFixed(${pointNames[3]}, true)`,
+            `Polygon(${pointNames.join(",")})`,
+            `Vector(${pointNames[0]}, ${pointNames[1]})`,
+            `Vector(${pointNames[3]}, ${pointNames[2]})`,
+        ],
+        hideAxes: true,
+    });
+    return ggb.getOptions({
+        coords: [-2, 3, -3, 3],
+    });
+};
+const getKeys = (identifiers) => {
+    const { isAskingParallelogramName, pointNames } = identifiers;
+    const sorted = [...pointNames].sort((a, b) => a.localeCompare(b));
+    if (isAskingParallelogramName) {
+        return sorted;
+    }
+    else {
+        return ["overrightarrow", "equal", ...sorted];
+    }
+    return [];
+};
+const isAnswerValid = (ans, { answer, isAskingParallelogramName, pointNames }) => {
+    try {
+        if (isAskingParallelogramName) {
+            if (ans.length !== 4)
+                return false;
+            return isParaNameValid(ans, answer);
+        }
+        else {
+            //on crée le nom du parallélogramme ici de l'égalité et on check comme au dessus
+            let splitted = ans.split("=");
+            if (splitted.length !== 2)
+                return false;
+            if (splitted.some((e) => !e.startsWith("\\overrightarrow")))
+                return false;
+            splitted = splitted.map((e) => e.replace("\\overrightarrow{", "").replace("}", ""));
+            if (splitted.some((e) => e.length !== 2))
+                return false;
+            return isVectorEqualityValid(splitted[0], splitted[1], pointNames.join(""));
+        }
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getParallelogramCriterionQuestion = (ops) => {
+    const A = randomLetter(true);
+    const B = randomLetter(true, [A]);
+    const C = randomLetter(true, [A, B]);
+    const D = randomLetter(true, [A, B, C]);
+    const identifiers = {
+        isAskingParallelogramName: coinFlip(),
+        pointNames: [A, B, C, D],
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+};
+export const parallelogramCriterion = {
+    id: "parallelogramCriterion",
+    label: "Utiliser la propriété caractéristique du parallélogramme",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParallelogramCriterionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/parallelogram/parallelogramViaEqualVectors.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    xA: number;
+    xB: number;
+    xC: number;
+    xD: number;
+    yA: number;
+    yB: number;
+    yC: number;
+    yD: number;
+};
+export declare const parallelogramViaEqualVectors: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=parallelogramViaEqualVectors.d.ts.map

package/lib/exercises/math/geometry/vectors/parallelogram/parallelogramViaEqualVectors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parallelogramViaEqualVectors.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/parallelogram/parallelogramViaEqualVectors.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,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;AA4GF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}

package/lib/exercises/math/geometry/vectors/parallelogram/parallelogramViaEqualVectors.js

@@ -0,0 +1,116 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor } from "../../../../../math/geometry/point.js";
+import { Vector, VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { substract, } from "../../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.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);
+    const D = new Point("D", identifiers.xD, identifiers.yD);
+    return `Soient les points $${A.toTexWithCoords()}$, $${B.toTexWithCoords()}$, $${C.toTexWithCoords()}$ et $${D.toTexWithCoords()}$. 
+  
+$ABCD$ est-il un parallélogramme ?`;
+};
+const getAnswer = (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);
+    const D = new Point("D", identifiers.xD, identifiers.yD);
+    const vec1 = VectorConstructor.fromPoints(A, B);
+    const vec2 = VectorConstructor.fromPoints(D, C);
+    const isParallelogram = vec1.equals(vec2);
+    const answer = isParallelogram ? "Oui" : "Non";
+    return answer;
+};
+const getHint = (identifiers) => {
+    return `$ABCD$ est un parallélogramme si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux.`;
+};
+const getCorrection = (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);
+    const D = new Point("D", identifiers.xD, identifiers.yD);
+    const vec1 = new Vector("AB", substract(B.x, A.x), substract(B.y, A.y));
+    const vec2 = new Vector("DC", substract(C.x, D.x), substract(C.y, D.y));
+    const vec1Simp = vec1.simplify();
+    const vec2Simp = vec2.simplify();
+    const isParallelogram = vec1Simp.equals(vec2Simp);
+    return `$ABCD$ est un parallélogramme si et seulement si les vecteurs $\\overrightarrow{AB}$ et $\\overrightarrow{DC}$ sont égaux. On calcule donc les coordonnées de ces vecteurs : 
+
+$$
+${vec1.toTexWithCoords()}=${vec1Simp.toBinomCoords().toTex()}
+$$
+
+$$
+${vec2.toTexWithCoords()}=${vec2Simp.toBinomCoords().toTex()}
+$$
+
+${isParallelogram
+        ? `Puisque les vecteurs sont égaux, $ABCD$ est un parallélogramme.`
+        : `Puisque les vecteurs ne sont pas égaux, $ABCD$ n'est pas un parallélogramme.`}`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getParallelogramViaEqualVectorsQuestion = () => {
+    const points = PointConstructor.randomDifferent(2, { names: ["A", "B"] });
+    const AB = VectorConstructor.fromPoints(points[0], points[1]);
+    let D;
+    do {
+        D = PointConstructor.random("D");
+    } while (AB.isColinear(VectorConstructor.fromPoints(D, points[0])));
+    let C;
+    const isParallelogram = coinFlip();
+    if (isParallelogram) {
+        C = AB.getEndPoint(D, "C");
+    }
+    else {
+        do {
+            C = PointConstructor.random("C");
+        } while (AB.equals(VectorConstructor.fromPoints(D, C)));
+    }
+    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 getQuestionFromIdentifiers(identifiers);
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffle(propositions);
+};
+export const parallelogramViaEqualVectors = {
+    id: "parallelogramViaEqualVectors",
+    label: "Utiliser les vecteurs pour reconnaître un parallélogramme",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getParallelogramViaEqualVectorsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    points: string[][];
+    pointAskedIndex: number[];
+};
+export declare const translationFromPicture: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=translationFromPicture.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"translationFromPicture.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/translationFromPicture.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,eAAe,EAAE,MAAM,EAAE,CAAC;CAG3B,CAAC;AAqGF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}

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

@@ -0,0 +1,104 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, random(["A", "B", "C", "D", "E", "F", "G", "H"]));
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { points, pointAskedIndex } = identifiers;
+    return points[pointAskedIndex[0]][pointAskedIndex[1]];
+};
+const getInstruction = (identifiers) => {
+    const { points, pointAskedIndex } = identifiers;
+    const displayed = [[...points[0]], [...points[1]]];
+    displayed[pointAskedIndex[0]][pointAskedIndex[1]] = "\\ldots ";
+    return `On considère la figure ci-dessous : 
+  
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/figureTranslations2nde.png)
+
+Compléter la phrase suivante :
+
+*Le point $${displayed[0][1]}$ est l'image du point $${displayed[0][0]}$ par la translation de vecteur $\\overrightarrow{${displayed[1][0]}${displayed[1][1]}}$.*`;
+};
+const getHint = (identifiers) => {
+    const { points, pointAskedIndex } = identifiers;
+    const displayed = [[...points[0]], [...points[1]]];
+    displayed[pointAskedIndex[0]][pointAskedIndex[1]] = "X";
+    return `La question revient à déterminer le point $X$ tel que : 
+  
+$$
+\\overrightarrow{${displayed[0][0]}${displayed[0][1]}}=\\overrightarrow{${displayed[1][0]}${displayed[1][1]}}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { points, pointAskedIndex } = identifiers;
+    return `Puisque les vecteurs $\\overrightarrow{${points[0][0]}${points[0][1]}}$ et $\\overrightarrow{${points[1][0]}${points[1][1]}}$ sont égaux, le point $${points[0][1]}$ est l'image du point $${points[0][0]}$ par la translation de vecteur $\\overrightarrow{${points[1][0]}${points[1][1]}}$.`;
+};
+const getKeys = (identifiers) => {
+    return ["A", "B", "C", "D", "E", "F", "G", "H"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTranslationFromPictureQuestion = (ops) => {
+    const equalVectors = [
+        ["EF", "BC", "AD"],
+        ["EA", "FD"],
+        ["EG", "GC", "BD"],
+        ["BH", "HD"],
+        ["AB", "BG", "GF", "DC"],
+        ["AH", "HC"],
+        ["EB", "FC", "GD"],
+    ];
+    const chosen = random(equalVectors);
+    const willReverse = coinFlip();
+    let first = random(chosen);
+    willReverse && first.split("").reverse().join("");
+    let second = random(chosen, [first]);
+    willReverse && second.split("").reverse().join("");
+    const identifiers = {
+        pointAskedIndex: [random([0, 1]), random([0, 1])],
+        points: [first.split(""), second.split("")],
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const translationFromPicture = {
+    id: "translationFromPicture",
+    label: "Identifier une translation à partir d'une figure",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTranslationFromPictureQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    vec: string;
+    vecsProposed: string[];
+};
+export declare const vectorRepresentative: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=vectorRepresentative.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"vectorRepresentative.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/vectorRepresentative.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA6LF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}

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

@@ -0,0 +1,161 @@
+import { addValidProp, addWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../math/geometry/vector.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getPoints = () => {
+    const points = [];
+    let letter = 65; // A
+    for (let j = 0; j < 5; j++) {
+        for (let i = 0; i < 4; i++) {
+            points.push(new Point(String.fromCharCode(letter), i, j));
+            letter++;
+        }
+    }
+    return points;
+};
+const getPropositions = (n, { answer, vec, vecsProposed }) => {
+    const propositions = [];
+    // addValidProp(propositions, answer);
+    const points = getPoints();
+    const vector = VectorConstructor.fromPoints(points.find((p) => p.name === vec[0]), points.find((p) => p.name === vec[1]));
+    for (let i = 0; i < vecsProposed.length; i++) {
+        const vecProp = VectorConstructor.fromPoints(points.find((p) => p.name === vecsProposed[i][0]), points.find((p) => p.name === vecsProposed[i][1]));
+        if (vector.equals(vecProp)) {
+            addValidProp(propositions, vecsProposed[i]);
+        }
+        else {
+            addWrongProp(propositions, vecsProposed[i]);
+        }
+    }
+    return propositions;
+};
+const getInstruction = (identifiers) => {
+    return `On considère la figure ci-dessous : 
+  
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/pointsOnParallelogram2.png)
+
+Parmi les vecteurs suivants, lequel, ou lesquels, sont des représentants du vecteur $\\overrightarrow{${identifiers.vec}}$ ?`;
+};
+const getHint = (identifiers) => {
+    return `On appelle représentant d'un vecteur $\\overrightarrow{u}$ tout vecteur qui est égal à $\\overrightarrow{u}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { vec, vecsProposed } = identifiers;
+    const points = getPoints();
+    const vector = VectorConstructor.fromPoints(points.find((p) => p.name === vec[0]), points.find((p) => p.name === vec[1]));
+    const vectors = vecsProposed.map((vecProp) => VectorConstructor.fromPoints(points.find((p) => p.name === vecProp[0]), points.find((p) => p.name === vecProp[1])));
+    const booleans = vectors.map((vecProp) => vector.equals(vecProp));
+    return `Pour chaque vecteur proposé, on vérifie s'il est égal au vecteur $\\overrightarrow{${vec}}$. 
+  
+Pour cela, on peut compter les déplacements sur le quadrillage. On voit que le vecteur $\\overrightarrow{${vec}}$ représente un déplacement de $${vector.x.toTex()}$ unité(s) en "horizontal" et de $${vector.y.toTex()}$ unité(s) en "vertical". On cherche donc les vecteurs qui représentent le même déplacement. 
+
+${vectors
+        .map((vecProposed, i) => `- $\\overrightarrow{${vecsProposed[i]}}$ est un déplacement de $${vecProposed.x.toTex()}$ unité(s) en "horizontal" et de $${vecProposed.y.toTex()}$ unité(s) en "vertical". ${booleans[i]
+        ? `C'est donc bien un représentant de $\\overrightarrow{${vec}}$.`
+        : `Ce n'est donc pas un représentant de $\\overrightarrow{${vec}}$.`}`)
+        .join("\n\n")}`;
+};
+const getVectorRepresentativeQuestion = (ops) => {
+    const lettres = Array.from({ length: 20 }, (_, i) => String.fromCharCode(65 + i));
+    let vec = "";
+    do {
+        const vecA = random(lettres);
+        const vecB = random(lettres, [vecA]);
+        vec = `${vecA}${vecB}`;
+    } while (
+    //AT et QD n'ont pas de représentants
+    (vec.includes("A") && vec.includes("T")) ||
+        (vec.includes("Q") && vec.includes("D")));
+    const points = getPoints();
+    const vector = VectorConstructor.fromPoints(points.find((p) => p.name === vec[0]), points.find((p) => p.name === vec[1]));
+    //les problemes de performance sont une construction sociale de la classe capitaliste, il ne faut pas s'en occuper
+    const getRepresentant = () => {
+        const shuffled = shuffle(points);
+        for (let i = 0; i < shuffled.length; i++) {
+            const point = shuffled[i];
+            if (point.name === vec[0])
+                continue;
+            const end = vector.getEndPoint(point);
+            const endPoint = points.find((p) => p.x.evaluate() === end.x.evaluate() &&
+                p.y.evaluate() === end.y.evaluate());
+            if (endPoint) {
+                return `${point.name}${endPoint.name}`;
+            }
+        }
+        return "";
+    };
+    const vecsProposed = [getRepresentant()];
+    const coordsWith1Rep = [
+        [2, 4],
+        [3, 3],
+    ];
+    const coordsWith2Rep = [
+        [1, 4],
+        [3, 2],
+    ];
+    const vecCoords = [
+        Math.abs(vector.x.evaluate()),
+        Math.abs(vector.y.evaluate()),
+    ];
+    const vecRepCount = coordsWith1Rep.some((v) => v[0] === vecCoords[0] && v[1] === vecCoords[1])
+        ? 1
+        : coordsWith2Rep.some((v) => v[0] === vecCoords[0] && v[1] === vecCoords[1])
+            ? 2
+            : 3;
+    let repCounter = 1;
+    for (let i = 0; i < 3; i++) {
+        const isRep = repCounter >= vecRepCount ? false : coinFlip();
+        if (isRep) {
+            repCounter++;
+            const rep = doWhile(() => {
+                return getRepresentant();
+            }, (v) => vecsProposed.includes(v));
+            vecsProposed.push(rep);
+        }
+        else {
+            let point1;
+            let point2;
+            do {
+                point1 = random(points);
+                point2 = random(points);
+            } while (VectorConstructor.fromPoints(point1, point2).equals(vector) ||
+                vecsProposed.includes(`${point1.name}${point2.name}`));
+            vecsProposed.push(`${point1.name}${point2.name}`);
+        }
+    }
+    const identifiers = {
+        vec,
+        vecsProposed: shuffle(vecsProposed),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const vectorRepresentative = {
+    id: "vectorRepresentative",
+    label: "Citer des représentants d'un vecteur",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getVectorRepresentativeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    isQCM: true,
+    answerType: "QCM",
+};

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

@@ -5,4 +5,5 @@ export * from "./volumeOfPyramidWithTriangleBase.js";
 export * from "./coneVolume.js";
 export * from "./sphereVolume.js";
 export * from "./parallelepipedVolume.js";
+export * from "./variableVolume.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/geometry/volumes/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC"}

package/lib/exercises/math/geometry/volumes/index.js

@@ -5,3 +5,4 @@ export * from "./volumeOfPyramidWithTriangleBase.js";
 export * from "./coneVolume.js";
 export * from "./sphereVolume.js";
 export * from "./parallelepipedVolume.js";
+export * from "./variableVolume.js";

package/lib/exercises/math/geometry/volumes/variableVolume.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    width: number;
+    height: number;
+    depth: number;
+};
+export declare const variableVolume: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=variableVolume.d.ts.map

package/lib/exercises/math/geometry/volumes/variableVolume.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variableVolume.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/variableVolume.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA6NF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAoBhD,CAAC"}