math-exercises 3.0.199 → 3.0.200

package/lib/exercises/math/sequences/geometric/graph/geometricSignOfReasonFromGraph.js

@@ -0,0 +1,161 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { toolBarConstructor } from "../../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../../math/geometry/point.js";
+import { NodeConstructor, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
+const nbPoints = 4;
+const getArrPoint = (identifiers) => {
+    const { firstRank, nodeIdsInitial, nodeIdsReason } = identifiers;
+    const [nodeInitial, nodeReason] = [nodeIdsInitial, nodeIdsReason].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrNodeTerm = [...Array(nbPoints).keys()].map((i) => multiply(nodeInitial, power(nodeReason, i))
+        .simplify({
+        towardsDistribute: true,
+        calculatePowers: true,
+        distributePowersOnFrac: true,
+    })
+        .simplify({ towardsDistribute: false }));
+    const arrPoint = arrNodeTerm.map((nodeTerm, i) => {
+        const nodeX = (firstRank + i).toTree();
+        return new Point(`P${firstRank + i}`, nodeX, nodeTerm);
+    });
+    return arrPoint;
+};
+const getInstruction = () => {
+    return `Dans le repère ci-dessous, on a placé les points représentant les $${nbPoints}$ premiers termes d'une suite géométrique $u$.
+Que peut-on en déduire quant au signe de sa raison ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeIdsReason } = identifiers;
+    const nodeReason = NodeConstructor.fromIdentifiers(nodeIdsReason);
+    const indexAnswer = nodeReason.evaluate() > 0 ? 0 : 1;
+    return ["La raison est positive.", "La raison est négative."][indexAnswer];
+};
+const getHint = () => {
+    return `Dans le nuage de point qui représente la suite, l'abscisse de chaque point est le rang du terme, et l'ordonnée est le terme en lui-même.
+
+
+Dans une suite géométrique, pour calculer le terme suivant, on multiplie par la raison. 
+Si la raison est positive, le signe sera conservé.
+Si la raison est négative, les deux termes seront de signes différents.`;
+};
+const getCorrection = (identifiers) => {
+    const answer = getAnswer(identifiers);
+    return `Dans le nuage de point qui représente la suite, l'abscisse de chaque point est le rang du terme, et l'ordonnée est le terme en lui-même.
+
+Dans une suite géométrique, pour calculer le terme suivant, on multiplie par la raison.
+Si la raison est positive, le signe sera conservé.
+Si la raison est négative, les deux termes seront de signes différents.
+
+Ici, deux termes consécutifs sont toujours de ${answer === "La raison est positive." ? "même signe" : "signes opposés"}.
+Par conséquent, ${answer.toLocaleLowerCase()}.
+
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const arrPoint = getArrPoint(identifiers);
+    const values = arrPoint.map((point) => point.y.evaluate());
+    const ggb = new GeogebraConstructor({
+        commands: [
+            ...arrPoint.flatMap((point) => point.toGGBCommand({ color: `#000000`, showLabel: false })),
+        ],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+    });
+    const yMin = Math.min(...values);
+    const yMax = Math.max(...values);
+    return ggb.getOptions({
+        coords: [-1, 6, Math.min(yMin, 0) - 1, Math.max(yMax, 1) + 1],
+    });
+};
+const getPropositions = (_, { answer }) => {
+    const propositions = [];
+    ["La raison est positive.", "La raison est négative."].forEach((strYN) => {
+        if (strYN === answer) {
+            addValidProp(propositions, strYN, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, strYN, "raw");
+        }
+    });
+    return propositions;
+};
+const getGeometricSignOfReasonFromGraphQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const [nodeInitialAbs, nodeReasonAbs] = random([
+        //increasing
+        [(1).toTree(), (2).toTree()],
+        [(1).toTree(), frac(3, 2)],
+        [(1).toTree(), frac(4, 3)],
+        // [(1).toTree(), frac(5, 3)],
+        [frac(1, 2), (2).toTree()],
+        [frac(1, 2), frac(3, 2)],
+        [frac(1, 3), (3).toTree()],
+        [(2).toTree(), frac(3, 2)],
+        [(2).toTree(), frac(4, 3)],
+        //decreasing
+        [(8).toTree(), frac(1, 2)],
+        [(9).toTree(), frac(1, 3)],
+        [(9).toTree(), frac(2, 3)],
+        [(8).toTree(), frac(3, 4)],
+        // [(10).toTree(), frac(3, 5)],
+    ]);
+    const nodeInitial = (() => {
+        const sign = coinFlip() ? +1 : -1;
+        return multiply(sign, nodeInitialAbs).simplify({
+            towardsDistribute: true,
+        });
+    })();
+    const nodeReason = (() => {
+        const sign = coinFlip() ? +1 : -1;
+        return multiply(sign, nodeReasonAbs).simplify({
+            towardsDistribute: true,
+        });
+    })();
+    const identifiers = {
+        firstRank,
+        nodeIdsInitial: nodeInitial.toIdentifiers(),
+        nodeIdsReason: nodeReason.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne, {});
+const options = [generatorOptionFirstTermRankOne];
+export const geometricSignOfReasonFromGraph = {
+    id: "geometricSignOfReasonFromGraph",
+    label: "À partir d'un nuage de point d'une suite géométrique, retrouver le signe de sa raison",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricSignOfReasonFromGraphQuestion(opts), nb),
+    ggbTimer: 60,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    getInstruction,
+    getGGBOptions,
+    hasGeogebra: true,
+    answerType: "QCU",
+    getAnswer,
+    getPropositions,
+    getQuestionFromIdentifiers,
+    options,
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsSetA: NodeIdentifiers;
+    nodeIdsSetB: NodeIdentifiers;
+    isAskedACrossB: boolean;
+};
+export declare const findCardinalOfCartesianProductOfFiniteSets: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findCardinalOfCartesianProductOfFiniteSets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"findCardinalOfCartesianProductOfFiniteSets.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/cartesianProduct/findCardinalOfCartesianProductOfFiniteSets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAsC7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,eAAe,CAAC;IAC7B,WAAW,EAAE,eAAe,CAAC;IAC7B,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AA8OF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAkB1E,CAAC"}

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