math-exercises 3.0.215 → 3.0.216

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

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

@@ -0,0 +1,301 @@
+import { addValidProp, tryToAddWrongProp, 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 { Vector } from "../../../math/geometry/vector.js";
+import { GraphConstructor, Graph, } 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 { probaLawFlip } from "../../../utils/alea/probaLawFlip.js";
+import { random, randomMany } from "../../../utils/alea/random.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+const getHydrated = (identifiers) => {
+    const { graphIds1, graphIds2, graphNodes1, graphEdges1, graphNodes2, graphEdges2, } = identifiers;
+    const [graph1, graph2] = [graphIds1, graphIds2].map((graphIds) => GraphConstructor.fromIdentifiers(graphIds));
+    const isSameGraph = graph1.equals(graph2);
+    const graphNodeOnlyIn2 = (() => {
+        if (isSameGraph) {
+            return undefined;
+        }
+        else {
+            return graphNodes2.find(({ label: label2 }) => !graphNodes1.map(({ label }) => label).includes(label2));
+        }
+    })();
+    const graphEdgeOnlyIn2 = (() => {
+        if (isSameGraph) {
+            return undefined;
+        }
+        else {
+            return graphEdges2.find(({ from: from2, to: to2 }) => !graphEdges1
+                .map(({ from, to }) => `${from}-${to}`)
+                .includes(`${from2}-${to2}`));
+        }
+    })();
+    return {
+        graph1,
+        graph2,
+        isSameGraph,
+        graphNodeOnlyIn2,
+        graphEdgeOnlyIn2,
+    };
+};
+const getInstruction = () => {
+    return `Deux graphes sont représentés ci-dessous.
+S'agit-il du même graphe ?
+
+*On peut déplacer les points sur la figure.*`;
+};
+const getAnswer = (identifiers) => {
+    const { isSameGraph } = getHydrated(identifiers);
+    return isSameGraph ? "Oui" : "Non";
+};
+const getHint = () => {
+    return `Si les sommets et les arêtes correspondent deux à deux alors il s'agit du même graphe, représenté de deux façons différentes.`;
+};
+const getCorrection = (identifiers) => {
+    const { graph2, isSameGraph, graphNodeOnlyIn2, graphEdgeOnlyIn2 } = getHydrated(identifiers);
+    if (isSameGraph) {
+        return `Les sommets et les arêtes correspondent deux à deux donc il s'agit du même graphe, représenté de deux façons différentes.`;
+    }
+    else {
+        if (graphNodeOnlyIn2) {
+            return `Le sommet $${graphNodeOnlyIn2.label}$ est présent dans le graphe de droite et pas dans celui de gauche.
+Ce sont donc des graphes différents.`;
+        }
+        else if (graphEdgeOnlyIn2) {
+            return `L'arête $${graph2.isDirected
+                ? `${graphEdgeOnlyIn2.from} \\rightarrow ${graphEdgeOnlyIn2.to}`
+                : `${graphEdgeOnlyIn2.from}-${graphEdgeOnlyIn2.to}`}$ est présente dans le graphe de droite et pas dans celui de gauche.
+Ce sont donc des graphes différents.`;
+        }
+        else {
+            throw new Error("!isSameGraph && !graphNodeOnlyIn2 && !graphEdgeOnlyIn2");
+        }
+    }
+};
+// const getCorrectionGGBOptions: GetGGBOptions<Identifiers> = (identifiers) => {
+//   const ggb = new GeogebraConstructor({
+//     commands: ["p = (0,1)"],
+//     fontSize: 16,
+//     hideAxes: true,
+//     hideGrid: true,
+//   });
+//   return ggb.getOptions({
+//     coords: ggb.getCoordsForPoints([
+//       new Point("O", 0, 0),
+//       new Point("A", 1, 0),
+//     ]),
+//   });
+// };
+const getGGBOptions = (identifiers) => {
+    const { graphNodes1, graphEdges1, scale1, graphNodes2, graphEdges2, scale2 } = identifiers;
+    const { graph1, graph2 } = getHydrated(identifiers);
+    function createDisplayObjForGraph(graph, graphNodes, graphEdges, scale, index, vecOffset = new Vector("offset", (0).toTree(), (0).toTree())) {
+        const arrDictPoint = graphNodes
+            .map(({ label, x, y }) => new Point(label, x * scale, y * scale))
+            .map((point) => {
+            const strNamePointOld = point.name;
+            const strNamePointNew = `${point.name}${index}`;
+            return {
+                label: strNamePointOld,
+                point: vecOffset.getEndPoint(point, strNamePointNew),
+            };
+        });
+        const pointCommands = arrDictPoint.flatMap(({ label, point }) => point.toGGBCommand({
+            isFixed: false,
+            isSelectionnable: true,
+            showLabel: true,
+            style: 0,
+            size: 8,
+            label,
+        }));
+        const edgeCommands = graphEdges.map((e, i) => graph.isDirected
+            ? `v${index}I${i + 1} = Vector(${e.from}${index}, ${e.to}${index})`
+            : `s${index}I${i + 1} = Segment(${e.from}${index}, ${e.to}${index})`);
+        const arrGGBCommandForGraph = [...pointCommands, ...edgeCommands];
+        const arrPoint = arrDictPoint.map(({ point }) => point);
+        return {
+            arrPoint,
+            arrGGBCommandForGraph,
+        };
+    }
+    const { arrPoint: arrPoint1, arrGGBCommandForGraph: arrGGBCommandForGraph1 } = createDisplayObjForGraph(graph1, graphNodes1, graphEdges1, scale1, 1);
+    const xMin1 = Math.min(...arrPoint1.map((point) => point.x.evaluate()));
+    const xMax1 = Math.max(...arrPoint1.map((point) => point.x.evaluate()));
+    const width1 = xMax1 - xMin1;
+    const vecOffset = new Vector("offset", (xMax1 + 0.1 * width1).toTree(), (0).toTree());
+    const { arrPoint: arrPoint2, arrGGBCommandForGraph: arrGGBCommandForGraph2 } = createDisplayObjForGraph(graph2, graphNodes2, graphEdges2, scale2, 2, vecOffset);
+    const ggb = new GeogebraConstructor({
+        commands: [...arrGGBCommandForGraph1, ...arrGGBCommandForGraph2],
+        fontSize: 16,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints([...arrPoint1, ...arrPoint2]),
+    });
+};
+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 = (isDirected) => {
+    const isSimple = true;
+    const graph0 = (() => {
+        const nbVertices = randint(6, 8);
+        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;
+            }
+        })();
+        const graph = GraphConstructor.random(nbVertices, isSimple, isDirected, minDensity, "ABCDEFGHIJKLM".split(""), true);
+        return graph;
+    })();
+    const isSameGraph = coinFlip();
+    const [graph1, graph2] = (() => {
+        if (isSameGraph) {
+            return [graph0, graph0];
+        }
+        else {
+            const poolVertexName = "ABCDEFGHIJKLM".split("");
+            const poolVertexNameAvailable = poolVertexName.filter((str) => !graph0.vertexNames.includes(str));
+            const typeDiff = probaLawFlip([
+                ["different vertex names", 0.25],
+                ["extraneous vertex", 0.25],
+                ["same vertices, extraneous edge", 0.5],
+            ]);
+            switch (typeDiff) {
+                case "different vertex names": {
+                    const [nameVertex1, nameVertex2] = randomMany(poolVertexNameAvailable, 2);
+                    const indexReplacement = randint(0, graph0.vertexNames.length);
+                    const [vertexNames1, vertexNames2] = [nameVertex1, nameVertex2].map((nameVertex) => {
+                        const vertexNames = [...graph0.vertexNames];
+                        vertexNames[indexReplacement] = nameVertex;
+                        return vertexNames;
+                    });
+                    const [graph1, graph2] = [vertexNames1, vertexNames2].map((vertexNames) => new Graph(vertexNames, graph0.mat));
+                    return [graph1, graph2];
+                }
+                case "extraneous vertex": {
+                    const isGraph1Graph0 = coinFlip();
+                    const graph1 = isGraph1Graph0
+                        ? graph0
+                        : (() => {
+                            const miniGraph = GraphConstructor.random(2, isSimple, graph0.isDirected, 0, [random(graph0.vertexNames), random(poolVertexNameAvailable)], true);
+                            return GraphConstructor.graphByMergingSimpleGraphs([
+                                graph0,
+                                miniGraph,
+                            ]);
+                        })();
+                    const graph2 = (() => {
+                        const poolVertexNameAvailable = poolVertexName.filter((str) => !graph1.vertexNames.includes(str));
+                        const miniGraph = GraphConstructor.random(2, isSimple, graph0.isDirected, 0, [random(graph0.vertexNames), random(poolVertexNameAvailable)], true);
+                        return GraphConstructor.graphByMergingSimpleGraphs([
+                            graph0,
+                            miniGraph,
+                        ]);
+                    })();
+                    return [graph1, graph2];
+                }
+                case "same vertices, extraneous edge": {
+                    //it is possible that graph1===graph2
+                    const isGraph1Graph0 = coinFlip();
+                    const graph1 = isGraph1Graph0
+                        ? graph0
+                        : GraphConstructor.graphByAddingRandomEdge(graph0);
+                    const graph2 = GraphConstructor.graphByAddingRandomEdge(graph0);
+                    return [graph1, graph2];
+                }
+                default:
+                    throw new Error("Unsupported typeDiff: " + typeDiff);
+            }
+        }
+    })();
+    const [[layoutEngine1, scale1], [layoutEngine2, scale2]] = shuffle([
+        ["fdp", 1.5],
+        ["circo", 1.0],
+    ]);
+    const [{ nodes: graphNodes1, edges: graphEdges1 }, { nodes: graphNodes2, edges: graphEdges2 },] = [
+        { graph: graph1, layoutEngine: layoutEngine1 },
+        { graph: graph2, layoutEngine: layoutEngine2 },
+    ].map(({ graph, layoutEngine }) => GraphRenderer.renderToNodesAndEdges(graph, layoutEngine));
+    const identifiers = {
+        graphIds1: graph1.toIdentifiers(),
+        graphIds2: graph2.toIdentifiers(),
+        graphNodes1,
+        graphEdges1,
+        scale1,
+        graphNodes2,
+        graphEdges2,
+        scale2,
+    };
+    return identifiers;
+};
+const getGraphsCheckIsSameGraphQuestion = (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),
+        answerFormat: "raw",
+        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 graphsCheckIsSameGraph = {
+    id: "graphsCheckIsSameGraph",
+    label: "Déterminer s'il s'agit du même graphe",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGraphsCheckIsSameGraphQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,16 @@
+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;
+    nameVertex1: string;
+    nameVertex2: string;
+    graphNodes: GraphNode[];
+    graphEdges: GraphEdge[];
+};
+type Options = {
+    graphType: string;
+};
+export declare const graphsCheckIsVerticesAdjacent: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=graphsCheckIsVerticesAdjacent.d.ts.map

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

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