math-exercises 3.0.214 → 3.0.216

package/lib/exercises/math/geometry/vectors/constructions/traceVectorSumFromVecs.js

@@ -0,0 +1,165 @@
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, greenMain, orange } from "../../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { GeogebraParser } from "../../../../../geogebra/parsers/geogebraParser.js";
+import { PointConstructor, } from "../../../../../math/geometry/point.js";
+import { VectorConstructor } from "../../../../../math/geometry/vector.js";
+const getHydrated = (identifiers) => {
+    const { pointIds } = identifiers;
+    const points = pointIds.map((pointIds) => PointConstructor.fromIdentifiers(pointIds));
+    const vec1 = (() => {
+        const vec = VectorConstructor.fromPoints(points[0], points[1]);
+        vec.name = "u";
+        return vec;
+    })();
+    const vec2 = (() => {
+        const vec = VectorConstructor.fromPoints(points[2], points[3]);
+        vec.name = "v";
+        return vec;
+    })();
+    const vecSum = vec1.add(vec2);
+    return {
+        points,
+        vec1,
+        vec2,
+        vecSum,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { vec1, vec2 } = getHydrated(identifiers);
+    return `Construire le vecteur $\\overrightarrow{w}$ tel que : 
+  
+$$
+\\overrightarrow{w} = ${vec1.toTex()} + ${vec2.toTex()}
+$$`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { points, vecSum } = getHydrated(identifiers);
+    const pointStart = points[0];
+    const pointEnd = vecSum.getEndPoint(pointStart);
+    return [
+        ...getStudentGGBCommands(points),
+        `PEnd = Point({${pointEnd.getXnumber()},${pointEnd.getYnumber()}})`,
+        `w = Vector(${points[0].name}, PEnd)`,
+        `SetColor(w, "${greenMain}")`,
+        `ShowLabel(w, true)`,
+    ];
+};
+const getHint = () => {
+    return `Avec l'outil vecteur, choisis un point sur la grille et, en partant de ce point, déplace toi suivant le vecteur $\\overrightarrow{u}$ puis suivant le vecteur $\\overrightarrow{v}$ et clique sur le point où tu es arrivé.`;
+};
+const getCorrection = (_identifiers) => {
+    return `Avec l'outil vecteur, on choisit un point sur la grille et, en partant de ce point, on se déplace suivant le vecteur $\\overrightarrow{u}$ puis suivant le vecteur $\\overrightarrow{v}$ et on clique sur le point où l'on est arrivé.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { points, vecSum } = getHydrated(identifiers);
+    const pointStart = points[0];
+    const pointEnd = vecSum.getEndPoint(pointStart);
+    const commands = [
+        ...getStudentGGBCommands(points),
+        `PEnd = Point({${pointEnd.getXnumber()},${pointEnd.getYnumber()}})`,
+        `w = Vector(${points[0].name}, PEnd)`,
+        `SetColor(w, "${greenMain}")`,
+        `ShowLabel(w, true)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            vector: true,
+        }),
+        hideAxes: true,
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, pointEnd]),
+    });
+};
+const getStudentGGBCommands = (points) => {
+    return [
+        ...points.flatMap((point) => point.toGGBCommand({ isFixed: true, isVisible: false })),
+        `u = Vector(${points[0].name}, ${points[1].name})`,
+        `SetColor(u, "${orange}")`,
+        `ShowLabel(u, true)`,
+        `v = Vector(${points[2].name}, ${points[3].name})`,
+        `SetColor(v, "${blueMain}")`,
+        `ShowLabel(v, true)`,
+    ];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { points, vecSum } = getHydrated(identifiers);
+    const pointStart = points[0];
+    const pointEnd = vecSum.getEndPoint(pointStart);
+    const commands = [...getStudentGGBCommands(points)];
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            vector: true,
+        }),
+        hideAxes: true,
+        fontSize: 16,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...points, pointEnd]),
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const commands = ans;
+    const ggbParser = new GeogebraParser(commands);
+    const objectDict = ggbParser.objectDict();
+    const arrStrVector = Object.entries(objectDict)
+        .filter(([_, strObj]) => strObj.startsWith("Vector"))
+        .map(([_, strObj]) => strObj);
+    //required: only one vector
+    if (arrStrVector.length !== 1) {
+        return false;
+    }
+    const [strVector] = arrStrVector;
+    const [namePointStart, namePointEnd] = GeogebraParser.argNamesForVectorObj(strVector);
+    const [pointStart, pointEnd] = [namePointStart, namePointEnd].map((namePoint) => PointConstructor.fromCoords(ggbParser.pointCoords(namePoint)));
+    const vecAns = VectorConstructor.fromPoints(pointStart, pointEnd);
+    const { vecSum } = getHydrated(identifiers);
+    const isSameVecs = vecAns.substract(vecSum).getNorm().evaluate() < 0.2;
+    return isSameVecs;
+};
+const getTraceVectorSumFromVecsQuestion = () => {
+    const names = ["A", "B", "C", "D"];
+    const points = PointConstructor.randomDifferent(4, {
+        minDistance: 2,
+        names,
+        minDistanceToOrigin: 3,
+    });
+    const identifiers = {
+        pointIds: points.map((point) => point.toIdentifiers()),
+    };
+    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 traceVectorSumFromVecs = {
+    id: "traceVectorSumFromVecs",
+    label: "Construire un vecteur défini par une somme de vecteurs",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTraceVectorSumFromVecsQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -6,4 +6,5 @@ export * from "./coneVolume.js";
 export * from "./sphereVolume.js";
 export * from "./parallelepipedVolume.js";
 export * from "./variableVolume.js";
+export * from "./volumeOfCylinder.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,0CAA0C,CAAC;AACzD,cAAc,0CAA0C,CAAC;AACzD,cAAc,sCAAsC,CAAC;AACrD,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC"}

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

@@ -6,3 +6,4 @@ export * from "./coneVolume.js";
 export * from "./sphereVolume.js";
 export * from "./parallelepipedVolume.js";
 export * from "./variableVolume.js";
+export * from "./volumeOfCylinder.js";

package/lib/exercises/math/geometry/volumes/volumeOfCylinder.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    radius: number;
+    height: number;
+};
+export declare const volumeOfCylinder: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=volumeOfCylinder.d.ts.map

package/lib/exercises/math/geometry/volumes/volumeOfCylinder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"volumeOfCylinder.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/volumes/volumeOfCylinder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA2KF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}

package/lib/exercises/math/geometry/volumes/volumeOfCylinder.js

@@ -0,0 +1,157 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { round } from "../../../../math/utils/round.js";
+import { numberParser } from "../../../../tree/parsers/numberParser.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { radius, height } = identifiers;
+    return `Le cylindre ci-dessous a une base de rayon $${radius}$ et une hauteur de $${height}$. 
+  
+Calculer son volume (arrondir au centième).`;
+};
+const getHint = (identifiers) => {
+    const { radius } = identifiers;
+    return `Le volume d'un cylindre se calcule avec la formule : 
+  
+$$
+\\mathcal{V} = \\text{aire de la base} \\times \\text{hauteur}
+$$
+
+La base est un disque de rayon $${radius}$. Il faut donc commencer par calculer son aire. 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { radius, height } = identifiers;
+    round((1 / 3) * Math.PI * Math.pow(radius, 2) * height, 2).toTree();
+    const area = round(Math.PI * radius ** 2, 2).frenchify();
+    return `Le volume d'un cylindre se calcule avec la formule : 
+  
+$$
+\\mathcal{V} = \\text{aire de la base} \\times \\text{hauteur}
+$$
+
+Ici, la base est un disque de rayon $${radius}$. Son aire est donc : 
+
+$$
+\\mathcal{A} = \\pi\\times ${radius}^2 \\approx ${area}
+$$
+
+Le volume du cylindre est donc : 
+
+${alignTex([
+        [
+            "\\mathcal{V}",
+            "\\approx",
+            `${area} \\times ${height} = ${getAnswer(identifiers)}`,
+        ],
+        ["", "\\approx", getAnswer(identifiers)],
+    ])}
+`;
+};
+const getAnswer = (identifiers) => {
+    const { radius, height } = identifiers;
+    const volume = round(Math.PI * Math.pow(radius, 2) * height, 2)
+        .toTree()
+        .toTex();
+    return volume;
+};
+const getGGBOptions = (identifiers) => {
+    const { radius, height } = identifiers;
+    const xMin = -radius - 5;
+    const xMax = radius + 5;
+    const yMin = -radius - 5;
+    const yMax = radius + 5;
+    const zMax = height + 5;
+    const commands = [
+        `A = (0, 0, 0)`,
+        `B = (0, 0, ${height})`,
+        `SetFixed(A, true, false)`,
+        `SetFixed(B, true, false)`,
+        `SetVisibleInView(A, -1, false)`,
+        `SetVisibleInView(B, -1, false)`,
+        `Cylinder(A, B, ${radius})`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        lockedAxesRatio: false,
+        hideAxes: true,
+        hideGrid: true,
+        is3D: true,
+    });
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax, 0, zMax],
+    });
+};
+const getPropositions = (n, { answer, radius, height }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const wrongVolume1 = round(Math.PI * Math.pow(radius, 2) * height, 2)
+        .toTree()
+        .toTex();
+    tryToAddWrongProp(propositions, wrongVolume1);
+    const wrongVolume2 = round(Math.PI * radius * height, 2)
+        .toTree()
+        .toTex();
+    tryToAddWrongProp(propositions, wrongVolume2);
+    const wrongVolume3 = round((1 / 3) * Math.PI * Math.pow(radius, 2) * height, 2)
+        .toTree()
+        .toTex();
+    tryToAddWrongProp(propositions, wrongVolume3);
+    propWhile(propositions, n, () => {
+        let wrongRadius, wrongHeight;
+        do {
+            wrongRadius = randint(1, 5);
+            wrongHeight = randint(2, 10);
+        } while (wrongHeight <= wrongRadius);
+        const wrongVolume = round(Math.PI * Math.pow(wrongRadius, 2) * wrongHeight, 2)
+            .toTree()
+            .toTex();
+        tryToAddWrongProp(propositions, wrongVolume);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const parsed = numberParser(ans);
+    if (!parsed)
+        return false;
+    return parsed === answer;
+};
+const getVolumeOfCylinderQuestion = () => {
+    let radius, height;
+    do {
+        radius = randint(1, 11);
+        height = randint(2, 12);
+    } while (height <= radius);
+    const identifiers = { radius, height };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const volumeOfCylinder = {
+    id: "volumeOfCylinder",
+    label: "Calculer le volume d'un cylindre de hauteur et de rayon donnés",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getVolumeOfCylinderQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
+};

package/lib/exercises/math/graphs/adjacentMatrixPath.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { MatrixIdentifiers } from "../../../math/matrices/matrix.js";
+type Identifiers = {
+    matrixIds: MatrixIdentifiers;
+    startIndex: number;
+    endIndex: number;
+};
+export declare const adjacentMatrixPath: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=adjacentMatrixPath.d.ts.map

package/lib/exercises/math/graphs/adjacentMatrixPath.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adjacentMatrixPath.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/graphs/adjacentMatrixPath.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAIvC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,iBAAiB,CAAC;IAC7B,UAAU,EAAE,MAAM,CAAC;IACnB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AA6FF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAmBpD,CAAC"}

package/lib/exercises/math/graphs/adjacentMatrixPath.js

@@ -0,0 +1,89 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { MatrixConstructor, } from "../../../math/matrices/matrix.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { ordinalSuffixed } from "../../../utils/strings/ordinalSuffixed.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { matrixIds, endIndex, startIndex } = identifiers;
+    const matrix = MatrixConstructor.fromIdentifiers(matrixIds);
+    return matrix.elements[startIndex][endIndex].toTex() === "0" ? "Non" : "Oui";
+};
+const getInstruction = (identifiers) => {
+    const { matrixIds, endIndex, startIndex } = identifiers;
+    const matrix = MatrixConstructor.fromIdentifiers(matrixIds);
+    const length = matrix.rows;
+    const summitNames = Array.from({ length: length }, (_, index) => `$${String.fromCharCode(65 + index)}$`);
+    return `La matrice d'adjacence d'un graphe non-orienté $G$ de sommets ${summitNames.join(", ")}  est donnée ci-dessous (les sommets sont classés par ordre alphabétique).
+  
+$$
+${matrix.toTex()}
+$$
+
+Existe-t-il une arête reliant les sommets ${summitNames[startIndex]} et ${summitNames[endIndex]} ? `;
+};
+const getHint = () => {
+    return `Dans une matrice d'adjacence, le terme de la $i$-ème ligne et de la $j$-ème colonne est le nombre d'arêtes reliant les sommets $i$ et $j$.`;
+};
+const getCorrection = (identifiers) => {
+    const { matrixIds, endIndex, startIndex } = identifiers;
+    const matrix = MatrixConstructor.fromIdentifiers(matrixIds);
+    const length = matrix.rows;
+    const summitNames = Array.from({ length: length }, (_, index) => `$${String.fromCharCode(65 + index)}$`);
+    const hasNoEdge = matrix.elements[startIndex][endIndex].toTex() === "0";
+    return `Dans une matrice d'adjacence d'un graphe non-orienté, le terme de la $i$-ème ligne et de la $j$-ème colonne est le nombre d'arêtes reliant les sommets $i$ et $j$.
+  
+Ici, on regarde donc le terme à la ${ordinalSuffixed(startIndex + 1)} ligne et ${ordinalSuffixed(endIndex + 1)} colonne : c'est $${matrix.elements[startIndex][endIndex].toTex()}$.
+
+${!hasNoEdge
+        ? `Il y a donc bien une arête reliant les sommets ${summitNames[startIndex]} et ${summitNames[endIndex]}.`
+        : `Il n'y a donc pas d'arête reliant les sommets ${summitNames[startIndex]} et ${summitNames[endIndex]}.`}
+`;
+};
+const getAdjacentMatrixPathQuestion = () => {
+    const length = randint(4, 6);
+    const m = MatrixConstructor.randomAdjacent(length);
+    const startIndex = randint(0, length);
+    const endIndex = randint(0, length, [startIndex]);
+    const identifiers = {
+        matrixIds: m.toIdentifiers(),
+        startIndex,
+        endIndex,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const adjacentMatrixPath = {
+    id: "adjacentMatrixPath",
+    connector: "=",
+    label: "Vérifier si deux sommets d'un graphe sont reliés grâce à la matrice d'adjacence",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAdjacentMatrixPathQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/graphs/edgesNumberFromSummitsDegrees.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    degrees: number[];
+};
+export declare const edgesNumberFromSummitsDegrees: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=edgesNumberFromSummitsDegrees.d.ts.map

package/lib/exercises/math/graphs/edgesNumberFromSummitsDegrees.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"edgesNumberFromSummitsDegrees.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/graphs/edgesNumberFromSummitsDegrees.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA4FF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAsB/D,CAAC"}

package/lib/exercises/math/graphs/edgesNumberFromSummitsDegrees.js

@@ -0,0 +1,98 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../exercises/vea/rationalVEA.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../math/utils/random/randTupleInt.js";
+import { AddNode } from "../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
+import { doWhile } from "../../../utils/doWhile.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { mdTable } from "../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer, degrees }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, degrees.reduce((acc, curr) => acc + curr, 0).frenchify());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(0, 10).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { degrees } = identifiers;
+    const sum = degrees.reduce((acc, curr) => acc + curr, 0);
+    return frac(sum, 2).simplify().toTex();
+};
+const getInstruction = (identifiers) => {
+    const { degrees } = identifiers;
+    const summitNames = Array.from({ length: degrees.length }, (_, index) => String.fromCharCode(65 + index));
+    return `On considère un graphe non-orienté $G$ dont les degrés des sommets sont donnés dans le tableau suivant :
+  
+${mdTable([
+        ["Sommet", ...summitNames.map((el) => `$${el}$`)],
+        ["Degré", ...degrees.map((el) => `$${el}$`)],
+    ])}
+  
+Quel est le nombre d'arêtes de $G$ ?`;
+};
+const getHint = () => {
+    return `Le degré d'un sommet est le nombre d'arêtes incidentes à ce sommet. Or, chaque arête relie deux sommets...`;
+};
+const getCorrection = (identifiers) => {
+    const { degrees } = identifiers;
+    return `Dans un graphe non-orienté, la somme des degrés des sommets est égale au double du nombre d'arêtes.
+  
+En effet, chaque arête possède deux extrémités, donc chaque arête est comptée deux fois dans la somme des degrés des sommets. Le raisonnement reste valable pour les boucles, qui comptent pour deux dans le degré d'un sommet.
+
+Il suffit donc de calculer la somme des degrés et de diviser par $2$ pour obtenir le nombre d'arêtes :
+
+$$
+${operatorComposition(AddNode, degrees.map((e) => e.toTree())).toTex()} = ${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getEdgesNumberFromSummitsDegreesQuestion = () => {
+    const length = randint(4, 6);
+    const degrees = doWhile(() => randTupleInt(length, { from: 2, to: length + 2 }), (arr) => arr.filter((x) => x % 2 !== 0).length % 2 !== 0);
+    const identifiers = { degrees };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const edgesNumberFromSummitsDegrees = {
+    id: "edgesNumberFromSummitsDegrees",
+    connector: "=",
+    label: "Déterminer le nombre d'arêtes d'un graphe non-orienté à partir du degré de ses sommets",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getEdgesNumberFromSummitsDegreesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/graphs/eulerianChainFromAdjacentMatrix.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { MatrixIdentifiers } from "../../../math/matrices/matrix.js";
+type Identifiers = {
+    matrixIds: MatrixIdentifiers;
+};
+export declare const eulerianChainFromAdjacentMatrix: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=eulerianChainFromAdjacentMatrix.d.ts.map

package/lib/exercises/math/graphs/eulerianChainFromAdjacentMatrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eulerianChainFromAdjacentMatrix.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/graphs/eulerianChainFromAdjacentMatrix.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,iBAAiB,EAClB,MAAM,+BAA+B,CAAC;AAGvC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,iBAAiB,CAAC;CAC9B,CAAC;AA8FF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAqBjE,CAAC"}