math-exercises 3.0.198 → 3.0.200

package/lib/exercises/math/calculLitteral/inequations/firstDegreeInequationsType3.js

@@ -7,6 +7,9 @@ import { Affine } from "../../../../math/polynomials/affine.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { InequationNode } from "../../../../tree/nodes/inequations/inequationNode.js";
 import { InequationSolutionNode } from "../../../../tree/nodes/inequations/inequationSolutionNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { inequationParser } from "../../../../tree/parsers/inequationParser.js";
 import { intervalParser } from "../../../../tree/parsers/intervalParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
@@ -41,37 +44,59 @@ const getAnswerNode = (identifiers, opts) => {
 const getAnswer = (identifiers, opts) => {
     return getAnswerNode(identifiers, opts).toTex();
 };
-// const getHint: GetHint<Identifiers, Options> = (identifiers, opts) => {
-//   return `Isole le terme $x$ dans le membre de gauche de l'inéquation. Attention : lorsqu'on multiplie (ou divise) les deux membres d'une inéquation par un nombre négatif, le sens de l'inéquation est inversé.`;
-// };
-// const getCorrection: GetHint<Identifiers, Options> = (identifiers, opts) => {
-//   const { a, b, c, d,ineqType } = identifiers;
-//   const isInterval =
-//     opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
-//   const answer = getAnswer(identifiers, opts);
-//   return `On isole $x$ dans le membre de gauche de l'inéquation :
-// $$
-// ${firstDegreeInequationResolutionTex(new Affine(a, b), ineqType, new Affine(c,d))}
-// $$
-// ${
-//   identifiers.a < 0
-//     ? `On a changé le sens de l'inéquation, car $${a}$ est négatif.`
-//     : ""
-// }
-// ${
-//   isInterval
-//     ? `On traduit ensuite cette inéquation en intervalle :
-// $$
-// ${answer}
-// $$
-// `
-//     : ""
-// }
-// `;
-// };
+const getHint = () => {
+    return `Commence par regrouper les termes en $x$ d'un même côté de l'inéquation. Puis isole $x$ en effectuant les bonnes opérations.
+  
+Attention, lorsqu'on divise ou multiplie les deux membres d'une inéquation par un nombre négatif, l'inéquation change de sens. `;
+};
+const getCorrection = (identifiers, opts) => {
+    const { a, b, c, d, ineqType } = identifiers;
+    const affine1 = new Affine(a, b);
+    const affine2 = new Affine(c, d);
+    const isInterval = opts?.inequationSolutionFormat === "Intervalle (S = [a;b])";
+    return `On doit résoudre l'inéquation : 
+  
+$$
+${affine1.toTex()} ${ineqType} ${affine2.toTex()}
+$$
+
+On ${c < 0 ? "ajoute" : "enlève"} $${multiply(Math.abs(c), "x").toTex()}$ des deux côtés :
+
+$$
+${add(multiply(substract(a, c).simplify(), "x"), b).toTex()} ${ineqType} ${d.frenchify()}
+$$
+
+On ${b < 0 ? "ajoute" : "enlève"} $${Math.abs(b).frenchify()}$ des deux côtés :
+
+$$
+${multiply(substract(a, c).simplify(), "x").toTex()} ${ineqType} ${substract(d, b)
+        .simplify()
+        .toTex()}
+$$
+
+On divise ensuite par $${substract(a, c)
+        .simplify()
+        .toTex()}$. Puisque $${substract(a, c).simplify().toTex()}$ est ${a > c ? "positif" : "négatif"}, l'inéquation ${a > c ? "ne change pas" : "change"} de sens :
+
+$$
+${getAnswer(identifiers, {
+        inequationSolutionFormat: "Inégalité (x>a)",
+    })}
+$$
+
+${isInterval
+        ? `On traduit cette inégalité par un intervalle : 
+  
+$$
+${getAnswer(identifiers, opts)}
+$$`
+        : ""}
+`;
+};
 const getFirstDegreeInequationsQuestion = (opts) => {
-    const affine1 = new Affine(randint(-10, 10, [0]), randint(-10, 10));
-    const affine2 = new Affine(randint(-10, 10, [0, affine1.a]), randint(-10, 10));
+    // ax+b < cx+d
+    const affine1 = new Affine(randint(-10, 10, [0, 1]), randint(-10, 10, [0]));
+    const affine2 = new Affine(randint(-10, 10, [0, affine1.a, 1, affine1.a - 1]), randint(-10, 10, [0]));
     const coeff = affine1.a - affine2.a;
     const ineqType = InequationSymbolConstructor.random();
     const identifiers = {
@@ -91,6 +116,8 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         keys: getKeys(identifiers, opts),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -157,6 +184,7 @@ export const firstDegreeInequationsType3 = {
     subject: "Mathématiques",
     options,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };
 // export const reuseFirstDegreeInequationsType3 = {
 //   getAnswerNode,

package/lib/exercises/math/combinatory/combination/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./writeCombinationFormulaUsingFactorial.js";
+export * from "./mentalCalculateCombination.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/combinatory/combination/index.d.ts.map

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

package/lib/exercises/math/combinatory/combination/index.js

@@ -0,0 +1,2 @@
+export * from "./writeCombinationFormulaUsingFactorial.js";
+export * from "./mentalCalculateCombination.js";

package/lib/exercises/math/combinatory/combination/mentalCalculateCombination.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    total: number;
+    picked: number;
+};
+type Options = {
+    statementFormulaType: string;
+};
+export declare const mentalCalculateCombination: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=mentalCalculateCombination.d.ts.map

package/lib/exercises/math/combinatory/combination/mentalCalculateCombination.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mentalCalculateCombination.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/combinatory/combination/mentalCalculateCombination.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA8OF,KAAK,OAAO,GAAG;IACb,oBAAoB,EAAE,MAAM,CAAC;CAC9B,CAAC;AAgBF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBrE,CAAC"}

package/lib/exercises/math/combinatory/combination/mentalCalculateCombination.js

@@ -0,0 +1,225 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { facto } from "../../../../tree/nodes/functions/factorialNode.js";
+import { binom } from "../../../../tree/nodes/operators/binomialCoefficientNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { statementFormulaType } = opts;
+    const { total, picked } = identifiers;
+    const texFormula = (() => {
+        switch (statementFormulaType) {
+            case "$\\binom{n}{k}$":
+                return binom(total, picked).toTex();
+            case "$\\frac{n!}{k!(n-k)!}$":
+                return binom(total, picked).toFormulaWithFactoFractionNode().toTex();
+            default:
+                throw new Error("Unsupported statementFormulaType:" + statementFormulaType);
+        }
+    })();
+    return `Sans calculatrice, et en utilisant des simplifications, calculer : 
+  
+$$
+${texFormula}
+$$`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { total, picked } = identifiers;
+    const nodeBinom = binom(total, picked);
+    const nodeFormulaRaw = nodeBinom.toFormulaWithFactoFractionNode();
+    const nodeAnswer = nodeBinom.toFormulaWithoutFacto();
+    return { nodeBinom, nodeFormulaRaw, nodeAnswer };
+};
+const getAnswer = (identifiers) => {
+    return getAnswerStuff(identifiers)
+        .nodeAnswer.simplify({
+        towardsDistribute: true,
+    })
+        .toTex();
+};
+const getHint = (identifiers) => {
+    const { total, picked } = identifiers;
+    const { nodeBinom, nodeFormulaRaw } = getAnswerStuff(identifiers);
+    return `Voici la formule pour $${picked}$ parmi $${total}$: 
+
+$$
+${nodeBinom.toTex()} = ${nodeFormulaRaw.toTex()}
+$$
+
+Voici les produits qui correspondent à chaque factorielle :
+
+${alignTex([facto(total), facto(picked), facto(total - picked)].flatMap((nodeFacto) => {
+        const texExpanded = nodeFacto
+            .toMultiplyNode()
+            .toTex({ forceNoSimplification: true, forceTimesSign: true });
+        const arrTexFactor = texExpanded.split("\\times");
+        const arrArrTexFactor = arrTexFactor.reduce((acc, texFactor, i, arr) => {
+            acc.running.push(texFactor);
+            if (acc.running.length >= 4 || i === arr.length - 1) {
+                acc.chunks.push(acc.running);
+                acc.running = [];
+            }
+            return acc;
+        }, {
+            chunks: [],
+            running: [],
+        }).chunks;
+        return arrArrTexFactor.map((arrTexFactor, i) => {
+            const texChunk = arrTexFactor.join(" \\times ");
+            if (i === 0) {
+                return [nodeFacto.toTex(), "= \\ \\ \\ ", texChunk];
+            }
+            else {
+                return [" ", "\\ \\ \\ \\times", texChunk];
+            }
+        });
+    }))}
+
+Remplace chaque factorielle par le produit qui lui correspond puis simplifie quand le même terme apparaît au numérateur et au dénominateur.
+`;
+};
+const getCorrection = (identifiers) => {
+    const { total, picked } = identifiers;
+    const { nodeBinom, nodeFormulaRaw, nodeAnswer } = getAnswerStuff(identifiers);
+    const nodeFracFacto = frac(facto(total), facto(picked));
+    const nodeNum = nodeAnswer.leftChild;
+    return `Voici la formule pour $${picked}$ parmi $${total}$: 
+
+$$
+${nodeBinom.toTex()} = ${nodeFormulaRaw.toTex()}
+$$
+
+Or : 
+
+$$
+${nodeFracFacto.toTex()} = ${nodeNum.toTex()}
+$$
+
+Donc: 
+
+${alignTex([
+        [
+            nodeFormulaRaw.toTex(),
+            "=",
+            nodeAnswer.toTex({ forceTimesSign: true, forceNoSimplification: true }),
+        ],
+        ["", "=", nodeAnswer.simplify({ towardsDistribute: true }).toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { total, picked } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    function checkAndTryToAddNode(node) {
+        const value = node.evaluate();
+        if (0.01 <= value && value <= 220) {
+            tryToAddWrongProp(propositions, node.simplify({ towardsDistribute: true }).toTex());
+        }
+    }
+    //student: total!/(total-picked)!
+    {
+        const node = frac(facto(total), facto(substract(total, picked)));
+        checkAndTryToAddNode(node);
+    }
+    //student: total!/picked!
+    {
+        const node = frac(facto(total), facto(picked));
+        checkAndTryToAddNode(node);
+    }
+    //student: picked!/total!
+    {
+        const node = frac(facto(total), facto(picked));
+        checkAndTryToAddNode(node);
+    }
+    //student: forgets factorial somewhere
+    {
+        {
+            const node = frac(facto(total), multiply(picked, facto(substract(total, picked))));
+            checkAndTryToAddNode(node);
+        }
+        {
+            const node = frac(facto(picked), multiply(total, facto(substract(total, picked))));
+            checkAndTryToAddNode(node);
+        }
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = () => {
+    const total = randint(5, 13);
+    const nbFactors = randint(2, 4);
+    const picked = coinFlip() ? nbFactors : total - nbFactors;
+    return {
+        total,
+        picked,
+    };
+};
+const getMentalCalculateCombinationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    statementFormulaType: "$\\binom{n}{k}$",
+};
+const options = [
+    {
+        id: "statementFormulaType",
+        label: "Type de formule dans l'énoncé",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["$\\binom{n}{k}$", "$\\frac{n!}{k!(n-k)!}$"],
+        defaultValue: optsDefault.statementFormulaType,
+    },
+];
+export const mentalCalculateCombination = {
+    id: "mentalCalculateCombination",
+    connector: "=",
+    label: "Calculer une combinaison sans calculatrice",
+    isSingleStep: true,
+    generator: (nb, opts) => [...Array(nb).keys()].map(() => getMentalCalculateCombinationQuestion(opts)),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: false,
+};

package/lib/exercises/math/combinatory/combination/writeCombinationFormulaUsingFactorial.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsTotal: NodeIdentifiers;
+    nodeIdsPicked: NodeIdentifiers;
+    operandType: string;
+};
+type Options = {
+    operandType: string;
+};
+export declare const writeCombinationFormulaUsingFactorial: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=writeCombinationFormulaUsingFactorial.d.ts.map

package/lib/exercises/math/combinatory/combination/writeCombinationFormulaUsingFactorial.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"writeCombinationFormulaUsingFactorial.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/combinatory/combination/writeCombinationFormulaUsingFactorial.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiB7C,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,eAAe,CAAC;IAC9B,aAAa,EAAE,eAAe,CAAC;IAC/B,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA2UF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsBF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAC1D,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/combinatory/combination/writeCombinationFormulaUsingFactorial.js

@@ -0,0 +1,285 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { facto } from "../../../../tree/nodes/functions/factorialNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { binom } from "../../../../tree/nodes/operators/binomialCoefficientNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { nodeIdsTotal, nodeIdsPicked } = identifiers;
+    const [nodeTotal, nodePicked] = [nodeIdsTotal, nodeIdsPicked].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Ecrire à l'aide de la factorielle la formule permettant de calculer : 
+  
+$$
+${binom(nodeTotal, nodePicked).toTex()}
+$$`;
+};
+const getAnswerStuff = (identifiers) => {
+    const { nodeIdsTotal, nodeIdsPicked } = identifiers;
+    const [nodeTotal, nodePicked] = [nodeIdsTotal, nodeIdsPicked].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeBinom = binom(nodeTotal, nodePicked);
+    const nodeAnswer = nodeBinom.toFormulaWithFactoFractionNode();
+    return { nodeBinom, nodeAnswer };
+};
+const getAnswer = (identifiers) => {
+    return getAnswerStuff(identifiers).nodeAnswer.toTex({
+        forceParenthesis: true,
+    });
+};
+const getHint = () => {
+    return `Le nombre de combinaisons de $k$ élements parmi $n$ (noté $${binom(new VariableNode("n"), new VariableNode("k")).toTex()}$) 
+est égal au nombre de façon de prendre $k$ éléments parmi $n$ sans tenir compte de l'ordre.
+
+Exemple: 
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIdsTotal, nodeIdsPicked, operandType } = identifiers;
+    const [nodeTotal, nodePicked] = [nodeIdsTotal, nodeIdsPicked].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeBinom = binom(nodeTotal, nodePicked);
+    const nodeAnswerRaw = nodeBinom.toFormulaWithFactoFractionNode(false);
+    const nodeAnswerPretty = nodeBinom.toFormulaWithFactoFractionNode(true);
+    switch (operandType) {
+        case "lettres":
+            return `
+
+$$
+${nodeBinom.toTex()} = ${nodeBinom.toTex()}
+$$
+
+`;
+        case "entiers":
+            return `
+
+${alignTex([
+                [nodeBinom.toTex(), "=", nodeAnswerRaw.toTex()],
+                ["", "=", nodeAnswerPretty.toTex()],
+            ])}
+
+`;
+        default:
+            throw new Error("Unsupported operandType: " + operandType);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { nodeIdsTotal, nodeIdsPicked, operandType } = identifiers;
+    const [nodeTotal, nodePicked] = [nodeIdsTotal, nodeIdsPicked].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //student: total<->picked
+    {
+        switch (operandType) {
+            case "lettres":
+                {
+                    const node = frac(facto(nodePicked), multiply(facto(nodeTotal), facto(substract(nodePicked, nodeTotal))));
+                    tryToAddWrongProp(propositions, node.toTex());
+                }
+                break;
+            case "entiers":
+                {
+                    const node = frac(facto(nodePicked), multiply(facto(nodeTotal), facto(substract(nodeTotal, nodePicked).simplify({
+                        towardsDistribute: true,
+                    }))));
+                    tryToAddWrongProp(propositions, node.toTex());
+                }
+                break;
+            default:
+                throw new Error("Unsupported operandType: " + operandType);
+        }
+    }
+    //student: total!/(total-picked)!
+    {
+        const node = frac(facto(nodeTotal), facto(substract(nodeTotal, nodePicked).simplify({ towardsDistribute: true })));
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    //student: total!/picked!
+    {
+        const node = frac(facto(nodeTotal), facto(nodePicked));
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    //student: picked!/total!
+    {
+        const node = frac(facto(nodePicked), facto(nodeTotal));
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    //student: forgets factorial somewhere
+    {
+        {
+            const node = frac(facto(nodeTotal), multiply(nodePicked, facto(substract(nodeTotal, nodePicked).simplify({
+                towardsDistribute: true,
+            }))));
+            tryToAddWrongProp(propositions, node.toTex());
+        }
+        switch (operandType) {
+            case "lettres":
+                {
+                    {
+                        const node = frac(facto(nodePicked), multiply(nodeTotal, facto(substract(nodePicked, nodeTotal))));
+                        tryToAddWrongProp(propositions, node.toTex());
+                    }
+                }
+                break;
+            case "entiers":
+                {
+                    const node = frac(facto(nodePicked), multiply(nodeTotal, facto(substract(nodeTotal, nodePicked).simplify({
+                        towardsDistribute: true,
+                    }))));
+                    tryToAddWrongProp(propositions, node.toTex());
+                }
+                break;
+            default:
+                throw new Error("Unsupported operandType: " + operandType);
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { operandType } = identifiers;
+    const keyFacto = {
+        id: "custom",
+        label: "!",
+        labelType: "tex",
+        mathfieldInstructions: {
+            method: "write",
+            content: "!",
+        },
+    };
+    switch (operandType) {
+        case "lettres": {
+            const { nodeIdsTotal, nodeIdsPicked } = identifiers;
+            const [nodeTotal, nodePicked] = [nodeIdsTotal, nodeIdsPicked].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+            return [
+                // "facto",
+                keyFacto,
+                ...[nodeTotal, nodePicked].map((node) => node.name),
+            ];
+        }
+        case "entiers":
+            // return ["facto"];
+            return [keyFacto];
+        default:
+            throw new Error("Unsupported operandType: " + operandType);
+    }
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { operandType } = identifiers;
+    switch (operandType) {
+        case "lettres": {
+            try {
+                //TODO: parse factorial
+                const nodeAnswer = getAnswerStuff(identifiers).nodeAnswer;
+                const isFormat1 = (str) => str === nodeAnswer.toTex();
+                const isFormat2 = (str) => str ===
+                    (() => {
+                        const nodeDenum = nodeAnswer.rightChild;
+                        const nodeAnswer2 = frac(nodeAnswer.leftChild, multiply(nodeDenum.rightChild, nodeDenum.leftChild));
+                        return nodeAnswer2;
+                    })().toTex();
+                return isFormat1(ans) || isFormat2(ans);
+            }
+            catch (err) {
+                return handleVEAError(err);
+            }
+        }
+        case "entiers": {
+            try {
+                //TODO: parse factorial
+                function countFactorialSymbols(str) {
+                    return str.split("").filter((str) => str === "!").length;
+                }
+                if (countFactorialSymbols(ans) !== countFactorialSymbols(answer)) {
+                    return false;
+                }
+                const nodeAns = parseAlgebraic(ans);
+                const nodeAnswer = parseAlgebraic(answer);
+                return NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer);
+            }
+            catch (err) {
+                return handleVEAError(err);
+            }
+        }
+        default:
+            throw new Error("Unsupported operandType: " + operandType);
+    }
+};
+const createRandomIdentifiers = (operandType) => {
+    switch (operandType) {
+        case "lettres": {
+            const poolLetters = "abcdklmnpqrst".split("");
+            const [nodeTotal, nodePicked] = randomMany(poolLetters, 2).map((letter) => new VariableNode(letter));
+            return {
+                nodeIdsTotal: nodeTotal.toIdentifiers(),
+                nodeIdsPicked: nodePicked.toIdentifiers(),
+                operandType,
+            };
+        }
+        case "entiers": {
+            const total = randint(30, 61);
+            const picked = randint(5, 21);
+            const [nodeTotal, nodePicked] = [total, picked].map((v) => v.toTree());
+            return {
+                nodeIdsTotal: nodeTotal.toIdentifiers(),
+                nodeIdsPicked: nodePicked.toIdentifiers(),
+                operandType,
+            };
+        }
+        default:
+            throw new Error("Unsupported operandType: " + operandType);
+    }
+};
+const getWriteCombinationFormulaUsingFactorialQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const operandType = random(arrayedOpts.operandType);
+    const identifiers = createRandomIdentifiers(operandType);
+    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;
+};
+const arrayedOptsDefault = {
+    operandType: ["entiers"],
+};
+const options = [
+    {
+        id: "operandType",
+        label: "Type d'opérandes",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["lettres", "entiers"],
+        defaultValue: arrayedOptsDefault.operandType,
+    },
+];
+export const writeCombinationFormulaUsingFactorial = {
+    id: "writeCombinationFormulaUsingFactorial",
+    connector: "=",
+    label: "Écrire à l'aide de factorielles la formule pour $\\binom{n}{k}$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getWriteCombinationFormulaUsingFactorialQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: false,
+};