math-exercises 3.0.214 → 3.0.216

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,
+};

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

@@ -0,0 +1,11 @@
+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;
+    graphNodes: GraphNode[];
+    graphEdges: GraphEdge[];
+};
+export declare const graphsCheckIsConnectedGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=graphsCheckIsConnectedUndirectedGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphsCheckIsConnectedUndirectedGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/graphs/graphsCheckIsConnectedUndirectedGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAGL,gBAAgB,EACjB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,SAAS,EACT,SAAS,EAEV,MAAM,0CAA0C,CAAC;AASlD,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAG3B,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB,CAAC;AA2OF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAiB7D,CAAC"}

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

@@ -0,0 +1,178 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.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 { shuffle } from "../../../utils/alea/shuffle.js";
+import { splitIntoRandomChunks } from "../../../utils/arrays/arrayChunks.js";
+import { joinanded } from "../../../utils/strings/joinanded.js";
+import * as Flatten from "@flatten-js/core";
+const getHydrated = (identifiers) => {
+    const { graphIds } = identifiers;
+    const graph = GraphConstructor.fromIdentifiers(graphIds);
+    return {
+        graph,
+    };
+};
+const getInstruction = () => {
+    return `Un graphe non orienté est représenté ci-dessous.
+Le graphe est-il connexe ?
+*On peut déplacer les points sur la figure.*`;
+};
+const getAnswer = (identifiers) => {
+    const { graph } = getHydrated(identifiers);
+    return graph.isWeaklyConnected() ? "Oui" : "Non";
+};
+const getHint = () => {
+    return `Un graphe non orienté est connexe si et seulement si chaque couple de ses sommets peut être relié par une chaîne.`;
+};
+const getCorrection = (identifiers) => {
+    const { graph } = getHydrated(identifiers);
+    const arrWeaklyConnectedSubgraph = graph
+        .getWeaklyConnectedSubgraphChainsAsArrIndex()
+        .map((chain) => chain.map((index) => graph.vertexNames[index]));
+    if (graph.isWeaklyConnected()) {
+        const [chain0] = arrWeaklyConnectedSubgraph;
+        return `On peut former une chaîne qui relie tous les sommets : ${chain0
+            .map((str) => `$${str}$`)
+            .join("-")}.
+Le graphe est donc connexe.`;
+    }
+    else {
+        return `On ne peut pas former une chaîne qui relie tous les sommets.
+Le graphe contient des sous-graphes disjoints contenant les chaînes ${joinanded(arrWeaklyConnectedSubgraph.map((chain) => chain.map((str) => `$${str}$`).join("-")), ", ", " et ")}.
+Le graphe n'est donc pas connexe.`;
+    }
+};
+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 = (_, { answer }) => {
+    const propositions = [];
+    ["Oui", "Non"].forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+const createRandomIdentifiers = () => {
+    const nbVertices = randint(7, 9);
+    const isSimple = true;
+    const minDensity = 0.4;
+    const isConnected = coinFlip();
+    const vertexNames = "ABCDEFGHIJKLM".split("").slice(0, nbVertices);
+    const { graph, graphNodes, graphEdges } = (() => {
+        let isFound = false;
+        let graph;
+        let graphNodes;
+        let arrGraphEdges;
+        while (!isFound) {
+            const graphForPoints = GraphConstructor.randomConnected(nbVertices, isSimple, false, minDensity, vertexNames);
+            const { nodes: graphNodes0, edges: graphEdges0 } = GraphRenderer.renderToNodesAndEdges(graphForPoints, "circo");
+            graphNodes = graphNodes0;
+            let arrGraphNodes; //to check overlapping
+            [graph, arrGraphEdges, arrGraphNodes] = (() => {
+                if (isConnected) {
+                    return [graphForPoints, [graphEdges0], [graphNodes0]];
+                }
+                else {
+                    const arrVertexNamesChunk = splitIntoRandomChunks(shuffle(vertexNames), 3);
+                    const arrSubGraph = arrVertexNamesChunk.map((vertexNamesChunk) => GraphConstructor.randomConnected(vertexNamesChunk.length, isSimple, false, minDensity, vertexNamesChunk));
+                    const graph = GraphConstructor.graphByMergingSimpleGraphs(arrSubGraph);
+                    const arrGraphEdges = arrSubGraph.map((graph) => graph.arrConnection().map(([from, to, _]) => {
+                        return { from, to };
+                    }));
+                    const dictGraphNodes = Object.fromEntries(graphNodes.map((graphNode) => [graphNode.label, graphNode]));
+                    const arrGraphNodes = arrSubGraph.map((graph) => graph.vertexNames.map((nameVertex) => dictGraphNodes[nameVertex]));
+                    return [graph, arrGraphEdges, arrGraphNodes];
+                }
+            })();
+            const arrGraphNodes1GraphNodes2 = [...Array(arrGraphNodes.length).keys()]
+                .flatMap((i) => [...Array(i + 1).keys()].map((j) => [i, j]))
+                .map(([i, j]) => [arrGraphNodes[i], arrGraphNodes[j]]);
+            try {
+                isFound = arrGraphNodes1GraphNodes2.every(([graphNodes1, graphNodes2]) => {
+                    const [polygon1, polygon2] = [graphNodes1, graphNodes2].map((graphNodes) => {
+                        const arrPoint = graphNodes.map(({ x, y }) => new Flatten.Point(x, y));
+                        const polygon = new Flatten.Polygon(arrPoint);
+                        return polygon;
+                    });
+                    return Flatten.Relations.intersect(polygon1, polygon2);
+                });
+            }
+            catch {
+                isFound = false;
+            }
+        }
+        const graphEdges = arrGraphEdges.reduce((acc, graphEdges) => {
+            acc = [...acc, ...graphEdges];
+            return acc;
+        }, []);
+        return { graph: graph, graphNodes: graphNodes, graphEdges };
+    })();
+    const identifiers = {
+        graphIds: graph.toIdentifiers(),
+        graphNodes,
+        graphEdges,
+    };
+    return identifiers;
+};
+const getGraphsCheckIsConnectedGraphQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        ggbOptions: getGGBOptions(identifiers, opts),
+    };
+    return question;
+};
+export const graphsCheckIsConnectedGraph = {
+    id: "graphsCheckIsConnectedGraph",
+    label: "Déterminer si un graphe est connexe",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGraphsCheckIsConnectedGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,19 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { GraphIdentifiers } from "../../../math/graphs/graph.js";
+import { GraphEdge, GraphNode } from "../../../math/utils/graphs/graphRenderer.js";
+type Identifiers = {
+    graphIds1: GraphIdentifiers;
+    graphIds2: GraphIdentifiers;
+    graphNodes1: GraphNode[];
+    graphEdges1: GraphEdge[];
+    scale1: number;
+    graphNodes2: GraphNode[];
+    graphEdges2: GraphEdge[];
+    scale2: number;
+};
+type Options = {
+    graphType: string;
+};
+export declare const graphsCheckIsSameGraph: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=graphsCheckIsSameGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphsCheckIsSameGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/graphs/graphsCheckIsSameGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,gBAAgB,EAEjB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,SAAS,EACT,SAAS,EAEV,MAAM,0CAA0C,CAAC;AAQlD,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,SAAS,EAAE,gBAAgB,CAAC;IAG5B,WAAW,EAAE,SAAS,EAAE,CAAC;IACzB,WAAW,EAAE,SAAS,EAAE,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IAEf,WAAW,EAAE,SAAS,EAAE,CAAC;IACzB,WAAW,EAAE,SAAS,EAAE,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAyXF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAsBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAejE,CAAC"}