math-exercises 3.0.139 → 3.0.141

package/lib/exercises/math/functions/affines/placePointsFromAffine.js

@@ -0,0 +1,135 @@
+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 { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+const getInstruction = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIds);
+    return `Placer trois points appartenant à la courbe de la fonction $f$, d'expression :
+
+$$
+f(x) = ${nodeF.toTex()}
+$$
+  
+`;
+};
+const getHint = () => {
+    return `En calculant $f(0)$ et $f(1)$, tu pourras déjà placer deux points.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIds);
+    const arrValueAndNodeFAtValue = [-1, 0, 1].map((value) => {
+        const nodeFAtValue = nodeBySubstitutingVar(nodeF, value.toTree(), "x".toTree());
+        return [value, nodeFAtValue];
+    });
+    return `On a : 
+${arrValueAndNodeFAtValue
+        .map(([value, nodeFAtValue]) => `
+
+$$
+f(${value}) = ${nodeFAtValue.toTex()} = ${nodeFAtValue.simplify().toTex()}
+$$
+
+`)
+        .join("")}
+
+Donc on peut placer les points de coordonnées ${joinanded(arrValueAndNodeFAtValue.map(([value, nodeFAtValue]) => `$(${value};${nodeFAtValue.simplify().toTex()})$`), ", ", " et ")}.
+  
+On aurait pu choisir d'autre valeurs de $x$ mais on préfère choisir des valeurs qui facilitent les calculs.`;
+};
+const getSolutionPoints = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIds);
+    return [-1, 0, 1].map((x, i) => {
+        const y = nodeF.evaluate({ x });
+        return new Point(`S_${i}`, x, y);
+    });
+};
+const getOtherSolutionPoints = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIds);
+    const nbOther = 10;
+    const arrX = [...Array(nbOther).keys()].reduce((acc, _) => [...acc, randfloat(-10, 10, 2, acc)], []);
+    return arrX.map((x, i) => {
+        const y = nodeF.evaluate({ x });
+        return new Point(`U_${i}`, x, y);
+    });
+};
+const getGGBAnswer = (identifiers) => {
+    const solutionPoints = getSolutionPoints(identifiers);
+    const otherSolutionPoints = getOtherSolutionPoints(identifiers);
+    return [
+        ...solutionPoints.flatMap((point) => point.toGGBCommand({ color: `${greenMain}`, showLabel: false })),
+        ...otherSolutionPoints.flatMap((point) => point.toGGBCommand({ color: `black`, showLabel: false })),
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const points = getSolutionPoints(identifiers);
+    const ggb = new GeogebraConstructor({
+        commands: [],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(points),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const { nodeIds } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIds);
+    const commands = ans;
+    const ggbParser = new GeogebraParser(commands);
+    const objectDict = ggbParser.objectDict();
+    const pointsCoords = Object.keys(objectDict).map((name) => ggbParser.pointCoords(name));
+    return (pointsCoords.length == 3 &&
+        pointsCoords.every(([x, y]) => {
+            const studentPoint = new Point("StudentPoint", x, y);
+            const answerY = nodeF.evaluate({ x });
+            const solutionPoint = new Point("SolutionPoint", x, answerY);
+            const distance = studentPoint.distanceTo(solutionPoint);
+            return distance < 1;
+        }));
+};
+const getPlacePointsFromAffineQuestion = () => {
+    const affine = AffineConstructor.random({ min: -5, max: 6 });
+    const identifiers = {
+        nodeIds: affine.toTree().toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const placePointsFromAffine = {
+    id: "placePointsFromAffine",
+    label: "Placer des points issus de l'expression algébrique d'une fonction affine",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlacePointsFromAffineQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/affines/recognizeAffinePointsFromPoints.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIds: NodeIdentifiers;
+    pointIds: PointIdentifiers[];
+};
+export declare const recognizeAffinePointsFromPoints: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=recognizeAffinePointsFromPoints.d.ts.map

package/lib/exercises/math/functions/affines/recognizeAffinePointsFromPoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeAffinePointsFromPoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/recognizeAffinePointsFromPoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAKtC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,CAAC;IACzB,QAAQ,EAAE,gBAAgB,EAAE,CAAC;CAC9B,CAAC;AA4OF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAkBjE,CAAC"}

package/lib/exercises/math/functions/affines/recognizeAffinePointsFromPoints.js

@@ -0,0 +1,208 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { greenMain } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { nodeBySubstitutingVar } from "../../../../math/utils/functions/functionComposition.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIds);
+    return `Soit la fonction $f$, d'expression :
+
+$$
+f(x) = ${nodeF.toTex()}
+$$
+
+Parmi les points ci-dessous, lequel ou lesquels appartiennent à la courbe représentative de $f$ ?
+`;
+};
+const getHint = () => {
+    return `Un point $I$ de coordonnées $(x;y)$ appartient à la courbe $\\mathcal C_f$ d'une fonction $f$ si et seulement si $f(x)=y$.
+  
+Pour chaque point, il faut donc vérifier si son ordonnée est égale à l'image par $f$ de son abscisse.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIds, pointIds } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIds);
+    const points = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const pointsDict = getValidAndInvalidPointsDict(identifiers);
+    return `${points.map((point) => {
+        const isValid = !!pointsDict.valid[point.name];
+        const nodeFAtX = nodeBySubstitutingVar(nodeF, point.x);
+        return `Pour le point $${point.name}$, on lit les coordonnées $(${point.x.toTex()};${point.y.toTex()})$.
+
+$$
+f(${point.x.toTex()}) = ${nodeFAtX.toTex()} = ${nodeFAtX.simplify().toTex()} 
+$$
+
+donc
+
+$$
+f(x_${point.name}) ${isValid ? "=" : "\\neq"} y_${point.name}
+$$
+
+$${point.name}$ ${isValid ? "appartient" : "n'appartient pas"} à $\\mathcal C_f$.
+    `;
+    }).join(`
+      
+`)}`;
+};
+const getValidAndInvalidPointsDict = (identifiers) => {
+    const { nodeIds, pointIds } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIds);
+    const points = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const pointsDict = {
+        valid: {},
+        invalid: {},
+    };
+    return points.reduce((acc, point) => {
+        const x = point.x.evaluate();
+        const yF = nodeF.evaluate({ x });
+        //imperfect check
+        const isValid = Math.abs(point.y.evaluate() - yF) < power(10, -7).evaluate();
+        if (isValid) {
+            acc.valid[point.name] = point;
+        }
+        else {
+            acc.invalid[point.name] = point;
+        }
+        return acc;
+    }, pointsDict);
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodeF = NodeConstructor.fromIdentifiers(nodeIds);
+    const fName = "f";
+    const pointsDict = getValidAndInvalidPointsDict(identifiers);
+    const points = [
+        ...Object.values(pointsDict.valid),
+        ...Object.values(pointsDict.invalid),
+    ];
+    const commands = [
+        ...[
+            `${fName} = Function(${nodeF.toMathString()}, x, -20, 20)`,
+            `ShowLabel(${fName}, true)`,
+            `SetCaption(${fName}, "$\\mathcal C_${fName}$")`,
+            `SetColor(${fName}, "black")`,
+        ],
+        ...Object.values(pointsDict.valid).flatMap((point) => point.toGGBCommand({ color: `${greenMain}` })),
+        ...Object.values(pointsDict.invalid).flatMap((point) => point.toGGBCommand({ color: `red` })),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: false,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(points),
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { pointIds } = identifiers;
+    const points = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const ggb = new GeogebraConstructor({
+        commands: [...points.flatMap((point) => point.toGGBCommand())],
+        lockedAxesRatio: false,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(points),
+    });
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const propositions = [];
+    const pointsDict = getValidAndInvalidPointsDict(identifiers);
+    //keep same order on each question
+    ["A", "B", "C", "D"].forEach((pointName) => {
+        if (pointsDict.valid[pointName]) {
+            addValidProp(propositions, pointName);
+        }
+        else {
+            tryToAddWrongProp(propositions, pointName);
+        }
+    });
+    return propositions;
+};
+const getPlacePointsFromAffineQuestion = () => {
+    const affine = AffineConstructor.random({ min: -3, max: 4 }, { min: -5, max: 6 });
+    const [xMin, xMax] = [-3, 3];
+    const x1 = randint(xMin, 0);
+    const x2 = randint(xMin, 0, [x1]);
+    const x3 = randint(0, xMax + 1, [0]);
+    const x4 = randint(0, xMax + 1, [0, x3]);
+    const arrX = [x1, x2, x3, x4].toSorted((x1, x2) => x1 - x2);
+    const arrYF = arrX.map((x) => affine.calculate(x));
+    const [yFMin, yFMax] = arrYF
+        .slice(1)
+        .reduce((acc, y) => [Math.min(acc[0], y), Math.max(acc[1], y)], [arrYF[0], arrYF[0]]);
+    const validIndexesDict = Object.fromEntries(randomMany([0, 1, 2, 3], randint(1, 5)).map((i) => [i, true]));
+    const points = ["A", "B", "C", "D"].map((name, i) => {
+        const x = arrX[i];
+        const yF = arrYF[i];
+        if (validIndexesDict[i]) {
+            return new Point(name, x, yF);
+        }
+        else {
+            const coeffs = affine.coefficients;
+            let yWrong;
+            if (coinFlip()) {
+                //wrongAffine (wrong signs)
+                const wrongCoeffs = [
+                    [+1, -1],
+                    [-1, +1],
+                    [-1, -1],
+                ].map((arrSign) => arrSign.map((sign, i) => sign * coeffs[i]));
+                const wrongCoeffsDistinct = [...new Set(wrongCoeffs)]; //maudit 0
+                const wrongAffine = AffineConstructor.fromCoeffs(random(wrongCoeffsDistinct));
+                yWrong = wrongAffine.calculate(x);
+            }
+            else {
+                //wrongPoints (random offset)
+                if (coinFlip()) {
+                    yWrong = random([yF + 1, yF - 1]);
+                }
+                else {
+                    yWrong = randint(yFMin, yFMax, [yF]);
+                }
+            }
+            return new Point(name, x, yWrong);
+        }
+    });
+    const identifiers = {
+        nodeIds: affine.toTree().toIdentifiers(),
+        pointIds: points.map((point) => point.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+    };
+};
+export const recognizeAffinePointsFromPoints = {
+    id: "recognizeAffinePointsFromPoints",
+    label: "Repérer les points pouvant appartenir à la courbe d'une fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlacePointsFromAffineQuestion(opts), nb),
+    ggbTimer: 60,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getPropositions,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/exercises/math/functions/basics/index.d.ts

@@ -16,4 +16,5 @@ export * from "./isPointOnFunction.js";
 export * from "./countFunctionZeroes.js";
 export * from "./findZeroesProductQuotient.js";
 export * from "./coordsOfPointOnCurveFindY.js";
+export * from "./placePointsFromValueTable.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/basics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mCAAmC,CAAC;AAClD,cAAc,sBAAsB,CAAC;AACrC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kCAAkC,CAAC;AACjD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,gCAAgC,CAAC"}

package/lib/exercises/math/functions/basics/index.js

@@ -16,3 +16,4 @@ export * from "./isPointOnFunction.js";
 export * from "./countFunctionZeroes.js";
 export * from "./findZeroesProductQuotient.js";
 export * from "./coordsOfPointOnCurveFindY.js";
+export * from "./placePointsFromValueTable.js";

package/lib/exercises/math/functions/basics/placePointsFromValueTable.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    arrCoordsAsNodeIds: NodeIdentifiers[][];
+};
+export declare const placePointsFromValueTable: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=placePointsFromValueTable.d.ts.map

package/lib/exercises/math/functions/basics/placePointsFromValueTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placePointsFromValueTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/placePointsFromValueTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAI7C,KAAK,WAAW,GAAG;IACjB,kBAAkB,EAAE,eAAe,EAAE,EAAE,CAAC;CACzC,CAAC;AAwJF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAiB3D,CAAC"}

package/lib/exercises/math/functions/basics/placePointsFromValueTable.js

@@ -0,0 +1,128 @@
+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 { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+const getValueTable = (arrPoint) => {
+    return [
+        ["x", ...arrPoint.map((p) => p.x.toTex())].map((str) => `$${str}$`),
+        ["f(x)", ...arrPoint.map((p) => p.y.toTex())].map((str) => `$${str}$`),
+    ];
+};
+const getInstruction = (identifiers) => {
+    const valueTable = getValueTable(getSolutionPoints(identifiers));
+    return `Placer les points correspondant au tableau de valeurs ci-dessous de la fonction $f$.
+
+${mdTable(valueTable)}
+  
+`;
+};
+const getHint = () => {
+    return `Place chaque point de coordonnées $(x;f(x))$.`;
+};
+const getCorrection = (identifiers) => {
+    const solutionPoints = getSolutionPoints(identifiers);
+    return `On place chaque point de coordonnées $(x;f(x))$.
+  
+On place donc les points de coordonnées ${joinanded(solutionPoints.map((p) => `$(${p.x.toTex()};${p.y.toTex()})$`), ", ", " et ")}.`;
+};
+const getSolutionPoints = (identifiers) => {
+    const { arrCoordsAsNodeIds } = identifiers;
+    const arrCoordsAsNodes = arrCoordsAsNodeIds.map(([nodeIdsX, nodeIdsY]) => [nodeIdsX, nodeIdsY].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)));
+    return arrCoordsAsNodes.map(([nodeX, nodeY], i) => {
+        return new Point(`S_${i}`, nodeX, nodeY);
+    });
+};
+const getGGBAnswer = (identifiers) => {
+    const solutionPoints = getSolutionPoints(identifiers);
+    return [
+        ...solutionPoints.flatMap((point) => point.toGGBCommand({ color: `${greenMain}`, showLabel: false })),
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const points = getSolutionPoints(identifiers);
+    const ggb = new GeogebraConstructor({
+        commands: [],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(points),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const commands = ans;
+    const ggbParser = new GeogebraParser(commands);
+    const objectDict = ggbParser.objectDict();
+    const pointsCoords = Object.keys(objectDict).map((name) => ggbParser.pointCoords(name));
+    const pointsCoordsSortedByAscX = pointsCoords.toSorted(([x1], [x2]) => {
+        return x1 - x2;
+    });
+    const solutionPointsSortedByAscX = getSolutionPoints(identifiers).toSorted((p1, p2) => {
+        return p1.x.evaluate() - p2.x.evaluate();
+    });
+    return (pointsCoordsSortedByAscX.length === solutionPointsSortedByAscX.length &&
+        pointsCoordsSortedByAscX.every(([x, y], i) => {
+            const studentPoint = new Point("StudentPoint", x, y);
+            const solutionPoint = solutionPointsSortedByAscX[i];
+            const distance = studentPoint.distanceTo(solutionPoint);
+            return distance < 1;
+        }));
+};
+const getPlacePointsFromValueTableQuestion = () => {
+    function createArrCoordsAsNodes() {
+        const xs = [
+            randint(-10, -5),
+            randint(-5, 0),
+            randint(0, 5),
+            randint(6, 10),
+        ];
+        const points = [[xs[0], randint(-9, 10)]];
+        for (let i = 1; i < xs.length; i++) {
+            const y = points[i - 1][1] + randint(-5, 6);
+            points.push([xs[i], y]);
+        }
+        const arrCoordsAsNodeIds = points.map(([x, y]) => {
+            return [x, y].map((v) => v.toTree());
+        });
+        return arrCoordsAsNodeIds;
+    }
+    const arrCoordsAsNodes = createArrCoordsAsNodes();
+    const identifiers = {
+        arrCoordsAsNodeIds: arrCoordsAsNodes.map(([nodeX, nodeY]) => [nodeX, nodeY].map((node) => node.toIdentifiers())),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const placePointsFromValueTable = {
+    id: "placePointsFromValueTable",
+    label: "Placer des points issus d'un tableau de valeurs d'une fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlacePointsFromValueTableQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/geometry/pythagore/isTriangleRight.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"isTriangleRight.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/isTriangleRight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA+GF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAkBjD,CAAC"}
+{"version":3,"file":"isTriangleRight.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/pythagore/isTriangleRight.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA2HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAkBjD,CAAC"}

package/lib/exercises/math/geometry/pythagore/isTriangleRight.js

@@ -2,8 +2,8 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exer
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { pythagoricianTriplets } from "../../../../math/utils/geometry/pythagoricianTriplets.js";
 import { round } from "../../../../math/utils/round.js";
-import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
-import { SquareNode } from "../../../../tree/nodes/operators/powerNode.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { square, SquareNode } from "../../../../tree/nodes/operators/powerNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
 import { doWhile } from "../../../../utils/doWhile.js";
@@ -28,16 +28,24 @@ const getInstruction = (identifiers) => {
 Le triangle $${triangleName}$ est-il rectangle ?`;
 };
 const getHint = () => {
-    return `Si la somme des carrés des côtés est égale au carré de l'hypoténuse, alors le triangle est rectangle, d'après la réciproque du théorème de Pythagore. Si ce n'est pas le cas, alors le triangle n'est pas rectangle, d'après la contraposée du théorème de Pythagore. L'hypoténuse est toujours le côté le plus grand dans un triangle.`;
+    return `Si la somme des carrés des côtés est égale au carré du plus grand côté, alors le triangle est rectangle, d'après la réciproque du théorème de Pythagore. 
+  
+Si ce n'est pas le cas, alors le triangle n'est pas rectangle, d'après la contraposée du théorème de Pythagore.`;
 };
 const getCorrection = (identifiers) => {
     const hypo = Math.max(identifiers.a, identifiers.b, identifiers.c);
     const sides = [identifiers.a, identifiers.b, identifiers.c].filter((e) => e !== hypo);
+    const sideNames = identifiers.vertices.map((vertex, index) => vertex + identifiers.vertices[(index + 1) % 3]);
     return `La somme des carrés des côtés est égale à : 
   
 ${alignTex([
         [
+            add(square(sideNames[0]), square(sideNames[1])).toTex(),
+            "=",
             new AddNode(new SquareNode(sides[0].toTree()), new SquareNode(sides[1].toTree())).toTex(),
+        ],
+        [
+            "",
             "=",
             round(sides[0] ** 2, 6).frenchify() +
                 "+" +
@@ -46,15 +54,17 @@ ${alignTex([
         ["", "=", round(sides[0] ** 2 + sides[1] ** 2, 6).frenchify()],
     ])}
 
-Le carré de l'hypoténuse vaut : 
+Le carré du plus grand côté vaut : 
+
+${alignTex([
+        [square(sideNames[2]).toTex(), "=", square(hypo).toTex()],
+        ["", "=", round(hypo ** 2, 6).frenchify()],
+    ])}
 
-$$
-${new SquareNode(hypo.toTree()).toTex()} = ${round(hypo ** 2, 6).frenchify()}
-$$
 
 ${identifiers.isRight
-        ? "La somme des carrés des côtés est donc égale au carré de l'hypoténuse. D'après la réciproque du théorème de Pythagore, le triangle est donc rectangle."
-        : "La somme des carrés des côtés n'est donc pas égale au carré de l'hypoténuse. D'après la contraposée du théorème de Pythagore, le triangle n'est donc pas rectangle."}`;
+        ? "La somme des carrés des côtés est donc égale au carré du plus grand côté. D'après la réciproque du théorème de Pythagore, le triangle est donc rectangle."
+        : "La somme des carrés des côtés n'est donc pas égale au carré du plus grand côté. D'après la contraposée du théorème de Pythagore, le triangle n'est donc pas rectangle."}`;
 };
 const getKeys = () => {
     return [];

package/lib/exercises/utils/data/boxXY.d.ts

@@ -0,0 +1,7 @@
+export declare const boxXY: (arrXY: number[][]) => {
+    xMin: number;
+    xMax: number;
+    yMin: number;
+    yMax: number;
+};
+//# sourceMappingURL=boxXY.d.ts.map

package/lib/exercises/utils/data/boxXY.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boxXY.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/data/boxXY.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,KAAK,GAAI,OAAO,MAAM,EAAE,EAAE;;;;;CAkBtC,CAAC"}

package/lib/exercises/utils/data/boxXY.js

@@ -0,0 +1,16 @@
+export const boxXY = (arrXY) => {
+    const { xMin, xMax, yMin, yMax } = arrXY.slice(1).reduce((acc, [x, y]) => {
+        return {
+            xMin: Math.min(x, acc.xMin),
+            xMax: Math.max(x, acc.xMax),
+            yMin: Math.min(y, acc.yMin),
+            yMax: Math.max(y, acc.yMax),
+        };
+    }, {
+        xMin: arrXY[0][0],
+        xMax: arrXY[0][0],
+        yMin: arrXY[0][1],
+        yMax: arrXY[0][1],
+    });
+    return { xMin, xMax, yMin, yMax };
+};

package/lib/exercises/utils/data/isBoxable.d.ts

@@ -0,0 +1,2 @@
+export declare const isBoxable: (arrXY: number[][]) => boolean;
+//# sourceMappingURL=isBoxable.d.ts.map

package/lib/exercises/utils/data/isBoxable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isBoxable.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/data/isBoxable.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,EAAE,EAAE,YAG1C,CAAC"}

package/lib/exercises/utils/data/isBoxable.js

@@ -0,0 +1,5 @@
+import { boxXY } from "./boxXY.js";
+export const isBoxable = (arrXY) => {
+    const { xMin, xMax, yMin, yMax } = boxXY(arrXY);
+    return xMin !== xMax && yMin !== yMax;
+};

package/lib/exercises/utils/data/randomDataTable.d.ts

@@ -0,0 +1,11 @@
+type DataCategory = {
+    nameTex: string;
+    gen: (min?: number, max?: number) => number;
+};
+export declare const randomDataCategAndValues: (nbCateg: number, nbValues: number) => {
+    categ: DataCategory;
+    values: number[];
+}[];
+export declare const randomDataTable: (nbCateg?: number, nbValues?: number, isRowBased?: boolean) => string[][];
+export {};
+//# sourceMappingURL=randomDataTable.d.ts.map

package/lib/exercises/utils/data/randomDataTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"randomDataTable.d.ts","sourceRoot":"","sources":["../../../../src/exercises/utils/data/randomDataTable.ts"],"names":[],"mappings":"AAKA,KAAK,YAAY,GAAG;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,GAAG,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;CAC7C,CAAC;AA6DF,eAAO,MAAM,wBAAwB,GAAI,SAAS,MAAM,EAAE,UAAU,MAAM;;;GAazE,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,UAAS,MAAU,EACnB,WAAU,MAAU,EACpB,aAAY,OAAc,eAW3B,CAAC"}