math-exercises 3.0.99 → 3.0.101

package/lib/exercises/math/geometry/vectors/constructions/placePointFromPointAndVector.js

@@ -0,0 +1,171 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { Vector, VectorConstructor, } from "../../../../../math/geometry/vector.js";
+import { randTupleInt } from "../../../../../math/utils/random/randTupleInt.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { randomLetter } from "../../../../../utils/strings/randomLetter.js";
+const getInstruction = (identifiers) => {
+    const { pointAskedName, isStartingPointAsked, pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    const name = isStartingPointAsked
+        ? `\\overrightarrow{${pointAskedName}${point.toTex()}}`
+        : `\\overrightarrow{${point.toTex()}${pointAskedName}}`;
+    return `Construire le point $${pointAskedName}$ tel que $${name} = ${vector.toTex()}$.`;
+};
+const getHint = (identifiers) => {
+    const { isStartingPointAsked, pointAskedName, pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    if (isStartingPointAsked) {
+        return `Trace le vecteur $${vector.toTex()}$ de telle sorte que l'extrémité du vecteur soit le point $${point.toTex()}$.`;
+    }
+    return `Trace le vecteur $${vector.toTex()}$ à partir du point $${point.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { isStartingPointAsked, pointAskedName, pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    if (isStartingPointAsked) {
+        return `On trace le vecteur $${vector.toTex()}$ de telle sorte que l'extrémité du vecteur soit le point $${point.toTex()}$. L'origine du vecteur est alors le point recherché.`;
+    }
+    return `On trace le vecteur $${vector.toTex()}$ à partir du point $${point.toTex()}$. On obtient alors le point recherché.`;
+};
+const getSolutionPoint = (identifiers) => {
+    const { pointAskedName, isStartingPointAsked, pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    if (isStartingPointAsked) {
+        //x = xA-xu
+        //y = yA-yu
+        return new Point(pointAskedName, substract(point.x, vector.x).simplify(), substract(point.y, vector.y).simplify());
+    }
+    else {
+        //x = xA+xu
+        //y = yA+yu
+        return new Point(pointAskedName, add(point.x, vector.x).simplify(), add(point.y, vector.y).simplify());
+    }
+};
+const getGGBAnswer = (identifiers) => {
+    const { pointAskedName, isStartingPointAsked, pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const solutionPoint = getSolutionPoint(identifiers);
+    return [
+        ...solutionPoint.toGGBCommand(),
+        isStartingPointAsked
+            ? `a = Vector(${solutionPoint.toMathString()},${point.toMathString()})`
+            : `a = Vector(${point.toMathString()}, ${solutionPoint.toMathString()})`,
+        `SetFixed(a, true)`,
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { pointAskedName, isStartingPointAsked, pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    const pointSolution = getSolutionPoint(identifiers);
+    let deltaX, deltaY;
+    do {
+        [deltaX, deltaY] = randTupleInt(2, {
+            excludes: [[0, 0]],
+            from: 2,
+            to: 5,
+        });
+        coinFlip() && (deltaX *= -1);
+        coinFlip() && (deltaY *= -1);
+        //empecher une translation colinéaire pour s'assurer de ne pas gener l'élève dans son input GGB
+    } while (deltaX * vector.y.evaluate() - deltaY * vector.x.evaluate() === 0);
+    const vectorStartPoint = (isStartingPointAsked ? pointSolution : point).translate(deltaX, deltaY);
+    const vectorEndPoint = (isStartingPointAsked ? point : pointSolution).translate(deltaX, deltaY);
+    const ggb = new GeogebraConstructor({
+        commands: [
+            ...point.toGGBCommand(),
+            `${vector.name}=Vector(${vectorStartPoint.toMathString()},${vectorEndPoint.toMathString()})`,
+            `SetCaption(${vector.name},"$${vector.toTex()}$")`,
+            `ShowLabel(${vector.name},true)`,
+            `SetFixed(${vector.name},true)`,
+        ],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const oppositeSolution = getSolutionPoint({
+        ...identifiers,
+        isStartingPointAsked: !isStartingPointAsked,
+    });
+    const points = [
+        oppositeSolution,
+        vectorStartPoint,
+        vectorEndPoint,
+        point,
+        pointSolution,
+    ];
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(points),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const { isStartingPointAsked, pointAskedName, pointIds, vectorIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const vector = VectorConstructor.fromIdentifiers(vectorIds);
+    const studentAns = ans.filter((c) => ![point.name, vector.name, "D"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = parseGGBPoints(studentAns).map((p) => ggbPointToCoords(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getPlacePointFromPointAndVectorQuestion = () => {
+    const isStartingPointAsked = coinFlip();
+    const point = PointConstructor.random(randomLetter(true));
+    const pointAskedName = randomLetter(true, [point.name]);
+    const vectorName = random(["u", "v", "w"]);
+    const [vectorX, vectorY] = randTupleInt(2, {
+        from: -3,
+        to: 4,
+        excludes: [[0, 0]],
+    });
+    const identifiers = {
+        isStartingPointAsked,
+        pointAskedName,
+        pointIds: point.toIdentifiers(),
+        vectorIds: new Vector(vectorName, vectorX.toTree(), vectorY.toTree()).toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const placePointFromPointAndVector = {
+    id: "placePointFromPointAndVector",
+    label: "Construire un point à partir d'un point et d'un vecteur donné",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlacePointFromPointAndVectorQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/constructions/traceOppositeVector.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPointIndex: number;
+    vectorPointsIndexes: number[];
+};
+export declare const traceOppositeVector: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=traceOppositeVector.d.ts.map

package/lib/exercises/math/geometry/vectors/constructions/traceOppositeVector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceOppositeVector.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/traceOppositeVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B,CAAC;AAuJF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}

package/lib/exercises/math/geometry/vectors/constructions/traceOppositeVector.js

@@ -0,0 +1,135 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { red } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { randomMany } from "../../../../../utils/alea/random.js";
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vec = VectorConstructor.fromPoints(points[identifiers.vectorPointsIndexes[0]], points[identifiers.vectorPointsIndexes[1]]);
+    return vec.opposite().getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = `${identifiers.points[vectorPointsIndexes[0]].name}${identifiers.points[vectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+      
+$$
+\\overrightarrow{${origin}K} = -\\overrightarrow{${vec}}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { startPointIndex, points, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = `${identifiers.points[vectorPointsIndexes[0]].name}${identifiers.points[vectorPointsIndexes[1]].name}`;
+    return `Rappelle toi que $-\\overrightarrow{v}$ est le vecteur de même norme et de même direction que $\\overrightarrow{v}$, mais de sens opposé.`;
+};
+const getCorrection = (identifiers) => {
+    const { startPointIndex, points, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = `${identifiers.points[vectorPointsIndexes[0]].name}${identifiers.points[vectorPointsIndexes[1]].name}`;
+    const trueVec = vec.split("").reverse().join("");
+    return `On se place au point $${origin}$. On trace à partir de ce point le vecteur $-\\overrightarrow{${vec}} = \\overrightarrow{${trueVec}}$. Le point d'arrivée est le point $K$ recherché.`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { startPointIndex, points, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = [
+        identifiers.points[vectorPointsIndexes[1]].name,
+        identifiers.points[vectorPointsIndexes[0]].name,
+    ];
+    const endPoint = getSolutionPoint(identifiers);
+    return [
+        ...endPoint.toGGBCommand(),
+        `a = Vector(${origin}, K)`,
+        `SetColor(a, "${red}")`,
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => PointConstructor.fromIdentifiers(p).toGGBCommand({ size: 4 }));
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        hideAxes: true,
+        fontSize: 16,
+    });
+    const points = identifiers.points.map((p) => PointConstructor.fromIdentifiers(p));
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = parseGGBPoints(studentAns).map((p) => ggbPointToCoords(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceOppositeVectorQuestion = () => {
+    const names = ["A", "B", "C"];
+    let points = [];
+    let startPointIndex;
+    let vectorPointsIndexes;
+    while (true) {
+        points = [];
+        points.push(...PointConstructor.randomDifferent(3, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = randint(0, names.length);
+        vectorPointsIndexes = randomMany([0, 1, 2], 2);
+        const vec = VectorConstructor.fromPoints(points[vectorPointsIndexes[0]], points[vectorPointsIndexes[1]]);
+        const endPoint = vec.opposite().getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        vectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        startPointIndex,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const traceOppositeVector = {
+    id: "traceOppositeVector",
+    label: "Placer un point $K$ tel que $\\overrightarrow{AK} = -\\overrightarrow{BC}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTraceOppositeVectorQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/constructions/traceVectorDifference.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPointIndex: number;
+    firstVectorPointsIndexes: number[];
+    secondVectorPointsIndexes: number[];
+};
+export declare const traceVectorDifference: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=traceVectorDifference.d.ts.map

package/lib/exercises/math/geometry/vectors/constructions/traceVectorDifference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorDifference.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/traceVectorDifference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,wBAAwB,EAAE,MAAM,EAAE,CAAC;IACnC,yBAAyB,EAAE,MAAM,EAAE,CAAC;CACrC,CAAC;AA4NF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}

package/lib/exercises/math/geometry/vectors/constructions/traceVectorDifference.js

@@ -0,0 +1,163 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { purpleDark, red } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { randomMany } from "../../../../../utils/alea/random.js";
+import { doWhile } from "../../../../../utils/doWhile.js";
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vecs = [
+        VectorConstructor.fromPoints(points[identifiers.firstVectorPointsIndexes[0]], points[identifiers.firstVectorPointsIndexes[1]]),
+        VectorConstructor.fromPoints(points[identifiers.secondVectorPointsIndexes[0]], points[identifiers.secondVectorPointsIndexes[1]]),
+    ];
+    return vecs[0].substract(vecs[1]).getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, secondVectorPointsIndexes, } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = `${identifiers.points[firstVectorPointsIndexes[0]].name}${identifiers.points[firstVectorPointsIndexes[1]].name}`;
+    const secondVec = `${identifiers.points[secondVectorPointsIndexes[0]].name}${identifiers.points[secondVectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+    
+$$
+\\overrightarrow{${origin}K} = \\overrightarrow{${firstVec}} - \\overrightarrow{${secondVec}}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, secondVectorPointsIndexes, points, } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = `${identifiers.points[firstVectorPointsIndexes[0]].name}${identifiers.points[firstVectorPointsIndexes[1]].name}`;
+    const secondVec = `${identifiers.points[secondVectorPointsIndexes[0]].name}${identifiers.points[secondVectorPointsIndexes[1]].name}`;
+    return `À partir du point $${origin}$, trace à la suite les vecteurs $\\overrightarrow{${firstVec}}$ et $-\\overrightarrow{${secondVec}}$. Rappelle toi que $-\\overrightarrow{v}$ est le vecteur de même norme et de même direction que $\\overrightarrow{v}$, mais de sens opposé.`;
+};
+const getCorrection = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, secondVectorPointsIndexes, points, } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = `${identifiers.points[firstVectorPointsIndexes[0]].name}${identifiers.points[firstVectorPointsIndexes[1]].name}`;
+    const secondVec = `${identifiers.points[secondVectorPointsIndexes[0]].name}${identifiers.points[secondVectorPointsIndexes[1]].name}`;
+    return `On se place au point $${origin}$. On trace à partir de ce point le vecteur $\\overrightarrow{${firstVec}}$. Puis, à la suite, on trace le vecteur $-\\overrightarrow{${secondVec}} = \\overrightarrow{${secondVec
+        .split("")
+        .reverse()
+        .join("")}}$. Le point d'arrivée est le point $K$ recherché.`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { startPointIndex, firstVectorPointsIndexes, secondVectorPointsIndexes, points, } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const firstVec = [
+        identifiers.points[firstVectorPointsIndexes[0]].name,
+        identifiers.points[firstVectorPointsIndexes[1]].name,
+    ];
+    const secondVec = [
+        identifiers.points[secondVectorPointsIndexes[0]].name,
+        identifiers.points[secondVectorPointsIndexes[1]].name,
+    ];
+    const midPoint = `${origin}+Vector(${firstVec[0]}, ${firstVec[1]})`;
+    const endPoint = getSolutionPoint(identifiers);
+    return [
+        ...endPoint.toGGBCommand(),
+        `a = Vector(${origin}, ${midPoint})`,
+        `SetColor(a, "${red}")`,
+        `b = Vector(${midPoint}, K)`,
+        `SetColor(b, "${purpleDark}")`,
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { firstVectorPointsIndexes, secondVectorPointsIndexes, startPointIndex, } = identifiers;
+    const commands = identifiers.points.flatMap((p) => PointConstructor.fromIdentifiers(p).toGGBCommand({ size: 4 }));
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        hideAxes: true,
+        fontSize: 16,
+    });
+    const points = identifiers.points.map((p) => PointConstructor.fromIdentifiers(p));
+    const firstVec = VectorConstructor.fromPoints(points[firstVectorPointsIndexes[0]], points[firstVectorPointsIndexes[1]]);
+    const origin = points[startPointIndex];
+    const midPoint = firstVec.getEndPoint(origin);
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint, midPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C", "D"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = parseGGBPoints(studentAns).map((p) => ggbPointToCoords(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceVectorDifferenceQuestion = () => {
+    const names = ["A", "B", "C", "D"];
+    let points = [];
+    let startPointIndex;
+    let firstVectorPointsIndexes;
+    let secondVectorPointsIndexes;
+    while (true) {
+        points = [];
+        points.push(...PointConstructor.randomDifferent(4, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = randint(0, names.length);
+        firstVectorPointsIndexes = randomMany([0, 1, 2, 3], 2);
+        secondVectorPointsIndexes = doWhile(() => randomMany([0, 1, 2, 3], 2), (arr) => arr[0] === firstVectorPointsIndexes[0] &&
+            arr[1] === firstVectorPointsIndexes[1]);
+        //AC = AB+BC
+        const firstVec = VectorConstructor.fromPoints(points[firstVectorPointsIndexes[0]], points[firstVectorPointsIndexes[1]]);
+        const second = VectorConstructor.fromPoints(points[secondVectorPointsIndexes[0]], points[secondVectorPointsIndexes[1]]);
+        const endPoint = firstVec
+            .substract(second)
+            .getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        firstVectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        secondVectorPointsIndexes,
+        startPointIndex,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const traceVectorDifference = {
+    id: "traceVectorDifference",
+    label: "Placer un point défini par une différence de vecteurs",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTraceVectorDifferenceQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/vectors/constructions/traceVectorMultiple.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+type Identifiers = {
+    points: PointIdentifiers[];
+    startPointIndex: number;
+    vectorPointsIndexes: number[];
+    coeff: number;
+};
+export declare const traceVectorMultiple: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=traceVectorMultiple.d.ts.map

package/lib/exercises/math/geometry/vectors/constructions/traceVectorMultiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorMultiple.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/vectors/constructions/traceVectorMultiple.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAOtC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA0KF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}

package/lib/exercises/math/geometry/vectors/constructions/traceVectorMultiple.js

@@ -0,0 +1,148 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { purpleDark, red } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { random, randomMany } from "../../../../../utils/alea/random.js";
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vec = VectorConstructor.fromPoints(points[identifiers.vectorPointsIndexes[0]], points[identifiers.vectorPointsIndexes[1]]);
+    return vec.times(identifiers.coeff.toTree()).getEndPoint(origin, "K");
+};
+const getInstruction = (identifiers) => {
+    const { startPointIndex, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = `${identifiers.points[vectorPointsIndexes[0]].name}${identifiers.points[vectorPointsIndexes[1]].name}`;
+    return `Placer le point $K$ tel que : 
+        
+$$
+\\overrightarrow{${origin}K} = ${identifiers.coeff}\\overrightarrow{${vec}}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { startPointIndex, points, coeff, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = `${identifiers.points[vectorPointsIndexes[0]].name}${identifiers.points[vectorPointsIndexes[1]].name}`;
+    return `Rappelle toi que $-\\overrightarrow{v}$ est le vecteur de même norme et de même direction que $\\overrightarrow{v}$, mais de sens opposé.`;
+};
+const getCorrection = (identifiers) => {
+    const { startPointIndex, points, coeff, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = `${identifiers.points[vectorPointsIndexes[0]].name}${identifiers.points[vectorPointsIndexes[1]].name}`;
+    const trueVec = coeff < 0 ? vec.split("").reverse().join("") : vec;
+    return `On se place au point $${origin}$. On trace à partir de ce point le vecteur ${coeff < 0
+        ? `$-\\overrightarrow{${vec}} = \\overrightarrow{${trueVec}}$`
+        : `$\\overrightarrow{${vec}}$`}, $${Math.abs(coeff)}$ fois à la suite. Le point d'arrivée est le point $K$ recherché.`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { startPointIndex, points, coeff, vectorPointsIndexes } = identifiers;
+    const origin = identifiers.points[startPointIndex].name;
+    const vec = [
+        identifiers.points[vectorPointsIndexes[coeff < 0 ? 1 : 0]].name,
+        identifiers.points[vectorPointsIndexes[coeff < 0 ? 0 : 1]].name,
+    ];
+    const endPoint = getSolutionPoint(identifiers);
+    const commands = [...endPoint.toGGBCommand()];
+    let midPoint = `${origin}`;
+    for (let i = 0; i < Math.abs(coeff); i++) {
+        const next = midPoint + `+Vector(${vec[0]}, ${vec[1]})`;
+        commands.push(...[
+            `a_${i} = Vector(${midPoint}, ${next})`,
+            `SetColor(a_${i}, "${i % 2 === 0 ? red : purpleDark}")`,
+        ]);
+        midPoint = next;
+    }
+    return [...endPoint.toGGBCommand(), ...commands];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => PointConstructor.fromIdentifiers(p).toGGBCommand({ size: 4 }));
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        hideAxes: true,
+        fontSize: 16,
+    });
+    const points = identifiers.points.map((p) => PointConstructor.fromIdentifiers(p));
+    const solutionPoint = getSolutionPoint(identifiers);
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, solutionPoint]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A", "B", "C"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = parseGGBPoints(studentAns).map((p) => ggbPointToCoords(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new Point("K", pointCoords[0].x, pointCoords[0].y).distanceTo(solutionPoint) < 1);
+};
+const getTraceVectorMultipleQuestion = () => {
+    const names = ["A", "B", "C"];
+    let points = [];
+    let startPointIndex;
+    let vectorPointsIndexes;
+    let coeff = 0;
+    while (true) {
+        points = [];
+        coeff = random([-3, -2, 2, 3]);
+        points.push(...PointConstructor.randomDifferent(3, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = randint(0, names.length);
+        vectorPointsIndexes = randomMany([0, 1, 2], 2);
+        const vec = VectorConstructor.fromPoints(points[vectorPointsIndexes[0]], points[vectorPointsIndexes[1]]);
+        const endPoint = vec
+            .times(coeff.toTree())
+            .getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        vectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        startPointIndex,
+        coeff,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const traceVectorMultiple = {
+    id: "traceVectorMultiple",
+    label: "Placer un point $M$ tel que $\\overrightarrow{AM} = k\\overrightarrow{BC}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTraceVectorMultipleQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};