math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/sets/combinations/proposeCombination.js

@@ -0,0 +1,347 @@
+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 { randomCombinationFromDiscreteSet, randomManyCombinationsFromDiscreteSet, 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 une combinaison de $${k}$ éléments de E.`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsSetE, k } = identifiers;
+    const nodeSetE = NodeConstructor.fromIdentifiers(nodeIdsSetE);
+    const arrCombination = k <= nodeSetE.elements.length
+        ? randomManyCombinationsFromDiscreteSet(nodeSetE, k, 5)
+        : [];
+    return { arrCombination };
+};
+const getAnswer = (identifiers) => {
+    const { arrCombination } = getAnswerStuff(identifiers);
+    if (arrCombination.length === 0) {
+        return "\\text{Ce n'est pas possible.}";
+    }
+    else {
+        return arrCombination[0].toTex();
+    }
+};
+const getHint = (identifiers) => {
+    const { k } = identifiers;
+    return `Pour prendre une combinaison de $${k}$ éléments de $E$, il faut effectuer $${k}$ tirages simultanés d'un élement de $E$.
+Il faut donc s'assurer que l'ensemble $E$ contient suffisament d'éléments pour former un $${k}$-uplet d'éléments distincts.
+
+La combinaison se notera {élement tirage $1$ ; élement tirage $2$ ; élement tirage $3$ ; ...} (c'est un ensemble (l'ordre n'a pas d'importance)).`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsSetE, k } = identifiers;
+    const nodeSetE = NodeConstructor.fromIdentifiers(nodeIdsSetE);
+    const arrCombination = getAnswerStuff(identifiers).arrCombination;
+    return `
+$$
+E = ${discreteSetNodeToTex(nodeSetE)}
+$$
+
+${(() => {
+        if (arrCombination.length === 0) {
+            return `On veut prendre $${k}$ éléments distincts dans un ensemble qui n'en contient que $${nodeSetE.elements.length}$.
+Ce n'est pas possible.`;
+        }
+        else if (arrCombination.length === 1) {
+            return `Voici la seule combinaison à $${k}$ éléments de E : 
+
+${alignTex(arrCombination.map((discreteSetNode) => [
+                discreteSetNodeToTex(discreteSetNode),
+            ]))}`;
+        }
+        else {
+            return `Voici quelques combinaisons à $${k}$ éléments de E : 
+
+${alignTex(arrCombination.map((discreteSetNode) => [
+                discreteSetNodeToTex(discreteSetNode),
+            ]))}
+
+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",
+        "rbrace",
+        ...arrVarNode.map((varNode) => {
+            const tex = varNode.toTex();
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+        {
+            id: "custom",
+            label: "\\text{Ce n'est pas possible.}",
+            labelType: "tex",
+            mathfieldInstructions: {
+                method: "write",
+                content: "\\text{Ce n'est pas possible.}",
+            },
+        },
+    ];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    if (ans === answer) {
+        return true;
+    }
+    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 getProposeCombinationQuestion = () => {
+    const k = randint(2, 6);
+    const dict = randomDiscreteSetIdsAndDescription();
+    const nodeSetE = NodeConstructor.fromIdentifiers(dict.nodeIdsSetE);
+    const items = (() => {
+        const _nbValid = 1;
+        const items = [
+            //valid: combination or "it's not possible"
+            (() => {
+                if (k <= nodeSetE.elements.length) {
+                    const combination = randomCombinationFromDiscreteSet(nodeSetE, k);
+                    return {
+                        str: `$${combination.toTex()}$`,
+                        isValid: true,
+                    };
+                }
+                else {
+                    return {
+                        str: "Ce n'est pas possible.",
+                        isValid: true,
+                    };
+                }
+            })(),
+            //invalid: tuple with distinct
+            ...(() => {
+                if (k <= nodeSetE.elements.length) {
+                    const tuple = randomTupleInDiscreteSetPower(nodeSetE, k, true);
+                    return [
+                        {
+                            str: `$${tuple.toTex()}$`,
+                            isValid: false,
+                        },
+                    ];
+                }
+                else {
+                    return [];
+                }
+            })(),
+            //invalid: tuple with duplicate
+            (() => {
+                const tuple = randomTupleInDiscreteSetPower(nodeSetE, k, false, true);
+                return {
+                    str: `$${tuple.toTex()}$`,
+                    isValid: false,
+                };
+            })(),
+            //invalid: wrong cardinal
+            ...(() => {
+                if (k <= nodeSetE.elements.length) {
+                    return [];
+                }
+                else {
+                    const combination = randomCombinationFromDiscreteSet(nodeSetE, 1);
+                    return [
+                        {
+                            str: `$${combination.toTex()}$`,
+                            isValid: false,
+                        },
+                    ];
+                }
+            })(),
+            //invalid: "it's not possible" or contains duplicate
+            (() => {
+                if (k <= nodeSetE.elements.length) {
+                    return {
+                        str: "Ce n'est pas possible.",
+                        isValid: false,
+                    };
+                }
+                else {
+                    const combination = randomCombinationFromDiscreteSet(nodeSetE, nodeSetE.elements.length);
+                    return {
+                        str: `$${combination.toTex()}$`,
+                        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 proposeCombination = {
+    id: "proposeCombination",
+    connector: "=",
+    isSingleStep: true,
+    label: "Un ensemble $E$ étant donné, donner une combinaison de $k$ éléments de $E$",
+    generator: (nb) => getDistinctQuestions(getProposeCombinationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sets/index.d.ts

@@ -3,4 +3,7 @@ export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
 export * from "./subsetsOfKnownSets.js";
 export * from "./isNumberDecimal.js";
+export * from "./cartesianProduct/index.js";
+export * from "./partialPermutations/index.js";
+export * from "./combinations/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sets/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC"}

package/lib/exercises/math/sets/index.js

@@ -3,3 +3,6 @@ export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
 export * from "./subsetsOfKnownSets.js";
 export * from "./isNumberDecimal.js";
+export * from "./cartesianProduct/index.js";
+export * from "./partialPermutations/index.js";
+export * from "./combinations/index.js";

package/lib/exercises/math/sets/partialPermutations/findNumberOfPartialPermutationsFromSituation.d.ts

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

package/lib/exercises/math/sets/partialPermutations/findNumberOfPartialPermutationsFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findNumberOfPartialPermutationsFromSituation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/partialPermutations/findNumberOfPartialPermutationsFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAuD7C,KAAK,SAAS,GAAG;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,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;AAqEF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AAsJF,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CAAC,WAAW,CAmB5E,CAAC"}

package/lib/exercises/math/sets/partialPermutations/findNumberOfPartialPermutationsFromSituation.js

@@ -0,0 +1,186 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { random } from "../../../../utils/alea/random.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { facto } from "../../../../tree/nodes/functions/factorialNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { round } from "../../../../math/utils/round.js";
+import { binom } from "../../../../tree/nodes/operators/binomialCoefficientNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+const situationTemplates = [
+    {
+        strInstruction: `Un coffret contient $\${total}$ perles toutes distinctes. Syrine enfile l'une après l'autre $\${picked}$ perles. Combien d'enfilements sont ainsi réalisables ?`,
+        strCorrection: `Pour la première perle, Syrine a $\${total}$ choix possibles.
+Pour la deuxième perle, Syrine a $\${total-1}$ choix possibles.
+Pour la troisième perle, Syrine a $\${total-2}$ choix possibles, etc.
+Pour la dernière perle, Syrine a $\${total-(picked-1)}$ choix possibles.
+Le nombre d'enfilements distincts est donc :
+
+$$
+\${cardinal}
+$$
+
+`,
+        dictFuncs: {
+            total: () => {
+                return {
+                    value: randint(50, 101),
+                };
+            },
+            picked: () => {
+                return {
+                    value: randint(20, 30),
+                };
+            },
+        },
+    },
+];
+class SituationConstructor {
+    static randomSituationFromTemplate(situationTemplate) {
+        const dictSets = Object.entries(situationTemplate.dictFuncs).reduce((acc, [key, func]) => {
+            acc[key] = func();
+            return acc;
+        }, {});
+        const { strInstruction, strCorrection: strCorrectionIncomplete } = Object.entries(dictSets).reduce((acc, [key, miniDict]) => {
+            acc.strInstruction = acc.strInstruction.replace(`\${${key}}`, `${miniDict.value}`);
+            acc.strCorrection = acc.strCorrection.replace(`\${${key}}`, `${miniDict.value}`);
+            return acc;
+        }, {
+            strInstruction: situationTemplate.strInstruction,
+            strCorrection: situationTemplate.strCorrection,
+        });
+        const { total: { value: valueTotal }, picked: { value: valuePicked }, } = dictSets;
+        const nodeCardinal = frac(facto(valueTotal), facto(substract(valueTotal, valuePicked)));
+        const strCorrection = strCorrectionIncomplete
+            .replace(`\${cardinal}`, `${valueTotal} \\times ${round(valueTotal - 1, 0)} \\times ${round(valueTotal - 2, 0)} \\times ... \\times ${round(valueTotal - valuePicked + 1, 0)} = ${nodeCardinal.toTex()}`)
+            .replace(`\${total-1}`, `${round(valueTotal - 1, 0)}`)
+            .replace(`\${total-2}`, `${round(valueTotal - 2, 0)}`)
+            .replace(`\${total-(picked-1)}`, `${substract(valueTotal, valuePicked - 1).toTex()} = ${round(valueTotal - valuePicked + 1, 0)}`);
+        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).toTex();
+};
+const getHint = () => {
+    return `Ici, il faut tenir compte de l'ordre. 
+Tu as deux possibilités : 
+- soit tu appliques directement la formule du nombre d'arrangements
+- soit tu retrouves la formule en comptant le nombre de choix possibles pour la première perle, puis pour la seconde, etc.`;
+};
+const getCorrection = (identifiers) => {
+    const { situation: { strCorrection }, } = identifiers;
+    return `${strCorrection}
+  
+On utilise la formule car elle est équivalente et beaucoup moins longue à écrire.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { situation: { dictSets }, } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { total: { value: valueTotal }, picked: { value: valuePicked }, } = dictSets;
+    //student: picked!
+    {
+        const nodeWrong = facto(valuePicked);
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: binom(total, picked)
+    {
+        const nodeWrong = binom(valueTotal, valuePicked);
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: power(total, picked)
+    {
+        const nodeWrong = power(valueTotal, valuePicked);
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    const keyFacto = {
+        id: "custom",
+        label: "!",
+        labelType: "tex",
+        mathfieldInstructions: {
+            method: "write",
+            content: "!",
+        },
+    };
+    return [
+        // "facto",
+        keyFacto,
+    ];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer) ||
+            (() => {
+                if (isFractionNode(nodeAns)) {
+                    return (NodeComparator.isEqualViaFrac(nodeAns.leftChild, nodeAnswer.leftChild) ||
+                        NodeComparator.isEqualViaFrac(nodeAns.rightChild, nodeAnswer.rightChild));
+                }
+                else {
+                    return false;
+                }
+            })());
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getFindNumberOfPartialPermutationsFromSituationQuestion = () => {
+    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 findNumberOfPartialPermutationsFromSituation = {
+    id: "findNumberOfPartialPermutationsFromSituation",
+    connector: "=",
+    isSingleStep: true,
+    label: "Déterminer le nombre de $k$-uplets d'éléments distincts à partir d'une situation",
+    generator: (nb) => getDistinctQuestions(getFindNumberOfPartialPermutationsFromSituationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/sets/partialPermutations/findNumberOfPermutationsFromSituation.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 findNumberOfPermutationsFromSituation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findNumberOfPermutationsFromSituation.d.ts.map

package/lib/exercises/math/sets/partialPermutations/findNumberOfPermutationsFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findNumberOfPermutationsFromSituation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/partialPermutations/findNumberOfPermutationsFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AA4F7C,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;AA0DF,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,SAAS,CAAC;CACtB,CAAC;AA+JF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAkBvE,CAAC"}