math-exercises 3.0.214 → 3.0.216

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

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

@@ -0,0 +1,207 @@
+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 { greenMain } from "../../../geogebra/colors.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 { shuffle } from "../../../utils/alea/shuffle.js";
+const getHydrated = (identifiers) => {
+    const { graphIds, nameVertex1, nameVertex2 } = identifiers;
+    const graph = GraphConstructor.fromIdentifiers(graphIds);
+    const dictConnections = graph.dictConnections();
+    const isAdjacent = dictConnections[nameVertex1][nameVertex2] ||
+        dictConnections[nameVertex2][nameVertex1];
+    return {
+        graph,
+        isAdjacent,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nameVertex1, nameVertex2 } = identifiers;
+    return `Un graphe est représenté ci-dessous.
+Les sommets $${nameVertex1}$ et $${nameVertex2}$ sont-ils adjacents ?`;
+};
+const getAnswer = (identifiers) => {
+    const { isAdjacent } = getHydrated(identifiers);
+    return isAdjacent ? "Oui" : "Non";
+};
+const getHint = () => {
+    return `Deux sommets sont adjacents si et seulement si ils sont reliés par une arête.`;
+};
+const getCorrection = (identifiers) => {
+    const { nameVertex1, nameVertex2 } = identifiers;
+    const { isAdjacent } = getHydrated(identifiers);
+    if (isAdjacent) {
+        return `Les sommets $${nameVertex1}$ et $${nameVertex2}$ sont reliés par au moins une arête.
+Ils sont adjacents.`;
+    }
+    else {
+        return `Les sommets $${nameVertex1}$ et $${nameVertex2}$ ne sont pas reliés par une arête.
+Ils ne sont pas adjacents.`;
+    }
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { graphNodes, graphEdges, nameVertex1, nameVertex2 } = 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,
+        color: point.name === nameVertex1 || point.name === nameVertex2
+            ? greenMain
+            : "#000000",
+    }));
+    const edgeCommands = graphEdges.flatMap((e, i) => {
+        return [
+            graph.isDirected
+                ? `edge${i + 1} = Vector(${e.from}, ${e.to})`
+                : `edge${i + 1} = Segment(${e.from}, ${e.to})`,
+            ...((e.from === nameVertex1 && e.to === nameVertex2) ||
+                (e.from === nameVertex2 && e.to === nameVertex1)
+                ? [`SetColor(edge${i + 1}, "${greenMain}")`]
+                : []),
+        ];
+    });
+    const ggb = new GeogebraConstructor({
+        commands: [...pointCommands, ...edgeCommands],
+        fontSize: 16,
+        hideAxes: true,
+        hideGrid: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getCoordsForPoints(arrPoint),
+    });
+};
+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 = (isDirected) => {
+    const nbVertices = randint(5, 10);
+    const isSimple = true;
+    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);
+    const { nodes: graphNodes, edges: graphEdges } = GraphRenderer.renderToNodesAndEdges(graph);
+    const [nameVertex1, nameVertex2] = shuffle((() => {
+        const isAdjacent = coinFlip();
+        const arrConnection = graph.arrConnection();
+        return random(arrConnection
+            .filter(([_nameVertexStart, _nameVertexEnd, isConnection]) => isConnection === isAdjacent)
+            .map(([nameVertexStart, nameVertexEnd, _]) => [
+            nameVertexStart,
+            nameVertexEnd,
+        ]));
+    })());
+    const identifiers = {
+        graphIds: graph.toIdentifiers(),
+        nameVertex1,
+        nameVertex2,
+        graphNodes,
+        graphEdges,
+    };
+    return identifiers;
+};
+const getGraphsCheckIsVerticesAdjacentQuestion = (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),
+        correctionGgbOptions: getCorrectionGGBOptions(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 graphsCheckIsVerticesAdjacent = {
+    id: "graphsCheckIsVerticesAdjacent",
+    label: "Déterminer si deux sommets sont adjacents",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGraphsCheckIsVerticesAdjacentQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/graphs/graphsDegreeOfVertex.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;
+    indexAsked: number;
+    graphNodes: GraphNode[];
+    graphEdges: GraphEdge[];
+};
+type Options = {
+    graphType: string;
+};
+export declare const graphsDegreeOfVertex: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=graphsDegreeOfVertex.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphsDegreeOfVertex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/graphs/graphsDegreeOfVertex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAAoB,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAChF,OAAO,EACL,SAAS,EACT,SAAS,EAEV,MAAM,0CAA0C,CAAC;AASlD,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;IAGnB,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB,CAAC;AAmQF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAsBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe/D,CAAC"}