math-exercises 2.2.76 → 2.2.78

package/lib/exercises/math/geometry/euclidianConstructions/buildPointFromAxialSymetry.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { LineIdentifiers } from "../../../../math/geometry/line";
+import { PointIdentifiers } from "../../../../math/geometry/point";
+type Identifiers = {
+    point: PointIdentifiers;
+    line: LineIdentifiers;
+};
+export declare const buildPointFromAxialSymetry: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=buildPointFromAxialSymetry.d.ts.map

package/lib/exercises/math/geometry/euclidianConstructions/buildPointFromAxialSymetry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buildPointFromAxialSymetry.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/buildPointFromAxialSymetry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAGL,eAAe,EAChB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAEnC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,gBAAgB,CAAC;IACxB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AAiGF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAe5D,CAAC"}

package/lib/exercises/math/geometry/euclidianConstructions/buildPointFromAxialSymetry.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPointFromAxialSymetry = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const parseGGBPoints_1 = require("../../../../geogebra/parsers/parseGGBPoints");
+const circle_1 = require("../../../../math/geometry/circle");
+const line_1 = require("../../../../math/geometry/line");
+const point_1 = require("../../../../math/geometry/point");
+const getInstruction = (identifiers) => {
+    return `Placer le point $A'$, symétrique du point $A$ par rapport à la droite $d$.`;
+};
+// const getHint : GetHint<Identifiers> = (identifiers)=>{
+// }
+// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
+// }
+const getSolutionPoint = (identifiers) => {
+    const point = point_1.PointConstructor.fromIdentifiers(identifiers.point);
+    const line = line_1.LineConstructor.fromIdentifiers(identifiers.line);
+    return point.axialSymetric(line, "A'");
+};
+const getGGBAnswer = (identifiers) => {
+    const point = point_1.PointConstructor.fromIdentifiers(identifiers.point);
+    const sol = getSolutionPoint(identifiers);
+    const perp = new line_1.Line(point, sol);
+    const center = point.midpoint(sol);
+    const circle = new circle_1.Circle(center, point, "C");
+    return [
+        ...sol.toGGBCommand(),
+        ...perp.toGGBCommands(false),
+        ...circle.toGGBCommands(false),
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const point = point_1.PointConstructor.fromIdentifiers(identifiers.point);
+    const line = line_1.LineConstructor.fromIdentifiers(identifiers.line);
+    const commands = [
+        ...point.toGGBCommand(),
+        ...line.toGGBCommands(false, {
+            showLabel: true,
+        }),
+    ];
+    const sol = getSolutionPoint(identifiers);
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        hideAxes: true,
+        hideGrid: true,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({
+            orthogonal: true,
+            circleTwoPoints: true,
+            point: true,
+            intersect: true,
+        }),
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([point, sol]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const studentAns = ans.filter((c) => !["A"].includes(c[0]));
+    const points = (0, parseGGBPoints_1.parseGGBPoints)(studentAns)
+        .map((p) => (0, ggbPointToCoords_1.ggbPointToCoords)(p))
+        .map((coords) => new point_1.Point("K", coords.x, coords.y));
+    if (!points.length)
+        return false;
+    const solution = getSolutionPoint(identifiers);
+    if (points.some((p) => p.distanceTo(solution) < 0.001))
+        return true;
+    return false;
+};
+const getBuildPointFromAxialSymetryQuestion = () => {
+    const linePoints = point_1.PointConstructor.randomDifferent(2, {
+        names: ["B", "C"],
+    });
+    const line = new line_1.Line(linePoints[0], linePoints[1], "d");
+    const point = point_1.PointConstructor.random("A");
+    const identifiers = {
+        point: point.toIdentifiers(),
+        line: line.toIdentifiers(),
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers)
+    };
+    return question;
+};
+exports.buildPointFromAxialSymetry = {
+    id: "buildPointFromAxialSymetry",
+    label: "Construire le symétrique d'un point par rapport à une droite",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getBuildPointFromAxialSymetryQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

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

@@ -1,4 +1,5 @@
 export * from "./buildMediatriceWithCompass";
 export * from "./buildTriangleWithSizes";
 export * from "./pointImageFromTranslation";
+export * from "./buildPointFromAxialSymetry";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC"}

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

@@ -17,3 +17,4 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./buildMediatriceWithCompass"), exports);
 __exportStar(require("./buildTriangleWithSizes"), exports);
 __exportStar(require("./pointImageFromTranslation"), exports);
+__exportStar(require("./buildPointFromAxialSymetry"), exports);

package/lib/exercises/math/geometry/euclidianConstructions/pointImageFromTranslation.js

@@ -69,7 +69,7 @@ const getPointImageFromTranslationQuestion = (opts) => {
     const points = [];
     for (let i = 0; i < 4; i++) {
         const name = String.fromCharCode(65 + i);
-        const newPoint = (0, doWhile_1.doWhile)(() => point_1.PointConstructor.random(name, -4, 5), (p) => points.some((p2) => p.equals(p2)));
+        const newPoint = (0, doWhile_1.doWhile)(() => point_1.PointConstructor.random(name, -4, 5), (p) => points.some((p2) => p.distanceTo(p2) < 2));
         points.push(newPoint);
     }
     const startPoint = (0, random_1.random)(points).name;

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

@@ -10,7 +10,7 @@ const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const coinFlip_1 = require("../../../../utils/alea/coinFlip");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getAlignementViaColinearityQuestion = () => {
-    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const points = point_1.PointConstructor.randomDifferent(2, { names: ["A", "B"] });
     const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
     let C;
     const isAligned = (0, coinFlip_1.coinFlip)();

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

@@ -10,7 +10,7 @@ const randint_1 = require("../../../../math/utils/random/randint");
 const numberNode_1 = require("../../../../tree/nodes/numbers/numberNode");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getFourthParallelogramPointQuestion = () => {
-    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const points = point_1.PointConstructor.randomDifferent(2, { names: ["A", "B"] });
     const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
     let D;
     do {

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

@@ -13,4 +13,8 @@ export * from "./vectorNormCalculation";
 export * from "./lineFromDirectorVector";
 export * from "./drawAVectorInGGB";
 export * from "./scalarProduct";
+export * from "./traceVectorSum";
+export * from "./traceVectorDifference";
+export * from "./traceOppositeVector";
+export * from "./traceVectorMultiple";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,kCAAkC,CAAC;AACjD,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,kCAAkC,CAAC;AACjD,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC"}

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

@@ -29,3 +29,7 @@ __exportStar(require("./vectorNormCalculation"), exports);
 __exportStar(require("./lineFromDirectorVector"), exports);
 __exportStar(require("./drawAVectorInGGB"), exports);
 __exportStar(require("./scalarProduct"), exports);
+__exportStar(require("./traceVectorSum"), exports);
+__exportStar(require("./traceVectorDifference"), exports);
+__exportStar(require("./traceOppositeVector"), exports);
+__exportStar(require("./traceVectorMultiple"), exports);

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

@@ -13,7 +13,7 @@ const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getParalellismViaColinearityQuestion = () => {
     let points = [];
     do {
-        points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+        points = point_1.PointConstructor.randomDifferent(2, { names: ["A", "B"] });
     } while (points[0].x.equals(points[1].x));
     const line = new line_1.Line(points[0], points[1]);
     let C;

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

@@ -8,7 +8,7 @@ const vector_1 = require("../../../../math/geometry/vector");
 const coinFlip_1 = require("../../../../utils/alea/coinFlip");
 const shuffle_1 = require("../../../../utils/alea/shuffle");
 const getParallelogramViaEqualVectorsQuestion = () => {
-    const points = point_1.PointConstructor.randomDifferent(["A", "B"]);
+    const points = point_1.PointConstructor.randomDifferent(2, { names: ["A", "B"] });
     const AB = vector_1.VectorConstructor.fromPoints(points[0], points[1]);
     let D;
     do {

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { PointIdentifiers } from "../../../../math/geometry/point";
+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/traceOppositeVector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceOppositeVector.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/traceOppositeVector.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAOnC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAC3B,eAAe,EAAE,MAAM,CAAC;IACxB,mBAAmB,EAAE,MAAM,EAAE,CAAC;CAC/B,CAAC;AAqHF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}

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

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceOppositeVector = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const parseGGBPoints_1 = require("../../../../geogebra/parsers/parseGGBPoints");
+const point_1 = require("../../../../math/geometry/point");
+const vector_1 = require("../../../../math/geometry/vector");
+const randint_1 = require("../../../../math/utils/random/randint");
+const random_1 = require("../../../../utils/alea/random");
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(point_1.PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vec = vector_1.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: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getSolutionPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => point_1.PointConstructor.fromIdentifiers(p).toGGBCommand());
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const points = identifiers.points.map((p) => point_1.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 = (0, parseGGBPoints_1.parseGGBPoints)(studentAns).map((p) => (0, ggbPointToCoords_1.ggbPointToCoords)(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new point_1.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(...point_1.PointConstructor.randomDifferent(3, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = (0, randint_1.randint)(0, names.length);
+        vectorPointsIndexes = (0, random_1.randomMany)([0, 1, 2], 2);
+        const vec = vector_1.VectorConstructor.fromPoints(points[vectorPointsIndexes[0]], points[vectorPointsIndexes[1]]);
+        const endPoint = vec.opposite().getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new point_1.Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        vectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        startPointIndex,
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.traceOppositeVector = {
+    id: "traceOppositeVector",
+    label: "Placer un point $K$ tel que $\\overrightarrow{AK} = -\\overrightarrow{BC}$",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getTraceOppositeVectorQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { PointIdentifiers } from "../../../../math/geometry/point";
+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/traceVectorDifference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorDifference.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/traceVectorDifference.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAMnC,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;AAgJF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}

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

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceVectorDifference = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const parseGGBPoints_1 = require("../../../../geogebra/parsers/parseGGBPoints");
+const point_1 = require("../../../../math/geometry/point");
+const vector_1 = require("../../../../math/geometry/vector");
+const randint_1 = require("../../../../math/utils/random/randint");
+const random_1 = require("../../../../utils/alea/random");
+const doWhile_1 = require("../../../../utils/doWhile");
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(point_1.PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vecs = [
+        vector_1.VectorConstructor.fromPoints(points[identifiers.firstVectorPointsIndexes[0]], points[identifiers.firstVectorPointsIndexes[1]]),
+        vector_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: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getSolutionPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => point_1.PointConstructor.fromIdentifiers(p).toGGBCommand());
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const points = identifiers.points.map((p) => point_1.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", "D"].includes(c[0]));
+    if (studentAns.length !== 1)
+        return false;
+    const solutionPoint = getSolutionPoint(identifiers);
+    const pointCoords = (0, parseGGBPoints_1.parseGGBPoints)(studentAns).map((p) => (0, ggbPointToCoords_1.ggbPointToCoords)(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new point_1.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(...point_1.PointConstructor.randomDifferent(4, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = (0, randint_1.randint)(0, names.length);
+        firstVectorPointsIndexes = (0, random_1.randomMany)([0, 1, 2, 3], 2);
+        secondVectorPointsIndexes = (0, doWhile_1.doWhile)(() => (0, random_1.randomMany)([0, 1, 2, 3], 2), (arr) => arr[0] === firstVectorPointsIndexes[0] &&
+            arr[1] === firstVectorPointsIndexes[1]);
+        //AC = AB+BC
+        const firstVec = vector_1.VectorConstructor.fromPoints(points[firstVectorPointsIndexes[0]], points[firstVectorPointsIndexes[1]]);
+        const second = vector_1.VectorConstructor.fromPoints(points[secondVectorPointsIndexes[0]], points[secondVectorPointsIndexes[1]]);
+        const endPoint = firstVec
+            .substract(second)
+            .getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new point_1.Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        firstVectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        secondVectorPointsIndexes,
+        startPointIndex,
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.traceVectorDifference = {
+    id: "traceVectorDifference",
+    label: "Placer un point défini par une différence de vecteurs",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getTraceVectorDifferenceQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise";
+import { PointIdentifiers } from "../../../../math/geometry/point";
+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/traceVectorMultiple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorMultiple.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/traceVectorMultiple.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAOnC,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;AA0HF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceVectorMultiple = void 0;
+const toolBarConstructor_1 = require("../../../../exercises/utils/geogebra/toolBarConstructor");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const ggbPointToCoords_1 = require("../../../../geogebra/parsers/ggbPointToCoords");
+const parseGGBPoints_1 = require("../../../../geogebra/parsers/parseGGBPoints");
+const point_1 = require("../../../../math/geometry/point");
+const vector_1 = require("../../../../math/geometry/vector");
+const randint_1 = require("../../../../math/utils/random/randint");
+const random_1 = require("../../../../utils/alea/random");
+const getSolutionPoint = (identifiers) => {
+    const points = identifiers.points.map(point_1.PointConstructor.fromIdentifiers);
+    const origin = points[identifiers.startPointIndex];
+    const vec = vector_1.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: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = (identifiers) => {
+    return getSolutionPoint(identifiers).toGGBCommand();
+};
+const getStudentGGBOptions = (identifiers) => {
+    const commands = identifiers.points.flatMap((p) => point_1.PointConstructor.fromIdentifiers(p).toGGBCommand());
+    const ggb = new geogebraConstructor_1.GeogebraConstructor({
+        commands,
+        customToolBar: (0, toolBarConstructor_1.toolBarConstructor)({
+            point: true,
+        }),
+        hideAxes: true,
+    });
+    const points = identifiers.points.map((p) => point_1.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 = (0, parseGGBPoints_1.parseGGBPoints)(studentAns).map((p) => (0, ggbPointToCoords_1.ggbPointToCoords)(p));
+    if (pointCoords.length !== 1)
+        return false;
+    return (new point_1.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 = (0, random_1.random)([-3, -2, 2, 3]);
+        points.push(...point_1.PointConstructor.randomDifferent(3, {
+            minDistance: 2,
+            names,
+            minDistanceToOrigin: 3,
+        }));
+        startPointIndex = (0, randint_1.randint)(0, names.length);
+        vectorPointsIndexes = (0, random_1.randomMany)([0, 1, 2], 2);
+        const vec = vector_1.VectorConstructor.fromPoints(points[vectorPointsIndexes[0]], points[vectorPointsIndexes[1]]);
+        const endPoint = vec
+            .times(coeff.toTree())
+            .getEndPoint(points[startPointIndex], "K");
+        if (endPoint.distanceTo(new point_1.Point("O", 0, 0)) > 10 ||
+            points.some((p) => p.equals(endPoint)))
+            continue;
+        break;
+    }
+    const identifiers = {
+        vectorPointsIndexes,
+        points: points.map((p) => p.toIdentifiers()),
+        startPointIndex,
+        coeff,
+    };
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+    };
+    return question;
+};
+exports.traceVectorMultiple = {
+    id: "traceVectorMultiple",
+    label: "Placer un point $M$ tel que $\\overrightarrow{AM} = k\\overrightarrow{BC}$",
+    isSingleStep: true,
+    generator: (nb, opts) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getTraceVectorMultipleQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    // getHint,
+    getInstruction,
+    // getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"traceVectorSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/traceVectorSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAGL,gBAAgB,EACjB,MAAM,2BAA2B,CAAC;AAMnC,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;AAgJF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}