math-exercises 3.0.198 → 3.0.200

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

@@ -0,0 +1,232 @@
+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 } 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, square } 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: `Combien y a-t-il de manières différentes d'organiser une file d'attente de $\${total}$ personnes ?`,
+        strHint: `le nombre de manières en commençant par le nombre de choix possibles pour la première personne, puis pour la seconde, etc.`,
+        strCorrection: `Pour la première personne de la file, il y a $\${total}$ choix possibles.
+Pour la deuxième personne, il y a $\${total-1}$ choix possibles.
+Pour la troisième personne, il y  a $\${total-2}$ choix possibles, etc.
+Pour la dernière personne, toutes les autres étant déjà dans la file, il n'y a qu'un choix possible.
+Le nombre de manières différentes d'organiser une file d'attente de $\${total}$ personnes est donc :
+
+$$
+\${cardinal}
+$$
+
+`,
+        dictFuncs: {
+            total: () => {
+                return {
+                    value: randint(50, 101),
+                };
+            },
+        },
+    },
+    {
+        strInstruction: `On fait une pile avec un paquet d'un jeu de $\${total}$ cartes classique que l'on a mélangé. Combien y a-t-il d'organisations possibles de la pile ?`,
+        strHint: `le nombre de manières en commençant par le nombre de choix possibles pour la première carte, puis pour la seconde, etc.`,
+        strCorrection: `Pour la première carte de la pile, il y a $\${total}$ choix possibles.
+Pour la deuxième carte, il y a $\${total-1}$ choix possibles.
+Pour la troisième carte, il y  a $\${total-2}$ choix possibles, etc.
+Pour la dernière carte, toutes les autres étant déjà dans la pile, il n'y a qu'un choix possible.
+Le nombre de manières différentes d'organiser une pile avec un paquet d'un jeu de $\${total}$ classique est donc :
+
+$$
+\${cardinal}
+$$
+
+`,
+        dictFuncs: {
+            total: () => {
+                return {
+                    value: random([32, 52]),
+                };
+            },
+        },
+    },
+    {
+        strInstruction: `À la parade d'une fête de village, $\${total}$ chars défilent les uns après les autres. Combien y a-t-il de défilés possibles de la parade ?`,
+        strHint: `le nombre de manières en commençant par le nombre de choix possibles pour le premier char, puis pour le second, etc.`,
+        strCorrection: `Pour le premier char de la parade, il y a $\${total}$ choix possibles.
+Pour le deuxième char, il y a $\${total-1}$ choix possibles.
+Pour le troisième char, il y a $\${total-2}$ choix possibles, etc.
+Pour le dernière char, toutes les autres étant déjà passés, il n'y a qu'un choix possible.
+Le nombre de manières différentes d'organiser un défilé avec $\${total}$ chars est donc :
+
+$$
+\${cardinal}
+$$
+
+`,
+        dictFuncs: {
+            total: () => {
+                return {
+                    value: random([7, 13]),
+                };
+            },
+        },
+    },
+];
+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 }, } = dictSets;
+        const nodeCardinal = facto(valueTotal);
+        const strCorrection = strCorrectionIncomplete
+            .replace(`\${cardinal}`, `${valueTotal} \\times ${round(valueTotal - 1, 0)} \\times ${round(valueTotal - 2, 0)} \\times ... \\times 1 = ${nodeCardinal.toTex()}`)
+            .replace(`\${total}`, `${valueTotal}`)
+            .replace(`\${total-1}`, `${round(valueTotal - 1, 0)}`)
+            .replace(`\${total-2}`, `${round(valueTotal - 2, 0)}`)
+            .replace(`\${total-(picked-1)}`, `1`);
+        return {
+            nodeIdsCardinal: nodeCardinal.toIdentifiers(),
+            strInstruction,
+            strHint: situationTemplate.strHint,
+            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 = (identifiers) => {
+    const { situation: { dictSets, strHint }, } = identifiers;
+    const { total: { value: valueTotal }, } = dictSets;
+    return `Ici, il faut tenir compte de l'ordre. 
+Tu as trois possibilités : 
+- soit tu appliques directement la formule du nombre de permutations d'un ensemble à $${valueTotal}$ éléments
+- soit tu appliques la formule du nombre d'arrangements de $${valueTotal}$ éléments pris parmi $${valueTotal}$ éléments
+- soit tu comptes ${strHint}`;
+};
+const getCorrection = (identifiers) => {
+    const { situation: { strCorrection, dictSets }, } = identifiers;
+    const { total: { value: valueTotal }, } = dictSets;
+    return `${strCorrection}
+  
+On pouvait aussi utiliser la formule du nombre d'arrangements : 
+On arrange $${valueTotal}$ éléments pris parmi $${valueTotal}$ éléments. 
+En effet :
+
+$$
+${frac(facto(valueTotal), facto(substract(valueTotal, valueTotal))).toTex()} = ${frac(facto(valueTotal), facto(0)).toTex()} = ${frac(facto(valueTotal), 1).toTex()} = ${facto(valueTotal).toTex()}
+$$
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { situation: { dictSets }, } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { total: { value: valueTotal }, } = dictSets;
+    const valuePicked = valueTotal;
+    //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());
+    }
+    //student: square(total)
+    {
+        const nodeWrong = square(valueTotal);
+        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);
+    }
+    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 findNumberOfPermutationsFromSituation = {
+    id: "findNumberOfPermutationsFromSituation",
+    connector: "=",
+    isSingleStep: true,
+    label: "Déterminer le nombre de permutations d'un ensemble à 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/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./proposePartialPermutation.js";
+export * from "./findNumberOfPartialPermutationsFromSituation.js";
+export * from "./findNumberOfPermutationsFromSituation.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/partialPermutations/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC;AAC/C,cAAc,mDAAmD,CAAC;AAClE,cAAc,4CAA4C,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./proposePartialPermutation.js";
+export * from "./findNumberOfPartialPermutationsFromSituation.js";
+export * from "./findNumberOfPermutationsFromSituation.js";

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"proposePartialPermutation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/partialPermutations/proposePartialPermutation.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;AAqSF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAe3D,CAAC"}

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

@@ -0,0 +1,343 @@
+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 distincts 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 arrTuple = shuffle([...arrTupleWithoutDuplicate]);
+    return { arrTuple };
+};
+const getAnswer = (identifiers) => {
+    const { arrTuple } = getAnswerStuff(identifiers);
+    if (arrTuple.length === 0) {
+        return "\\text{Ce n'est pas possible.}";
+    }
+    else {
+        return arrTuple[0].toTex();
+    }
+};
+const getHint = (identifiers) => {
+    const { k } = identifiers;
+    return `Pour prendre un $${k}$-uplet d'éléments distincts de $E$, il faut effectuer $${k}$ tirages d'un élement de $E$, successifs et sans remise.
+Il faut donc s'assurer que l'ensemble $E$ contient suffisament d'éléments pour former un $${k}$-uplet d'éléments distincts.
+  
+Le $${k}$-uplet se notera (élement tirage $1$ ; élement tirage $2$ ; élement tirage $3$ ; ...).`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsSetE, k } = identifiers;
+    const nodeSetE = NodeConstructor.fromIdentifiers(nodeIdsSetE);
+    const arrTuple = getAnswerStuff(identifiers).arrTuple;
+    return `
+$$
+E = ${discreteSetNodeToTex(nodeSetE)}
+$$
+
+${(() => {
+        if (arrTuple.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 {
+            return `Voici quelques $${k}$-uplets d'éléments distincts 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,
+                },
+            };
+        }),
+        {
+            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 getProposePartialPermutationQuestion = () => {
+    const k = randint(3, 6);
+    const dict = randomDiscreteSetIdsAndDescription();
+    const nodeSetE = NodeConstructor.fromIdentifiers(dict.nodeIdsSetE);
+    const items = (() => {
+        const _nbValid = 1;
+        const items = [
+            //valid: tuple or "it's not possible"
+            (() => {
+                if (k <= nodeSetE.elements.length) {
+                    const tuple = randomTupleInDiscreteSetPower(nodeSetE, k, true);
+                    return {
+                        str: `$${tuple.toTex()}$`,
+                        isValid: true,
+                    };
+                }
+                else {
+                    return {
+                        str: "Ce n'est pas possible.",
+                        isValid: true,
+                    };
+                }
+            })(),
+            //invalid: contains duplicate
+            (() => {
+                const tuple = randomTupleInDiscreteSetPower(nodeSetE, k, false, true);
+                return {
+                    str: `$${discreteSetNodeToTex(new DiscreteSetNode(tuple.components))}$`,
+                    isValid: false,
+                };
+            })(),
+            //invalid: wrong notation
+            ...(() => {
+                if (k <= nodeSetE.elements.length) {
+                    const tuple = randomTupleInDiscreteSetPower(nodeSetE, k, true);
+                    return [
+                        {
+                            str: `$${discreteSetNodeToTex(new DiscreteSetNode(tuple.components))}$`,
+                            isValid: false,
+                        },
+                    ];
+                }
+                else {
+                    return [];
+                }
+            })(),
+            //invalid: in E^card(E)
+            ...(() => {
+                if (k <= nodeSetE.elements.length) {
+                    return [];
+                }
+                else {
+                    const tuple = randomTupleInDiscreteSetPower(nodeSetE, nodeSetE.elements.length, true);
+                    return [
+                        {
+                            str: `$${tuple.toTex()}$`,
+                            isValid: false,
+                        },
+                    ];
+                }
+            })(),
+            //invalid: "it's not possible" or contains duplicate
+            ...(() => {
+                if (k <= nodeSetE.elements.length) {
+                    const tuple = randomTupleInDiscreteSetPower(nodeSetE, k, false, true);
+                    return [
+                        {
+                            str: `$${discreteSetNodeToTex(new DiscreteSetNode(tuple.components))}$`,
+                            isValid: false,
+                        },
+                    ];
+                }
+                else {
+                    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 proposePartialPermutation = {
+    id: "proposePartialPermutation",
+    connector: "=",
+    isSingleStep: true,
+    label: "Un ensemble $E$ étant donné, donner un $k$-uplet d'éléments distincts de $E$",
+    generator: (nb) => getDistinctQuestions(getProposePartialPermutationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/spaceGeometry/vectors/spaceVectorLinearCombinationCoords.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spaceVectorLinearCombinationCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorLinearCombinationCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAiFF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAcpE,CAAC"}
+{"version":3,"file":"spaceVectorLinearCombinationCoords.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/vectors/spaceVectorLinearCombinationCoords.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAkFF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAcpE,CAAC"}

package/lib/exercises/math/trigonometry/functions/parityOfCosAXTimesSinBX.d.ts

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

package/lib/exercises/math/trigonometry/functions/parityOfCosAXTimesSinBX.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parityOfCosAXTimesSinBX.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/trigonometry/functions/parityOfCosAXTimesSinBX.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAqD7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAoKF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}