math-exercises 3.0.56 → 3.0.58

package/lib/exercises/math/calcul/operations/operationsPriorities.d.ts

@@ -6,12 +6,14 @@
  * a/b ± c*d
  */
 import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
 type Identifiers = {
     type: number;
     a: number;
     b: number;
     c: number;
     d: number | undefined;
+    statementIds: NodeIdentifiers;
 };
 export declare const operationsPriorities: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/calcul/operations/operationsPriorities.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"operationsPriorities.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/operationsPriorities.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AAkJF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}
+{"version":3,"file":"operationsPriorities.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/operations/operationsPriorities.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAEtB,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA6JF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAYtD,CAAC"}

package/lib/exercises/math/calcul/operations/operationsPriorities.js

@@ -7,17 +7,49 @@
  */
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { DivideNode } from "../../../../tree/nodes/operators/divideNode.js";
 import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getStartStatement = (identifiers) => {
+    const { statementIds } = identifiers;
+    return reifyAlgebraic(statementIds).toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Calculer : 
+  
+$$
+${getStartStatement(identifiers)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { statementIds } = identifiers;
+    return reifyAlgebraic(statementIds).simplify().toTex();
+};
+const getHint = (identifiers) => {
+    return ``;
+};
+const getCorrection = (identifiers) => {
+    return ``;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
 const getPriorityQuestions = () => {
     const type = randint(1, 9);
-    let startStatement = "";
-    let answer = "";
     let a, b, c, d;
     let statement;
     switch (type) {
@@ -30,8 +62,6 @@ const getPriorityQuestions = () => {
                 : //a*b middle
                     new AddNode(new AddNode(new NumberNode(c), new MultiplyNode(new NumberNode(a), new NumberNode(b))), new NumberNode(d));
             statement = statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a * b + c + d).toString();
             break;
         case 2: // a/b ±c±d
             [b, c, d] = [1, 2, 3].map((el) => randint(-10, 11, [0]));
@@ -42,67 +72,50 @@ const getPriorityQuestions = () => {
                 : //a/b middle
                     new AddNode(new AddNode(new NumberNode(c), new DivideNode(new NumberNode(a), new NumberNode(b))), new NumberNode(d));
             statement = statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a / b + c + d).toString();
             break;
         case 3: // a*b ± c*d
             [a, b, c, d] = [1, 2, 3, 4].map((el) => randint(-10, 11));
             statement = new AddNode(new MultiplyNode(new NumberNode(a), new NumberNode(b)), new MultiplyNode(new NumberNode(c), new NumberNode(d)));
-            startStatement = statement.toTex();
-            answer = (a * b + c * d).toString();
             break;
         case 4: // a*b ± c/d
             [a, b] = [1, 2].map((el) => randint(-10, 11));
             d = randint(-10, 11, [0]);
             c = d * randint(0, 11);
             statement = new AddNode(new MultiplyNode(new NumberNode(a), new NumberNode(b)), new DivideNode(new NumberNode(c), new NumberNode(d)));
-            statement = statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a * b + c / d).toString();
             break;
         case 5: // a/b ± c/d
             [b, d] = [1, 2].map((el) => randint(-10, 11, [0]));
             a = b * randint(0, 11);
             c = d * randint(0, 11);
             statement = new AddNode(new DivideNode(new NumberNode(a), new NumberNode(b)), new DivideNode(new NumberNode(c), new NumberNode(d)));
-            startStatement = statement.toTex();
-            answer = (a / b + c / d).toString();
             break;
         case 6: // a*b*c ± d
             [a, b, c, d] = [1, 2, 3, 4].map((el) => randint(-10, 11, [0]));
             statement = new AddNode(new MultiplyNode(new MultiplyNode(new NumberNode(a), new NumberNode(b)), new NumberNode(c)), new NumberNode(d));
-            statement = statement.shuffle();
-            startStatement = statement.toTex();
-            answer = (a * b * c + d).toString();
             break;
         case 7: //a/b*c et c*a/b
             b = randint(2, 10);
             a = b * randint(2, 10);
             c = randint(2, 10);
             statement = new MultiplyNode(new DivideNode(a.toTree(), b.toTree()), c.toTree()).shuffle();
-            answer = ((a / b) * c).frenchify();
-            startStatement = statement.toTex();
             break;
         case 8: //a+-b+-c
+        default:
             a = randint(-15, 15);
             b = randint(-10, 10);
             c = b > 0 ? randint(-10, 0) : randint(-10, 10);
             statement = new AddNode(new AddNode(a.toTree(), b.toTree()), c.toTree());
-            answer = (a + b + c).frenchify();
-            startStatement = statement.toTex();
             break;
-        default:
-            throw Error("impossible");
     }
-    const question = {
-        instruction: `Calculer : $${startStatement}$`,
-        startStatement,
-        answer,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: { type, a, b, c, d },
+    const identifiers = {
+        type,
+        a,
+        b,
+        c,
+        d,
+        statementIds: statement.toIdentifiers(),
     };
-    return question;
+    return getQuestionFromIdentifiers(identifiers);
 };
 const getPropositions = (n, { answer }) => {
     const propositions = [];
@@ -112,17 +125,13 @@ const getPropositions = (n, { answer }) => {
     }
     return shuffle(propositions);
 };
-const isAnswerValid = (studentAns, { answer }) => {
-    const answerTree = new NumberNode(Number(answer));
-    const texs = answerTree.toAllValidTexs();
-    return texs.includes(studentAns);
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
 };
 export const operationsPriorities = {
     id: "operationsPriorities",
     connector: "=",
     label: "Priorités opératoires",
-    levels: ["5ème", "4ème"],
-    sections: ["Calculs"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(getPriorityQuestions, nb),
     qcmTimer: 60,
@@ -130,4 +139,5 @@ export const operationsPriorities = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
 };

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

@@ -1 +1 @@
-{"version":3,"file":"choseOperationToSolveEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/choseOperationToSolveEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAuJF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}
+{"version":3,"file":"choseOperationToSolveEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/choseOperationToSolveEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA6MF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}

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

@@ -77,17 +77,6 @@ $$
 il faut d'abord effectuer :
 `;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//     return ``
-// };
-const getKeys = (identifiers) => {
-    return [];
-};
-const isAnswerValid = (ans, { answer }) => {
-    throw Error("VEA not implemented");
-};
 const getChoseOperationToSolveEquationQuestion = (opts) => {
     //ax=b avec a entier, ax+b = c tout entier, x/a = b tout entier, x+-a = b entiers ,
     let a;
@@ -132,13 +121,76 @@ const getChoseOperationToSolveEquationQuestion = (opts) => {
     const identifiers = { type, a, b, c };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    const { type } = identifiers;
+    switch (type) {
+        case 1:
+            //ax = b tous entiers
+            return `L'écriture $ax$ signifie $a$ multiplié par $x$. 
+      
+Quelle opération permet d'annuler une multiplication ?`;
+        case 2:
+            // ax + b = c tous entiers
+            return `Quelle opération permet d'annuler une addition ?`;
+        case 3:
+            //ax-b = c tous entiers
+            return `Quelle opération permet d'annuler une soustraction ?`;
+        case 4:
+            //x/a = b tous entiers
+            return `Quelle opération permet d'annuler une division ?`;
+        case 5:
+            //x+a = b
+            return `Quelle opération permet d'annuler une addition ?`;
+        case 6:
+        default:
+            //x-a = b
+            return `Quelle opération permet d'annuler une soustraction ?`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { type, a, b, c } = identifiers;
+    switch (type) {
+        case 1:
+            //ax = b tous entiers
+            return `$${multiply(a, "x").toTex()}$ est une multiplication de $${a}$ par $x$. 
+      
+Pour isoler $x$, il faut donc diviser par $${a}$.`;
+        case 2:
+            // ax + b = c tous entiers
+            return `Pour isoler $x$, on commence par passer $${b}$ à droite de l'équation. 
+      
+Pour cela, il faut soustraire par $${b}$.`;
+        case 3:
+            //ax-b = c tous entiers
+            return `Pour isoler $x$, on commence par passer $${-b}$ à droite de l'équation. 
+      
+Pour cela, il faut additionner par $${b}$.`;
+        case 4:
+            //x/a = b tous entiers
+            return `Pour isoler $x$, on doit "annuler" la division par $${a}$. 
+
+Pour cela, on multiplie par $${a}$.`;
+        case 5:
+            //x+a = b
+            return `Pour isoler $x$, il faut faire passer $${a}$ à droite de l'équation. 
+      
+Pour cela, il faut soustraire par $${a}$.`;
+        case 6:
+        default:
+            //x-a = b
+            return `Pour isoler $x$, il faut faire passer $${-a}$ à droite de l'équation. 
+      
+Pour cela, il faut additionner par $${a}$.`;
+    }
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
-        keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -151,10 +203,10 @@ export const choseOperationToSolveEquation = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     getInstruction,
     getAnswer,
     answerType: "QCU",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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,EAcT,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;AA8HF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}
+{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,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;AA8HF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

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

@@ -123,8 +123,5 @@ export const multiplicationEquation = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
-    getInstruction,
-    getAnswer,
-    getCorrection,
-    getHint,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/calculLitteral/factorisation/facto1.d.ts

@@ -0,0 +1,16 @@
+/**
+ *  type (ax+b)(cx+d) ± (ax+b)(ex+f)
+ */
+import { Exercise } from "../../../../exercises/exercise.js";
+/**
+ * facto du type (ax+b)(cx+d) ± (ax+b)(ex+f)
+ * b, d, f non nuls
+ */
+type Identifiers = {
+    affinesCoeffs: number[][];
+    operation: string;
+    affinesOrder: number[];
+};
+export declare const factoType1Exercise: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=facto1.d.ts.map

package/lib/exercises/math/calculLitteral/factorisation/facto1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facto1.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/facto1.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAwBrC;;;GAGG;AACH,KAAK,WAAW,GAAG;IAEjB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAIlB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA4NF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/facto1.js

@@ -0,0 +1,184 @@
+/**
+ *  type (ax+b)(cx+d) ± (ax+b)(ex+f)
+ */
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { MultiplyNode, isMultiplyNode, multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { isPowerNode, isSquareNode, } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract, } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getStatementNode = (identifiers) => {
+    const { affinesCoeffs, operation, affinesOrder } = identifiers;
+    const affines = affinesCoeffs.map((coeffs) => new Affine(coeffs[1], coeffs[0]));
+    const order = [[], []];
+    order[0][affinesOrder[0]] = affines[1];
+    order[1][affinesOrder[1]] = affines[2];
+    order[0][1 - affinesOrder[0]] = affines[0];
+    order[1][1 - affinesOrder[1]] = affines[0];
+    const statementTree = (operation === "add" ? add : substract)(new MultiplyNode(order[0][0].toTree(), order[0][1].toTree()), new MultiplyNode(order[1][0].toTree(), order[1][1].toTree()));
+    return statementTree;
+};
+const getInstruction = (identifiers) => {
+    const { affinesCoeffs, operation } = identifiers;
+    return `Factoriser et réduire : 
+
+$$
+${getStatementNode(identifiers).toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { affinesCoeffs, operation } = identifiers;
+    const factor = new Affine(affinesCoeffs[0][1], affinesCoeffs[0][0]);
+    const affine2 = new Affine(affinesCoeffs[2][1], affinesCoeffs[2][0]);
+    const affine1 = new Affine(affinesCoeffs[1][1], affinesCoeffs[1][0]);
+    const secondTerm = (operation === "add"
+        ? add(affine1.toTree(), affine2.toTree())
+        : substract(affine1.toTree(), affine2.toTree())).simplify({ forbidFactorize: true, towardsDistribute: true });
+    const sol = multiply(factor.toTree(), secondTerm).simplify({});
+    return sol;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getFactoType1Question = () => {
+    const a = randint(-9, 10, [0]);
+    const b = randint(-9, 10, [0]);
+    let operation = random(["add", "substract"]);
+    let c, d;
+    let e, f;
+    do {
+        c = randint(-9, 10, [0]);
+        d = randint(-9, 10, [0]);
+        e = randint(-9, 10, [0]);
+        f = randint(-9, 10, [0]);
+    } while (c / a === d / b ||
+        e / a === f / b ||
+        //éviter un multiple +-1
+        (operation === "add" && f === -d && Math.abs(e + c) === 1) ||
+        (operation === "substract" && f === d && Math.abs(e - c) === 1));
+    const identifiers = {
+        affinesCoeffs: [
+            [a, b],
+            [c, d],
+            [e, f],
+        ],
+        operation,
+        affinesOrder: [random([0, 1]), random([0, 1])],
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStatementNode(identifiers).toTex(),
+        answer: getAnswer(identifiers),
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getHint = (identifiers) => {
+    return `On repère le facteur commun dans les deux termes de l'expression. 
+  
+On utilise ensuite la propriété : 
+
+$$
+k\\times a + k \\times b = k\\times (a+b)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { affinesCoeffs, operation, affinesOrder } = identifiers;
+    const affines = affinesCoeffs.map((coeffs) => new Affine(coeffs[1], coeffs[0]));
+    const order = [[], []];
+    order[0][affinesOrder[0]] = affines[1];
+    order[1][affinesOrder[1]] = affines[2];
+    order[0][1 - affinesOrder[0]] = affines[0];
+    order[1][1 - affinesOrder[1]] = affines[0];
+    const statementTree = (operation === "add" ? add : substract)(new MultiplyNode(order[0][0].toTree(), order[0][1].toTree()), new MultiplyNode(order[1][0].toTree(), order[1][1].toTree()));
+    return `On repère que le facteur commun dans les deux termes est : 
+  
+$$
+${affines[0].toTree().toTex()}
+$$
+
+On a donc : 
+
+${alignTex([
+        ["", statementTree.toTex()],
+        [
+            "=",
+            multiply(affines[0].toTree(), (operation === "add" ? add : substract)(affines[1].toTree(), affines[2].toTree())).toTex(),
+        ],
+        ["=", getAnswer(identifiers)],
+    ])}`;
+};
+const getPropositions = (n, { answer, affinesCoeffs, operation }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const affines = affinesCoeffs.map((coeffs) => new Affine(coeffs[1], coeffs[0]));
+    tryToAddWrongProp(propositions, new MultiplyNode(affines[0].toTree(), affines[1]
+        .add(operation !== "add" ? affines[2] : affines[2].opposite())
+        .toTree()).toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode(affines[1].toTree(), affines[0]
+        .add(operation === "add" ? affines[2] : affines[2].opposite())
+        .toTree()).toTex());
+    tryToAddWrongProp(propositions, new MultiplyNode(affines[2].toTree(), affines[0]
+        .add(operation === "add" ? affines[2] : affines[2].opposite())
+        .toTree()).toTex());
+    while (propositions.length < n) {
+        const wrongAnswer = new MultiplyNode(affines[0].toTree(), affines[1].add(AffineConstructor.differentRandoms(1)[0]).toTree());
+        tryToAddWrongProp(propositions, wrongAnswer.toTex());
+    }
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        if (answer !== "0" &&
+            !isMultiplyNode(parsed) &&
+            !isSquareNode(parsed) &&
+            !isPowerNode(parsed))
+            return false;
+        const simp = parsed.simplify({
+            forbidFactorize: true,
+            towardsDistribute: true,
+        });
+        const answerSimp = getAnswerNode(identifiers).simplify({
+            towardsDistribute: true,
+            forbidFactorize: true,
+        });
+        // const simp = parsed.simplify({});
+        return simp.toTex() === answerSimp.toTex();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+export const factoType1Exercise = {
+    id: "facto1",
+    connector: "=",
+    isSingleStep: false,
+    label: "Factorisation du type $(ax+b)(cx+d) \\pm (ax+b)(ex+f)$",
+    generator: (nb) => getDistinctQuestions(getFactoType1Question, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/factorisation/factoType1Exercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factoType1Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType1Exercise.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAuBrC;;;GAGG;AACH,KAAK,WAAW,GAAG;IAEjB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAIlB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAoKF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}
+{"version":3,"file":"factoType1Exercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoType1Exercise.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAwBrC;;;GAGG;AACH,KAAK,WAAW,GAAG;IAEjB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,SAAS,EAAE,MAAM,CAAC;IAIlB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA4NF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAepD,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/factoType1Exercise.js

@@ -13,6 +13,7 @@ import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
 const getStatementNode = (identifiers) => {
     const { affinesCoeffs, operation, affinesOrder } = identifiers;
     const affines = affinesCoeffs.map((coeffs) => new Affine(coeffs[1], coeffs[0]));
@@ -71,6 +72,9 @@ const getFactoType1Question = () => {
         operation,
         affinesOrder: [random([0, 1]), random([0, 1])],
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
         startStatement: getStatementNode(identifiers).toTex(),
@@ -78,9 +82,46 @@ const getFactoType1Question = () => {
         keys: ["x"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getHint = (identifiers) => {
+    return `On repère le facteur commun dans les deux termes de l'expression. 
+  
+On utilise ensuite la propriété : 
+
+$$
+k\\times a + k \\times b = k\\times (a+b)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { affinesCoeffs, operation, affinesOrder } = identifiers;
+    const affines = affinesCoeffs.map((coeffs) => new Affine(coeffs[1], coeffs[0]));
+    const order = [[], []];
+    order[0][affinesOrder[0]] = affines[1];
+    order[1][affinesOrder[1]] = affines[2];
+    order[0][1 - affinesOrder[0]] = affines[0];
+    order[1][1 - affinesOrder[1]] = affines[0];
+    const statementTree = (operation === "add" ? add : substract)(new MultiplyNode(order[0][0].toTree(), order[0][1].toTree()), new MultiplyNode(order[1][0].toTree(), order[1][1].toTree()));
+    return `On repère que le facteur commun dans les deux termes est : 
+  
+$$
+${affines[0].toTree().toTex()}
+$$
+
+On a donc : 
+
+${alignTex([
+        ["", statementTree.toTex()],
+        [
+            "=",
+            multiply(affines[0].toTree(), (operation === "add" ? add : substract)(affines[1].toTree(), affines[2].toTree())).toTex(),
+        ],
+        ["=", getAnswer(identifiers)],
+    ])}`;
+};
 const getPropositions = (n, { answer, affinesCoeffs, operation }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -138,4 +179,6 @@ export const factoType1Exercise = {
     subject: "Mathématiques",
     getInstruction,
     getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

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

@@ -1,7 +1,7 @@
 export * from "./factoIdRmq1.js";
 export * from "./factoIdRmq2.js";
 export * from "./factoIdRmq3.js";
-export * from "./factoType1Exercise.js";
+export * from "./facto1.js";
 export * from "./factorizeCanonicalForm.js";
 export * from "./factorizeCanonicalFormWithSqrt.js";
 export * from "./factoType2.js";

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}

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

@@ -1,7 +1,7 @@
 export * from "./factoIdRmq1.js";
 export * from "./factoIdRmq2.js";
 export * from "./factoIdRmq3.js";
-export * from "./factoType1Exercise.js";
+export * from "./facto1.js";
 export * from "./factorizeCanonicalForm.js";
 export * from "./factorizeCanonicalFormWithSqrt.js";
 export * from "./factoType2.js";

package/lib/exercises/math/calculLitteral/systems/basicNiceValuesSystemResolution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basicNiceValuesSystemResolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/basicNiceValuesSystemResolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAKtE,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,EAAE,CAAC;CAIhC,CAAC;AA2EF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAgBjE,CAAC"}
+{"version":3,"file":"basicNiceValuesSystemResolution.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/systems/basicNiceValuesSystemResolution.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAKtE,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,EAAE,CAAC;CAIhC,CAAC;AAkGF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAiBjE,CAAC"}

package/lib/exercises/math/calculLitteral/systems/basicNiceValuesSystemResolution.js

@@ -22,6 +22,26 @@ $$
 
 *Donner le couple solution sous la forme $\\left(x;y\\right)$ : par exemple, si la solution est $x=2$ et $y=3$, alors on écrira $\\left(2;3\\right)$.*`;
 };
+const getHint = (identifiers) => {
+    return `On peut utilise la méthode par substitution ou bien celle par combinaison : 
+  
+- Si une des variables est facile à isoler dans une des équations, alors on utilise la méthode par substitution : on isole cette variable, puis on injecte le résultat obtenu dans l'autre équation.
+
+- Sinon, on utilise la méthode par combinaison : on multiple une (ou les deux) équation(s) par un nombre, afin que lorsqu'on additionne les deux équations, une des variables disparaisse.`;
+};
+const getCorrection = (identifiers) => {
+    const sys = GeneralSystemConstructor.fromIdentifiers(identifiers);
+    let corr = "";
+    corr += sys.toCorrectionTex();
+    corr += `
+  
+La solution du système est donc le couple :
+
+$$
+${getAnswer(identifiers)}
+$$`;
+    return corr;
+};
 const getAnswer = (identifiers) => {
     const sys = GeneralSystemConstructor.fromIdentifiers(identifiers);
     const { x, y } = sys.solve();
@@ -41,6 +61,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -80,4 +102,5 @@ export const basicNiceValuesSystemResolution = {
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
     rebuildIdentifiers,
+    hasHintAndCorrection: true,
 };