math-exercises 3.0.199 → 3.0.200

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

@@ -0,0 +1,228 @@
+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 { 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: `Une boîte contient $\${total}$ perles toutes distinctes. Pour faire un bracelet, Jade commence par prendre en une seule fois une poignée de $\${picked}$ perles dans la boîte. Combien de poignées différentes existe-t-il ?`,
+        strHint: `Est-ce que l'ordre a de l'importance ici ? Comment appelle-t-on le sous-ensemble que Jade a prélevé ?`,
+        strCorrection: `Jade prend un ensemble de $\${picked}$ perles parmi $\${total}$.
+Elle prend un sous-ensemble de perles : C'est une combinaison.
+Le nombre de combinaisons possible est :
+
+$$
+\${cardinal}
+$$
+
+`,
+        dictFuncs: {
+            total: () => {
+                return {
+                    value: randint(50, 101),
+                };
+            },
+            picked: () => {
+                return {
+                    value: randint(12, 30),
+                };
+            },
+        },
+    },
+    {
+        strInstruction: `Marion pioche au hasard $\${picked}$ cartes dans un paquet d'un jeu de $\${total}$ cartes classique. Combien de mains différentes Marion peut-elle avoir ?`,
+        strHint: `Est-ce que l'ordre a de l'importance ici ? Comment appelle-t-on le sous-ensemble que Marion a pioché ?`,
+        strCorrection: `Marion prend un ensemble de $\${picked}$ cartes parmi $\${total}$.
+Elle prend un sous-ensemble de cartes : C'est une combinaison.
+Le nombre de combinaisons possible est :
+
+$$
+\${cardinal}
+$$
+
+`,
+        dictFuncs: {
+            total: () => {
+                return {
+                    value: random([32, 52]),
+                };
+            },
+            picked: () => {
+                return {
+                    value: randint(6, 10),
+                };
+            },
+        },
+    },
+    {
+        strInstruction: `Dans une course automobile, $\${total}$ équipages sont en lice. Les $\${picked}$ derniers n'iront pas en finale. Combien de groupes d'éliminés sont possibles ?`,
+        strHint: `Est-ce que l'ordre a de l'importance ici ? Comment appelle-t-on le sous-ensemble des éliminés ?`,
+        strCorrection: `Les éliminés sont un ensemble de $\${picked}$ participants parmi $\${total}$.
+Les éliminés sont un sous-ensemble de l'ensemble des participants : C'est une combinaison.
+Le nombre de combinaisons possible est :
+
+$$
+\${cardinal}
+$$
+
+`,
+        dictFuncs: {
+            total: () => {
+                return {
+                    value: random([16, 33]),
+                };
+            },
+            picked: () => {
+                return {
+                    value: randint(8, 11),
+                };
+            },
+        },
+    },
+];
+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 = binom(valueTotal, valuePicked);
+        const strCorrection = strCorrectionIncomplete.replace(`\${cardinal}`, `${nodeCardinal.toTex()} = ${nodeCardinal
+            .toFormulaWithFactoFractionNode()
+            .toTex()}`);
+        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: { strHint }, } = identifiers;
+    return `${strHint}`;
+};
+const getCorrection = (identifiers) => {
+    const { situation: { strCorrection }, } = identifiers;
+    return `${strCorrection}`;
+};
+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: frac(total!, picked!)
+    {
+        const nodeWrong = frac(facto(valueTotal), facto(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,
+        "binom",
+    ];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        if (isFractionNode(nodeAns)) {
+            //ans is probably formula with factorials
+            const nodeAnswerVer2 = nodeAnswer.toFormulaWithFactoFractionNode();
+            return NodeComparator.isEqualViaFrac(nodeAns, nodeAnswerVer2);
+        }
+        else {
+            //ans is probably formula with binom notation
+            return NodeComparator.isEqualViaSub(nodeAns, nodeAnswer);
+        }
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getFindNumberOfCombinationsFromSituationQuestion = () => {
+    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 findNumberOfCombinationsFromSituation = {
+    id: "findNumberOfCombinationsFromSituation",
+    connector: "=",
+    isSingleStep: true,
+    label: "Déterminer le nombre de combinaisons à partir d'une situation",
+    generator: (nb) => getDistinctQuestions(getFindNumberOfCombinationsFromSituationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"findNumberOfProductsOfCombinationsFromSituation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/combinations/findNumberOfProductsOfCombinationsFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAuM7C,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;AAuOF,eAAO,MAAM,+CAA+C,EAAE,QAAQ,CAAC,WAAW,CAmB/E,CAAC"}

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

@@ -0,0 +1,388 @@
+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 { 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";
+import { isMultiplyNode, multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const situationTemplates = [
+    {
+        strInstruction: `Jade a deux boîtes de perles toutes distinctes : une boîte avec $\${total1}$ perles bleues et une boîte avec $\${total2}$ perles rouges. 
+Pour faire un bracelet, Jade prend une poignée de $\${picked1}$ perles bleues et une poignée de $\${picked2}$ perles rouges. 
+Combien y a-t-il de prélèvements possibles ?`,
+        strHint: `Est-ce que l'ordre a de l'importance ici ? Comment appelle-t-on les sous-ensembles que Jade a prélevés ? 
+Fais un compte pour les perles bleues et un autre pour les perles rouges. 
+Enfin, trouve une opération pour utiliser les deux comptes qui soit cohérente 
+(pour raisonner, tu peux imaginer qu'elle n'a pris qu'une perle de chaque couleur).`,
+        strCorrection: `Jade prend un ensemble de $\${picked1}$ perles bleues parmi $\${total1}$.
+Elle prend un sous-ensemble de perles : C'est une combinaison.
+Le nombre de combinaisons possibles pour les perles bleues est :
+
+$$
+\${cardinal1}
+$$
+
+De même, lorsqu'elle prend un ensemble de $\${picked2}$ perles rouges parmi $\${total2}$.
+Le nombre de combinaisons possibles pour les perles rouges est :
+
+$$
+\${cardinal2}
+$$
+
+On peut représenter un prélèvement de perles avec un $2$-uplet $(\\text{prélèvement}_{\\text{bleues}};\\text{prélèvement}_{\\text{rouges}})$.
+
+Le prélèvement total de Jade est donc un élément du produit cartésien de l'ensemble des prélèvements de perles bleues avec l'ensemble des prélèvements de perles rouges.
+Le nombre de prélèvements possibles est donc : 
+
+$$
+\${cardinal}
+$$
+
+`,
+        dictFuncs: {
+            total1: () => {
+                return {
+                    value: randint(50, 101),
+                };
+            },
+            picked1: () => {
+                return {
+                    value: randint(22, 41),
+                };
+            },
+            total2: () => {
+                return {
+                    value: randint(26, 46),
+                };
+            },
+            picked2: () => {
+                return {
+                    value: randint(12, 21),
+                };
+            },
+        },
+    },
+    {
+        strInstruction: `Dans une classe de terminale il y a $\${total1}$ filles et $\${total2}$ garçons. 
+On consitue une équipe en choisissant $\${picked1}$ filles et $\${picked2}$ garçons. 
+Combien d'équipes distinctes peut-on ainsi constituer ?`,
+        strHint: `Est-ce que l'ordre a de l'importance ici ? Comment appelle-t-on les sous-équipes que l'on peut constituer ? 
+Fais un compte pour les filles et un autre pour les garçons. 
+Enfin, trouve une opération pour utiliser les deux comptes qui soit cohérente 
+(pour raisonner, tu peux imaginer qu'on n'a pris qu'une fille et un garçon).`,
+        strCorrection: `On prend un ensemble de $\${picked1}$ filles parmi $\${total1}$.
+On prend un sous-ensemble de filles : C'est une combinaison.
+Le nombre de combinaisons possibles pour les filles est :
+
+$$
+\${cardinal1}
+$$
+
+De même, lorsqu'on prend un ensemble de $\${picked2}$ garçons parmi $\${total2}$.
+Le nombre de combinaisons possibles pour les garçons est :
+
+$$
+\${cardinal2}
+$$
+
+On peut représenter une équipe de filles et de garçons avec un $2$-uplet $(\\text{sous-équipe}_{\\text{filles}};\\text{sous-équipe}_{\\text{garçons}})$.
+
+Une équipe de filles et de garçons est donc un élément du produit cartésien des équipes de filles avec les équipes de garçons.
+Le nombre d'équipes possibles est donc : 
+
+$$
+\${cardinal}
+$$
+
+`,
+        dictFuncs: {
+            total1: () => {
+                return {
+                    value: randint(10, 21),
+                };
+            },
+            total2: () => {
+                return {
+                    value: randint(10, 21),
+                };
+            },
+            picked1: () => {
+                return {
+                    value: randint(3, 7),
+                };
+            },
+            //picked2 is picked1
+        },
+    },
+    {
+        strInstruction: `Un fromager a une grande sélection de fromages tous distincts : $\${total1}$ fromages au lait de vache et $\${total2}$ fromages au lait de brebis. 
+Pour constituer un plateau de fromages, le fromager prend $\${picked1}$ fromages au lait de vache et $\${picked2}$ fromages au lait de brebis. 
+Combien y a-t-il de plateaux possibles ?`,
+        strHint: `Est-ce que l'ordre a de l'importance ici ? Comment appelle-t-on les sous-ensembles de chaque type de fromage ? 
+Fais un compte pour les fromages au lait de vache et un autre pour les fromages au lait de brebis. 
+Enfin, trouve une opération pour utiliser les deux comptes qui soit cohérente 
+(pour raisonner, tu peux imaginer qu'il n'a pris qu'un fromage de chaque type).`,
+        strCorrection: `Le fromager prend un ensemble de $\${picked1}$ fromages au lait de vache parmi $\${total1}$.
+Il prend un sous-ensemble de fromages : C'est une combinaison.
+Le nombre de combinaisons possibles pour les fromages au lait de vache est :
+
+$$
+\${cardinal1}
+$$
+
+De même, lorsqu'il prend un ensemble de $\${picked2}$ fromages au lait de brebis parmi $\${total2}$.
+Le nombre de combinaisons possibles pour les fromages au lait de brebis est :
+
+$$
+\${cardinal2}
+$$
+
+On peut représenter un plateau de fromages avec un $2$-uplet $(\\text{prélèvement}_{\\text{lait de vache}};\\text{prélèvement}_{\\text{lait de brebis}})$.
+
+Le plateau peut donc être représenté par un élément du produit cartésien de l'ensemble des prélèvements de fromages au lait de vache avec l'ensemble des prélèvements de fromages au lait de brebis.
+Le nombre de plateaux possibles est donc : 
+
+$$
+\${cardinal}
+$$
+
+`,
+        dictFuncs: {
+            total1: () => {
+                return {
+                    value: randint(50, 101),
+                };
+            },
+            picked1: () => {
+                return {
+                    value: randint(3, 7),
+                };
+            },
+            total2: () => {
+                return {
+                    value: randint(26, 46),
+                };
+            },
+            picked2: () => {
+                return {
+                    value: randint(3, 7),
+                };
+            },
+        },
+    },
+];
+class SituationConstructor {
+    static randomSituationFromTemplate(situationTemplate) {
+        const dictSets = Object.entries(situationTemplate.dictFuncs).reduce((acc, [key, func]) => {
+            acc[key] = func();
+            return acc;
+        }, {});
+        if (!dictSets["picked2"]) {
+            dictSets["picked2"] = dictSets["picked1"];
+        }
+        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 { total1: { value: valueTotal1 }, picked1: { value: valuePicked1 }, total2: { value: valueTotal2 }, picked2: { value: valuePicked2 }, } = dictSets;
+        const nodeCardinal1 = binom(valueTotal1, valuePicked1);
+        const nodeCardinal2 = binom(valueTotal2, valuePicked2);
+        const nodeCardinal = multiply(nodeCardinal1, nodeCardinal2);
+        const strCorrection = strCorrectionIncomplete
+            .replace(`\${cardinal}`, `${nodeCardinal.toTex()}`)
+            .replace(`\${cardinal1}`, `${nodeCardinal1.toTex()}`)
+            .replace(`\${cardinal2}`, `${nodeCardinal2.toTex()}`);
+        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: { strHint }, } = identifiers;
+    return `${strHint}`;
+};
+const getCorrection = (identifiers) => {
+    const { situation: { strCorrection }, } = identifiers;
+    return `${strCorrection}`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { situation: { dictSets }, } = identifiers;
+    const { total1: { value: valueTotal1 }, picked1: { value: valuePicked1 }, total2: { value: valueTotal2 }, picked2: { value: valuePicked2 }, } = dictSets;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    if (coinFlip()) {
+        //student: binom(total1, picked1) + binom(total2, picked2)
+        {
+            const nodeWrong = add(binom(valueTotal1, valuePicked1), binom(valueTotal2, valuePicked2));
+            tryToAddWrongProp(propositions, nodeWrong.toTex());
+        }
+    }
+    {
+        const [arrFuncOp1, arrFuncOp2, arrFuncOp3] = shuffle(random([
+            [
+                [multiply, add],
+                [add, multiply],
+                [add, multiply],
+            ],
+            [
+                [multiply, add],
+                [multiply, add],
+                [add, multiply],
+            ],
+            [
+                [multiply, add],
+                [multiply, add],
+                [multiply, add],
+            ],
+        ]));
+        //student: picked1! \\times picked2!
+        {
+            const [funcOpMain, funcOpAlt] = arrFuncOp1;
+            {
+                const nodeWrong = funcOpMain(facto(valuePicked1), facto(valuePicked2));
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+            }
+            if (coinFlip()) {
+                const nodeWrong = funcOpAlt(facto(valuePicked1), facto(valuePicked2));
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+            }
+        }
+        //student: frac(total1!, picked1!) \\times frac(total2!, picked2!)
+        {
+            const [funcOpMain, funcOpAlt] = arrFuncOp2;
+            {
+                const nodeWrong = funcOpMain(frac(facto(valueTotal1), facto(valuePicked1)), frac(facto(valueTotal2), facto(valuePicked2)));
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+            }
+            if (coinFlip()) {
+                const nodeWrong = funcOpAlt(frac(facto(valueTotal1), facto(valuePicked1)), frac(facto(valueTotal2), facto(valuePicked2)));
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+            }
+        }
+        //student: power(total1, picked1) \\times power(total2, picked2)
+        {
+            const [funcOpMain, funcOpAlt] = arrFuncOp3;
+            {
+                const nodeWrong = funcOpMain(power(valueTotal1, valuePicked1), power(valueTotal2, valuePicked2));
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+            }
+            if (coinFlip()) {
+                const nodeWrong = funcOpAlt(power(valueTotal1, valuePicked1), power(valueTotal2, valuePicked2));
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+            }
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    const keyFacto = {
+        id: "custom",
+        label: "!",
+        labelType: "tex",
+        mathfieldInstructions: {
+            method: "write",
+            content: "!",
+        },
+    };
+    return [
+        // "facto",
+        keyFacto,
+        "binom",
+    ];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        const isEqualViaSubOrViaFrac = (node1, node2) => NodeComparator.isEqualViaSub(node1, node2) ||
+            NodeComparator.isEqualViaFrac(node1, node2);
+        if (isMultiplyNode(nodeAns)) {
+            if (!isFractionNode(nodeAns.leftChild) &&
+                !isFractionNode(nodeAns.rightChild)) {
+                //multiply is commutative
+                return ((isEqualViaSubOrViaFrac(nodeAns.leftChild, nodeAnswer.leftChild) &&
+                    isEqualViaSubOrViaFrac(nodeAns.rightChild, nodeAnswer.rightChild)) ||
+                    (isEqualViaSubOrViaFrac(nodeAns.leftChild, nodeAnswer.rightChild) &&
+                        isEqualViaSubOrViaFrac(nodeAns.rightChild, nodeAnswer.leftChild)));
+            }
+            else {
+                //fallback
+                return NodeComparator.isEqualViaSub(nodeAns, nodeAnswer);
+            }
+        }
+        else if (isFractionNode(nodeAns)) {
+            //TODO
+            return NodeComparator.isEqualViaSub(nodeAns, nodeAnswer);
+        }
+        else {
+            return NodeComparator.isEqualViaSub(nodeAns, nodeAnswer);
+        }
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getFindNumberOfProductsOfCombinationsFromSituationQuestion = () => {
+    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 findNumberOfProductsOfCombinationsFromSituation = {
+    id: "findNumberOfProductsOfCombinationsFromSituation",
+    connector: "=",
+    isSingleStep: true,
+    label: "Déterminer le nombre de produits de combinaisons à partir d'une situation",
+    generator: (nb) => getDistinctQuestions(getFindNumberOfProductsOfCombinationsFromSituationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,4 @@
+export * from "./proposeCombination.js";
+export * from "./findNumberOfCombinationsFromSituation.js";
+export * from "./findNumberOfProductsOfCombinationsFromSituation.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/combinations/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,4CAA4C,CAAC;AAC3D,cAAc,sDAAsD,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./proposeCombination.js";
+export * from "./findNumberOfCombinationsFromSituation.js";
+export * from "./findNumberOfProductsOfCombinationsFromSituation.js";

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"proposeCombination.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/combinations/proposeCombination.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAwH7C,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;AAiSF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}