math-exercises 3.0.151 → 3.0.153

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

@@ -6,13 +6,20 @@ import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
 import { Circle } from "../../../../math/geometry/circle.js";
 import { Line, LineConstructor, } from "../../../../math/geometry/line.js";
 import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { Segment } from "../../../../math/geometry/segment.js";
 const getInstruction = () => {
     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 getHint = () => {
+    return `La droite $d$ est la médiatrice de $[AA']$. Comment est la droite $(AA')$ par rapport à $d$ ?`;
+};
+const getCorrection = () => {
+    return `$A$ n'est pas sur $d$ donc $A$ et $A'$ sont de part et d'autre de $d$.
+Il y a plusieurs façons de construire $A'$.
+Une d'entre elles consiste à tracer la perpendiculaire à $d$ passant par $A$. 
+Cette perpendiculaire contient $A'$. Elle coupe $d$ en $I$ : C'est le milieu de $AA'$.
+On reporte donc la longueur $AI$ de l'autre côté en traçant le cercle de centre $I$ passant par $A$, et on a $A'$.`;
+};
 const getSolutionPoint = (identifiers) => {
     const point = PointConstructor.fromIdentifiers(identifiers.point);
     const line = LineConstructor.fromIdentifiers(identifiers.line);
@@ -21,10 +28,16 @@ const getSolutionPoint = (identifiers) => {
 const getGGBAnswer = (identifiers) => {
     const point = PointConstructor.fromIdentifiers(identifiers.point);
     const sol = getSolutionPoint(identifiers);
+    const midPoint = ((pointA, pointB) => {
+        const midPoint = new Segment(pointA, pointB).getMidpoint();
+        midPoint.name = "I";
+        return midPoint;
+    })(point, sol);
     const perp = new Line(point, sol);
     const center = point.midpoint(sol);
     const circle = new Circle(center, point, "C");
     return [
+        ...midPoint.toGGBCommand(),
         ...sol.toGGBCommand(),
         ...perp.toGGBCommands(false, { color: "black" }),
         ...circle.toGGBCommands(false),
@@ -86,8 +99,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         instruction: getInstruction(identifiers),
         studentGgbOptions: getStudentGGBOptions(identifiers),
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers)
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -99,9 +112,10 @@ export const buildPointFromAxialSymetry = {
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",
-    // getHint,
     getInstruction,
-    // getCorrection,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
     getGGBAnswer,
     getStudentGGBOptions,
     answerType: "GGB",

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    pointsDict: Record<string, PointIdentifiers>;
+    namePointSrc: string;
+    namePointCenter: string;
+    instructionIndex: number;
+};
+export declare const buildPointFromCentralSymmetry: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=buildPointFromCentralSymmetry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"buildPointFromCentralSymmetry.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/buildPointFromCentralSymmetry.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAMtC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,MAAM,CAAC;CAC1B,CAAC;AA6MF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAe/D,CAAC"}

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

@@ -0,0 +1,169 @@
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenDark } 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 { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getInstruction = (identifiers) => {
+    const { namePointSrc, namePointCenter, instructionIndex } = identifiers;
+    switch (instructionIndex) {
+        case 1:
+            return `Avec les outils disponibles, construire l'image, par la symétrie de centre $${namePointCenter}$, du point $${namePointSrc}$.`;
+        case 0:
+        default:
+            return `Avec les outils disponibles, construire l'image du point $${namePointSrc}$ par la symétrie de centre $${namePointCenter}$.`;
+    }
+};
+const getHint = () => {
+    return `Tu peux commencer par tracer un cercle dont le centre est le centre de symétrie.`;
+};
+const getCorrection = (identifiers) => {
+    const { namePointSrc, namePointCenter } = identifiers;
+    return `On trace le cercle $\\mathcal C$ de centre $${namePointCenter}$ passant par $${namePointSrc}$.
+On trace la droite $(${namePointCenter}${namePointSrc})$.
+Les deux points d'intersection de $(${namePointCenter}${namePointSrc})$ avec $\\mathcal C$ sont $${namePointSrc}$ et son symétrique.`;
+};
+const getAnswerPoint = (identifiers) => {
+    const { namePointSrc, namePointCenter, pointsDict } = identifiers;
+    const [pointSrc, pointCenter] = [namePointSrc, namePointCenter].map((pointName) => PointConstructor.fromIdentifiers(pointsDict[pointName]));
+    const vec = VectorConstructor.fromPoints(pointSrc, pointCenter);
+    return vec.getEndPoint(pointCenter, `${pointSrc}'`);
+};
+const getGGBAnswer = (identifiers) => {
+    const { namePointSrc, namePointCenter, pointsDict } = identifiers;
+    const [pointSrc, pointCenter] = [namePointSrc, namePointCenter].map((pointName) => PointConstructor.fromIdentifiers(pointsDict[pointName]));
+    const ggbAnswer = [
+        ...pointSrc.toGGBCommand(),
+        ...pointCenter.toGGBCommand(),
+        `L_1 = Line(${pointSrc.name},${pointCenter.name})`,
+        `C_1 = Circle(${pointCenter.name},${pointSrc.name})`,
+        `I_2 = Intersect(L_1, C_1,2)`,
+        `SetColor(I_2, "${greenDark}")`,
+        `SetCaption(I_2, "${pointSrc.name}'")`,
+        `ShowLabel(I_2, true)`,
+    ];
+    return ggbAnswer;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const points = Object.values(identifiers.pointsDict).map((p) => PointConstructor.fromIdentifiers(p));
+    const ggb = new GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        commands: getGGBAnswer(identifiers),
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, getAnswerPoint(identifiers)]),
+    });
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { namePointSrc, namePointCenter, pointsDict } = identifiers;
+    const [pointSrc, pointCenter] = [namePointSrc, namePointCenter].map((pointName) => PointConstructor.fromIdentifiers(pointsDict[pointName]));
+    const studentGGB = new GeogebraConstructor({
+        commands: [pointSrc, pointCenter].flatMap((point) => point.toGGBCommand()),
+        hideGrid: true,
+        hideAxes: true,
+        customToolBar: toolBarConstructor({
+            join: true,
+            circleTwoPoints: true,
+            intersect: true,
+        }),
+    });
+    const length = VectorConstructor.fromPoints(pointSrc, pointCenter)
+        .getNorm()
+        .evaluate();
+    const [xMin1, xMax1, yMin1, yMax1] = studentGGB.getCoordsForPoints([
+        pointSrc,
+        pointCenter,
+    ]);
+    const xMin = xMin1 - length;
+    const xMax = xMax1 + length;
+    const yMin = yMin1 - length;
+    const yMax = yMax1 + length;
+    return studentGGB.getOptions({
+        coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const { namePointSrc, namePointCenter } = identifiers;
+    const isLineValid = () => {
+        const regexs = [
+            [namePointCenter, namePointSrc],
+            [namePointSrc, namePointCenter],
+        ].map(([namePointA, namePointB]) => new RegExp(`Line\\[${namePointA},\\s${namePointB}\\]`));
+        return (ans.filter((cmd) => regexs.some((regex) => regex.test(cmd))).length > 0);
+    };
+    const isCircleValid = () => {
+        const regexs = [[namePointCenter, namePointSrc]].map(([namePointA, namePointB]) => new RegExp(`Circle\\[${namePointA},\\s${namePointB}\\]`));
+        return (ans.filter((cmd) => regexs.some((regex) => regex.test(cmd))).length > 0);
+    };
+    const isPointValid = () => {
+        const points = parseGGBPoints(ans)
+            .map((p) => ggbPointToCoords(p))
+            .map((coords, i) => new Point(`K_${i}`, coords.x, coords.y));
+        const answerPoint = getAnswerPoint(identifiers);
+        return points.some((point) => point.distanceTo(answerPoint) < 0.0000001);
+    };
+    return isLineValid() && isCircleValid() && isPointValid();
+};
+const getBuildPointFromCentralSymmetryQuestion = () => {
+    const [namePointSrc, namePointCenter] = randomMany("ABCDEFGHIJKLMNOPQRST".split(""), 2);
+    function createRandomPoints(names) {
+        const points = [];
+        for (let i = 0; i < names.length; i++) {
+            const name = names[i];
+            const newPoint = doWhile(() => PointConstructor.random(name, -3, 4), (p) => points.some((p2) => p.distanceTo(p2) < 2));
+            points.push(newPoint);
+        }
+        return points;
+    }
+    const pointsDict = Object.fromEntries(createRandomPoints([namePointSrc, namePointCenter]).map((point) => [
+        point.name,
+        point.toIdentifiers(),
+    ]));
+    const instructionIndex = probaLawFlip([
+        [0, 0.7],
+        [1, 0.3],
+    ]);
+    const identifiers = {
+        pointsDict,
+        namePointSrc,
+        namePointCenter,
+        instructionIndex,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+    return question;
+};
+export const buildPointFromCentralSymmetry = {
+    id: "buildPointFromCentralSymmetry",
+    connector: "=",
+    label: "Construire l'image d'un point par symétrie centrale",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getBuildPointFromCentralSymmetryQuestion, nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

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

@@ -4,4 +4,6 @@ export * from "./pointImageFromTranslation.js";
 export * from "./buildPointFromAxialSymetry.js";
 export * from "./pointImageFromHomothety.js";
 export * from "./segmentImageFromHomothety.js";
+export * from "./buildPointFromCentralSymmetry.js";
+export * from "./placeHomothetyCenter.js";
 //# 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,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,2BAA2B,CAAC"}

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

@@ -4,3 +4,5 @@ export * from "./pointImageFromTranslation.js";
 export * from "./buildPointFromAxialSymetry.js";
 export * from "./pointImageFromHomothety.js";
 export * from "./segmentImageFromHomothety.js";
+export * from "./buildPointFromCentralSymmetry.js";
+export * from "./placeHomothetyCenter.js";

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

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    pointsDict: Record<string, PointIdentifiers>;
+    nameSrcPoint: string;
+    nameDstPoint: string;
+    factor: NodeIdentifiers;
+};
+type Options = {
+    isPositiveFactorOnly: boolean;
+    factorTypes: string[];
+};
+export declare const placeHomothetyCenter: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=placeHomothetyCenter.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"placeHomothetyCenter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/euclidianConstructions/placeHomothetyCenter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAItC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgE7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC;IAC7C,YAAY,EAAE,MAAM,CAAC;IACrB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AAuSF,KAAK,OAAO,GAAG;IACb,oBAAoB,EAAE,OAAO,CAAC;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAyBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB/D,CAAC"}

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

@@ -0,0 +1,309 @@
+import { GeneratorOptionType, GeneratorOptionTarget, } from "../../../../exercises/exercise.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { approxEqual } from "../../../../geogebra/parsers/approxEqual.js";
+import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.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 { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getHomothetyCenterPoint = (pointSrc, pointDst, nodeFactor, pointName) => {
+    const nodeX = frac(substract(multiply(nodeFactor, pointSrc.x), pointDst.x), substract(nodeFactor, 1)).simplify();
+    const nodeY = frac(substract(multiply(nodeFactor, pointSrc.y), pointDst.y), substract(nodeFactor, 1)).simplify();
+    return new Point(pointName, nodeX, nodeY);
+};
+const getDivisorsOfVector = (vec) => {
+    return [2, 3, 4, 5, 7, 8, 9].filter((n) => [vec.x, vec.y].every((z) => z.evaluate() % n === 0));
+};
+const getRandomFactorNodeForVector = (vec, isPositiveFactorOnly = false, excludes = [], factorType) => {
+    let factorNode;
+    switch (factorType) {
+        case "fraction":
+            {
+                const divisorsOfVec = getDivisorsOfVector(vec);
+                if (divisorsOfVec.length > 0) {
+                    const den = random(divisorsOfVec);
+                    const num = randint(1, 3 * den, [den, 2 * den]);
+                    factorNode = frac(num, den);
+                }
+                else {
+                    throw new Error("can't find frac for vec");
+                }
+            }
+            break;
+        default:
+        case "entier":
+            {
+                factorNode = randint(1, 5, excludes).toTree();
+            }
+            break;
+    }
+    return multiply(isPositiveFactorOnly ? 1 : coinFlip() ? 1 : -1, factorNode);
+};
+const getInstruction = (identifiers) => {
+    const { nameSrcPoint, nameDstPoint, factor } = identifiers;
+    const nodeFactor = NodeConstructor.fromIdentifiers(factor);
+    return `Placer le centre de l'homothétie de rapport $${nodeFactor.toTex()}$ qui transforme $${nameSrcPoint}$ en $${nameDstPoint}$.`;
+};
+const getAnswerPoint = (identifiers) => {
+    const { nameSrcPoint, nameDstPoint, pointsDict, factor } = identifiers;
+    const nodeFactor = NodeConstructor.fromIdentifiers(factor);
+    // dst.x - center.x = factor * (src.x - center.x)
+    // (factor - 1) * center.x = factor * src.x - dst.x
+    //center.x = (factor * src.x - dst.x) / (factor - 1)
+    const [pointSrc, pointDst] = [nameSrcPoint, nameDstPoint].map((pointName) => PointConstructor.fromIdentifiers(pointsDict[pointName]));
+    return getHomothetyCenterPoint(pointSrc, pointDst, nodeFactor, "P");
+};
+const getWrongPoints = (identifiers) => {
+    const { nameSrcPoint, nameDstPoint, pointsDict, factor } = identifiers;
+    const nodeFactor = NodeConstructor.fromIdentifiers(factor);
+    const [pointSrc, pointDst] = [nameSrcPoint, nameDstPoint].map((pointName) => PointConstructor.fromIdentifiers(pointsDict[pointName]));
+    const wrongFactorNodes = [
+        multiply(-1, nodeFactor).simplify(),
+        ...(() => {
+            const invNode = frac(1, nodeFactor).simplify();
+            return [invNode, multiply(-1, invNode).simplify()];
+        })(),
+    ];
+    return wrongFactorNodes
+        .flatMap((wrongFactorNode, i) => [
+        getHomothetyCenterPoint(pointSrc, pointDst, wrongFactorNode, `W_{N${i}}`),
+        getHomothetyCenterPoint(pointDst, pointSrc, wrongFactorNode, `W_{R${i}}`),
+    ])
+        .filter((point) => {
+        const isIntegerPoint = () => point.x.evaluate() % 1 === 0 && point.y.evaluate() % 1 === 0;
+        const isCloseEnough = () => [pointSrc, pointDst].every((pointMain) => point.distanceTo(pointMain) < 15);
+        return isIntegerPoint() && isCloseEnough();
+    });
+};
+const getGGBAnswer = (identifiers) => {
+    const answerPoint = getAnswerPoint(identifiers);
+    return [...answerPoint.toGGBCommand()];
+};
+const getHint = (identifiers) => {
+    const { nameSrcPoint, nameDstPoint, factor } = identifiers;
+    const nodeFactor = NodeConstructor.fromIdentifiers(factor);
+    return `Le centre de l'homothétie appartient à la droite $(${nameSrcPoint}${nameDstPoint})$.
+Si on l'appelle $P$, il faut chercher $P$ tel que :
+
+$$
+\\frac{\\overline{P${nameDstPoint}}}{\\overline{P${nameSrcPoint}}} = ${nodeFactor.toTex()}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nameSrcPoint, nameDstPoint, factor } = identifiers;
+    const nodeFactor = NodeConstructor.fromIdentifiers(factor);
+    const isAboveZero = nodeFactor.evaluate() > 0;
+    const isAbsBelowOne = Math.abs(nodeFactor.evaluate()) < 1;
+    return `L'homothétie transforme $${nameSrcPoint}$ en $${nameDstPoint}$.
+${(() => {
+        if (isAboveZero) {
+            return `Le rapport d'homothétie est positif 
+donc le centre est donc à l'extérieur du segment $[${nameSrcPoint}${nameDstPoint}]$.`;
+        }
+        else {
+            return `Le rapport d'homothétie est négatif
+donc le centre est donc à l'intérieur du segment $[${nameSrcPoint}${nameDstPoint}]$.`;
+        }
+    })()}${(() => {
+        if (isAbsBelowOne) {
+            return `Le rapport est inférieur à $1$ en valeur absolue
+donc le centre est donc plus proche de $${nameDstPoint}$ que de $${nameSrcPoint}$.`;
+        }
+        else {
+            return `Le rapport est supérieur à $1$ en valeur absolue
+donc le centre est donc plus proche de $${nameSrcPoint}$ que de $${nameDstPoint}$.`;
+        }
+    })()}
+
+Si on l'appelle $P$, il faut chercher $P$ tel que :
+
+$$
+\\frac{\\overline{P${nameDstPoint}}}{\\overline{P${nameSrcPoint}}} = ${nodeFactor.toTex()}
+$$
+
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const points = Object.values(identifiers.pointsDict).map((p) => PointConstructor.fromIdentifiers(p));
+    const answerPoint = getAnswerPoint(identifiers);
+    const ggb = new GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        commands: [
+            ...points.flatMap((p) => p.toGGBCommand({
+                size: 3,
+                style: 1,
+            })),
+            ...answerPoint.toGGBCommand({ color: `${greenMain}` }),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, answerPoint]),
+    });
+};
+const getStudentGGBOptions = (identifiers) => {
+    const points = Object.values(identifiers.pointsDict).map((p) => PointConstructor.fromIdentifiers(p));
+    const answerPoint = getAnswerPoint(identifiers);
+    const wrongPoints = getWrongPoints(identifiers);
+    const ggb = new GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        customToolBar: toolBarConstructor({ point: true }),
+        commands: [
+            ...points.flatMap((p) => p.toGGBCommand({
+                size: 3,
+                style: 1,
+            })),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, answerPoint, ...wrongPoints]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer }) => {
+    const studentAns = ans;
+    if (studentAns.length !== 1)
+        return false;
+    const studentPoint = studentAns[0].split("=")[1];
+    if (studentPoint === undefined)
+        return false;
+    const coords = ggbPointToCoords(studentPoint);
+    const coordsAns = ggbPointToCoords(ggbAnswer[0].split("=")[1]);
+    return (approxEqual(coords.x, coordsAns.x, 0.2) &&
+        approxEqual(coords.y, coordsAns.y, 0.2));
+};
+const getPlaceHomothetyCenterQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isPositiveFactorOnly, factorTypes } = opts;
+    const factorType = random(factorTypes);
+    function createRandomPoints() {
+        const points = [];
+        for (let i = 0; i < 2; i++) {
+            const name = String.fromCharCode(65 + i);
+            const newPoint = doWhile(() => PointConstructor.random(name, -3, 4), (p) => points.some((p2) => p.distanceTo(p2) < 2));
+            points.push(newPoint);
+        }
+        return points;
+    }
+    function createRandomIdentifiersBud() {
+        const points = createRandomPoints();
+        const [pointCenter, pointSrc] = randomMany(points, 2);
+        const vec1 = VectorConstructor.fromPoints(pointCenter, pointSrc);
+        const factorNode = getRandomFactorNodeForVector(vec1, isPositiveFactorOnly, [1], factorType).simplify();
+        const pointDst = vec1
+            .times(factorNode)
+            .getEndPoint(pointCenter, String.fromCharCode(65 + points.length));
+        points.push(pointDst);
+        const identifiers = {
+            pointsDict: Object.fromEntries([pointSrc, pointDst].map((p) => [p.name, p.toIdentifiers()])),
+            nameSrcPoint: pointSrc.name,
+            nameDstPoint: pointDst.name,
+            factor: factorNode.toIdentifiers(),
+            //clandestine
+            pointCenter,
+        };
+        return identifiers;
+    }
+    const pointOrigin = new Point("O", 0, 0);
+    let identifiers;
+    let counter = -1;
+    let isValidIdentifiers = false;
+    while (!isValidIdentifiers && counter < 100) {
+        let identifiersBud;
+        counter++;
+        try {
+            identifiersBud = createRandomIdentifiersBud();
+        }
+        catch (_) {
+            continue;
+        }
+        const points = [
+            ...Object.values(identifiersBud.pointsDict).map((pointIds) => PointConstructor.fromIdentifiers(pointIds)),
+            identifiersBud.pointCenter,
+        ];
+        const isPointsDistinct = [...new Set(points.map((point) => point.toCoords()))].length ===
+            points.length;
+        const isPointsCloseToOrigin = points.every((point) => point.distanceTo(pointOrigin) < 10);
+        isValidIdentifiers = isPointsDistinct && isPointsCloseToOrigin;
+        if (isValidIdentifiers) {
+            identifiers = { ...identifiersBud };
+        }
+    }
+    // const identifiers = createRandomIdentifiers(points);
+    const defaultIdentifiers = {
+        pointsDict: Object.fromEntries([
+            new Point("O", 0, 0),
+            new Point("A", 5, 0),
+            new Point("B", 0, 5),
+            new Point("C", -5, 0),
+            new Point("D", 0, -5),
+        ].map((point) => [point.name, point.toIdentifiers()])),
+        nameSrcPoint: "A",
+        nameDstPoint: "C",
+        factor: (-1).toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers ?? defaultIdentifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        studentGgbOptions: getStudentGGBOptions(identifiers, opts),
+        keys: [],
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+    return question;
+};
+const options = [
+    {
+        id: "isPositiveFactorOnly",
+        label: "Rapports positifs uniquement",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        defaultValue: false,
+    },
+    {
+        id: "factorTypes",
+        label: "Rapport: type de nombre",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["entier", "fraction"],
+        defaultValue: ["entier", "fraction"],
+    },
+];
+const optsDefault = {
+    isPositiveFactorOnly: false,
+    factorTypes: ["entier", "fraction"],
+};
+export const placeHomothetyCenter = {
+    id: "placeHomothetyCenter",
+    label: "Placer le centre d'une homothétie",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlaceHomothetyCenterQuestion(opts), nb),
+    ggbTimer: 60,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getStudentGGBOptions,
+    options,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    isGGBAnswerValid,
+    answerType: "GGB",
+};

package/lib/exercises/math/probaStat/basicProbas/calculateProbaFromProbaLaw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"calculateProbaFromProbaLaw.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/calculateProbaFromProbaLaw.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AA6HF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}
+{"version":3,"file":"calculateProbaFromProbaLaw.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/calculateProbaFromProbaLaw.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAoIF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAmB5D,CAAC"}

package/lib/exercises/math/probaStat/basicProbas/calculateProbaFromProbaLaw.js

@@ -106,6 +106,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
         identifiers,
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
+        },
     };
 };
 export const calculateProbaFromProbaLaw = {

package/lib/exercises/math/probaStat/basicProbas/getMissingProbabilityValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMissingProbabilityValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/getMissingProbabilityValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAiHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}
+{"version":3,"file":"getMissingProbabilityValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/getMissingProbabilityValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAwHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}

package/lib/exercises/math/probaStat/basicProbas/getMissingProbabilityValue.js

@@ -89,6 +89,13 @@ const getQuestionFromIdentifiers = (identifiers) => ({
     identifiers,
     hint: getHint(identifiers),
     correction: getCorrection(identifiers),
+    style: {
+        tableOptions: {
+            firstColumnIsHeader: true,
+            firstCellIsDivided: false,
+            firstRowIsHeader: false,
+        },
+    },
 });
 export const getMissingProbabilityValue = {
     id: "getMissingProbabilityValue",

package/lib/exercises/math/probaStat/basicProbas/getMissingProbabilityValueMiddleSchool.d.ts

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

package/lib/exercises/math/probaStat/basicProbas/getMissingProbabilityValueMiddleSchool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getMissingProbabilityValueMiddleSchool.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/getMissingProbabilityValueMiddleSchool.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AA4HF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAoBxE,CAAC"}