math-exercises 3.0.215 → 3.0.217

package/lib/exercises/math/arithmetic/whichDayInXDays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"whichDayInXDays.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/whichDayInXDays.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAyEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAiBjD,CAAC"}
+{"version":3,"file":"whichDayInXDays.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/whichDayInXDays.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAyEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAiBjD,CAAC"}

package/lib/exercises/math/arithmetic/whichDayInXDays.js

@@ -4,6 +4,7 @@ import { randint } from "../../../math/utils/random/randint.js";
 import { random } from "../../../utils/alea/random.js";
 import { doWhile } from "../../../utils/doWhile.js";
 import { frenchDays } from "../../../utils/strings/frenchDays.js";
+import { pluralize } from "../../../utils/strings/pluralize.js";
 const getPropositions = (n, { answer }) => {
     const propositions = [];
     addValidProp(propositions, answer, "raw");
@@ -39,7 +40,7 @@ $$
 ${step} = 7\\times ${quot} + ${left}
 $$
 
-En ajoutant $${left}$ jours à ${day}, on obtient ${answer}.
+En ajoutant $${left}$ ${pluralize("jour", left)} à ${day}, on obtient ${answer}.
 
 Dans $${step}$ jours, nous serons donc ${answer}.
 `;

package/lib/exercises/math/calculLitteral/equation/exp/expOfFEqualsExpOfGEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"expOfFEqualsExpOfGEquation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/exp/expOfFEqualsExpOfGEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AA4DrC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAyaF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAkCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBrE,CAAC"}
+{"version":3,"file":"expOfFEqualsExpOfGEquation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/exp/expOfFEqualsExpOfGEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AA4DrC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA2ZF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAkCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBrE,CAAC"}

package/lib/exercises/math/calculLitteral/equation/exp/expOfFEqualsExpOfGEquation.js

@@ -268,6 +268,8 @@ const getKeys = (_, optsIn) => {
     ];
 };
 const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
+    console.log("ans", ans);
+    console.log("answer", answer);
     const opts = optsIn ?? optsDefault;
     const answerInputTypes = getAnswerInputTypes(opts);
     const answerNode = getAnswerNode(identifiers);
@@ -276,27 +278,23 @@ const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
             .elements;
         function getParsedNodesForAnswerInputType(ans, answerInputType) {
             switch (answerInputType) {
-                case "x=... ou x=...":
-                    {
-                        const formated = ans
-                            .replaceAll("text{ ou }", ";")
-                            .replaceAll("x", "")
-                            .replaceAll("=", "");
-                        const elements = formated.split(";").map((e) => parseAlgebraic(e));
-                        return elements;
+                case "x=... ou x=...": {
+                    const formated = ans
+                        .replaceAll("text{ ou }", ";")
+                        .replaceAll("x", "")
+                        .replaceAll("=", "");
+                    const elements = formated.split(";").map((e) => parseAlgebraic(e));
+                    return elements;
+                }
+                case "S={...;...}": {
+                    const discreteSetNodeCandidate = discreteSetParser(ans);
+                    if (discreteSetNodeCandidate) {
+                        return discreteSetNodeCandidate.elements;
                     }
-                    break;
-                case "S={...;...}":
-                    {
-                        const discreteSetNodeCandidate = discreteSetParser(ans);
-                        if (discreteSetNodeCandidate) {
-                            return discreteSetNodeCandidate.elements;
-                        }
-                        else {
-                            return [];
-                        }
+                    else {
+                        return [];
                     }
-                    break;
+                }
                 default:
                     throw new Error("Unsupported answerInputType: " + answerInputType);
             }
@@ -325,19 +323,8 @@ const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
         return answerInputTypes.some((answerInputType) => isAnswerValidForAnswerInputType(answerInputType));
     }
     else {
-        const inequationSolutionNode = answerNode;
-        const texInterval = inequationSolutionNode.intervalSolution.toTex();
-        function isAnswerValidForAnswerInputType(answerInputType) {
-            switch (answerInputType) {
-                case "x=... ou x=...":
-                    return `x\\in${texInterval}`;
-                case "S={...;...}":
-                    return `S=${texInterval}`;
-                default:
-                    throw new Error("Unsupported answerInputType: " + answerInputType);
-            }
-        }
-        return answerInputTypes.some((answerInputType) => isAnswerValidForAnswerInputType(answerInputType));
+        //answer is mathbbR
+        return ans === answer;
     }
 };
 const getExpOfFEqualsExpOfGEquationQuestion = (optsIn) => {

package/lib/exercises/math/complex/unitRoots/giveOneSolutionToComplexPowNEqualsOne.js

@@ -56,7 +56,7 @@ si et seulement si $${substract("z", a)
 const getCorrection = (identifiers) => {
     const { a, n } = identifiers;
     const root = `e^{i${frac(multiply(2, PiNode), n).simplify().toTex()}}`;
-    const equa = `${power(substract("z", a).simplify().toTex(), n)} = 1`;
+    const equa = `${power(substract("z", a).simplify(), n).toTex()} = 1`;
     return `$z$ est une solution de l'équation 
   
 $$

package/lib/exercises/math/conversion/clock/index.d.ts

@@ -1,3 +1,2 @@
 export * from "./clockReading.js";
-export * from "./dateTimeOperationAdd.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/conversion/clock/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/conversion/clock/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAGlC,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/conversion/clock/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/lib/exercises/math/conversion/clock/index.js

@@ -1,4 +1,4 @@
 export * from "./clockReading.js";
 // export * from "./clockReadingPlusTimeOperation.js";
 // export * from "./clockWritingByManipulatingNeedles.js";
-export * from "./dateTimeOperationAdd.js";
+// export * from "./dateTimeOperationAdd.js"; //TODO: à fix

package/lib/exercises/math/derivation/derivative/trigo/sinCosDerivativeRewriteUsingCos2PlusSin2Equals1.js

@@ -388,10 +388,10 @@ const getPropositions = (n, { answer: _answer, ...identifiers }) => {
     }
     return shuffleProps(propositions, n);
 };
-const isAnswerValid = (ans, { answer, ...identifiers }) => {
+const isAnswerValid = (ans, { answer }) => {
     try {
         const nodeAns = parseAlgebraic(ans);
-        const nodeAnswer = getAnswerNode(identifiers);
+        const nodeAnswer = parseAlgebraic(answer);
         return NodeComparator.isEqualViaRandomSubstitutions(nodeAns, nodeAnswer, 3);
     }
     catch (e) {

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"}

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

@@ -0,0 +1,96 @@
+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";
+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 matrix = MatrixConstructor.fromIdentifiers(identifiers.matrixIds);
+    const degrees = [];
+    for (let i = 0; i < matrix.rows; i++) {
+        degrees.push(matrix.elements[i].reduce((acc, el) => acc + el.evaluate(), 0));
+    }
+    const unEvenDegrees = degrees.filter((deg) => deg % 2 !== 0).length;
+    return unEvenDegrees === 0 || unEvenDegrees === 2 ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const matrix = MatrixConstructor.fromIdentifiers(identifiers.matrixIds);
+    return `La matrice d'adjacence d'un graphe non-orienté $G$ est donnée ci-dessous.
+
+$$
+${matrix.toTex()}
+$$
+
+Le graphe $G$ admet-il une chaîne eulérienne ?
+`;
+};
+const getHint = () => {
+    return `Une chaîne eulérienne est une chaîne (donc une suite de sommets adjacents) qui contient chaque arête du graphe une et une seule fois.
+  
+Un certain théorème du cours permet de déterminer si une telle chaîne existe dans un graphe !`;
+};
+const getCorrection = (identifiers) => {
+    const matrix = MatrixConstructor.fromIdentifiers(identifiers.matrixIds);
+    const degrees = [];
+    for (let i = 0; i < matrix.rows; i++) {
+        degrees.push(matrix.elements[i].reduce((acc, el) => acc + el.evaluate(), 0));
+    }
+    const unEvenDegrees = degrees.filter((deg) => deg % 2 !== 0).length;
+    return `D'après le théorème d'Euler, un graphe connexe non-orienté admet une chaîne eulérienne si et seulement si le nombre de sommets de degré impair vaut $0$ ou $2$.
+  
+Il s'agit donc ici de déterminer les degrés de chaque sommet. Pour cela, il suffit d'additionner les termes de chaque ligne de la matrice d'adjacence.
+
+On obtient : 
+
+$$
+${degrees.map((e) => `${e.frenchify()}`).join("\\ ; \\ ")}
+$$
+
+Il y a donc $${unEvenDegrees.frenchify()}$ sommet(s) de degré impair.
+
+${unEvenDegrees === 0 || unEvenDegrees === 2
+        ? "Il existe donc bien une chaîne eulérienne dans ce graphe."
+        : "Il n'existe donc pas de chaîne eulérienne dans ce graphe."}
+`;
+};
+const getEulerianChainFromAdjacentMatrixQuestion = () => {
+    const length = randint(4, 6);
+    const mat = MatrixConstructor.randomAdjacent(length);
+    const identifiers = {
+        matrixIds: mat.toIdentifiers(),
+    };
+    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 eulerianChainFromAdjacentMatrix = {
+    id: "eulerianChainFromAdjacentMatrix",
+    label: "Déterminer si un graphe admet une chaîne eulérienne à partir de sa matrice d'adjacence",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getEulerianChainFromAdjacentMatrixQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { GraphIdentifiers } from "../../../math/graphs/graph.js";
+import { GraphEdge, GraphNode } from "../../../math/utils/graphs/graphRenderer.js";
+type Identifiers = {
+    graphIds: GraphIdentifiers;
+    lengthAsked: number;
+    graphNodes: GraphNode[];
+    graphEdges: GraphEdge[];
+};
+type Options = {
+    graphType: string;
+};
+export declare const graphsChainOrPathOfLengthN: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=graphsChainOrPathOfLengthN.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphsChainOrPathOfLengthN.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/graphs/graphsChainOrPathOfLengthN.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAoB,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,EACL,SAAS,EACT,SAAS,EAEV,MAAM,0CAA0C,CAAC;AAWlD,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,WAAW,EAAE,MAAM,CAAC;IAGpB,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB,CAAC;AA8SF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAsBF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}