math-exercises 3.0.150 → 3.0.152

package/lib/exercises/math/geometry/triangles/similar/isSimilarTrianglesWrtSideLengths.js

@@ -0,0 +1,351 @@
+import { addValidProp, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { primes } from "../../../../../math/numbers/integer/primes.js";
+import { gcd } from "../../../../../math/utils/arithmetic/gcd.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.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 { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { joinanded } from "../../../../../utils/strings/joinanded.js";
+const getNAllDigits = (n) => {
+    const strN = n.frenchify();
+    if (strN.includes(",")) {
+        const [leftOfSep, rightOfSep] = strN.split(",");
+        const roundTo = 1;
+        const nAllDigits = parseInt(leftOfSep + rightOfSep.slice(0, roundTo));
+        return nAllDigits;
+    }
+    else {
+        return n;
+    }
+};
+const extendedGcd = (n1, n2) => {
+    try {
+        const [n1AllDigits, n2AllDigits] = [n1, n2].map(getNAllDigits);
+        const commonDivisor = gcd(n1AllDigits, n2AllDigits);
+        return commonDivisor;
+    }
+    catch (_) {
+        return 1;
+    }
+};
+const getHydratedObjs = (identifiers) => {
+    const { nodeIdsLengths1, nodeIdsLengths2, namePoints1, namePoints2 } = identifiers;
+    const [nodeLengths1, nodeLengths2] = [nodeIdsLengths1, nodeIdsLengths2].map((arrNodeIds) => arrNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).simplify({
+        fractionsToDecimal: true,
+    })));
+    const [nameTriangle1, nameTriangle2] = [namePoints1, namePoints2].map((pointNames) => pointNames.join(""));
+    const [nameSegments1, nameSegments2] = [namePoints1, namePoints2].map((pointNames) => [
+        [0, 1],
+        [1, 2],
+        [2, 0],
+    ].map(([i1, i2]) => `${pointNames[i1]}${pointNames[i2]}`));
+    return {
+        nodeLengths1,
+        nodeLengths2,
+        nameTriangle1,
+        nameTriangle2,
+        nameSegments1,
+        nameSegments2,
+    };
+};
+const isSimilar = (identifiers) => {
+    const { nodeLengths1, nodeLengths2 } = getHydratedObjs(identifiers);
+    const [nodeLengths1SortedAsc, nodeLengths2SortedAsc] = [
+        nodeLengths1,
+        nodeLengths2,
+    ].map((nodeLengths) => nodeLengths.toSorted((node1, node2) => node1.evaluate() - node2.evaluate()));
+    const nodeCoeffs = nodeLengths2SortedAsc.map((nodeLength2, i) => frac(nodeLength2, nodeLengths1SortedAsc[i]));
+    const nodeCoeff0 = nodeCoeffs[0].simplify();
+    return nodeCoeffs.slice(1).every((nodeCoeff) => {
+        return (substract(nodeCoeff.simplify(), nodeCoeff0).simplify().evaluate() === 0);
+    });
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const propositions = [];
+    const answerFromIdentifiers = getAnswer(identifiers);
+    ["Oui", "Non"].forEach((strProp) => {
+        if (strProp === answerFromIdentifiers) {
+            addValidProp(propositions, strProp, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, strProp, "raw");
+        }
+    });
+    return propositions;
+};
+const getAnswer = (identifiers) => {
+    return isSimilar(identifiers) ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { nodeLengths1, nodeLengths2, nameTriangle1, nameTriangle2, nameSegments1, nameSegments2, } = getHydratedObjs(identifiers);
+    return `Soit $${nameTriangle1}$ un triangle tel que ${joinanded(nameSegments1.map((nameSegment, i) => `$${nameSegment} = ${nodeLengths1[i].toTex()} \\ \\textrm{cm}$`), ", ", " et ")}.
+Soit $${nameTriangle2}$ un triangle tel que ${joinanded(nameSegments2.map((nameSegment, i) => `$${nameSegment} = ${nodeLengths2[i].toTex()} \\ \\textrm{cm}$`), ", ", " et ")}.
+
+Les triangles $${nameTriangle1}$ et $${nameTriangle2}$ sont-ils semblables ?`;
+};
+const getHint = (identifiers) => {
+    const { namePoints1, namePoints2 } = identifiers;
+    const [nameTriangle1, nameTriangle2] = [namePoints1, namePoints2].map((pointNames) => pointNames.join(""));
+    return `Regarde si tu peux trouver un coefficient de proportionnalité entre les longueurs de $${nameTriangle1}$ et celles de $${nameTriangle2}$ (même prises dans un autre ordre).`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeLengths1, nodeLengths2, nameTriangle1, nameTriangle2 } = getHydratedObjs(identifiers);
+    const [nodeLengths1SortedAsc, nodeLengths2SortedAsc] = [
+        nodeLengths1,
+        nodeLengths2,
+    ].map((nodeLengths) => nodeLengths.toSorted((node1, node2) => node1.evaluate() - node2.evaluate()));
+    const nodeCoeffs = nodeLengths2SortedAsc.map((nodeLength2, i) => frac(nodeLength2, nodeLengths1SortedAsc[i]));
+    const isSim = isSimilar(identifiers);
+    return `Pour ne pas avoir à tester tous les cas possibles, pour chaque triangle, on range les longueurs par ordre croissant.
+
+Pour $${nameTriangle1}$ : 
+
+$$
+${nodeLengths1SortedAsc.map((node) => node.toTex()).join(" < ")}
+$$
+
+Pour $${nameTriangle2}$ :
+
+$$
+${nodeLengths2SortedAsc.map((node) => node.toTex()).join(" < ")}
+$$
+
+On regarde ensuite si les rapports $\\frac{\\text{longueur dans ${nameTriangle2}}}{\\text{longueur dans ${nameTriangle1}}}$ sont tous égaux.
+
+On a :
+
+${alignTex([0, 1, 2].map((i) => [
+        `${nodeCoeffs[i].toTex()}`,
+        "=",
+        `${nodeCoeffs[i].simplify({ fractionsToDecimal: true }).toTex()}`,
+    ]))}
+
+Les triangles $${nameTriangle1}$ et $${nameTriangle2}$ ${isSim ? "sont donc semblables" : "ne sont donc pas semblables"}.`;
+};
+const getIsSimilarTrianglesWrtSideLengthsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    function createRandomNodeCoeff(numberTypeForCoeff) {
+        switch (numberTypeForCoeff) {
+            // case "Fraction":
+            //   {
+            //     return RationalConstructor.randomIrreductible().toTree();
+            //   }
+            //   break;
+            case "Décimal":
+                {
+                    return round(randint(1, 20) + 0.1 * randint(1, 10), 1)
+                        .toTree()
+                        .simplify({ fractionsToDecimal: true });
+                }
+                break;
+            default:
+            case "Entier":
+                {
+                    return randint(2, 10).toTree();
+                }
+                break;
+        }
+    }
+    function createRandomNodeLength(numberTypeForLength) {
+        switch (numberTypeForLength) {
+            case "Décimal":
+                {
+                    return round(randint(2, 15) + 0.1 * randint(1, 10), 1)
+                        .toTree()
+                        .simplify({ fractionsToDecimal: true });
+                }
+                break;
+            default:
+            case "Entier":
+                {
+                    return randint(2, 16).toTree();
+                }
+                break;
+        }
+    }
+    function isTriangleWrtSideLenghts(nodeLengths) {
+        return nodeLengths.every((nodeLength, i) => {
+            const nodeSumOfOther = nodeLengths
+                .filter((_, j) => j !== i)
+                .reduce((acc, x) => add(acc, x));
+            return nodeLength.evaluate() <= nodeSumOfOther.evaluate();
+        });
+    }
+    function createRandomTriangleNodes(numberTypesForLengths) {
+        let nodeLengths;
+        let isValidTriangle = false;
+        let counter = -1;
+        while (!isValidTriangle && counter < 100) {
+            counter++;
+            nodeLengths = [0, 1, 2].map(() => {
+                const numberTypeForLength = random(numberTypesForLengths);
+                return createRandomNodeLength(numberTypeForLength);
+            });
+            isValidTriangle = isTriangleWrtSideLenghts(nodeLengths);
+        }
+        if (!isValidTriangle) {
+            if (numberTypesForLengths.includes("Entier") &&
+                !numberTypesForLengths.includes("Décimal")) {
+                return [3, 4, 5].map((n) => n.toTree());
+            }
+            else if (!numberTypesForLengths.includes("Entier") &&
+                numberTypesForLengths.includes("Décimal")) {
+                return [3.3, 4.4, 5.5].map((n) => n.toTree());
+            }
+            else {
+                return [3.3, 4, 5.5].map((n) => n.toTree());
+            }
+        }
+        return nodeLengths;
+    }
+    function createRandomHighGcdTriangleNodes(numberTypesForLengths) {
+        let nodeLengths;
+        let isValidTriangle = false;
+        let counter = -1;
+        while (!isValidTriangle && counter < 100) {
+            counter++;
+            const commonDivisor = random(primes.filter((n) => 7 <= n && n <= 23));
+            const numberTypeForLength = random(numberTypesForLengths);
+            if (numberTypeForLength === "Entier") {
+                nodeLengths = randomMany([2, 3, 4, 5, 6, 7, 8], 3)
+                    .map((n) => n * commonDivisor)
+                    .map((n) => n.toTree())
+                    .map((node) => round(node.evaluate(), 1).toTree());
+            }
+            else {
+                nodeLengths = randomMany([2, 3, 4, 5, 6, 7, 8], 3)
+                    .map((n) => n * commonDivisor)
+                    .map((n) => (n * 0.1).toTree())
+                    .map((node) => round(node.evaluate(), 1).toTree());
+            }
+            isValidTriangle = isTriangleWrtSideLenghts(nodeLengths);
+        }
+        if (!isValidTriangle) {
+            if (numberTypesForLengths.includes("Entier") &&
+                !numberTypesForLengths.includes("Décimal")) {
+                return [3, 4, 5].map((n) => n.toTree());
+            }
+            else if (!numberTypesForLengths.includes("Entier") &&
+                numberTypesForLengths.includes("Décimal")) {
+                return [3.3, 4.4, 5.5].map((n) => n.toTree());
+            }
+            else {
+                return [3.3, 4, 5.5].map((n) => n.toTree());
+            }
+        }
+        return nodeLengths;
+    }
+    let isSimilar = coinFlip();
+    const numberTypeForCoeffCandidate = random(opts.numberTypesForCoeffs);
+    const nodeLengths1 = (() => {
+        if (numberTypeForCoeffCandidate === "Fraction") {
+            return createRandomHighGcdTriangleNodes(opts.numberTypesForLengths);
+        }
+        else {
+            return createRandomTriangleNodes(opts.numberTypesForLengths);
+        }
+    })();
+    const nodeLengths1SortedAsc = nodeLengths1.toSorted((node1, node2) => node1.evaluate() - node2.evaluate());
+    const createNodeCoeff = () => {
+        const numberTypeForCoeff = numberTypeForCoeffCandidate === "Fraction"
+            ? numberTypeForCoeffCandidate
+            : random(opts.numberTypesForCoeffs.filter((numberTypeForCoeff) => numberTypeForCoeff !== "Fraction"));
+        if (numberTypeForCoeff === "Fraction") {
+            const den = nodeLengths1
+                .reduce((acc, x) => extendedGcd(acc.evaluate(), x.evaluate()).toTree())
+                .evaluate();
+            const num = random(primes.filter((n) => n < 5 * den));
+            return frac(num, den);
+        }
+        else {
+            const nodeCoeff = createRandomNodeCoeff(numberTypeForCoeff);
+            return nodeCoeff;
+        }
+    };
+    const nodeCoeffs = isSimilar
+        ? (() => {
+            const nodeCoeff = createNodeCoeff();
+            return nodeLengths1.map(() => nodeCoeff);
+        })()
+        : nodeLengths1.map(() => createNodeCoeff());
+    const nodeCoeffsSortedAsc = nodeCoeffs.toSorted((node1, node2) => node1.evaluate() - node2.evaluate());
+    isSimilar = (() => {
+        const nodeCoeff0 = nodeCoeffsSortedAsc[0].simplify();
+        return nodeCoeffsSortedAsc.slice(1).every((nodeCoeff) => {
+            return (substract(nodeCoeff.simplify(), nodeCoeff0).simplify().evaluate() === 0);
+        });
+    })();
+    const nodeLengths2SortedAsc = nodeLengths1SortedAsc.map((nodeLength, i) => multiply(nodeCoeffsSortedAsc[i], nodeLength).simplify());
+    const nodeLengths1Shuffled = shuffle(nodeLengths1SortedAsc);
+    const nodeLengths2Shuffled = shuffle(nodeLengths2SortedAsc);
+    const [A, B, C, D, E, F] = randomMany("ABCDEFGHIJKLMNOPQRSTUVWXYZ".split(""), 6);
+    const namePoints1 = [A, B, C];
+    const namePoints2 = [D, E, F];
+    const identifiers = {
+        nodeIdsLengths1: nodeLengths1Shuffled.map((node) => node.toIdentifiers()),
+        nodeIdsLengths2: nodeLengths2Shuffled.map((node) => node.toIdentifiers()),
+        namePoints1,
+        namePoints2,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+};
+const optsDefault = {
+    numberTypesForLengths: ["Décimal"],
+    numberTypesForCoeffs: ["Entier"],
+};
+const options = [
+    {
+        id: "numberTypesForLengths",
+        label: "Types de nombres pour les longueurs",
+        defaultValue: optsDefault.numberTypesForLengths,
+        values: ["Entier", "Décimal"],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+    },
+    {
+        id: "numberTypesForCoeffs",
+        label: "Types de nombres pour les rapports",
+        defaultValue: optsDefault.numberTypesForCoeffs,
+        values: ["Entier", "Décimal", "Fraction"],
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+    },
+];
+export const isSimilarTrianglesWrtSideLengths = {
+    id: "isSimilarTrianglesWrtSideLengths",
+    label: "Justifier que deux triangles sont semblables par le rapport de leurs côtés",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsSimilarTrianglesWrtSideLengthsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/geometry/triangles/similar/placeSegmentsOfSimilarTriangle.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { TriangleIdentifiers } from "../../../../../math/geometry/triangles/triangle.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    triangleIds1: TriangleIdentifiers;
+    triangleIds2: TriangleIdentifiers;
+    factor: NodeIdentifiers;
+};
+export declare const placeSegmentsOfSimilarTriangle: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=placeSegmentsOfSimilarTriangle.d.ts.map

package/lib/exercises/math/geometry/triangles/similar/placeSegmentsOfSimilarTriangle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placeSegmentsOfSimilarTriangle.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/geometry/triangles/similar/placeSegmentsOfSimilarTriangle.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAGL,mBAAmB,EACpB,MAAM,2CAA2C,CAAC;AAQnD,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAwC7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,mBAAmB,CAAC;IAClC,YAAY,EAAE,mBAAmB,CAAC;IAClC,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AAkXF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAgBhE,CAAC"}

package/lib/exercises/math/geometry/triangles/similar/placeSegmentsOfSimilarTriangle.js

@@ -0,0 +1,311 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { greenMain, orange } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../../math/geometry/point.js";
+import { Segment } from "../../../../../math/geometry/segment.js";
+import { Triangle, TriangleConstructor, } from "../../../../../math/geometry/triangles/triangle.js";
+import { Vector, VectorConstructor } from "../../../../../math/geometry/vector.js";
+import { dividersOf } from "../../../../../math/utils/arithmetic/dividersOf.js";
+import { randfloat } from "../../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { opposite } from "../../../../../tree/nodes/functions/oppositeNode.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { random, randomMany } from "../../../../../utils/alea/random.js";
+import { intersect } from "../../../../../utils/arrays/arrayIntersection.js";
+function getCoordsForPoints(points) {
+    const xMin = Math.min(...points.map((p) => p.x.evaluate()));
+    const xMax = Math.max(...points.map((p) => p.x.evaluate()));
+    const yMin = Math.min(...points.map((p) => p.y.evaluate()));
+    const yMax = Math.max(...points.map((p) => p.y.evaluate()));
+    return { xMin, xMax, yMin, yMax };
+}
+const getDivisorsOfVector = (vec) => {
+    const arrDivisors = [vec.x, vec.y].map((z) => {
+        const n = Math.abs(z.evaluate());
+        if (n !== 0) {
+            return dividersOf(n);
+        }
+        else {
+            return [...Array(100).keys()].map((i) => i + 1); //everything divides 0
+        }
+    });
+    const divisorsOfVec = intersect(arrDivisors);
+    return divisorsOfVec;
+};
+const getRandomFactorNodeForVectors = (vecs) => {
+    const divisorsOfVecs = intersect(vecs.map((vec) => getDivisorsOfVector(vec)));
+    if (divisorsOfVecs.length !== 1) {
+        const den = random(divisorsOfVecs.filter((n) => n !== 1));
+        const num = randint(1, 3 * den, [den]);
+        const factorNode = frac(num, den);
+        return factorNode;
+    }
+    else {
+        return (1).toTree();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { triangleIds1, triangleIds2 } = identifiers;
+    const [nameTriangle1, nameTriangle2] = [triangleIds1, triangleIds2].map((triangleIds) => `${triangleIds.points[0].name}${triangleIds.points[1].name}${triangleIds.points[2].name}`);
+    const [angles1, angles2] = [triangleIds1, triangleIds2].map((triangle) => [
+        `\\widehat{${triangle.points[0].name}}`,
+        `\\widehat{${triangle.points[1].name}}`,
+    ]);
+    return `Construire les deux segments manquants du triangle $${nameTriangle2}$ sachant que :
+  
+- $${nameTriangle1}$ et $${nameTriangle2}$ sont semblables et que 
+
+- $${angles1[0]} = ${angles2[1]}$ et $${angles1[1]} = ${angles2[0]}$`;
+};
+const getHint = (identifiers) => {
+    const { triangleIds1, triangleIds2 } = identifiers;
+    const [nameBaseSegment1, nameBaseSegment2] = [triangleIds1, triangleIds2].map((triangleIds) => `[${triangleIds.points[0].name}${triangleIds.points[1].name}]`);
+    return `Tu peux trouver le rapport d'agrandissement ou de réduction grâce aux segments $${nameBaseSegment1}$ et $${nameBaseSegment2}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { triangleIds1, triangleIds2, factor } = identifiers;
+    const [nameBaseLength1, nameBaseLength2] = [triangleIds1, triangleIds2].map((triangleIds) => `${triangleIds.points[0].name}${triangleIds.points[1].name}`);
+    const [triangle1, triangle2] = [triangleIds1, triangleIds2].map((triangleIds) => TriangleConstructor.fromIdentifiers(triangleIds));
+    const vec1 = triangle1.sides[1].toVector();
+    const vec2 = triangle2.sides[0].toVector();
+    const [isLeft1, isLeft2] = [vec1, vec2].map((vec) => vec.x.evaluate() < 0);
+    const [absX1, absX2] = [vec1, vec2].map((vec) => Math.abs(vec.x.evaluate()));
+    const factorNode = NodeConstructor.fromIdentifiers(factor);
+    const [angles1, angles2] = [triangleIds1, triangleIds2].map((triangle) => [
+        `\\widehat{${triangle.points[0].name}}`,
+        `\\widehat{${triangle.points[1].name}}`,
+    ]);
+    return `Le rapport d'agrandissement ou de réduction vaut :
+
+$$
+\\frac{${nameBaseLength2}}{${nameBaseLength1}} = ${factorNode
+        .simplify()
+        .toTex()}
+$$
+
+Pour aller de $${triangle1.sides[1].pointA.name}$ à $${triangle1.sides[1].pointB.name}$, 
+on va $${absX1.frenchify()}$ cases vers la ${isLeft1 ? "gauche" : "droite"} et $${vec1.y.toTex()}$ cases vers le haut.
+Il faut respecter les mesures d'angles : 
+On a $${angles1[0]} = ${angles2[1]}$. 
+Ainsi, 
+pour aller de $${triangle2.sides[0].pointA.name}$ à $${triangle2.sides[0].pointB.name}$, 
+on va $${absX2.frenchify()}$ cases vers la ${isLeft2 ? "gauche" : "droite"} et $${vec2.y.toTex()}$ cases vers le haut.
+`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { triangleIds1, triangleIds2 } = identifiers;
+    const [triangle1, triangle2] = [triangleIds1, triangleIds2].map((triangleIds) => TriangleConstructor.fromIdentifiers(triangleIds));
+    const ggb = new GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        customToolBar: toolBarConstructor({ point: true, segment: true }),
+        commands: [
+            //triangles
+            ...triangle1.commands,
+            ...triangle2.commands,
+            //base segment
+            ...triangle2.sides[2].toGGBCommands(true),
+            `SetColor(${triangle2.sides[2].ggbName}, "${orange}")`,
+            ...getGGBAnswer(identifiers),
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...triangle1.points, ...triangle2.points]),
+    });
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { triangleIds1, triangleIds2 } = identifiers;
+    const [triangle1, triangle2] = [triangleIds1, triangleIds2].map((triangleIds) => TriangleConstructor.fromIdentifiers(triangleIds));
+    const ggb = new GeogebraConstructor({
+        hideAxes: true,
+        isGridSimple: true,
+        customToolBar: toolBarConstructor({ point: true, segment: true }),
+        commands: [
+            //triangles
+            ...triangle1.commands,
+            //base segment
+            ...triangle2.sides[2].toGGBCommands(true),
+            `SetColor(${triangle2.sides[2].ggbName}, "${orange}")`,
+        ],
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...triangle1.points, ...triangle2.points]),
+    });
+};
+const getAnswerSegments = (identifiers) => {
+    const { triangleIds1, triangleIds2 } = identifiers;
+    const [_, triangle2] = [triangleIds1, triangleIds2].map((triangleIds) => TriangleConstructor.fromIdentifiers(triangleIds));
+    return [triangle2.sides[0], triangle2.sides[1]];
+};
+const getGGBAnswer = (identifiers) => {
+    return [
+        //answer segments
+        ...getAnswerSegments(identifiers).flatMap((segment) => [
+            ...segment.toGGBCommands(true),
+            `SetColor(${segment.ggbName}, "${greenMain}")`,
+        ]),
+    ];
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const { triangleIds1, triangleIds2 } = identifiers;
+    const [triangle1, triangle2] = [triangleIds1, triangleIds2].map((triangleIds) => TriangleConstructor.fromIdentifiers(triangleIds));
+    const studentCommands = ans;
+    function getStudentPointsDictFromStudentCommands(commands) {
+        const regexPoint = new RegExp(`(?<name>\\w+)\\s?=\\s?\\((?<strX>-?\\d+(\\.\\d+)?),\\s?(?<strY>-?\\d+(\\.\\d+)?)\\)`);
+        const pointsDict = commands.reduce((acc, command) => {
+            const match = command.match(regexPoint);
+            if (match && match.groups) {
+                const { name, strX, strY } = match.groups;
+                const [x, y] = [strX, strY].map((strZ) => parseFloat(strZ));
+                const point = new Point(name, x, y);
+                acc[name] = point;
+            }
+            return acc;
+        }, {});
+        return pointsDict;
+    }
+    function getStudentSegmentsDictFromStudentCommands(commands) {
+        const studentPointsDict = getStudentPointsDictFromStudentCommands(commands);
+        const allPointsDict = Object.assign({}, Object.fromEntries([...triangle1.points, ...triangle2.points].map((point) => [
+            point.name,
+            point,
+        ])), studentPointsDict);
+        const regexSegment = new RegExp(`(?<name>\\w+)\\s?=\\s?Segment\\[(?<namePointA>\\w+),\\s?(?<namePointB>\\w+)\\]`);
+        const segmentsDict = studentCommands.reduce((acc, command) => {
+            const match = command.match(regexSegment);
+            if (match && match.groups) {
+                const { name, namePointA, namePointB } = match.groups;
+                const segment = new Segment(allPointsDict[namePointA], allPointsDict[namePointB]);
+                acc[name] = segment;
+            }
+            return acc;
+        }, {});
+        return segmentsDict;
+    }
+    const isSameSegment = (segment1, segment2) => {
+        return ((segment1.pointA.distanceTo(segment2.pointA) < 0.1 &&
+            segment1.pointB.distanceTo(segment2.pointB) < 0.1) ||
+            (segment1.pointB.distanceTo(segment2.pointA) < 0.1 &&
+                segment1.pointA.distanceTo(segment2.pointB) < 0.1));
+    };
+    const isSegmentsValid = (studentSegmentsDict) => {
+        const segmentsAns = Object.values(studentSegmentsDict);
+        const segmentsAnswer = getAnswerSegments(identifiers);
+        return ((isSameSegment(segmentsAns[0], segmentsAnswer[1]) &&
+            isSameSegment(segmentsAns[1], segmentsAnswer[0])) ||
+            (isSameSegment(segmentsAns[0], segmentsAnswer[0]) &&
+                isSameSegment(segmentsAns[1], segmentsAnswer[1])));
+    };
+    const studentSegmentsDict = getStudentSegmentsDictFromStudentCommands(studentCommands);
+    const isStudentSegmentsDictValid = (studentSegmentsDict) => Object.keys(studentSegmentsDict).length === 2;
+    return (isStudentSegmentsDictValid(studentSegmentsDict) &&
+        isSegmentsValid(studentSegmentsDict));
+};
+const getPlaceSegmentsOfSimilarTriangleQuestion = () => {
+    function createRandomGridTriangle(pointNames, point1) {
+        const baseX = randint(2, 11);
+        const point2 = new Point(pointNames[1], point1.x.evaluate() - baseX, point1.y.evaluate());
+        const midX = round((point1.x.evaluate() + point2.x.evaluate()) / 2.0, 0);
+        const offsetFromMidX = round(baseX * randfloat(-2, 2), 0);
+        const x3Candidate = midX + offsetFromMidX;
+        const point3 = new Point(pointNames[2], x3Candidate !== midX ? x3Candidate : midX + 1, point1.y.evaluate() + Math.max(1, round(baseX * randfloat(0, 2), 0)));
+        return new Triangle([point1, point2, point3]);
+    }
+    function createRandomIdentifiers() {
+        const [A, B, C, D, E, F] = randomMany("ABCDEFGHIJKLMNOPQRSTUVWXYZ".split(""), 6);
+        const point1 = new Point(A, -5, 0);
+        const triangle1 = createRandomGridTriangle([A, B, C], point1);
+        const vec1 = VectorConstructor.fromPoints(triangle1.points[0], triangle1.points[1]);
+        const vec2 = VectorConstructor.fromPoints(triangle1.points[0], triangle1.points[2]);
+        const factorNode = getRandomFactorNodeForVectors([vec1, vec2]).simplify();
+        const vec1Flipped = new Vector("vec1F", opposite(vec1.x), vec1.y);
+        const vec2Flipped = new Vector("vec2F", opposite(vec2.x), vec2.y);
+        const pointE = new Point(D, point1.x.evaluate() + 2, point1.y.evaluate());
+        const pointD = vec1Flipped.times(factorNode).getEndPoint(pointE, E);
+        const pointF = vec2Flipped.times(factorNode).getEndPoint(pointE, F);
+        const triangle2 = new Triangle([pointD, pointE, pointF]);
+        return {
+            triangleIds1: triangle1.toIdentifiers(),
+            triangleIds2: triangle2.toIdentifiers(),
+            factor: factorNode.toIdentifiers(),
+        };
+    }
+    function isSmallCoords(identifiers) {
+        const { triangleIds1, triangleIds2 } = identifiers;
+        const [triangle1, triangle2] = [triangleIds1, triangleIds2].map((triangleIds) => TriangleConstructor.fromIdentifiers(triangleIds));
+        const { xMin, xMax, yMin, yMax } = getCoordsForPoints([
+            ...triangle1.points,
+            ...triangle2.points,
+        ]);
+        return xMax - xMin < 15 && yMax - yMin < 15;
+    }
+    let identifiers;
+    let counter = -1;
+    let isValidIdentifiers = false;
+    while (!isValidIdentifiers && counter < 200) {
+        counter++;
+        identifiers = createRandomIdentifiers();
+        isValidIdentifiers = (() => {
+            if (counter < 100) {
+                const factorNode = NodeConstructor.fromIdentifiers(identifiers.factor);
+                const isIntegerFactor = () => factorNode.evaluate() % 1 === 0;
+                return !isIntegerFactor() && isSmallCoords(identifiers);
+            }
+            else {
+                return isSmallCoords(identifiers);
+            }
+        })();
+    }
+    if (!isValidIdentifiers) {
+        const triangle1 = new Triangle([
+            new Point("A", -5, 0),
+            new Point("B", -7, 0),
+            new Point("C", -7, 2),
+        ]);
+        const triangle2 = new Triangle([
+            new Point("D", -2, 0),
+            new Point("E", -3, 0),
+            new Point("F", -3, 1),
+        ]);
+        const defaultIdentifiers = {
+            triangleIds1: triangle1.toIdentifiers(),
+            triangleIds2: triangle2.toIdentifiers(),
+            factor: (2).toTree().toIdentifiers(),
+        };
+        identifiers = defaultIdentifiers;
+    }
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+    return question;
+};
+export const placeSegmentsOfSimilarTriangle = {
+    id: "placeSegmentsOfSimilarTriangle",
+    label: "Tracer un triangle semblable sur une grille",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getPlaceSegmentsOfSimilarTriangleQuestion(), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};