math-exercises 3.0.29 → 3.0.31

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

@@ -0,0 +1,111 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { equationKeys } from "../../../../exercises/utils/keys/equationKeys.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";
+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, b } = identifiers;
+    return `Il faut isoler $x$ à gauche. Pour cela, effectue l'opération des deux côtés de l'équation 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 = () => {
+    const b = randint(-10, 11);
+    const a = randint(-10, 11, [0]);
+    const identifiers = { a, b };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: equationKeys,
+        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}`);
+    while (propositions.length < 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);
+};
+export const equationType1Exercise = {
+    id: "equa1",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $x+a = b$",
+    levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Équations"],
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getEquationType1ExerciseQuestion, nb),
+    getPropositions,
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getCorrection,
+    getHint,
+    getInstruction,
+    getAnswer,
+    getStartStatement,
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,17 @@
+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[];
+};
+export declare const equationType2Exercise: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=equa2.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"equa2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equa2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAsBrC,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;AA0JF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAaF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuBhE,CAAC"}

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

@@ -0,0 +1,164 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, 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 rebuildIdentifiers = (oldIdentifiers) => {
+    if (!!oldIdentifiers.aNumberType)
+        return oldIdentifiers;
+    return {
+        a: oldIdentifiers.a.toTree().toIdentifiers(),
+        b: oldIdentifiers.b.toTree().toIdentifiers(),
+        isXRight: false,
+        aNumberType: "Entier",
+    };
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre : 
+  
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, isXRight, aNumberType } = 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, b, isXRight, aNumberType } = identifiers;
+    const aTree = reifyAlgebraic(a);
+    const bTree = reifyAlgebraic(b);
+    return `Il faut isoler $x$ à ${isXRight ? "droite" : "gauche"}. Pour cela, effectue l'opération des deux côtés de l'équation qui permet de supprimer la multiplication par $${aTree.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, isXRight, aNumberType } = 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, aNumberType } = 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 getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: equationKeys,
+        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());
+    while (propositions.length < 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"],
+    },
+];
+export const equationType2Exercise = {
+    id: "equa2",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $ax=b$",
+    levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Équations"],
+    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,
+    rebuildIdentifiers,
+    getQuestionFromIdentifiers,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"equa3.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equa3.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,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;AAuGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAsBvD,CAAC"}

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

@@ -0,0 +1,113 @@
+import { addValidProp, 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 = (identifiers) => {
+    return "Isolez le terme $x$ dans la partie gauche de l'équation.";
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const statementTex = getStatementNode(identifiers).toTex();
+    const answer = getAnswer(identifiers);
+    return `Commencer par soustraire $${b}$ des deux côtés de l'équation pour 
+    l'éliminer du côté gauche. Ensuite, diviser les deux côtés de l'équation par 
+    $${a}$ pour isoler $x$, ce qui donne : 
+    
+${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 = () => {
+    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);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: equationKeys,
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < 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, { answer, a, b, c }) => {
+    const solution = frac(c - b, a)
+        .simplify()
+        .toTex();
+    return equationVEA(ans, solution);
+};
+export const equationType3Exercise = {
+    id: "equa3",
+    connector: "\\iff",
+    label: "Résoudre une équation du type $ax+b=c$",
+    levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Équations"],
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getEquationType3ExerciseQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getAnswer,
+    getInstruction,
+    getCorrection,
+    getHint,
+    getStartStatement,
+    getQuestionFromIdentifiers,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"equa4.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equa4.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAkBrC;;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;AAkGF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAoBvD,CAAC"}

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

@@ -0,0 +1,106 @@
+import { addValidProp, 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, equationResolutionTex, } from "../../../../tree/nodes/equations/equalNode.js";
+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";
+const getStatementNode = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const affines = [new Affine(a, b), new Affine(c, d)];
+    const statementTree = new EqualNode(affines[0].toTree(), affines[1].toTree());
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    return `Résoudre : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const solution = new Rational(d - b, a - c).simplify();
+    const answerTree = new EqualNode(new VariableNode("x"), solution.toTree());
+    const answer = answerTree.toTex();
+    return answer;
+};
+const getEquationType4ExerciseQuestion = () => {
+    const a = randint(-10, 11, [0, 1]);
+    const b = randint(-10, 11, [0]);
+    const c = randint(-10, 11, [0, a]);
+    const d = randint(-10, 11, [0]);
+    const identifiers = {
+        a,
+        b,
+        c,
+        d,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: equationKeys,
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getHint = (identifiers) => {
+    return `Commence par regrouper les termes en $x$ d'un même côté de l'équation. Puis, isole $x$ en effectuant les bonnes opérations.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    return `On regroupe les nombres d'un côté, et les termes en $x$ de l'autre :
+  
+$$
+${equationResolutionTex(a.toTree(), b.toTree(), c.toTree(), d.toTree())}
+$$`;
+};
+const getPropositions = (n, { answer, a, b, c, d }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const wrongAnswer = new Rational(d - b + randint(-7, 8, [0, -d + b]), a - c + randint(-7, 8, [-a + c, 0])).simplify();
+        tryToAddWrongProp(propositions, new EqualNode(new VariableNode("x"), wrongAnswer.toTree()).toTex());
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { a, b, c, d }) => {
+    const solution = frac(d - b, a - c)
+        .simplify()
+        .toTex();
+    return equationVEA(ans, solution);
+};
+export const equationType4Exercise = {
+    id: "equa4",
+    connector: "\\iff",
+    label: "Résoudre une équation du type  $ax+b=cx+d$",
+    levels: ["4ème", "3ème", "2nde", "CAP", "2ndPro", "1rePro", "1reTech"],
+    sections: ["Équations"],
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getEquationType4ExerciseQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

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

@@ -1,8 +1,8 @@
 export * from "./equationSimpleSquare.js";
-export * from "./equationType1Exercise.js";
-export * from "./equationType2Exercise.js";
-export * from "./equationType3Exercise.js";
-export * from "./equationType4Exercise.js";
+export * from "./equa1.js";
+export * from "./equa2.js";
+export * from "./equa3.js";
+export * from "./equa4.js";
 export * from "./fractionEquation.js";
 export * from "./multiplicationEquation.js";
 export * from "./firstDegreeEquation.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,YAAY,CAAC;AAC3B,cAAc,uBAAuB,CAAC;AACtC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,kCAAkC,CAAC;AACjD,cAAc,mCAAmC,CAAC;AAClD,cAAc,2CAA2C,CAAC;AAC1D,cAAc,iCAAiC,CAAC;AAChD,cAAc,oCAAoC,CAAC"}

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

@@ -1,8 +1,8 @@
 export * from "./equationSimpleSquare.js";
-export * from "./equationType1Exercise.js";
-export * from "./equationType2Exercise.js";
-export * from "./equationType3Exercise.js";
-export * from "./equationType4Exercise.js";
+export * from "./equa1.js";
+export * from "./equa2.js";
+export * from "./equa3.js";
+export * from "./equa4.js";
 export * from "./fractionEquation.js";
 export * from "./multiplicationEquation.js";
 export * from "./firstDegreeEquation.js";

package/lib/exercises/math/calculLitteral/simplifying/reduceExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reduceExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/reduceExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IAOjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IAGnB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AA+MF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAgBlD,CAAC"}
+{"version":3,"file":"reduceExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/reduceExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IAOjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IAGnB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAqNF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAiBlD,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/reduceExpression.js

@@ -140,11 +140,14 @@ const getReduceExpression = () => {
         variable,
         order,
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         startStatement: getStartStatement(identifiers),
         answer: getAnswer(identifiers),
-        keys: [variable],
+        keys: [identifiers.variable],
         answerFormat: "tex",
         identifiers,
     };
@@ -204,4 +207,5 @@ export const reduceExpression = {
     rebuildIdentifiers,
     getAnswer,
     getInstruction,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/calculLitteral/simplifying/valuateExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"valuateExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/valuateExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AA2GF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAiBnD,CAAC"}
+{"version":3,"file":"valuateExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/valuateExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAgHF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}

package/lib/exercises/math/calculLitteral/simplifying/valuateExpression.js

@@ -71,6 +71,9 @@ const getValuateExpressionQuestion = (ops) => {
         b,
         monomFirst,
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -98,4 +101,5 @@ export const valuateExpression = {
     getAnswer,
     answerType: "QCU",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/dataRepresentations/functionGraphReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionGraphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/functionGraphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA4HF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC;;AAEF,UAAU;AACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGE"}
+{"version":3,"file":"functionGraphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/functionGraphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAgIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC;;AAEF,UAAU;AACV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAsGE"}

package/lib/exercises/math/dataRepresentations/functionGraphReading.js

@@ -109,6 +109,9 @@ const getFunctionGraphReadingQuestion = (opts) => {
         xValue = randPoint[0];
     }
     const identifiers = { a, b, yValue, isAskingX, xValue };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -137,6 +140,7 @@ export const functionGraphReading = {
     getAnswer,
     getGGBOptions,
     hasGeogebra: true,
+    getQuestionFromIdentifiers,
 };
 /***SVG */
 /**