math-exercises 3.0.199 → 3.0.201

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

@@ -0,0 +1,291 @@
+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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { Tuple } from "../../../../math/sets/tuple.js";
+import { isVariableNode, VariableNode, } from "../../../../tree/nodes/variables/variableNode.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { random } from "../../../../utils/alea/random.js";
+import { discreteSetCartesianProduct, discreteSetSubstract, } from "../../../../math/sets/setOperations.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.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) => {
+    return `\\lbrace ${discreteSetNode.elements
+        .map((el) => el.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 un élément appartenant à $${texAskedSet}$.`;
+};
+const getAnswerStuff = (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 arrTuple = discreteSetCartesianProduct(nodeSetF, nodeSetS);
+    return { arrTuple };
+};
+const getAnswer = (identifiers) => {
+    const { arrTuple } = getAnswerStuff(identifiers);
+    return arrTuple[0].toTex();
+};
+const getHint = () => {
+    return `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)
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { isAskedACrossB } = identifiers;
+    const [texSetF, texSetS] = isAskedACrossB ? ["A", "B"] : ["B", "A"];
+    const texAskedSet = `${texSetF} \\times ${texSetS}`;
+    const arrTuple = getAnswerStuff(identifiers).arrTuple;
+    return `Les éléments de $${texAskedSet}$ sont tous les couples que l'on peut former 
+avec comme premier élément un élement de $${texSetF}$, et comme deuxième élément un élément de $${texSetS}$.
+
+Voici tous les éléments de $${texAskedSet}$ : 
+
+${alignTex(arrTuple.map((tuple) => [tuple.toTex()]))}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { items } = identifiers;
+    const propositions = [];
+    items.map(({ tex, isValid }) => {
+        if (isValid) {
+            addValidProp(propositions, tex);
+        }
+        else {
+            tryToAddWrongProp(propositions, tex);
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { nodeIdsSetA, nodeIdsSetB } = identifiers;
+    const [nodeSetA, nodeSetB] = [nodeIdsSetA, nodeIdsSetB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const arrVarNode = [...nodeSetA.elements, ...nodeSetB.elements].filter((node) => isVariableNode(node));
+    return [
+        "semicolon",
+        ...arrVarNode.map((varNode) => {
+            const tex = varNode.toTex();
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { nodeIdsSetA, nodeIdsSetB, isAskedACrossB } = identifiers;
+    const [nodeSetA, nodeSetB] = [nodeIdsSetA, nodeIdsSetB].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [nodeSetF, nodeSetS] = isAskedACrossB
+        ? [nodeSetA, nodeSetB]
+        : [nodeSetB, nodeSetA];
+    function matchGroups(regex, input) {
+        const match = regex.exec(input);
+        return match?.groups || undefined;
+    }
+    try {
+        const tupleAns = (() => {
+            const ansParts = matchGroups(/^\\left\((?<strOne>.*(?!;$));(?<strTwo>.*)\\right\)$/, ans);
+            if (ansParts === undefined) {
+                throw new Error("Parsing error: ans is not a tuple");
+            }
+            const { strOne, strTwo } = ansParts;
+            const [nodeOne, nodeTwo] = [strOne, strTwo].map((str) => {
+                try {
+                    return parseAlgebraic(str);
+                }
+                catch (_) {
+                    return new VariableNode(str);
+                }
+            });
+            return new Tuple([nodeOne, nodeTwo]);
+        })();
+        return NodeComparator.isTupleInCartesianProductOfDiscreteSets(tupleAns, [
+            nodeSetF,
+            nodeSetS,
+        ]);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getProposeElementInCartesianProductOfFiniteSetsQuestion = () => {
+    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, nbElemB] = random([
+        [2, 2],
+        [2, 3],
+        [3, 2],
+    ]);
+    const poolCommon = random([
+        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 items = (() => {
+        const [nodeSetF, nodeSetS] = isAskedACrossB
+            ? [nodeSetA, nodeSetB]
+            : [nodeSetB, nodeSetA];
+        const _nbValid = 1;
+        const nodeSetFMinusS = discreteSetSubstract(nodeSetF, nodeSetS);
+        const nodeSetSMinusF = discreteSetSubstract(nodeSetS, nodeSetF);
+        const items = [
+            //valid: in F x S
+            (() => {
+                const tuple = random(discreteSetCartesianProduct(nodeSetF, nodeSetS));
+                return {
+                    tex: tuple.toTex(),
+                    isValid: true,
+                };
+            })(),
+            //invalid: in F x (F\S)
+            (() => {
+                const tuple = random(discreteSetCartesianProduct(nodeSetF, nodeSetFMinusS));
+                return {
+                    tex: tuple.toTex(),
+                    isValid: false,
+                };
+            })(),
+            //invalid: in (S\F) x S
+            (() => {
+                const tuple = random(discreteSetCartesianProduct(nodeSetSMinusF, nodeSetS));
+                return {
+                    tex: tuple.toTex(),
+                    isValid: false,
+                };
+            })(),
+            //invalid: in (S\F) x F
+            (() => {
+                const tuple = random(discreteSetCartesianProduct(nodeSetSMinusF, nodeSetF));
+                return {
+                    tex: tuple.toTex(),
+                    isValid: false,
+                };
+            })(),
+        ];
+        return items;
+    })();
+    const identifiers = {
+        nodeIdsSetA: nodeSetA.toIdentifiers(),
+        nodeIdsSetB: nodeSetB.toIdentifiers(),
+        isAskedACrossB,
+        items,
+    };
+    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 proposeElementInCartesianProductOfFiniteSets = {
+    id: "proposeElementInCartesianProductOfFiniteSets",
+    connector: "=",
+    isSingleStep: true,
+    label: "Proposer un élément appartenant au produit cartésien de deux ensembles",
+    generator: (nb) => getDistinctQuestions(getProposeElementInCartesianProductOfFiniteSetsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Item = {
+    str: string;
+    isValid: boolean;
+};
+type Identifiers = {
+    strDescriptionE: string;
+    nodeIdsSetE: NodeIdentifiers;
+    k: number;
+    items: Item[];
+};
+export declare const proposeElementInPowEK: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=proposeElementInPowEK.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proposeElementInPowEK.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/cartesianProduct/proposeElementInPowEK.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAoH7C,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,MAAM,CAAC;IACxB,WAAW,EAAE,eAAe,CAAC;IAC7B,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAmOF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}

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

@@ -0,0 +1,274 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
+import { Tuple } from "../../../../math/sets/tuple.js";
+import { isVariableNode, VariableNode, } from "../../../../tree/nodes/variables/variableNode.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { randomTupleInDiscreteSetPower } from "../../../../math/sets/setOperations.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+const randomDiscreteSetIdsAndDescription = () => {
+    return probaLawFlip([
+        [
+            (() => {
+                const nbElements = randint(2, 5);
+                const arrLetter = shuffle(["a", "b", "c", "d"]).slice(0, nbElements);
+                const arrNode = arrLetter.map((letter) => new VariableNode(letter));
+                const nodeSetE = new DiscreteSetNode(arrNode);
+                return {
+                    nodeIdsSetE: nodeSetE.toIdentifiers(),
+                    strDescriptionE: `l'ensemble $${discreteSetNodeToTex(nodeSetE)}$`,
+                };
+            })(),
+            0.3,
+        ],
+        [
+            (() => {
+                const nbElements = randint(2, 6);
+                const arrNumber = randomMany([...Array(9).keys()].map((i) => i + 1), nbElements);
+                const arrNode = shuffle(arrNumber.map((v) => v.toTree()));
+                const nodeSetE = new DiscreteSetNode(arrNode);
+                return {
+                    nodeIdsSetE: nodeSetE.toIdentifiers(),
+                    strDescriptionE: `l'ensemble $${discreteSetNodeToTex(nodeSetE)}$`,
+                };
+            })(),
+            0.3,
+        ],
+        [
+            (() => {
+                const [boundLowRaw, boundHighRaw] = [randint(2, 8), randint(13, 19)];
+                const [isBoundLowIncluded, isBoundHighIncluded] = [0, 1].map(() => coinFlip());
+                const boundLow = boundLowRaw + (isBoundLowIncluded ? 0 : 1);
+                const boundHigh = boundHighRaw + (isBoundHighIncluded ? 0 : -1);
+                const arrNumber = [...Array(boundHigh - boundLow + 1).keys()].map((i) => i + boundLow);
+                const arrNode = arrNumber.map((v) => v.toTree());
+                const nodeSetE = new DiscreteSetNode(arrNode);
+                return {
+                    nodeIdsSetE: nodeSetE.toIdentifiers(),
+                    strDescriptionE: `l'ensemble des entiers compris entre $${boundLow}$ ${isBoundLowIncluded ? "inclus" : "exclu"} et $${boundHigh}$ ${isBoundHighIncluded ? "inclus" : "exclu"}`,
+                };
+            })(),
+            0.2,
+        ],
+        [
+            (() => {
+                const isFilterEven = coinFlip();
+                const [boundLowRaw, boundHighRaw] = [randint(2, 8), randint(13, 19)];
+                const [isBoundLowIncluded, isBoundHighIncluded] = [0, 1].map(() => coinFlip());
+                const boundLow = boundLowRaw + (isBoundLowIncluded ? 0 : 1);
+                const boundHigh = boundHighRaw + (isBoundHighIncluded ? 0 : -1);
+                const arrNumber = [...Array(boundHigh - boundLow + 1).keys()]
+                    .map((i) => i + boundLow)
+                    .filter((v) => (isFilterEven ? v % 2 === 0 : v % 2 === 1));
+                const arrNode = arrNumber.map((v) => v.toTree());
+                const nodeSetE = new DiscreteSetNode(arrNode);
+                return {
+                    nodeIdsSetE: nodeSetE.toIdentifiers(),
+                    strDescriptionE: `l'ensemble des entiers ${isFilterEven ? "pairs" : "impairs"} compris entre $${boundLow}$ ${isBoundLowIncluded ? "inclus" : "exclu"} et $${boundHigh}$ ${isBoundHighIncluded ? "inclus" : "exclu"}`,
+                };
+            })(),
+            0.2,
+        ],
+    ]);
+};
+/*
+  This toTex() function supports discreteSetNodes with variableNodes inside (this won't create unknown command \\lbracem if m is the first element)
+*/
+const discreteSetNodeToTex = (discreteSetNode) => {
+    return `\\lbrace ${discreteSetNode.elements
+        .map((el) => el.toTex())
+        .join(";")} \\rbrace`;
+};
+const getInstruction = (identifiers) => {
+    const { strDescriptionE, k } = identifiers;
+    return `Soit $E$ ${strDescriptionE}.
+Donner un $${k}$-uplet d'éléments de E.`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsSetE, k } = identifiers;
+    const nodeSetE = NodeConstructor.fromIdentifiers(nodeIdsSetE);
+    const arrTupleWithoutDuplicate = k < nodeSetE.elements.length
+        ? [...Array(5).keys()].map(() => randomTupleInDiscreteSetPower(nodeSetE, k, true))
+        : [];
+    const arrTupleWithDuplicate = [...Array(5).keys()].map(() => randomTupleInDiscreteSetPower(nodeSetE, k, false));
+    const arrTuple = shuffle([
+        ...arrTupleWithoutDuplicate,
+        ...arrTupleWithDuplicate,
+    ]);
+    return { arrTuple };
+};
+const getAnswer = (identifiers) => {
+    const { arrTuple } = getAnswerStuff(identifiers);
+    return arrTuple[0].toTex();
+};
+const getHint = (identifiers) => {
+    const { k } = identifiers;
+    return `Pour prendre un $${k}$-uplet au hasard, tu peux effectuer $${k}$ tirages avec remise d'un élement de $E$.
+  
+Le $${k}$-uplet se notera (élement tirage $1$ ; élement tirage $2$ ; élement tirage $3$ ; ...).`;
+};
+const getCorrection = (identifiers) => {
+    const { k } = identifiers;
+    const arrTuple = getAnswerStuff(identifiers).arrTuple;
+    return `Voici quelques $${k}$-uplets d'éléments de E : 
+
+${alignTex(arrTuple.map((tuple) => [tuple.toTex()]))}
+
+Attention à ne pas confondre la notation d'un ensemble (entre accolades) et la notation d'un k-uplet (entre parenthèses).`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { items } = identifiers;
+    const propositions = [];
+    items.map(({ str, isValid }) => {
+        if (isValid) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { nodeIdsSetE } = identifiers;
+    const nodeSetE = NodeConstructor.fromIdentifiers(nodeIdsSetE);
+    const arrVarNode = nodeSetE.elements.filter((node) => isVariableNode(node));
+    return [
+        "semicolon",
+        "lbrace", //pas gentil
+        "rbrace", //pas gentil
+        ...arrVarNode.map((varNode) => {
+            const tex = varNode.toTex();
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { nodeIdsSetE, k } = identifiers;
+    const nodeSetE = NodeConstructor.fromIdentifiers(nodeIdsSetE);
+    function matchGroups(regex, input) {
+        const match = regex.exec(input);
+        return match?.groups || undefined;
+    }
+    try {
+        const tupleAns = (() => {
+            const arrKey = [...Array(k).keys()]
+                .map((i) => i + 1)
+                .map((v) => `str${v}`);
+            const strRegex = `^\\\\left\\(${arrKey
+                .map((strKey) => `(?<${strKey}>.*(?!;$))`)
+                .join(";")}\\\\right\\)$`;
+            const regex = new RegExp(strRegex);
+            const ansParts = matchGroups(regex, ans);
+            if (ansParts === undefined) {
+                throw new Error("Parsing error: ans is not a tuple");
+            }
+            const arrNode = Object.entries(ansParts).map(([_key, str]) => {
+                try {
+                    return parseAlgebraic(str);
+                }
+                catch (_) {
+                    return new VariableNode(str);
+                }
+            });
+            return new Tuple(arrNode);
+        })();
+        return NodeComparator.isTupleInCartesianProductOfDiscreteSets(tupleAns, [...Array(k).keys()].map(() => nodeSetE));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getProposeElementInPowEKQuestion = () => {
+    const k = randint(3, 6);
+    const dict = randomDiscreteSetIdsAndDescription();
+    const nodeSetE = NodeConstructor.fromIdentifiers(dict.nodeIdsSetE);
+    const items = (() => {
+        const _nbValid = 1;
+        const items = [
+            //valid: in E^k
+            (() => {
+                const tuple = randomTupleInDiscreteSetPower(nodeSetE, k, k < nodeSetE.elements.length ? coinFlip() : false);
+                return {
+                    str: `$${tuple.toTex()}$`,
+                    isValid: true,
+                };
+            })(),
+            //invalid: wrong notation
+            (() => {
+                const tuple = randomTupleInDiscreteSetPower(nodeSetE, k, k < nodeSetE.elements.length ? coinFlip() : false);
+                return {
+                    str: `$${discreteSetNodeToTex(new DiscreteSetNode(tuple.components))}$`,
+                    isValid: false,
+                };
+            })(),
+            //invalid: in E^(k-1) and coinFlip(wrongNotation)
+            (() => {
+                const tuple = randomTupleInDiscreteSetPower(nodeSetE, k - 1, false);
+                return {
+                    str: coinFlip()
+                        ? `$${tuple.toTex()}$`
+                        : `$${discreteSetNodeToTex(new DiscreteSetNode(tuple.components))}$`,
+                    isValid: false,
+                };
+            })(),
+            //invalid: "it's not possible"
+            (() => {
+                return {
+                    str: "Ce n'est pas possible.",
+                    isValid: false,
+                };
+            })(),
+        ];
+        return items;
+    })();
+    const identifiers = {
+        strDescriptionE: dict.strDescriptionE,
+        nodeIdsSetE: nodeSetE.toIdentifiers(),
+        k,
+        items,
+    };
+    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 proposeElementInPowEK = {
+    id: "proposeElementInPowEK",
+    connector: "=",
+    isSingleStep: true,
+    label: "Un ensemble $E$ étant donné, donner un $k$-uplet de $E$",
+    generator: (nb) => getDistinctQuestions(getProposeElementInPowEKQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sets/combinations/findNumberOfCombinationsFromSituation.d.ts

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

package/lib/exercises/math/sets/combinations/findNumberOfCombinationsFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findNumberOfCombinationsFromSituation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/combinations/findNumberOfCombinationsFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAyG7C,KAAK,SAAS,GAAG;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC5C,eAAe,EAAE,eAAe,CAAC;CAClC,CAAC;AAqDF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AA2IF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAcvE,CAAC"}