math-exercises 3.0.198 → 3.0.200

package/lib/exercises/math/sets/cartesianProduct/findCardinalOfCartesianProductOfFiniteSets.js

@@ -0,0 +1,224 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { isVariableNode, VariableNode, } from "../../../../tree/nodes/variables/variableNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { isNumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+/*
+  This toTex() function supports discreteSetNodes with variableNodes inside (this won't create unknown command \\lbracem if m is the first element)
+*/
+const discreteSetNodeToTex = (discreteSetNode) => {
+    const myCompare = (node1, node2) => {
+        if (isNumberNode(node1) && isNumberNode(node2)) {
+            return node1.evaluate() - node2.evaluate();
+        }
+        else if (isNumberNode(node1) && isVariableNode(node2)) {
+            return 1;
+        }
+        else if (isVariableNode(node1) && isNumberNode(node2)) {
+            return -1;
+        }
+        else {
+            return node1.toTex().localeCompare(node2.toTex());
+        }
+    };
+    return `\\lbrace ${discreteSetNode.elements
+        .toSorted(myCompare)
+        .map((node) => node.toTex())
+        .join(";")} \\rbrace`;
+};
+const getInstruction = (identifiers) => {
+    const { nodeIdsSetA, nodeIdsSetB, isAskedACrossB } = identifiers;
+    const [nodeSetA, nodeSetB] = [nodeIdsSetA, nodeIdsSetB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const texAskedSet = isAskedACrossB ? `A \\times B` : `B \\times A`;
+    return `Soient deux ensembles : 
+  
+${alignTex([
+        ["A", nodeSetA],
+        ["B", nodeSetB],
+    ].map(([letter, nodeSet]) => [letter, "=", discreteSetNodeToTex(nodeSet)]))}
+
+Donner le cardinal de $${texAskedSet}$.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { nodeIdsSetA, nodeIdsSetB, isAskedACrossB } = identifiers;
+    const [nodeSetA, nodeSetB] = [nodeIdsSetA, nodeIdsSetB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeSetF, nodeSetS] = isAskedACrossB
+        ? [nodeSetA, nodeSetB]
+        : [nodeSetB, nodeSetA];
+    const [cardF, cardS] = [nodeSetF, nodeSetS].map((discreteSetNode) => discreteSetNode.elements.length);
+    const nodeCardinal = multiply(cardF, cardS);
+    return nodeCardinal;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers)
+        .simplify({ towardsDistribute: true })
+        .toTex();
+};
+const getHint = () => {
+    return `Le cardinal d'un ensemble fini est le nombre d'éléments de l'ensemble.
+  
+Soient deux ensembles $C$ et $D$. 
+Les éléments de $D \\times C$ sont tous les couples que l'on peut former 
+avec comme premier élément un élement de $D$, et comme deuxième élément un élément de $C$.
+  
+Voici un exemple : 
+  
+$$
+C = \\lbrace 32, 42, 52 \\rbrace
+$$
+
+$$
+D = \\lbrace u, v \\rbrace
+$$
+
+Voici les couples appartenant à $D \\times C$ :
+
+$$
+(u,32),(u,42),(u,52),
+$$
+
+$$
+(v,32),(v,42),(v,52)
+$$
+
+Le cardinal de $D \\times C$ est donc $2\\times3=6$.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsSetA, nodeIdsSetB, isAskedACrossB } = identifiers;
+    const [nodeSetA, nodeSetB] = [nodeIdsSetA, nodeIdsSetB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [texSetF, texSetS] = isAskedACrossB ? ["A", "B"] : ["B", "A"];
+    const [nodeSetF, nodeSetS] = isAskedACrossB
+        ? [nodeSetA, nodeSetB]
+        : [nodeSetB, nodeSetA];
+    const texAskedSet = `${texSetF} \\times ${texSetS}`;
+    const [cardF, cardS] = [nodeSetF, nodeSetS].map((discreteSetNode) => discreteSetNode.elements.length);
+    return `Le cardinal d'un ensemble fini est le nombre d'éléments de l'ensemble.
+
+${alignTex([
+        [
+            `\\text{card}(${texAskedSet})`,
+            "=",
+            `\\text{card}(${texSetF}) \\times \\text{card}(${texSetS})`,
+        ],
+        [``, "=", `${cardF.frenchify()} \\times ${cardS.frenchify()}`],
+        [``, "=", `${(cardF * cardS).frenchify()}`],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIdsSetA, nodeIdsSetB } = identifiers;
+    const [nodeSetA, nodeSetB] = [nodeIdsSetA, nodeIdsSetB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [cardA, cardB] = [nodeSetA, nodeSetB].map((discreteSetNode) => discreteSetNode.elements.length);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "2");
+    tryToAddWrongProp(propositions, add(cardA, cardB).simplify({ towardsDistribute: true }).toTex());
+    tryToAddWrongProp(propositions, power(cardA, cardB).simplify({ towardsDistribute: true }).toTex());
+    tryToAddWrongProp(propositions, power(cardB, cardA).simplify({ towardsDistribute: true }).toTex());
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindCardinalOfCartesianProductOfFiniteSetsQuestion = () => {
+    const poolNumberNode = [...Array(20).keys()]
+        .map((i) => i * 2)
+        .map((v) => v.toTree());
+    const poolVarNode1 = ["c", "d", "k"].map((letter) => new VariableNode(letter));
+    const poolVarNode2 = ["\\alpha", "\\beta", "\\gamma", "\\delta"].map((letter) => new VariableNode(letter));
+    function createRandomSetNode(funcCreateElem, nbElem) {
+        const arrNode = shuffle([...Array(nbElem).keys()].reduce((acc, i) => {
+            acc = [...acc, funcCreateElem(i, acc)];
+            return acc;
+        }, []));
+        return new DiscreteSetNode(arrNode);
+    }
+    const nbElemA = randint(2, 10);
+    const nbElemB = randint(2, 10, [nbElemA]);
+    const poolCommon = [...poolNumberNode, ...poolVarNode1, ...poolVarNode2];
+    const poolAOnly = [
+        new VariableNode("b"),
+        ...[...Array(20).keys()].map((i) => i * 2 + 1).map((v) => v.toTree()),
+    ];
+    const poolBOnly = ["a", "m", "n"].map((letter) => new VariableNode(letter));
+    function* genFuncElemA() {
+        yield* shuffle(poolCommon);
+        return "Done";
+    }
+    function* genFuncElemB() {
+        yield* shuffle(poolCommon);
+        return "Done";
+    }
+    const [generateElemA, generateElemB] = [genFuncElemA(), genFuncElemB()];
+    //ensure A\B is not empty
+    const nodeSetA = createRandomSetNode((i) => {
+        if (i === nbElemA - 1) {
+            return random(poolAOnly);
+        }
+        else {
+            return generateElemA.next().value;
+        }
+    }, nbElemA);
+    //ensure B\A is not empty
+    const nodeSetB = createRandomSetNode((i, _arrPrevious) => {
+        if (i === nbElemB - 1) {
+            return random(poolBOnly);
+        }
+        else {
+            return generateElemB.next().value;
+        }
+    }, nbElemB);
+    const isAskedACrossB = coinFlip();
+    const identifiers = {
+        nodeIdsSetA: nodeSetA.toIdentifiers(),
+        nodeIdsSetB: nodeSetB.toIdentifiers(),
+        isAskedACrossB,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const findCardinalOfCartesianProductOfFiniteSets = {
+    id: "findCardinalOfCartesianProductOfFiniteSets",
+    connector: "=",
+    isSingleStep: true,
+    label: "Donner le cardinal du produit cartésien de deux ensembles",
+    generator: (nb) => getDistinctQuestions(getFindCardinalOfCartesianProductOfFiniteSetsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sets/cartesianProduct/findCardinalOfCartesianProductOfFiniteSetsFromSituation.d.ts

@@ -0,0 +1,18 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Situation = {
+    strInstruction: string;
+    strCorrection: string;
+    dictSets: Record<string, {
+        cardinal: number;
+        strInjected: string;
+        strExplain: string;
+    }>;
+    nodeIdsCardinal: NodeIdentifiers;
+};
+type Identifiers = {
+    situation: Situation;
+};
+export declare const findCardinalOfCartesianProductOfFiniteSetsFromSituation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findCardinalOfCartesianProductOfFiniteSetsFromSituation.d.ts.map

package/lib/exercises/math/sets/cartesianProduct/findCardinalOfCartesianProductOfFiniteSetsFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findCardinalOfCartesianProductOfFiniteSetsFromSituation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/cartesianProduct/findCardinalOfCartesianProductOfFiniteSetsFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAuE7C,KAAK,SAAS,GAAG;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CACd,MAAM,EACN;QAAE,QAAQ,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAC9D,CAAC;IACF,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC;AAqDF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AA6IF,eAAO,MAAM,uDAAuD,EAAE,QAAQ,CAAC,WAAW,CAmBvF,CAAC"}

package/lib/exercises/math/sets/cartesianProduct/findCardinalOfCartesianProductOfFiniteSetsFromSituation.js

@@ -0,0 +1,198 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+const situationTemplates = [
+    {
+        strInstruction: "Un coffret contient ${shapes}, ${colors}, et ${sizes}. Combien de perles distinctes existe-t-il ?",
+        strCorrection: `\${shapes.explain} 
+\${colors.explain}
+\${sizes.explain}
+Le nombre de perles distinctes est donc $\${cardinal}$.`,
+        dictFuncs: {
+            shapes: () => {
+                const pool = ["rondes", "ovales", "carrées", "cylindriques"];
+                const cardinal = randint(1, pool.length);
+                const arrStr = randomMany(pool, cardinal);
+                return {
+                    cardinal,
+                    strInjected: `des perles ${joinanded(arrStr, ", ", " et ")}`,
+                    strExplain: cardinal === 1
+                        ? `Il y a une seule forme.`
+                        : `Il y a $${cardinal}$ formes différentes.`,
+                };
+            },
+            colors: () => {
+                const pool = ["rouges", "vertes", "bleues", "jaunes"];
+                const cardinal = randint(1, pool.length);
+                const arrStr = randomMany(pool, cardinal);
+                return {
+                    cardinal,
+                    strInjected: `des perles ${joinanded(arrStr, ", ", " et ")}`,
+                    strExplain: cardinal === 1
+                        ? `Il y a une seule couleur.`
+                        : `Il y a $${cardinal}$ couleurs différentes.`,
+                };
+            },
+            sizes: () => {
+                const cardinal = randint(2, 7);
+                return {
+                    cardinal,
+                    strInjected: cardinal === 1
+                        ? `une même taille pour toutes les perles.`
+                        : `$${cardinal}$ tailles de perles différentes`,
+                    strExplain: cardinal === 1
+                        ? `Il y a une seule taille.`
+                        : `Il y a $${cardinal}$ tailles différentes.`,
+                };
+            },
+        },
+    },
+];
+class SituationConstructor {
+    static randomSituationFromTemplate(situationTemplate) {
+        const dictSets = Object.entries(situationTemplate.dictFuncs).reduce((acc, [key, func]) => {
+            acc[key] = func();
+            return acc;
+        }, {});
+        const { strInstruction, strCorrection: strCorrectionIncomplete, nodeCardinal, } = Object.entries(dictSets).reduce((acc, [key, miniDict]) => {
+            acc.strInstruction = acc.strInstruction.replace(`\${${key}}`, miniDict.strInjected);
+            acc.strCorrection = acc.strCorrection.replace(`\${${key}.explain}`, miniDict.strExplain);
+            acc.nodeCardinal = acc.nodeCardinal
+                ? multiply(acc.nodeCardinal, miniDict.cardinal)
+                : miniDict.cardinal.toTree();
+            return acc;
+        }, {
+            strInstruction: situationTemplate.strInstruction,
+            strCorrection: situationTemplate.strCorrection,
+            nodeCardinal: undefined,
+        });
+        const strCorrection = strCorrectionIncomplete.replace(`\${cardinal}`, `${nodeCardinal.toTex()} = ${nodeCardinal
+            .simplify({ towardsDistribute: true })
+            .toTex()}`);
+        return {
+            nodeIdsCardinal: nodeCardinal.toIdentifiers(),
+            strInstruction,
+            strCorrection,
+            dictSets,
+        };
+    }
+}
+const getInstruction = (identifiers) => {
+    const { situation: { strInstruction }, } = identifiers;
+    return strInstruction;
+};
+const getAnswerNode = (identifiers) => {
+    const { situation: { nodeIdsCardinal }, } = identifiers;
+    const nodeCardinal = NodeConstructor.fromIdentifiers(nodeIdsCardinal);
+    return nodeCardinal;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers)
+        .simplify({ towardsDistribute: true })
+        .toTex();
+};
+const getHint = () => {
+    return `Le cardinal d'un ensemble fini est le nombre d'éléments de l'ensemble.
+
+On va prendre un exemple avec des cartes à jouer.
+Chaque carte peut être soit Valet, soit Dame, soit Roi.
+Chaque carte peut être soit Pique, soit Coeur.
+
+Voici toutes les cartes possibles :
+
+$$
+(\\text{Valet},\\text{Pique}),(\\text{Valet},\\text{Coeur})
+$$
+
+$$
+(\\text{Dame},\\text{Pique}),(\\text{Dame},\\text{Coeur})
+$$
+
+$$
+(\\text{Roi},\\text{Pique}),(\\text{Roi},\\text{Coeur})
+$$
+
+Il y en a $3\\times2=6$.`;
+};
+const getCorrection = (identifiers) => {
+    const { situation: { strCorrection }, } = identifiers;
+    return strCorrection;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { situation: { dictSets }, } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const arrSubCardinal = Object.values(dictSets).map(({ cardinal }) => cardinal);
+    //student: add
+    {
+        const cardinalWrong = arrSubCardinal.reduce((acc, x) => acc + x, 0);
+        tryToAddWrongProp(propositions, cardinalWrong.frenchify());
+    }
+    //student: max(dictSets.cardinal)
+    {
+        const cardinalWrong = arrSubCardinal.reduce((acc, x) => Math.max(acc, x), 0);
+        tryToAddWrongProp(propositions, cardinalWrong.frenchify());
+    }
+    propWhile(propositions, n, () => {
+        //filler: around answer wrt multiplication tables
+        {
+            const indexWrong = randint(0, arrSubCardinal.length);
+            const arrSubCardinalWrong = arrSubCardinal.map((v, i) => i === indexWrong ? (v === 1 ? v + 1 : v + (coinFlip() ? -1 : 1)) : v);
+            const cardinalWrong = arrSubCardinalWrong.reduce((acc, x) => acc * x, 1);
+            tryToAddWrongProp(propositions, cardinalWrong.frenchify());
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindCardinalOfCartesianProductOfFiniteSetsFromSituationQuestion = () => {
+    const situationTemplate = random(situationTemplates);
+    const situation = SituationConstructor.randomSituationFromTemplate(situationTemplate);
+    const identifiers = {
+        situation,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const findCardinalOfCartesianProductOfFiniteSetsFromSituation = {
+    id: "findCardinalOfCartesianProductOfFiniteSetsFromSituation",
+    connector: "=",
+    isSingleStep: true,
+    label: "Donner le cardinal d'un ensemble produit cartésien défini par une situation",
+    generator: (nb) => getDistinctQuestions(getFindCardinalOfCartesianProductOfFiniteSetsFromSituationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sets/cartesianProduct/findCardinalOfPowEK.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    strDescriptionE: string;
+    nodeIdsSetE: NodeIdentifiers;
+    k: number;
+};
+export declare const findCardinalOfPowEK: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findCardinalOfPowEK.d.ts.map

package/lib/exercises/math/sets/cartesianProduct/findCardinalOfPowEK.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findCardinalOfPowEK.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/cartesianProduct/findCardinalOfPowEK.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAsH7C,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,eAAe,CAAC;IAC7B,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqKF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAerD,CAAC"}