math-exercises 3.0.215 → 3.0.216

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

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

@@ -0,0 +1,262 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../exercises/utils/options/arrayedOptions.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../math/geometry/point.js";
+import { GraphConstructor } from "../../../math/graphs/graph.js";
+import { GraphRenderer, } from "../../../math/utils/graphs/graphRenderer.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getStrSeparator = (isDirected) => isDirected ? "\\ \\rightarrow\\ " : "\\ -\\ ";
+const getHydrated = (identifiers) => {
+    const { graphIds, lengthAsked } = identifiers;
+    const graph = GraphConstructor.fromIdentifiers(graphIds);
+    const arrTexPath = [...Array(3).keys()]
+        .flatMap(() => graph
+        .getSomePathsWithNbEdges(lengthAsked, 1)
+        .map((arrIndex) => arrIndex.map((i) => graph.vertexNames[i]))
+        .map((arrNameVertex) => arrNameVertex.join(getStrSeparator(graph.isDirected))))
+        .filter((texPath) => texPath !== "");
+    return {
+        graph,
+        arrTexPath,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { graphIds, lengthAsked } = identifiers;
+    return `Un graphe ${graphIds.isDirected ? "orienté" : "non orienté"} est représenté ci-dessous.
+Déterminer ${graphIds.isDirected ? "un chemin" : "une chaîne"} de longueur $${lengthAsked}$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { arrTexPath } = getHydrated(identifiers);
+    const [texPath] = arrTexPath;
+    return texPath;
+};
+const getHint = (identifiers) => {
+    const { graphIds: { isDirected }, lengthAsked, } = identifiers;
+    if (isDirected) {
+        return `Cherche une succession de $${lengthAsked}$ flèches, puis inscrit le chemin sous la forme : $P\\ \\rightarrow \\ Q\\ \\rightarrow \\ R\\ \\rightarrow \\ ...$`;
+    }
+    else {
+        return `Cherche une succession de $${lengthAsked}$ arêtes, puis inscrit la chaîne sous la forme : $P\\ - \\ Q\\ - \\ R \\ - \\ ...$`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { graphIds: { isDirected }, lengthAsked, } = identifiers;
+    const { arrTexPath } = getHydrated(identifiers);
+    if (isDirected) {
+        return `Voici quelque(s) chemin(s) de longueur $${lengthAsked}$ : 
+    
+${arrTexPath.map((texPath) => `- $${texPath}$`).join(`
+
+`)}`;
+    }
+    else {
+        return `Voici quelque(s) chaîne(s) de longueur $${lengthAsked}$ : 
+    
+${arrTexPath.map((texPath) => `- $${texPath}$`).join(`
+
+`)}`;
+    }
+};
+const getGGBOptions = (identifiers) => {
+    const { graphNodes, graphEdges } = identifiers;
+    const { graph } = getHydrated(identifiers);
+    const arrPoint = graphNodes.map(({ label, x, y }) => new Point(label, x, y));
+    const pointCommands = arrPoint.flatMap((point) => point.toGGBCommand({
+        isFixed: false,
+        isSelectionnable: true,
+        showLabel: true,
+        style: 0,
+        size: 8,
+    }));
+    const edgeCommands = graphEdges.map((e, i) => graph.isDirected
+        ? `v${i + 1} = Vector(${e.from}, ${e.to})`
+        : `s${i + 1} = Segment(${e.from}, ${e.to})`);
+    const arrGGBCommandForGraph = [...pointCommands, ...edgeCommands];
+    const ggb = new GeogebraConstructor({
+        commands: [...arrGGBCommandForGraph],
+        fontSize: 16,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(arrPoint),
+    });
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { lengthAsked: lengthAskedPure } = identifiers;
+    const { graph } = getHydrated(identifiers);
+    const lengthAsked = (() => {
+        const isTerror = coinFlip();
+        return isTerror ? lengthAskedPure - 1 : lengthAskedPure;
+    })();
+    //student: number of edges -> number of nodes
+    {
+        const identifiersWrong = {
+            ...identifiers,
+            lengthAsked: lengthAsked - 1,
+        };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    }
+    if (graph.isDirected) {
+        const graphUndirected = graph.undirectedGraph();
+        //student: path -> chain
+        {
+            const arrTexPath = [...Array(2).keys()]
+                .flatMap(() => graphUndirected
+                .getSomePathsWithNbEdges(lengthAsked, 1)
+                .map((arrIndex) => arrIndex.map((i) => graph.vertexNames[i]))
+                .filter((arrName) => !graph.isValidPath(arrName)))
+                .map((arrNameVertex) => arrNameVertex.join(getStrSeparator(graph.isDirected)));
+            arrTexPath.forEach((texPath) => {
+                tryToAddWrongProp(propositions, texPath);
+            });
+        }
+    }
+    //filler
+    {
+        function createRandomPath(vertexNames, length) {
+            const arrIndexVertex = [...Array(length).keys()].reduce((acc, _) => {
+                const indexPrev = acc[acc.length - 1];
+                const index = randint(0, vertexNames.length, [indexPrev]);
+                return [...acc, index];
+            }, [randint(0, vertexNames.length)]);
+            return arrIndexVertex.map((i) => vertexNames[i]);
+        }
+        propWhile(propositions, n, () => {
+            const arrVertex = createRandomPath(graph.vertexNames, lengthAsked);
+            if (!graph.isValidPath(arrVertex)) {
+                const texPath = arrVertex.join(getStrSeparator(graph.isDirected));
+                tryToAddWrongProp(propositions, texPath);
+            }
+            if (coinFlip()) {
+                if (lengthAsked >= 3) {
+                    const arrVertex = createRandomPath(graph.vertexNames, lengthAsked - 1);
+                    if (!graph.isValidPath(arrVertex)) {
+                        const texPath = arrVertex.join(getStrSeparator(graph.isDirected));
+                        tryToAddWrongProp(propositions, texPath);
+                    }
+                }
+            }
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { graphIds: { vertexNames, isDirected }, } = identifiers;
+    return [
+        ...vertexNames,
+        (() => {
+            const tex = getStrSeparator(isDirected);
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        })(),
+    ];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const { graphIds: { isDirected }, lengthAsked, } = identifiers;
+        const strSeparator = getStrSeparator(isDirected);
+        const arrNameVertexAns = ans.split(strSeparator);
+        console.log("arrNameVertexAns", arrNameVertexAns);
+        if (arrNameVertexAns.length !== lengthAsked + 1) {
+            return false;
+        }
+        const { graph } = getHydrated(identifiers);
+        return graph.isValidPath(arrNameVertexAns);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (isDirected) => {
+    const nbVertices = randint(5, 9);
+    const minDensity = (() => {
+        switch (nbVertices) {
+            case 5:
+                return isDirected ? 0.4 : 0.62;
+            case 6:
+                return isDirected ? 0.35 : 0.57;
+            case 7:
+                return isDirected ? 0.3 : 0.52;
+            case 8:
+                return isDirected ? 0.27 : 0.37;
+            case 9:
+                return isDirected ? 0.24 : 0.32;
+            default:
+                throw new Error("Unsupported nbVertices: " + nbVertices);
+        }
+    })();
+    const lengthAsked = randint(3, 4);
+    const graph = GraphConstructor.randomChain(nbVertices, "ABCDEFGHIJKLM".split(""), isDirected).densifyUpTo(minDensity);
+    const { nodes: graphNodes, edges: graphEdges } = GraphRenderer.renderToNodesAndEdges(graph);
+    const identifiers = {
+        graphIds: graph.toIdentifiers(),
+        lengthAsked,
+        graphNodes,
+        graphEdges,
+    };
+    return identifiers;
+};
+const getGraphsChainOrPathOfLengthNQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        graphType: random(arrayedOpts.graphType),
+    };
+    const isDirected = opts.graphType === "orienté";
+    const identifiers = createRandomIdentifiers(isDirected);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    graphType: ["non orienté"],
+};
+const options = [
+    {
+        id: "graphType",
+        label: "Types de graphes",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["non orienté", "orienté"],
+        defaultValue: arrayedOptsDefault.graphType,
+    },
+];
+export const graphsChainOrPathOfLengthN = {
+    id: "graphsChainOrPathOfLengthN",
+    label: "Déterminer une chaîne ou un chemin de longueur $n$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGraphsChainOrPathOfLengthNQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};