math-exercises 3.0.139 → 3.0.141

package/lib/exercises/math/calcul/proportionality/isProportionalFromProblem.js

@@ -0,0 +1,349 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { primes } from "../../../../math/numbers/integer/primes.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 { 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 } from "../../../../utils/alea/random.js";
+import { intersect } from "../../../../utils/arrays/arrayIntersection.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const roundToForDisplay = 7; //tristesse un peu
+const situations = [
+    {
+        instruction: (values) => `Chez un pépiniériste, un cerisier d'une hauteur de $${values[0][0].frenchify()}$ $\\textrm{cm}$ coûte $${values[1][0].frenchify()}$ $\\textrm{€}$ 
+et un cerisier d'une hauteur de $${values[0][1].frenchify()}$ $\\textrm{cm}$ coûte $${values[1][1].frenchify()}$ $\\textrm{€}$. 
+Le prix du cerisier est-il proportionnel à sa hauteur ?`,
+        correction: (values) => {
+            const m1 = multiply(values[0][0], values[1][1]);
+            const m2 = multiply(values[1][0], values[0][1]);
+            const isPropor = isProportional(values);
+            return `On peut dresser le tableau suivant: 
+${mdTable([
+                ["Cerisiers", ...values[0].map(() => "")],
+                [
+                    "Hauteur ($\\textrm{cm}$)",
+                    ...values[0].map((value) => `$${value.frenchify()}$`),
+                ],
+                [
+                    "Prix ($\\textrm{€}$)",
+                    ...values[1].map((value) => `$${value.frenchify()}$`),
+                ],
+            ])}
+
+On va comparer les produits en croix :
+
+$$
+${values[0][0].frenchify()} \\times ${values[1][1].frenchify()} = ${round(m1.evaluate(), roundToForDisplay).frenchify()}
+$$
+
+$$
+${values[1][0].frenchify()} \\times ${values[0][1].frenchify()} = ${round(m2.evaluate(), roundToForDisplay).frenchify()}
+$$
+
+${isPropor
+                ? `Les produits en croix sont égaux. 
+Le prix du cerisier est donc proportionnel à sa hauteur.`
+                : `Les produits en croix sont différents. 
+Le prix du cerisier n'est donc pas proportionnel à sa hauteur.`}`;
+        },
+        randValues: (isProportional) => {
+            const nbValues = 2;
+            const roundTo = 2;
+            const valuesA = [...Array(nbValues + 1).keys()].reduce((acc) => [...acc, randint(70, 150, acc)], []);
+            const coeff = randfloat(0.4, 0.7, roundTo);
+            const valuesB = valuesA.map((valueA) => round(valueA * coeff, roundTo));
+            if (isProportional) {
+                return [valuesA.slice(0, nbValues), valuesB.slice(0, nbValues)];
+            }
+            else {
+                return [valuesA.slice(0, nbValues), [valuesB[0], ...valuesB.slice(2)]];
+            }
+        },
+    },
+    {
+        instruction: (values) => `Samedi, Margot a consommé $${values[0][0].frenchify()}$ litres d'essence pour parcourir $${values[1][0].frenchify()}$ $\\textrm{km}$. 
+Dimanche, elle a parcouru $${values[1][1].frenchify()}$ $\\textrm{km}$ avec $${values[0][1].frenchify()}$ litres d'essence. 
+La distance parcourue est-elle proportionnelle à la consommation d'essence ?`,
+        correction: (values) => {
+            const m1 = multiply(values[0][0], values[1][1]);
+            const m2 = multiply(values[1][0], values[0][1]);
+            const isPropor = isProportional(values);
+            return `On peut dresser le tableau suivant: 
+${mdTable([
+                ["Margot", ...values[0].map(() => "")],
+                ["Jour", "Samedi", "Dimanche"],
+                [
+                    "Consommation ($\\textrm{L}$)",
+                    ...values[0].map((value) => `$${value.frenchify()}$`),
+                ],
+                [
+                    "Distance ($\\textrm{km}$)",
+                    ...values[1].map((value) => `$${value.frenchify()}$`),
+                ],
+            ])}
+
+On va comparer les produits en croix :
+
+$$
+${values[0][0].frenchify()} \\times ${values[1][1].frenchify()} = ${round(m1.evaluate(), roundToForDisplay).frenchify()}
+$$
+
+$$
+${values[1][0].frenchify()} \\times ${values[0][1].frenchify()} = ${round(m2.evaluate(), roundToForDisplay).frenchify()}
+$$
+
+${isPropor
+                ? `Les produits en croix sont égaux. 
+La distance parcourue est proportionnelle à la consommation d'essence.`
+                : `Les produits en croix sont différents. 
+La distance parcourue n'est pas proportionnelle à la consommation d'essence.`}`;
+        },
+        randValues: (isProportional) => {
+            const nbValues = 2;
+            const roundTo = 1;
+            const valuesA = [...Array(nbValues + 1).keys()].reduce((acc) => [...acc, randint(5, 50, acc)], []);
+            const coeff = randfloat(10, 30, roundTo);
+            const valuesB = valuesA.map((valueA) => round(valueA * coeff, roundTo));
+            if (isProportional) {
+                return [valuesA.slice(0, nbValues), valuesB.slice(0, nbValues)];
+            }
+            else {
+                return [valuesA.slice(0, nbValues), [valuesB[0], ...valuesB.slice(2)]];
+            }
+        },
+    },
+    {
+        instruction: (values) => `Jérome dirige deux casses automobiles. 
+Dans la première, il y a $${values[0][0].frenchify()}$ épaves et $${values[1][0].frenchify()}$ pneus. 
+Dans la deuxième, il y a $${values[0][1].frenchify()}$ épaves et $${values[1][1].frenchify()}$ pneus.
+Le nombre d'épaves est-il proportionnel au nombre de pneus ?`,
+        correction: (values) => {
+            const m1 = multiply(values[0][0], values[1][1]);
+            const m2 = multiply(values[1][0], values[0][1]);
+            const isPropor = isProportional(values);
+            return `On peut dresser le tableau suivant: 
+${mdTable([
+                ["Jérome", ...values[0].map(() => "")],
+                ["Casses", "Casse $1$", "Casse $2$"],
+                ["Épaves", ...values[0].map((value) => `$${value.frenchify()}$`)],
+                ["Pneus", ...values[1].map((value) => `$${value.frenchify()}$`)],
+            ])}
+
+On va comparer les produits en croix :
+
+$$
+${values[0][0].frenchify()} \\times ${values[1][1].frenchify()} = ${round(m1.evaluate(), roundToForDisplay).frenchify()}
+$$
+
+$$
+${values[1][0].frenchify()} \\times ${values[0][1].frenchify()} = ${round(m2.evaluate(), roundToForDisplay).frenchify()}
+$$
+
+${isPropor
+                ? `Les produits en croix sont égaux. 
+Le nombre d'épaves est proportionnel au nombre de pneus.`
+                : `Les produits en croix sont différents. 
+Le nombre d'épaves n'est pas proportionnel au nombre de pneus.`}`;
+        },
+        randValues: (isProportional) => {
+            const nbValues = 2;
+            const valuesA = [...Array(nbValues + 1).keys()].reduce((acc) => [...acc, randint(5, 50, acc)], []);
+            const coeff = randint(8, 37);
+            const valuesB = valuesA.map((valueA) => valueA * coeff);
+            if (isProportional) {
+                return [valuesA.slice(0, nbValues), valuesB.slice(0, nbValues)];
+            }
+            else {
+                return [valuesA.slice(0, nbValues), [valuesB[0], ...valuesB.slice(2)]];
+            }
+        },
+    },
+    {
+        instruction: (values) => `Alassan joue à un jeu vidéo sur son ordinateur. 
+Dans une première session, il a gagné $${values[1][0].frenchify()}$ niveaux en $${values[0][0].frenchify()}$ $\\textrm{min}$. 
+Dans une autre session, en $${values[0][1].frenchify()}$ $\\textrm{min}$, il a gagné $${values[1][1].frenchify()}$ niveaux.
+Le nombre de niveaux gagnés est-il proportionnel à la durée de jeu ?`,
+        correction: (values) => {
+            const m1 = multiply(values[0][0], values[1][1]);
+            const m2 = multiply(values[1][0], values[0][1]);
+            const isPropor = isProportional(values);
+            return `On peut dresser le tableau suivant: 
+${mdTable([
+                ["Alassan", ...values[0].map(() => "")],
+                ["Sessions", "Session $1$", "Session $2$"],
+                [
+                    "Durée de jeu ($\\textrm{min}$)",
+                    ...values[0].map((value) => `$${value.frenchify()}$`),
+                ],
+                [
+                    "Nombre de niveaux gagnés",
+                    ...values[1].map((value) => `$${value.frenchify()}$`),
+                ],
+            ])}
+
+On va comparer les produits en croix :
+
+$$
+${values[0][0].frenchify()} \\times ${values[1][1].frenchify()} = ${round(m1.evaluate(), roundToForDisplay).frenchify()}
+$$
+
+$$
+${values[1][0].frenchify()} \\times ${values[0][1].frenchify()} = ${round(m2.evaluate(), roundToForDisplay).frenchify()}
+$$
+
+${isPropor
+                ? `Les produits en croix sont égaux. 
+Le nombre de niveaux gagnés est proportionnel à la durée de jeu.`
+                : `Les produits en croix sont différents. 
+Le nombre de niveaux gagnés n'est pas proportionnel à la durée de jeu.`}`;
+        },
+        randValues: (isProportional) => {
+            const nbValues = 2;
+            let valuesA;
+            let valuesB;
+            let counter = -1;
+            let isValid = false;
+            while (!isValid && counter < 100) {
+                counter++;
+                valuesA = [...Array(nbValues + 1).keys()].reduce((acc) => [...acc, randint(15, 120, [...acc, ...primes])], []);
+                const commonDivisors = intersect(valuesA.map((valueA) => dividersOf(valueA)));
+                isValid = commonDivisors.length > 1;
+                const randomCommonDivisor = commonDivisors.length > 1
+                    ? random(commonDivisors.slice(1))
+                    : commonDivisors[0];
+                const coeff = frac(randint(1, randomCommonDivisor), randomCommonDivisor);
+                valuesB = valuesA.map((valueA) => multiply(valueA, coeff).simplify().evaluate());
+            }
+            if (isProportional) {
+                return [valuesA.slice(0, nbValues), valuesB.slice(0, nbValues)];
+            }
+            else {
+                return [
+                    valuesA.slice(0, nbValues),
+                    [valuesB[0], ...valuesB.slice(2)],
+                ];
+            }
+        },
+    },
+    {
+        instruction: (values) => `Dans un village, il y a $${values[0][0].frenchify()}$ terrains de pétanque et $${values[1][0].frenchify()}$ retraités.
+Dans un autre village, il y a $${values[0][1].frenchify()}$ terrains de pétanque et $${values[1][1].frenchify()}$ retraités.
+Le nombre de terrains de pétanque est-il proportionnel au nombre de retraités ?`,
+        correction: (values) => {
+            const m1 = multiply(values[0][0], values[1][1]);
+            const m2 = multiply(values[1][0], values[0][1]);
+            const isPropor = isProportional(values);
+            return `On peut dresser le tableau suivant: 
+${mdTable([
+                ["Pétanque", ...values[0].map(() => "")],
+                ["Village", "Village $1$", "Village $2$"],
+                ["Terrains", ...values[0].map((value) => `$${value.frenchify()}$`)],
+                ["Retraités", ...values[1].map((value) => `$${value.frenchify()}$`)],
+            ])}
+
+On va comparer les produits en croix :
+
+$$
+${values[0][0].frenchify()} \\times ${values[1][1].frenchify()} = ${round(m1.evaluate(), roundToForDisplay).frenchify()}
+$$
+
+$$
+${values[1][0].frenchify()} \\times ${values[0][1].frenchify()} = ${round(m2.evaluate(), roundToForDisplay).frenchify()}
+$$
+
+${isPropor
+                ? `Les produits en croix sont égaux. 
+Le nombre de terrains de pétanque est proportionnel au nombre de retraités.`
+                : `Les produits en croix sont différents. 
+Le nombre de terrains de pétanque n'est pas proportionnel au nombre de retraités.`}`;
+        },
+        randValues: (isProportional) => {
+            const nbValues = 2;
+            const valuesA = [...Array(nbValues + 1).keys()].reduce((acc) => [...acc, randint(3, 30, acc)], []);
+            const coeff = randint(8, 37);
+            const valuesB = valuesA.map((valueA) => valueA * coeff);
+            if (isProportional) {
+                return [valuesA.slice(0, nbValues), valuesB.slice(0, nbValues)];
+            }
+            else {
+                return [valuesA.slice(0, nbValues), [valuesB[0], ...valuesB.slice(2)]];
+            }
+        },
+    },
+];
+const isProportional = (values) => {
+    const m1 = multiply(values[0][0], values[1][1]);
+    const m2 = multiply(values[1][0], values[0][1]);
+    return round(substract(m1, m2).evaluate(), roundToForDisplay) === 0;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const propositions = [];
+    const answerFromIdentifiers = getAnswer(identifiers);
+    ["Oui", "Non"].forEach((strProp) => {
+        if (strProp === answerFromIdentifiers) {
+            addValidProp(propositions, strProp);
+        }
+        else {
+            tryToAddWrongProp(propositions, strProp);
+        }
+    });
+    return propositions;
+};
+const getAnswer = (identifiers) => {
+    const { values } = identifiers;
+    return isProportional(values) ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.instruction(values);
+};
+const getHint = () => {
+    return `Que doivent vérifier les valeurs données s'il y a proportionnalité ?`;
+};
+const getCorrection = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.correction(values);
+};
+const getIsProportionalFromProblemQuestion = () => {
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const isProportional = coinFlip();
+    const values = situation.randValues(isProportional);
+    const identifiers = { situationIndex, values };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const isProportionalFromProblem = {
+    id: "isProportionalFromProblem",
+    label: "Reconnaître une situation de proportionnalité à partir d'un énoncé",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsProportionalFromProblemQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/calculLitteral/equation/isEqualityTrue.js

@@ -21,10 +21,10 @@ const getPropositions = (_, { answer }) => {
     const propositions = [];
     ["Oui", "Non"].forEach((strYN) => {
         if (strYN === answer) {
-            addValidProp(propositions, strYN);
+            addValidProp(propositions, strYN, "raw");
         }
         else {
-            tryToAddWrongProp(propositions, strYN);
+            tryToAddWrongProp(propositions, strYN, "raw");
         }
     });
     return propositions;
@@ -140,7 +140,7 @@ const getIsEqualityTrue1Question = (optsIn) => {
         while (!isFound && counter < 100) {
             counter++;
             const num = randint(-9, 10);
-            const den = randint(0, 10, [0, num]);
+            const den = randint(0, 10, [0, 1, num]);
             const fractionNode = frac(num, den);
             const isExcluded = excludes.some((excludedNode) => substract(excludedNode, fractionNode).evaluate() === 0);
             if (!isExcluded) {
@@ -264,7 +264,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         answer: getAnswer(identifiers, opts),
         instruction: getInstruction(identifiers, opts),
         keys: getKeys(identifiers, opts),
-        answerFormat: "tex",
+        answerFormat: "raw",
         identifiers,
         hint: getHint(identifiers, opts),
         correction: getCorrection(identifiers, opts),

package/lib/exercises/math/dataRepresentations/index.js

@@ -15,6 +15,7 @@ export * from "./graphReading.js";
 export * from "./plausibleGraph.js";
 export * from "./halfPieChartReading.js";
 export * from "./halfPieChartCommenting.js";
+// export * from "./placePointsFromDataTable.js";
 // export * from "./testGen.js";
 // export * from "./testGenGGB.js";
 // export * from "./testGenStudentGGB.js";

package/lib/exercises/math/dataRepresentations/placePointsFromDataTable.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    isRowBased: boolean;
+    rowBasedDataTable: string[][];
+    indexX: number;
+    indexY: number;
+    arrCoordsAsNodeIds: NodeIdentifiers[][];
+};
+export declare const placePointsFromDataTable: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=placePointsFromDataTable.d.ts.map

package/lib/exercises/math/dataRepresentations/placePointsFromDataTable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placePointsFromDataTable.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/placePointsFromDataTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiB7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,iBAAiB,EAAE,MAAM,EAAE,EAAE,CAAC;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,kBAAkB,EAAE,eAAe,EAAE,EAAE,CAAC;CACzC,CAAC;AAyOF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAiB1D,CAAC"}

package/lib/exercises/math/dataRepresentations/placePointsFromDataTable.js

@@ -0,0 +1,175 @@
+import { boxXY } from "../../../exercises/utils/data/boxXY.js";
+import { isBoxable } from "../../../exercises/utils/data/isBoxable.js";
+import { randomDataTable } from "../../../exercises/utils/data/randomDataTable.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 { GeogebraParser } from "../../../geogebra/parsers/geogebraParser.js";
+import { Point } from "../../../math/geometry/point.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../utils/alea/random.js";
+import { transpose } from "../../../utils/arrays/transpose.js";
+import { mdTable } from "../../../utils/markdown/mdTable.js";
+import { joinanded } from "../../../utils/strings/joinanded.js";
+const getStrGraphName = (identifiers) => {
+    const { rowBasedDataTable, indexX, indexY } = identifiers;
+    const [nameTexX, nameTexY] = [indexX, indexY].map((i) => rowBasedDataTable[i][0]);
+    const graphName = `${nameTexY} en fonction de ${nameTexX}`;
+    return graphName;
+};
+const getDataTable = (identifiers) => {
+    const { isRowBased, rowBasedDataTable } = identifiers;
+    return isRowBased ? rowBasedDataTable : transpose(rowBasedDataTable);
+};
+const getInstruction = (identifiers) => {
+    const { isRowBased } = identifiers;
+    const dataTable = getDataTable(identifiers);
+    return `À partir du tableau de données ci-dessous, placer les points du graphique "${getStrGraphName(identifiers)}".
+
+${isRowBased
+        ? mdTable([
+            [...Array(dataTable[0].length).keys()].map((i) => i === 0 ? "Données" : ""),
+            ...getDataTable(identifiers),
+        ])
+        : mdTable(getDataTable(identifiers))}
+  
+`;
+};
+const getHint = () => {
+    return `Quand on construit un graphique "$A$ en fonction de $B$", $A$ se lira sur l'axe des ordonnées et $B$ sur l'axe des abscisses.`;
+};
+const getCorrection = (identifiers) => {
+    const { rowBasedDataTable, indexX, indexY } = identifiers;
+    const [nameTexX, nameTexY] = [indexX, indexY].map((i) => rowBasedDataTable[i][0]);
+    const solutionPoints = getSolutionPoints(identifiers);
+    return `On place chaque point de coordonnées (${nameTexX};${nameTexY}).
+  
+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 { xMin, xMax, yMin, yMax } = boxXY(points.map((p) => [p.x.evaluate(), p.y.evaluate()]));
+    const ggb = new GeogebraConstructor({
+        commands: [],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        lockedAxesRatio: false,
+    });
+    const coords = [
+        xMin - 0.5 * (xMax - xMin),
+        xMax + 0.5 * (xMax - xMin),
+        yMin - 0.5 * (yMax - yMin),
+        yMax + 0.5 * (yMax - yMin),
+    ];
+    return ggb.getOptions({
+        coords,
+    });
+};
+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 getPlacePointsFromDataTableQuestion = () => {
+    function createArrCoordsAsNodes(rowBasedDataTable, indexX, indexY) {
+        const [nodesX, nodesY] = [indexX, indexY].map((i) => rowBasedDataTable[i]
+            .slice(1)
+            .map((strValue) => parseAlgebraic(strValue)));
+        const arrCoordsAsNodes = nodesX.map((nodeX, i) => {
+            const nodeY = nodesY[i];
+            return [nodeX, nodeY];
+        });
+        return arrCoordsAsNodes;
+    }
+    const isRowBased = coinFlip();
+    const nbCateg = 3;
+    const nbValues = 3;
+    let rowBasedDataTable = [];
+    let indexX = -1;
+    let indexY = -1;
+    let arrCoordsAsNodes = [];
+    let counter = -1;
+    let isValidTable = false;
+    while (!isValidTable && counter < 100) {
+        counter++;
+        rowBasedDataTable = randomDataTable(nbCateg, nbValues, true);
+        [indexX, indexY] = randomMany([...Array(rowBasedDataTable.length).keys()], 2);
+        arrCoordsAsNodes = createArrCoordsAsNodes(rowBasedDataTable, indexX, indexY);
+        const arrXY = arrCoordsAsNodes.map(([nodeX, nodeY]) => [nodeX, nodeY].map((node) => node.evaluate()));
+        isValidTable = isBoxable(arrXY);
+    }
+    if (!isValidTable) {
+        rowBasedDataTable = [
+            ["âge", "10", "11", "12"],
+            ["nombre de frères et soeurs", "1", "2", "3"],
+        ];
+        [indexX, indexY] = [0, 1];
+        arrCoordsAsNodes = createArrCoordsAsNodes(rowBasedDataTable, indexX, indexY);
+    }
+    const identifiers = {
+        isRowBased,
+        rowBasedDataTable,
+        indexX,
+        indexY,
+        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 placePointsFromDataTable = {
+    id: "placePointsFromDataTable",
+    label: "Placer des points issus d'un tableau de données",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlacePointsFromDataTableQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -22,4 +22,6 @@ export * from "./coordsOfPointOnAffineFindY.js";
 export * from "./representationOfAffine.js";
 export * from "./drawAffineFromPointAndLeadingCoeff.js";
 export * from "./drawAffineFromProgCalc.js";
+export * from "./placePointsFromAffine.js";
+export * from "./recognizeAffinePointsFromPoints.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yCAAyC,CAAC;AACxD,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC;AACnD,cAAc,uBAAuB,CAAC;AACtC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,+BAA+B,CAAC;AAC9C,cAAc,sBAAsB,CAAC;AACrC,cAAc,oCAAoC,CAAC;AACnD,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yCAAyC,CAAC;AACxD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC"}

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

@@ -22,3 +22,5 @@ export * from "./coordsOfPointOnAffineFindY.js";
 export * from "./representationOfAffine.js";
 export * from "./drawAffineFromPointAndLeadingCoeff.js";
 export * from "./drawAffineFromProgCalc.js";
+export * from "./placePointsFromAffine.js";
+export * from "./recognizeAffinePointsFromPoints.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"placePointsFromAffine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/placePointsFromAffine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAI7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAkKF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAkBvD,CAAC"}