math-exercises 3.0.215 → 3.0.216

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

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

@@ -0,0 +1,232 @@
+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 { 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 { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../tree/utilities/nodeComparator.js";
+import { probaLawFlip } from "../../../utils/alea/probaLawFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { joinanded } from "../../../utils/strings/joinanded.js";
+const getHydrated = (identifiers) => {
+    const { graphIds, indexAsked } = identifiers;
+    const graph = GraphConstructor.fromIdentifiers(graphIds);
+    const nameVertexAsked = graph.vertexNames[indexAsked];
+    const arrNameVertexAdjacent = graph.getArrVertexNameAdjacent(nameVertexAsked);
+    return {
+        graph,
+        nameVertexAsked,
+        arrNameVertexAdjacent,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nameVertexAsked } = getHydrated(identifiers);
+    return `Un graphe est représenté ci-dessous.
+Quel est le degré du sommet $${nameVertexAsked}$ ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { arrNameVertexAdjacent } = getHydrated(identifiers);
+    return arrNameVertexAdjacent.length.toTree();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Le degré d'un sommet est le nombre d'arêtes incidentes à ce sommet, sans tenir compte de leur sens de parcours.`;
+};
+const getCorrection = (identifiers) => {
+    const { nameVertexAsked, arrNameVertexAdjacent } = getHydrated(identifiers);
+    const nbAdjacent = arrNameVertexAdjacent.length;
+    return `Le sommet $${nameVertexAsked}$ a pour ${nbAdjacent === 1 ? "sommet adjacent" : "sommets adjacents"} ${joinanded(arrNameVertexAdjacent.map((nameVertex) => `$${nameVertex}$`), ", ", " et ")}.
+  
+Le degré de $${nameVertexAsked}$ est donc $${nbAdjacent.frenchify()}$.`;
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { graphNodes, graphEdges } = identifiers;
+    const { graph, nameVertexAsked } = 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 === nameVertexAsked ? 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 === nameVertexAsked || e.to === nameVertexAsked
+                ? [`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 = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { graph, nameVertexAsked } = getHydrated(identifiers);
+    //student: d -> d+ or d -> d-
+    if (graph.isDirected) {
+        const [_, dMinus, dPlus] = graph.getArrDegreeOfVertex(nameVertexAsked);
+        const [isAddWrongPropDMinus, isAddWrongPropDPlus] = probaLawFlip([
+            [[true, false], 0.4],
+            [[false, true], 0.4],
+            [[true, true], 0.2],
+        ]);
+        if (isAddWrongPropDMinus) {
+            tryToAddWrongProp(propositions, dMinus.frenchify());
+        }
+        if (isAddWrongPropDPlus) {
+            tryToAddWrongProp(propositions, dPlus.frenchify());
+        }
+    }
+    //student: degree of other vertex
+    {
+        [...Array(graph.vertexNames.length).keys()].forEach((index) => {
+            const identifiersWrong = {
+                ...identifiers,
+                indexAsked: index,
+            };
+            tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+        });
+    }
+    //filler
+    propWhile(propositions, n, () => {
+        const dWrong = randint(1, 10);
+        tryToAddWrongProp(propositions, dWrong.frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const [nodeAns, nodeAnswer] = [ans, answer].map((str) => parseAlgebraic(str));
+        return NodeComparator.isEqualViaSub(nodeAns, nodeAnswer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+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 indexAsked = randint(0, nbVertices);
+    const { nodes: graphNodes, edges: graphEdges } = GraphRenderer.renderToNodesAndEdges(graph);
+    const identifiers = {
+        graphIds: graph.toIdentifiers(),
+        indexAsked,
+        graphNodes,
+        graphEdges,
+    };
+    return identifiers;
+};
+const getGraphsDegreeOfVertexQuestion = (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),
+        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 graphsDegreeOfVertex = {
+    id: "graphsDegreeOfVertex",
+    label: "Déterminer le degré du sommet d'un graphe",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGraphsDegreeOfVertexQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

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

@@ -0,0 +1,14 @@
+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[];
+};
+type Options = {
+    graphType: string;
+};
+export declare const graphsOrderOfGraph: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=graphsOrderOfGraph.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphsOrderOfGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/graphs/graphsOrderOfGraph.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;AAUlD,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,gBAAgB,CAAC;IAG3B,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,UAAU,EAAE,SAAS,EAAE,CAAC;CACzB,CAAC;AAoPF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAsBF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe7D,CAAC"}