math-exercises 3.0.150 → 3.0.152

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

@@ -1,6 +1,5 @@
-import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
-import { equationKeys } from "../../../../exercises/utils/keys/equationKeys.js";
 import { Rational } from "../../../../math/numbers/rationals/rational.js";
 import { Affine } from "../../../../math/polynomials/affine.js";
 import { randint } from "../../../../math/utils/random/randint.js";
@@ -9,6 +8,7 @@ import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { equationVEA } from "../../../../exercises/vea/equationVEA.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { equationKeys } from "../../../../exercises/utils/keys/equationKeys.js";
 const getStatementNode = (identifiers) => {
     const { a, b, c, d } = identifiers;
     const affines = [new Affine(a, b), new Affine(c, d)];
@@ -32,7 +32,7 @@ const getAnswer = (identifiers) => {
     const answer = answerTree.toTex();
     return answer;
 };
-const getEquationType4ExerciseQuestion = () => {
+const getEquationType4ExerciseQuestion = (opts) => {
     const a = randint(-10, 11, [0, 1]);
     const b = randint(-10, 11, [0]);
     const c = randint(-10, 11, [0, a]);
@@ -43,14 +43,23 @@ const getEquationType4ExerciseQuestion = () => {
         c,
         d,
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getKeys = (_identifiers, opts) => {
+    if (opts?.solutionFormat === "Ensemble") {
+        return ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"];
+    }
+    if (opts?.solutionFormat === "$x=\\ldots$") {
+        return ["x", "equal"];
+    }
+    return equationKeys;
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
         instruction: getInstruction(identifiers),
         startStatement: getStartStatement(identifiers),
         answer: getAnswer(identifiers),
-        keys: equationKeys,
+        keys: getKeys(identifiers, opts),
         answerFormat: "tex",
         identifiers,
         hint: getHint(identifiers),
@@ -84,12 +93,22 @@ const isAnswerValid = (ans, { a, b, c, d }) => {
         .toTex();
     return equationVEA(ans, solution);
 };
+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: "Permettre les deux",
+    },
+];
 export const equationType4Exercise = {
     id: "equa4",
     connector: "\\iff",
     label: "Résoudre une équation du type $ax+b=cx+d$",
     isSingleStep: false,
-    generator: (nb) => getDistinctQuestions(getEquationType4ExerciseQuestion, nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getEquationType4ExerciseQuestion(opts), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
@@ -101,4 +120,5 @@ export const equationType4Exercise = {
     getHint,
     getCorrection,
     hasHintAndCorrection: true,
+    options,
 };

package/lib/exercises/math/calculLitteral/equation/firstDegree/equa1.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+/**
+ *  type x+a=b
+ */
+type Identifiers = {
+    a: number;
+    b: number;
+};
+type Options = {
+    solutionFormat: string;
+};
+export declare const equationType1Exercise: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=equa1.d.ts.map

package/lib/exercises/math/calculLitteral/equation/firstDegree/equa1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equa1.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/firstDegree/equa1.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAYrC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqHF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAYF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBhE,CAAC"}

package/lib/exercises/math/calculLitteral/equation/firstDegree/equa1.js

@@ -0,0 +1,129 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine } from "../../../../../math/polynomials/affine.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { EqualNode } from "../../../../../tree/nodes/equations/equalNode.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { AddNode } from "../../../../../tree/nodes/operators/addNode.js";
+import { equationVEA } from "../../../../../exercises/vea/equationVEA.js";
+import { equationKeys } from "../../../../../exercises/utils/keys/equationKeys.js";
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(1, a).toTree();
+    const tree = new EqualNode(affine, new NumberNode(b));
+    const statementTree = tree.toTex();
+    return `Résoudre : 
+  
+$$
+${statementTree}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const solution = b - a;
+    const answer = `x=${solution}`;
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { a } = identifiers;
+    return `Il faut isoler $x$ à gauche. Pour cela, effectue des deux côtés de l'équation l'opération qui permet de supprimer le terme $${a < 0 ? "" : "+"}${a}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(1, a).toTree();
+    const tree = new EqualNode(affine, new NumberNode(b));
+    const statementTree = tree.toTex();
+    const answer = getAnswer(identifiers);
+    return `Pour isoler $x$ à gauche, on effectue l'opération $${a > 0 ? `-${a}` : `+${Math.abs(a)}`}$ des deux côtés de l'équation : 
+    
+${alignTex([
+        [
+            `${statementTree}`,
+            "\\iff",
+            new EqualNode(new AddNode(affine, new NumberNode(-a)), new AddNode(b.toTree(), new NumberNode(-a))).toTex(),
+        ],
+        ["", "\\iff", answer],
+    ])}`;
+};
+const getStartStatement = (identifiers) => {
+    const { a, b } = identifiers;
+    const affine = new Affine(1, a).toTree();
+    const tree = new EqualNode(affine, new NumberNode(b));
+    const statementTree = tree.toTex();
+    return statementTree;
+};
+const getEquationType1ExerciseQuestion = (opts) => {
+    const b = randint(-10, 11);
+    const a = randint(-10, 11, [0]);
+    const identifiers = { a, b };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getKeys = (_identifiers, opts) => {
+    if (opts?.solutionFormat === "Ensemble") {
+        return ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"];
+    }
+    if (opts?.solutionFormat === "$x=\\ldots$") {
+        return ["x", "equal"];
+    }
+    return equationKeys;
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const solution = b - a;
+    tryToAddWrongProp(propositions, `x=${b + a}`);
+    propWhile(propositions, n, () => {
+        const wrongAnswer = solution + randint(-3, 4, [0]);
+        tryToAddWrongProp(propositions, `x=${wrongAnswer}`);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { a, b }) => {
+    const solution = (b - a).toTree().toTex();
+    return equationVEA(ans, solution);
+};
+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: "Permettre les deux",
+    },
+];
+export const equationType1Exercise = {
+    id: "equa1",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $x+a = b$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getEquationType1ExerciseQuestion(opts), nb),
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getCorrection,
+    getHint,
+    getInstruction,
+    getAnswer,
+    getStartStatement,
+    getQuestionFromIdentifiers,
+    options,
+};

package/lib/exercises/math/calculLitteral/equation/firstDegree/equa2.d.ts

@@ -0,0 +1,18 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+/**
+ *  type ax=b
+ */
+type Identifiers = {
+    a: NodeIdentifiers;
+    b: NodeIdentifiers;
+    isXRight: boolean;
+    aNumberType: string;
+};
+type Options = {
+    aNumberType: string[];
+    solutionFormat: string;
+};
+export declare const equationType2Exercise: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=equa2.d.ts.map

package/lib/exercises/math/calculLitteral/equation/firstDegree/equa2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equa2.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/firstDegree/equa2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAEL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C;;GAEG;AAGH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,eAAe,CAAC;IACnB,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAuJF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAqBF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBhE,CAAC"}

package/lib/exercises/math/calculLitteral/equation/firstDegree/equa2.js

@@ -0,0 +1,167 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { equationKeys } from "../../../../../exercises/utils/keys/equationKeys.js";
+import { RationalConstructor } from "../../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { EqualNode, equal } from "../../../../../tree/nodes/equations/equalNode.js";
+import { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { GeneralAffine } from "../../../../../math/polynomials/generalAffine.js";
+import { NodeConstructor, reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { equationVEA } from "../../../../../exercises/vea/equationVEA.js";
+const getInstruction = (identifiers) => {
+    return `Résoudre : 
+  
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const aTree = reifyAlgebraic(a);
+    const bTree = reifyAlgebraic(b);
+    const solution = frac(bTree, aTree).simplify();
+    const answer = new EqualNode(new VariableNode("x"), solution).toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { a, isXRight } = identifiers;
+    const aTree = reifyAlgebraic(a);
+    return `Il faut isoler $x$ à ${isXRight ? "droite" : "gauche"}. Pour cela, effectue des deux côtés de l'équation l'opération qui permet de supprimer la multiplication par $${aTree.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, isXRight } = identifiers;
+    const aTree = reifyAlgebraic(a);
+    const bTree = reifyAlgebraic(b);
+    const affine = new GeneralAffine(aTree, 0).toTree();
+    const equalTree = new EqualNode(affine, bTree);
+    const tree = isXRight ? equalTree.reverse() : equalTree;
+    const answer = getAnswer(identifiers);
+    return `Pour isoler $x$ à ${isXRight ? "droite" : "gauche"}, on divise les deux côtés de l'équation par $${aTree.toTex()}$ : 
+    
+${alignTex([
+        [
+            `${tree.toTex()}`,
+            "\\iff",
+            isXRight
+                ? equal(frac(bTree, aTree), frac(affine, aTree)).toTex()
+                : equal(frac(affine, aTree), frac(bTree, aTree)).toTex(),
+        ],
+        ["", "\\iff", answer],
+    ])}
+    `;
+};
+const getStatementNode = (identifiers) => {
+    const { a, b, isXRight } = identifiers;
+    const aTree = reifyAlgebraic(a);
+    const bTree = reifyAlgebraic(b);
+    const affine = new GeneralAffine(aTree, 0).toTree();
+    const equalTree = new EqualNode(affine, bTree);
+    const tree = isXRight ? equalTree.reverse() : equalTree;
+    return tree;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getEquationType2ExerciseQuestion = (opts) => {
+    const types = opts?.aNumberType ?? ["Entier"];
+    const b = randint(-10, 11).toTree();
+    const type = random(types);
+    const a = type === "Entier"
+        ? randint(-9, 10, [0, 1]).toTree()
+        : RationalConstructor.randomIrreductibleWithSign().toTree();
+    const isXRight = coinFlip();
+    const identifiers = {
+        a: a.toIdentifiers(),
+        b: b.toIdentifiers(),
+        isXRight,
+        aNumberType: type,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getKeys = (_identifiers, opts) => {
+    if (opts?.solutionFormat === "Ensemble") {
+        return ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"];
+    }
+    if (opts?.solutionFormat === "$x=\\ldots$") {
+        return ["x", "equal"];
+    }
+    return equationKeys;
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b }) => {
+    const aNode = NodeConstructor.fromIdentifiers(a);
+    const bNode = NodeConstructor.fromIdentifiers(b);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, substract(bNode, aNode).simplify().toTex());
+    propWhile(propositions, n, () => {
+        const bEv = randint(-7, 8, [0, -bNode.evaluate()]);
+        const a = add(aNode, randint(-7, 8, [-aNode.evaluate(), 0]));
+        const wrongAnswer = frac(bEv, a).simplify();
+        tryToAddWrongProp(propositions, new EqualNode(new VariableNode("x"), wrongAnswer).toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { a, b }) => {
+    const aNode = NodeConstructor.fromIdentifiers(a);
+    const bNode = NodeConstructor.fromIdentifiers(b);
+    const solution = frac(bNode, aNode).simplify().toTex();
+    return equationVEA(ans, solution);
+};
+const options = [
+    {
+        id: "aNumberType",
+        label: "Type du coefficient $a$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: ["Entier"],
+        values: ["Entier", "Rationnel"],
+    },
+    {
+        id: "solutionFormat",
+        label: "Donner la solution sous la forme :",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["Ensemble", "$x=\\ldots$", "Permettre les deux"],
+        defaultValue: "Permettre les deux",
+    },
+];
+export const equationType2Exercise = {
+    id: "equa2",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $ax=b$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getEquationType2ExerciseQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    options,
+    getCorrection,
+    getHint,
+    getInstruction,
+    getAnswer,
+    getStartStatement,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/calculLitteral/equation/firstDegree/equa3.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+/**
+ *  type ax+b=c
+ */
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+};
+type Options = {
+    solutionFormat: string;
+};
+export declare const equationType3Exercise: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=equa3.d.ts.map

package/lib/exercises/math/calculLitteral/equation/firstDegree/equa3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equa3.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/firstDegree/equa3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAerC;;GAEG;AACH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmHF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAYF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAqBhE,CAAC"}

package/lib/exercises/math/calculLitteral/equation/firstDegree/equa3.js

@@ -0,0 +1,129 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { equationKeys } from "../../../../../exercises/utils/keys/equationKeys.js";
+import { Rational } from "../../../../../math/numbers/rationals/rational.js";
+import { Affine } from "../../../../../math/polynomials/affine.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 { shuffle } from "../../../../../utils/alea/shuffle.js";
+import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { MultiplyNode } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { equationVEA } from "../../../../../exercises/vea/equationVEA.js";
+const getStatementNode = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const affine = new Affine(a, b).toTree();
+    const statementTree = new EqualNode(affine, new NumberNode(c));
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre : 
+  
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getHint = () => {
+    return "Isole le terme $x$ dans le membre gauche de l'équation.";
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const statementTex = getStatementNode(identifiers).toTex();
+    const answer = getAnswer(identifiers);
+    return `On commence par soustraire $${b}$ des deux côtés de l'équation pour l'éliminer du côté gauche. Ensuite, on divise les deux côtés de l'équation par $${a}$ pour isoler $x$. 
+    
+${alignTex([
+        [
+            statementTex,
+            "\\iff",
+            new EqualNode(new MultiplyNode(a.toTree(), new VariableNode("x")), (c - b).toTree()).toTex(),
+        ],
+        ["", "\\iff", answer],
+    ])}`;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const solution = new Rational(c - b, a).simplify();
+    const answerTree = new EqualNode(new VariableNode("x"), solution.toTree());
+    const answer = answerTree.toTex();
+    return answer;
+};
+const getEquationType3ExerciseQuestion = (opts) => {
+    const b = randint(-10, 11, [0]);
+    const a = randint(-10, 11, [0, 1]);
+    const c = randint(-10, 11);
+    const identifiers = { a, b, c };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getKeys = (_identifiers, opts) => {
+    if (opts?.solutionFormat === "Ensemble") {
+        return ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"];
+    }
+    if (opts?.solutionFormat === "$x=\\ldots$") {
+        return ["x", "equal"];
+    }
+    return equationKeys;
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const wrongAnswer = new Rational(c - b + randint(-7, 8, [0, -c + b]), a + randint(-7, 8, [-a, 0])).simplify();
+        tryToAddWrongProp(propositions, new EqualNode(new VariableNode("x"), wrongAnswer.toTree()).toTex());
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const solution = frac(c - b, a)
+        .simplify()
+        .toTex();
+    return equationVEA(ans, solution);
+};
+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: "Permettre les deux",
+    },
+];
+export const equationType3Exercise = {
+    id: "equa3",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $ax+b=c$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getEquationType3ExerciseQuestion(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/firstDegree/equa4.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+/**
+ *  type ax+b=cx+d
+ */
+type Identifiers = {
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+};
+type Options = {
+    solutionFormat: string;
+};
+export declare const equationType4Exercise: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=equa4.d.ts.map

package/lib/exercises/math/calculLitteral/equation/firstDegree/equa4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"equa4.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/calculLitteral/equation/firstDegree/equa4.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAerC;;GAEG;AAEH,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;AAgHF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAaF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBhE,CAAC"}