math-exercises 3.0.156 → 3.0.158

package/lib/exercises/math/calculLitteral/equation/exp/expOfTrinomEquals1Equation.js

@@ -0,0 +1,292 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Rational } from "../../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { EqualNode } from "../../../../../tree/nodes/equations/equalNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { exp } from "../../../../../tree/nodes/functions/expNode.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { Polynomial } from "../../../../../math/polynomials/polynomial.js";
+import { Trinom } from "../../../../../math/polynomials/trinom.js";
+import { EquationSolutionNode } from "../../../../../tree/nodes/equations/equationSolutionNode.js";
+import { DiscreteSetNode } from "../../../../../tree/nodes/sets/discreteSetNode.js";
+import { SetVEA } from "../../../../../exercises/vea/setVEA.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { discreteSetParser } from "../../../../../tree/parsers/discreteSetParser.js";
+import { getCartesiansProducts } from "../../../../../utils/arrays/cartesianProducts.js";
+const texXDomain = `\\mathbb{R}`;
+const texNoSolution = (() => {
+    const trinom = new Trinom(1, 1, 1);
+    return trinom.getRootsEquationSolutionTex(true);
+})();
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getChildOfExpNode = (identifiers) => {
+    const { a, b, c } = identifiers;
+    return new Polynomial([c, b, a]).toTree();
+};
+const getStatementNode = (identifiers) => {
+    const nodeChildOfExp = getChildOfExpNode(identifiers);
+    const statementTree = new EqualNode(exp(nodeChildOfExp), (1).toTree());
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre dans $${texXDomain}$ : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const sortedSols = trinom.getRootsNode();
+    return new EquationSolutionNode(new DiscreteSetNode(sortedSols));
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const answer = trinom.getRootsEquationSolutionTex(opts.solutionFormat === "$x=\\ldots$");
+    return answer;
+};
+const getHint = () => {
+    return `Pour quelle valeur de $t$ a-t-on $e^t=1$ ? 
+  
+Quelle équation faut-il donc résoudre ?`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const nodeChildOfExp = getChildOfExpNode(identifiers);
+    return `L'équation est de la forme $e^{u(x)}=1$ avec $u(x)=${nodeChildOfExp.toTex()}$.
+
+La fonction exponentielle est strictement croissante de $\\mathbb{R}$ dans $\\mathbb{R}^{+*}$.
+
+Pour $t$ dans $\\mathbb{R}$, on a :
+
+$$
+e^t=1 \\Leftrightarrow t=0
+$$
+
+Ici, on a donc :
+
+$$
+e^{u(x)}=1 \\Leftrightarrow u(x)=0
+$$
+
+Conclusion :
+
+${alignTex([
+        ["", "", `e^{${nodeChildOfExp.toTex()}}=1`],
+        ["", `\\Leftrightarrow`, `${nodeChildOfExp.toTex()}=0`],
+        ["", `\\Leftrightarrow`, `${getAnswer(identifiers, opts)}`],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { a, b, c } = identifiers;
+    //random coeff signs
+    {
+        const arrIdentifiersWrong = getCartesiansProducts([...Array(3).keys()].map(() => [-1, 1]))
+            .filter((arrS) => !arrS.every((s) => s === 1))
+            .map(([sA, sB, sC]) => {
+            const identifiersWrong = {
+                a: sA * a,
+                b: sB * b,
+                c: sC * c,
+            };
+            return identifiersWrong;
+        });
+        arrIdentifiersWrong.forEach((identifiersWrong) => {
+            const texWrong = getAnswer(identifiersWrong, opts);
+            tryToAddWrongProp(propositions, texWrong);
+        });
+    }
+    //student makes as if exp was not there
+    {
+        const trinom = new Trinom(a, b, c - 1);
+        const texWrong = trinom.getRootsEquationSolutionTex(opts.solutionFormat === "$x=\\ldots$");
+        tryToAddWrongProp(propositions, texWrong);
+    }
+    //student divides both sides by e
+    // {
+    //   const trinom = new Trinom(a, b, c - frac(1, exp(1)));
+    //   const texWrong = trinom.getRootsEquationSolutionTex(
+    //     opts.solutionFormat === "$x=\\ldots$",
+    //   );
+    //   tryToAddWrongProp(propositions, texWrong);
+    // }
+    propWhile(propositions, n, () => {
+        const wrongAnswer = new Rational(-b + randint(-7, 8, [0, +b]), a + randint(-7, 8, [-a, 0])).simplify();
+        tryToAddWrongProp(propositions, new EqualNode(new VariableNode("x"), wrongAnswer.toTree()).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = (_, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const answerInputTypes = getAnswerInputTypes(opts);
+    return [
+        ...answerInputTypes.reduce((acc, answerInputType) => {
+            const specialSet = new Set((() => {
+                switch (answerInputType) {
+                    case "x=... ou x=...":
+                        return [
+                            ...["x", "equal", "ou"],
+                            ...[
+                                (() => {
+                                    return {
+                                        id: "custom",
+                                        label: texNoSolution,
+                                        labelType: "tex",
+                                        mathfieldInstructions: {
+                                            method: "write",
+                                            content: texNoSolution,
+                                        },
+                                    };
+                                })(),
+                            ],
+                        ];
+                    case "S={...;...}":
+                        return [
+                            "S",
+                            "equal",
+                            "lbrace",
+                            "semicolon",
+                            "rbrace",
+                            "varnothing",
+                        ];
+                    default:
+                        throw new Error("Unsupported answerInputType: " + answerInputType);
+                }
+            })());
+            return new Set([...acc, ...specialSet]);
+        }, new Set()),
+    ];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const answerInputTypes = getAnswerInputTypes(opts);
+    const answerNode = getAnswerNode(identifiers);
+    const arrNodeAnswer = answerNode.solutionsSet.elements;
+    function getParsedNodesForAnswerInputType(ans, answerInputType) {
+        switch (answerInputType) {
+            case "x=... ou x=...":
+                {
+                    const formated = ans
+                        .replaceAll("text{ ou }", ";")
+                        .replaceAll("x", "")
+                        .replaceAll("=", "");
+                    const elements = formated.split(";").map((e) => parseAlgebraic(e));
+                    return elements;
+                }
+                break;
+            case "S={...;...}":
+                {
+                    const discreteSetNodeCandidate = discreteSetParser(ans);
+                    if (discreteSetNodeCandidate) {
+                        return discreteSetNodeCandidate.elements;
+                    }
+                    else {
+                        return [];
+                    }
+                }
+                break;
+            default:
+                throw new Error("Unsupported answerInputType: " + answerInputType);
+        }
+    }
+    function isAnswerValidForAnswerInputType(answerInputType) {
+        try {
+            if (arrNodeAnswer.length === 0) {
+                switch (answerInputType) {
+                    case "x=... ou x=...":
+                        return ans === texNoSolution;
+                    case "S={...;...}":
+                        return ans === `S=\\varnothing`;
+                    default:
+                        throw new Error("Unsupported answerInputType: " + answerInputType);
+                }
+            }
+            else {
+                const arrAns = getParsedNodesForAnswerInputType(ans, answerInputType);
+                return SetVEA.isArrayOfNodesValid(arrAns, arrNodeAnswer);
+            }
+        }
+        catch (_) {
+            return false;
+        }
+    }
+    return answerInputTypes.some((answerInputType) => isAnswerValidForAnswerInputType(answerInputType));
+};
+const getExpOfTrinomEquals1EquationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const c = randint(-10, 11, [0]);
+    const b = randint(-10, 11, [0]);
+    const a = randint(-10, 11, [0, 1]);
+    const identifiers = { a, b, c };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getAnswerInputTypes = (opts) => {
+    const { solutionFormat } = opts;
+    switch (solutionFormat) {
+        case "$x=\\ldots$":
+            return ["x=... ou x=..."];
+        case "Ensemble":
+            return ["S={...;...}"];
+        case "Permettre les deux":
+            return ["x=... ou x=...", "S={...;...}"];
+        default:
+            throw new Error("Unsupported solutionFormat: " + solutionFormat);
+    }
+};
+const optsDefault = {
+    solutionFormat: "Permettre les deux",
+};
+const options = [
+    {
+        id: "solutionFormat",
+        label: "Donner la solution sous la forme :",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Ensemble", "$x=\\ldots$", "Permettre les deux"],
+        defaultValue: optsDefault.solutionFormat,
+    },
+];
+export const expOfTrinomEquals1Equation = {
+    id: "expOfTrinomEquals1Equation",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $e^{ax^2+bx+c}=1$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExpOfTrinomEquals1EquationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getAnswer,
+    getInstruction,
+    getCorrection,
+    getHint,
+    getStartStatement,
+    getQuestionFromIdentifiers,
+    options,
+};

package/lib/exercises/math/calculLitteral/equation/exp/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./expOfAffineEquals1Equation.js";
+export * from "./expOfTrinomEquals1Equation.js";
+export * from "./expOfFEqualsExpOfGEquation.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calculLitteral/equation/exp/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/exp/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC;AAChD,cAAc,iCAAiC,CAAC"}

package/lib/exercises/math/calculLitteral/equation/exp/index.js

@@ -0,0 +1,3 @@
+export * from "./expOfAffineEquals1Equation.js";
+export * from "./expOfTrinomEquals1Equation.js";
+export * from "./expOfFEqualsExpOfGEquation.js";

package/lib/exercises/math/calculLitteral/equation/factorizeEquation.d.ts

@@ -4,6 +4,9 @@ type Identifiers = {
     isSum: boolean;
     b: number;
 };
-export declare const factorizeEquation: Exercise<Identifiers>;
+type Options = {
+    answerInputTypes: string[];
+};
+export declare const factorizeEquation: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=factorizeEquation.d.ts.map

package/lib/exercises/math/calculLitteral/equation/factorizeEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factorizeEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/factorizeEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2JF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}
+{"version":3,"file":"factorizeEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/factorizeEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAyCrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+QF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAsBF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyB5D,CAAC"}

package/lib/exercises/math/calculLitteral/equation/factorizeEquation.js

@@ -1,5 +1,6 @@
-import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { SetVEA } from "../../../../exercises/vea/setVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
@@ -9,9 +10,30 @@ import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { square } from "../../../../tree/nodes/operators/powerNode.js";
 import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
 import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
-import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-const getPropositions = (n, { answer, ...identifiers }) => {
+const getTexForEquationSolutionNode = (nodeAnswer, opts) => {
+    const answerInputTypeDefault = "S={...;...}";
+    const answerInputType = opts.answerInputTypes.includes(answerInputTypeDefault)
+        ? answerInputTypeDefault
+        : opts.answerInputTypes[0];
+    switch (answerInputType) {
+        case "x=... ou x=...":
+            {
+                const arrNodeAnswer = nodeAnswer.solutionsSet.elements;
+                return arrNodeAnswer
+                    .map((node) => `x=${node.toTex()}`)
+                    .join("\\text{ ou }");
+            }
+            break;
+        case "S={...;...}":
+            return nodeAnswer.toTex();
+        default:
+            throw new Error("Unsupported answerInputType: " + answerInputType);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const { a, isSum, b } = identifiers;
     const propositions = [];
     addValidProp(propositions, answer);
@@ -19,19 +41,19 @@ const getPropositions = (n, { answer, ...identifiers }) => {
         new NumberNode(0),
         frac(multiply(isSum ? 1 : -1, b), a),
     ]);
-    tryToAddWrongProp(propositions, new EquationSolutionNode(solutions).simplify().toTex());
+    tryToAddWrongProp(propositions, getTexForEquationSolutionNode(new EquationSolutionNode(solutions).simplify(), opts));
     solutions = new DiscreteSetNode([new NumberNode(0)]);
     tryToAddWrongProp(propositions, new EquationSolutionNode(solutions).simplify().toTex());
     solutions = new DiscreteSetNode([frac(multiply(isSum ? 1 : -1, b), a)]);
-    tryToAddWrongProp(propositions, new EquationSolutionNode(solutions).simplify().toTex());
+    tryToAddWrongProp(propositions, getTexForEquationSolutionNode(new EquationSolutionNode(solutions).simplify(), opts));
     solutions = new DiscreteSetNode([frac(multiply(isSum ? -1 : 1, b), a)]);
-    tryToAddWrongProp(propositions, new EquationSolutionNode(solutions).simplify().toTex());
+    tryToAddWrongProp(propositions, getTexForEquationSolutionNode(new EquationSolutionNode(solutions).simplify(), opts));
     propWhile(propositions, n, () => {
         throw Error("QCM not implemented");
     });
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
+const getAnswerNode = (identifiers) => {
     const { a, b, isSum } = identifiers;
     // ax^2 + bx = x(ax + b) -> S = {0, -b/a}
     // ax^2 - bx = x(ax - b) -> S = {0, b/a}
@@ -39,8 +61,13 @@ const getAnswer = (identifiers) => {
         new NumberNode(0),
         frac(multiply(isSum ? -1 : 1, b), a),
     ]);
-    const answer = new EquationSolutionNode(solutions).simplify().toTex();
-    return answer;
+    const nodeAnswer = new EquationSolutionNode(solutions).simplify();
+    return nodeAnswer;
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const answerNode = getAnswerNode(identifiers);
+    return getTexForEquationSolutionNode(answerNode, opts);
 };
 const getInstruction = (identifiers) => {
     const { a, isSum, b } = identifiers;
@@ -49,7 +76,7 @@ const getInstruction = (identifiers) => {
     const eq = add(left, multiply(isSum ? 1 : -1, right));
     return `En factorisant $${eq
         .simplify({ forbidFactorize: true })
-        .toTex()}$, résoudre l'équation:
+        .toTex()}$, résoudre l'équation :
 $$
 ${left.toTex()} = ${multiply(isSum ? -1 : 1, right).toTex()}
 $$`;
@@ -67,7 +94,12 @@ ${left.toTex()} = ${multiply(isSum ? -1 : 1, right).toTex()} \\iff ${eq
         .toTex()} = 0
 $$`;
 };
-const getCorrection = (identifiers) => {
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const answerInputTypeDefault = "S={...;...}";
+    const answerInputType = opts.answerInputTypes.includes(answerInputTypeDefault)
+        ? answerInputTypeDefault
+        : opts.answerInputTypes[0];
     const { a, isSum, b } = identifiers;
     const left = multiply(a, square("x"));
     const right = multiply(b, "x");
@@ -82,55 +114,140 @@ $$
 x\\left(${factorizedInside}\\right) = 0
 $$
 
-Cette équation a deux solutions possibles: 
+Cette équation a deux solutions possibles : 
 
 - $x = 0$
-- ou $${factorizedInside} = 0 \\iff x = ${factorizedAnswer}$
 
-L'ensemble solution de l'équation est donc : 
+ou
+
+- $${factorizedInside} = 0 \\iff x = ${factorizedAnswer}$
+
+${(() => {
+        switch (answerInputType) {
+            case "x=... ou x=...":
+                return `Les solutions sont donc :`;
+            case "S={...;...}":
+                return `L'ensemble solution de l'équation est donc :`;
+            default:
+                throw new Error("Unsupported answerInputType: " + answerInputType);
+        }
+    })()}
 
 $$
-${getAnswer(identifiers)}
+${getAnswer(identifiers, opts)}
 $$`;
 };
-const getKeys = () => {
-    return ["S", "equal", "lbrace", "semicolon", "rbrace"];
+const getKeys = (_, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { answerInputTypes } = opts;
+    return [
+        ...answerInputTypes.reduce((acc, answerInputType) => {
+            const specialSet = new Set((() => {
+                switch (answerInputType) {
+                    case "x=... ou x=...":
+                        return ["x", "equal", "ou"];
+                    case "S={...;...}":
+                        return ["S", "equal", "lbrace", "semicolon", "rbrace"];
+                    default:
+                        throw new Error("Unsupported answerInputType: " + answerInputType);
+                }
+            })());
+            return new Set([...acc, ...specialSet]);
+        }, new Set()),
+    ];
 };
-const isAnswerValid = (ans, { answer }) => {
-    try {
-        const parsed = discreteSetParser(ans);
-        if (!parsed)
-            return false;
-        return "S=" + parsed.simplify().toTex() === answer;
+const isAnswerValid = (ans, { answer: _, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const answerNode = getAnswerNode(identifiers);
+    const arrNodeAnswer = answerNode.solutionsSet.elements;
+    function getParsedNodesForAnswerInputType(ans, answerInputType) {
+        switch (answerInputType) {
+            case "x=... ou x=...":
+                {
+                    const formated = ans
+                        .replaceAll("text{ ou }", ";")
+                        .replaceAll("x", "")
+                        .replaceAll("=", "");
+                    console.log("formated", formated);
+                    // if (formated === "\\varnothing") {
+                    //   return EmptySet;
+                    // }
+                    const elements = formated.split(";").map((e) => parseAlgebraic(e));
+                    return elements;
+                }
+                break;
+            case "S={...;...}":
+                {
+                    const discreteSetNodeCandidate = discreteSetParser(ans);
+                    if (discreteSetNodeCandidate) {
+                        return discreteSetNodeCandidate.elements;
+                    }
+                    else {
+                        return [];
+                    }
+                }
+                break;
+            default:
+                throw new Error("Unsupported answerInputType: " + answerInputType);
+        }
     }
-    catch (err) {
-        return handleVEAError(err);
+    function isAnswerValidForAnswerInputType(answerInputType) {
+        try {
+            const arrAns = getParsedNodesForAnswerInputType(ans, answerInputType);
+            return SetVEA.isArrayOfNodesValid(arrAns, arrNodeAnswer);
+        }
+        catch (_) {
+            return false;
+        }
     }
+    return opts.answerInputTypes.some((answerInputType) => isAnswerValidForAnswerInputType(answerInputType));
 };
-const getFactorizeEquationQuestion = () => {
+const getFactorizeEquationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
     const a = randint(1, 10);
     const b = randint(1, 10);
     const isSum = coinFlip();
     const identifiers = { a, isSum, b };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     return {
-        answer: getAnswer(identifiers),
+        answer: getAnswer(identifiers, opts),
         instruction: getInstruction(identifiers),
-        keys: getKeys(identifiers),
+        keys: getKeys(identifiers, opts),
         answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
     };
 };
+const optsDefault = {
+    answerInputTypes: ["x=... ou x=...", "S={...;...}"],
+};
+const options = [
+    {
+        id: "answerInputTypes",
+        label: "Format(s) de réponse",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["x=... ou x=...", "S={...;...}"],
+        defaultValue: optsDefault.answerInputTypes,
+    },
+];
 export const factorizeEquation = {
     id: "factorizeEquation",
     connector: "=",
     label: "Résoudre une équation se ramenant au premier degré",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getFactorizeEquationQuestion(opts), nb),
+    options,
+    validateOptions: (opts) => {
+        return {
+            valid: !!(opts?.answerInputTypes && opts?.answerInputTypes.length > 0),
+            message: "Veuillez choisir au moins un format de réponse.",
+        };
+    },
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,

package/lib/exercises/math/calculLitteral/equation/multiplicationEquation.d.ts

@@ -5,6 +5,9 @@ type Identifiers = {
     c: number;
     d: number;
 };
-export declare const multiplicationEquation: Exercise<Identifiers>;
+type Options = {
+    answerInputTypes: string[];
+};
+export declare const multiplicationEquation: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=multiplicationEquation.d.ts.map

package/lib/exercises/math/calculLitteral/equation/multiplicationEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAuCrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqMF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAsBF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAejE,CAAC"}