math-exercises 3.0.38 → 3.0.39

package/lib/exercises/math/calcul/fractions/fractionsSumsMultiplesDenominators.js

@@ -61,7 +61,7 @@ ${alignTex([
         ],
         [
             "=",
-            frac(orderedNums[0] * coeff + orderedNums[1], orderedDenums[1]).toSimplificationString(),
+            frac(orderedNums[0] * coeff + orderedNums[1], orderedDenums[1]).toSimplificationTex(),
         ],
     ])}`;
 };

package/lib/exercises/math/calcul/fractions/simplifyFraction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simplifyFraction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/simplifyFraction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgEF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAWlD,CAAC"}
+{"version":3,"file":"simplifyFraction.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/simplifyFraction.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAgGF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAgBlD,CAAC"}

package/lib/exercises/math/calcul/fractions/simplifyFraction.js

@@ -1,7 +1,11 @@
 import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { Rational, RationalConstructor, } from "../../../../math/numbers/rationals/rational.js";
+import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
 const getStatementNode = (identifiers) => {
     const { num, denum } = identifiers;
     const rational = new Rational(num, denum).toTree();
@@ -24,6 +28,32 @@ const getAnswer = (identifiers) => {
     const answer = rational.simplify().toTree().toTex();
     return answer;
 };
+const getHint = (identifiers) => {
+    return `Détermine le plus grand diviseur commun à $${identifiers.num}$ et $${identifiers.denum}$.
+  
+On peut alors simpfier la fraction par ce nombre.`;
+};
+const getCorrection = (identifiers) => {
+    const { num, denum } = identifiers;
+    const pgcd = gcd(num, denum);
+    const numDiv = num / pgcd;
+    const denumDiv = denum / pgcd;
+    return `Le plus grand diviseur commun à $${num}$ et $${denum}$ est $${pgcd}$. 
+
+En effet, on a $${num} = ${numDiv} \\times ${pgcd}$ et $${denum} = ${denumDiv} \\times ${pgcd}$.
+  
+On peut donc simplfier la fraction par $${pgcd}$ : 
+
+${alignTex([
+        [
+            frac(num, denum).toTex(),
+            "=",
+            frac(multiply(numDiv, pgcd.toTree({ toTexOptions: { cancel: true } })), multiply(denumDiv, pgcd.toTree({ toTexOptions: { cancel: true } }))).toTex(),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+`;
+};
 const getSimplifyFraction = () => {
     const rational = RationalConstructor.randomSimplifiable(10);
     const identifiers = { num: rational.num, denum: rational.denum };
@@ -34,6 +64,8 @@ const getSimplifyFraction = () => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -65,4 +97,9 @@ export const simplifyFraction = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    getCorrection,
+    getHint,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/calcul/rounding/rounding.d.ts

@@ -1,22 +1,25 @@
 import { Exercise } from "../../../../exercises/exercise.js";
+type Options = {
+    precisionAsked: number;
+};
 type Identifiers = {
     precisionAsked: number;
     decimal: number;
     precision: number;
 };
-export declare const roundToUnit: Exercise<Identifiers>;
+export declare const roundToUnit: Exercise<Identifiers, Options>;
 /**
  * arrondi à l'unité
  */
-export declare const roundToDixieme: Exercise<Identifiers>;
+export declare const roundToDixieme: Exercise<Identifiers, Options>;
 /**
  * arrondi à l'unité
  */
-export declare const roundToCentieme: Exercise<Identifiers>;
+export declare const roundToCentieme: Exercise<Identifiers, Options>;
 /**
  * arrondi à l'unité
  */
-export declare const roundToMillieme: Exercise<Identifiers>;
-export declare const allRoundings: Exercise<Identifiers>;
+export declare const roundToMillieme: Exercise<Identifiers, Options>;
+export declare const allRoundings: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=rounding.d.ts.map

package/lib/exercises/math/calcul/rounding/rounding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rounding.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/rounding.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AA6ErC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgDF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,CAe7C,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAkB9C,CAAC"}
+{"version":3,"file":"rounding.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/rounding.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AACF,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4HF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBtD,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBzD,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB1D,CAAC;AACF;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB1D,CAAC;AAEF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBvD,CAAC"}

package/lib/exercises/math/calcul/rounding/rounding.js

@@ -16,39 +16,61 @@ const instructions = [
     "Arrondir au centième :",
     "Arrondir au millième :",
 ];
-const getRoundQuestions = (opts) => {
-    244.8895;
-    const precisionAsked = opts?.precisionAsked || 0;
-    const precision = randint(precisionAsked + 1, precisionAsked + 5);
-    const dec = DecimalConstructor.random(0, 1000, precision);
+const getInstruction = (identifiers, opts) => {
+    const { precisionAsked } = identifiers;
+    const dec = new Decimal(identifiers.decimal);
     const decTex = dec.toTree().toTex();
+    return `${instructions[precisionAsked]} $${decTex}$`;
+};
+const getAnswer = (identifiers, opts) => {
+    const { precisionAsked } = identifiers;
+    const dec = new Decimal(identifiers.decimal);
     const answer = dec.round(precisionAsked).toTree().toTex();
+    return answer;
+};
+const getHint = (identifiers, opts) => {
+    const { precisionAsked } = identifiers;
+    return `Pour arrondir ${ranksWithAu[precisionAsked]}, on regarde le chiffre des ${ranks[precisionAsked + 1]}s. S'il est inférieur à $5$, on arrondit ${ranksWithAu[precisionAsked]} inférieur. S'il est supérieur ou égal à $5$, on arrondit ${ranksWithAu[precisionAsked]} supérieur.`;
+};
+const getCorrection = (identifiers, opts) => {
+    const { precisionAsked } = identifiers;
+    const dec = new Decimal(identifiers.decimal);
+    const decTex = dec.toTree().toTex();
+    const answer = getAnswer(identifiers, opts);
     const figureToLookAt = dec.getDigitAtRank(-(precisionAsked + 1));
-    const question = {
-        instruction: `${instructions[precisionAsked]} $${decTex}$`,
-        startStatement: decTex,
-        answer,
-        keys: [],
-        answerFormat: "tex",
-        identifiers: {
-            precisionAsked,
-            decimal: dec.value,
-            precision,
-        },
-        hint: `Pour arrondir ${ranksWithAu[precisionAsked]}, on regarde le chiffre des ${ranks[precisionAsked + 1]}s. S'il est inférieur à $5$, on arrondit ${ranksWithAu[precisionAsked]} inférieur. S'il est supérieur à $5$, on arrondit ${ranksWithAu[precisionAsked]} supérieur.`,
-        correction: `Le chiffre des ${ranks[precisionAsked + 1]}s est $${figureToLookAt}$. 
+    return `Le chiffre des ${ranks[precisionAsked + 1]}s est $${figureToLookAt}$. 
     
 ${figureToLookAt < 5
-            ? `Puisque $${figureToLookAt}$ est inférieur à $5$, on arrondit ${ranksWithAu[precisionAsked]} inférieur. 
+        ? `Puisque $${figureToLookAt}$ est inférieur à $5$, on arrondit ${ranksWithAu[precisionAsked]} inférieur. 
      
 Ainsi, en arrondissant ${ranksWithAu[precisionAsked]}, on a $${decTex} \\approx ${answer}$`
-            : `Puisque $${figureToLookAt}$ est supérieur à $5$, on arrondit ${ranksWithAu[precisionAsked]} supérieur. 
+        : `Puisque $${figureToLookAt}$ est supérieur ou égal à $5$, on arrondit ${ranksWithAu[precisionAsked]} supérieur. 
      
 Ainsi, en arrondissant ${ranksWithAu[precisionAsked]}, on a 
 
 $$
 ${decTex} \\approx ${answer}
-$$`}`,
+$$`}`;
+};
+const getRoundQuestions = (opts) => {
+    const precisionAsked = opts?.precisionAsked || 0;
+    const precision = randint(precisionAsked + 1, precisionAsked + 5);
+    const dec = DecimalConstructor.random(0, 1000, precision);
+    const decTex = dec.toTree().toTex();
+    const identifiers = {
+        precisionAsked,
+        decimal: dec.value,
+        precision,
+    };
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: decTex,
+        answer: getAnswer(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
     return question;
 };
@@ -82,8 +104,6 @@ export const roundToUnit = {
     id: "roundToUnit",
     connector: "\\approx",
     label: "Arrondir à l'unité",
-    levels: ["6ème", "5ème", "CAP", "2ndPro", "1rePro"],
-    sections: ["Calculs"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getRoundQuestions({ precisionAsked: 0 }), nb),
     qcmTimer: 60,
@@ -92,6 +112,10 @@ export const roundToUnit = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getCorrection,
+    getHint,
 };
 /**
  * arrondi à l'unité
@@ -100,8 +124,6 @@ export const roundToDixieme = {
     id: "roundToDixieme",
     connector: "\\approx",
     label: "Arrondir au dixième",
-    levels: ["6ème", "5ème", "CAP", "2ndPro", "1rePro"],
-    sections: ["Calculs"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getRoundQuestions({ precisionAsked: 1 }), nb),
     qcmTimer: 60,
@@ -110,6 +132,10 @@ export const roundToDixieme = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getCorrection,
+    getHint,
 };
 /**
  * arrondi à l'unité
@@ -118,8 +144,6 @@ export const roundToCentieme = {
     id: "roundToCentieme",
     connector: "\\approx",
     label: "Arrondir au centième",
-    levels: ["6ème", "5ème", "CAP", "2ndPro", "1rePro"],
-    sections: ["Calculs"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getRoundQuestions({ precisionAsked: 2 }), nb),
     qcmTimer: 60,
@@ -128,6 +152,10 @@ export const roundToCentieme = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getCorrection,
+    getHint,
 };
 /**
  * arrondi à l'unité
@@ -136,8 +164,6 @@ export const roundToMillieme = {
     id: "roundToMillieme",
     connector: "\\approx",
     label: "Arrondir au millième",
-    levels: ["6ème", "5ème", "CAP", "2ndPro", "1rePro"],
-    sections: ["Calculs"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getRoundQuestions({ precisionAsked: 3 }), nb),
     qcmTimer: 60,
@@ -146,13 +172,15 @@ export const roundToMillieme = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getCorrection,
+    getHint,
 };
 export const allRoundings = {
     id: "allRoundings",
     connector: "\\approx",
     label: "Arrondir un nombre décimal",
-    levels: ["6ème", "5ème", "CAP", "2ndPro", "1rePro"],
-    sections: ["Calculs"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getRoundQuestions({ precisionAsked: randint(0, 4) }), nb),
     qcmTimer: 60,
@@ -161,4 +189,8 @@ export const allRoundings = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getInstruction,
+    getAnswer,
+    getCorrection,
+    getHint,
 };

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,EAeT,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;AAqKF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAelD,CAAC"}
+{"version":3,"file":"reduceExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/reduceExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IAOjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IAGnB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAqOF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAkBlD,CAAC"}

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

@@ -6,11 +6,13 @@ import { randint } from "../../../../math/utils/random/randint.js";
 import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { monom } from "../../../../tree/nodes/polynomials/monomNode.js";
 import { polynomialParser } from "../../../../tree/parsers/polynomialParser.js";
 import { operatorComposition } from "../../../../tree/utilities/operatorComposition.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 rebuildIdentifiers = (oldids) => {
     if (oldids.variable)
         return oldids;
@@ -63,13 +65,59 @@ const getHint = (identifiers) => {
     const { coeffs, order, variable } = identifiers;
     return `Additionne les termes en $${variable}^2$ entre eux, puis les termes en $${variable}$ entre eux, et enfin les nombres entre eux.`;
 };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   const { coeffs, order, variable } = identifiers;
-//   return `On additionne les termes en $${variable}^2$ entre eux, puis les termes en $${variable}$ entre eux, et enfin les nombres entre eux.
-// - ${coeffs[2].length<2 ? `` : ``}
-// -
-// - `
-// };
+const getCorrection = (identifiers) => {
+    const { coeffs, order, variable } = identifiers;
+    const x2Count = coeffs[2].length;
+    const xCount = coeffs[1].length;
+    const nbCount = coeffs[0].length;
+    const xSimp = xCount === 0
+        ? ""
+        : xCount === 1
+            ? `$${monom(coeffs[1][0], 1, {
+                variable,
+            }).toTex()}$ est le seul terme en $${variable}$, on ne peut donc l'additionner avec aucun autre terme.`
+            : `On additionne les $${xCount}$ termes en $${variable}$ :
+  
+$$
+${operatorComposition(AddNode, coeffs[1].map((c) => monom(c, 1, { variable }).toTree())).toSimplificationTex()}
+$$`;
+    const x2Simp = x2Count === 0
+        ? ""
+        : x2Count === 1
+            ? `$${monom(coeffs[2][0], 2, {
+                variable,
+            }).toTex()}$ est le seul terme en $${square(variable).toTex()}$, on ne peut donc l'additionner avec aucun autre terme.`
+            : `On additionne les $${x2Count}$ termes en $${square(variable).toTex()}$ :
+
+$$
+${operatorComposition(AddNode, coeffs[2].map((c) => monom(c, 2, { variable }).toTree())).toSimplificationTex()}
+$$`;
+    const nbSimp = nbCount === 0
+        ? ""
+        : nbCount === 1
+            ? `$${coeffs[0][0]}$ est le seul nombre, on ne peut donc l'additionner avec aucun autre terme.`
+            : `On additionne les $${nbCount}$ nombres entre eux :
+
+$$
+${operatorComposition(AddNode, coeffs[0].map((c) => c.toTree())).toSimplificationTex()}
+$$`;
+    return `On additionne les termes en $${variable}^2$ entre eux, puis les termes en $${variable}$ entre eux, et enfin les nombres entre eux.
+
+${x2Count > 0 ? `- ${x2Simp}` : ""}
+
+${xCount > 0 ? `- ${xSimp}` : ""}
+
+${nbCount > 0 ? `- ${nbSimp}` : ""}
+
+
+Ainsi, on obtient :
+
+${alignTex([
+        ["", getStartStatement(identifiers)],
+        ["=", getAnswer(identifiers)],
+    ])}
+`;
+};
 const getReduceExpression = () => {
     const rand = randint(0, 7);
     let polynome1;
@@ -106,6 +154,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [identifiers.variable],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -162,4 +212,7 @@ export const reduceExpression = {
     getAnswer,
     getInstruction,
     getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/affines/leadingCoefficient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"leadingCoefficient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoefficient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAiFF,KAAK,OAAO,GAAG;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAYF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB7D,CAAC"}
+{"version":3,"file":"leadingCoefficient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/leadingCoefficient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAkHF,KAAK,OAAO,GAAG;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB,CAAC;AAYF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoB7D,CAAC"}

package/lib/exercises/math/functions/affines/leadingCoefficient.js

@@ -3,14 +3,35 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { randomColor } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { Rational } from "../../../../math/numbers/rationals/rational.js";
+import { Rational, RationalConstructor, } from "../../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 const getInstruction = (identifiers) => {
     return "Déterminer le coefficient directeur de la droite représentée ci-dessous : ";
 };
+const getHint = (identifiers) => {
+    return `Le coefficient directeur d'une droite passant par deux points $A(x_A; y_A)$ et $B(x_B; y_B)$ est :
+  
+$$
+\\frac{y_B - y_A}{x_B - x_A}
+$$
+
+Repère donc deux points appartenant à la droite, et utilise cette formule.`;
+};
+const getCorrection = (identifiers) => {
+    const { xA, yA, xB, yB } = identifiers;
+    return `On lit graphiquement que la droite passe par les deux points $A(${xA},${yA})$ et $B(${xB},${yB})$. 
+  
+Le coefficient directeur est donc : 
+
+$$
+${frac(substract(yB, yA), substract(xB, xA)).toSimplificationTex()}
+$$`;
+};
 const getAnswer = (identifiers) => {
     const { xA, yA, xB, yB } = identifiers;
     const a = frac(yB - yA, xB - xA).simplify();
@@ -32,7 +53,13 @@ const getGGBOptions = (identifiers) => {
         commands,
     });
     return ggb.getOptions({
-        coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+            ratio: 2,
+        }),
     });
 };
 const getLeadingCoefficientQuestion = (opts) => {
@@ -43,8 +70,14 @@ const getLeadingCoefficientQuestion = (opts) => {
     }
     else
         [xA, yA] = [1, 2].map((el) => randint(-5, 6));
-    xB = xA > 0 ? randint(xA - 4, 6, [xA]) : randint(-4, xA + 5, [xA]); // l'écart entre les deux points ne soit pas grand
-    yB = yA > 0 ? randint(yA - 4, 6) : randint(-4, yA + 5);
+    const aIsInt = coinFlip();
+    const a = aIsInt
+        ? [randint(-3, 3, [0])]
+        : RationalConstructor.randomIrreductible(5).toArray();
+    xB = xA + (aIsInt ? 1 : a[0]);
+    yB = yA + (aIsInt ? a[0] : a[1]);
+    // xB = xA > 0 ? randint(xA - 4, 6, [xA]) : randint(-4, xA + 5, [xA]); // l'écart entre les deux points ne soit pas grand
+    // yB = yA > 0 ? randint(yA - 4, 6) : randint(-4, yA + 5);
     const identifiers = { xA, xB, yA, yB };
     const question = {
         instruction: getInstruction(identifiers),
@@ -53,6 +86,8 @@ const getLeadingCoefficientQuestion = (opts) => {
         ggbOptions: getGGBOptions(identifiers),
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -96,4 +131,7 @@ export const leadingCoefficient = {
     getInstruction,
     getGGBOptions,
     options,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/trinoms/factoForm/factorizedFormFromRoots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"factorizedFormFromRoots.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/factoForm/factorizedFormFromRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAoGF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}
+{"version":3,"file":"factorizedFormFromRoots.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/factoForm/factorizedFormFromRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAuJF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAiBzD,CAAC"}

package/lib/exercises/math/functions/trinoms/factoForm/factorizedFormFromRoots.js

@@ -8,6 +8,7 @@ import { substract } from "../../../../../tree/nodes/operators/substractNode.js"
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
 import { probaFlip } from "../../../../../utils/alea/probaFlip.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
 const getAnswerNode = (identifiers) => {
     const { a, roots } = identifiers;
     const isSingleRoot = roots.length === 1;
@@ -28,6 +29,49 @@ const getInstruction = (identifiers) => {
   
 Déterminer la forme factorisée de $f$.`;
 };
+const getHint = (identifiers) => {
+    return `Soit $f$ un polynôme du second degré de la forme 
+  
+$$
+f(x)=ax^2+bx+c
+$$
+
+Si $f$ admet deux racines $x_1$ et $x_2$, alors la forme factorisée de $f$ est :
+
+$$
+f(x)=a(x-x_1)(x-x_2)
+$$
+
+Si $f$ n'admet qu'une racine $x_0$, alors sa forme factorisée est :
+
+$$
+f(x) = a(x-x_0)^2
+$$
+
+Si $f$ n'admet pas de racine, alors il n'admet pas de forme factorisée.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, roots } = identifiers;
+    const rawForm = roots.length === 1
+        ? multiply(a, square(substract("x", roots[0])))
+        : multiply(a, multiply(substract("x", roots[0]), substract("x", roots[1])));
+    const simpForm = rawForm.simplify();
+    const hasSimplified = rawForm.toTex() !== simpForm.toTex();
+    return roots.length === 1
+        ? `Puisque $f$ n'admet qu'une racine, sa forme factorisée est : 
+    
+${alignTex([
+            ["f(x)", "=", rawForm.toTex()],
+            hasSimplified ? ["", "=", simpForm.toTex()] : [],
+        ])}
+`
+        : `Puisque $f$ admet deux racines distinctes, sa forme factorisée est : 
+    
+${alignTex([
+            ["f(x)", "=", rawForm.toTex()],
+            hasSimplified ? ["", "=", simpForm.toTex()] : [],
+        ])}`;
+};
 const getFactorizedFormFromRootsQuestion = () => {
     const a = randint(-10, 10, [0]);
     const firstRoot = randint(-10, 10);
@@ -43,6 +87,8 @@ const getFactorizedFormFromRootsQuestion = () => {
         keys: ["x"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -92,4 +138,7 @@ export const factorizedFormFromRoots = {
     subject: "Mathématiques",
     getInstruction,
     getAnswer,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/trinoms/parabole/trinomSymetryAxisFromFacto.js

@@ -53,7 +53,7 @@ const getCorrection = (identifiers) => {
 L'axe de symétrie de la parabole représentant $f$ a donc pour équation : 
 
 $$
-x=${fraction.toTex()}=${frac(x1 + x2, 2).toSimplificationString()}
+x=${fraction.toTex()}=${frac(x1 + x2, 2).toSimplificationTex()}
 $$`;
 };
 const getKeys = (identifiers) => {

package/lib/exercises/math/functions/trinoms/roots/findSecondRoot.js

@@ -63,7 +63,7 @@ $$
 Or on sait que $x_1 = ${firstRoot.toTex()}$. On a donc : 
 
 $$
-x_2 = ${frac(cOverA, firstRoot).toSimplificationString()}
+x_2 = ${frac(cOverA, firstRoot).toSimplificationTex()}
 $$
 `;
 };

package/lib/exercises/math/functions/trinoms/roots/rootsProduct.js

@@ -59,7 +59,7 @@ $$
 Ici, on a $a = ${aTex}$ et $c = ${cTex}$, donc :
 
 $$
-P = ${ans.toSimplificationString()}
+P = ${ans.toSimplificationTex()}
 $$
   `;
 };

package/lib/exercises/math/functions/trinoms/roots/rootsSum.js

@@ -59,7 +59,7 @@ $$
 Ici, on a $a = ${aTex}$ et $b = ${bTex}$, donc :
 
 $$
-S = ${ans.toSimplificationString()}
+S = ${ans.toSimplificationTex()}
 $$
 `;
 };

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLine.js

@@ -52,7 +52,7 @@ const getStudentGGBOptions = ({ coeff, oneUnitTex, abscissType, }) => {
 const isGGBAnswerValid = (ans, { ggbAnswer, absciss, abscissTex, abscissType, axisUnit, coeff, oneUnitTex }) => {
     const points = parseGGBPoints(ans).map((p) => ggbPointToCoords(p));
     return (points.length === 1 &&
-        points[0].y === 0 &&
+        Math.abs(points[0].y) < 0.5 &&
         Math.abs(points[0].x - coeff) < 0.1);
 };
 const getPlaceAbscissOnSemiLineQuestion = () => {

package/lib/exercises/math/geometry/perimeters/rectanglePerimeter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectanglePerimeter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/rectanglePerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAkCF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}
+{"version":3,"file":"rectanglePerimeter.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/perimeters/rectanglePerimeter.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAkCF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAWpD,CAAC"}

package/lib/exercises/math/geometry/perimeters/rectanglePerimeter.js

@@ -32,9 +32,7 @@ export const rectanglePerimeter = {
     id: "rectanglePerimeter",
     connector: "=",
     label: "Calculer le périmètre d'un rectangle",
-    levels: ["4ème", "3ème", "2nde"],
     isSingleStep: false,
-    sections: ["Périmètres", "Géométrie euclidienne"],
     generator: (nb) => getDistinctQuestions(getRectanglePerimeter, nb),
     qcmTimer: 60,
     freeTimer: 60,

package/lib/exercises/math/geometry/vectors/chasles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chasles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/chasles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAuDF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAazC,CAAC"}
+{"version":3,"file":"chasles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/vectors/chasles.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAuDF,eAAO,MAAM,OAAO,EAAE,QAAQ,CAAC,WAAW,CAWzC,CAAC"}

package/lib/exercises/math/geometry/vectors/chasles.js

@@ -49,9 +49,7 @@ export const chasles = {
     id: "chasles",
     connector: "=",
     label: "Relation de Chasles pour les vecteurs",
-    levels: ["2nde", "1reESM", "1reSpé"],
     isSingleStep: true,
-    sections: ["Vecteurs"],
     generator: (nb) => getDistinctQuestions(getChaslesQuestion, nb),
     qcmTimer: 60,
     freeTimer: 60,

package/lib/exercises/math/geometry/vectors/scalarProduct/scalarProductViaCos.d.ts

@@ -3,6 +3,7 @@ type Identifiers = {
     AB: number;
     AC: number;
     trigoPoint: string;
+    letters: string[];
 };
 export declare const scalarProductViaCos: Exercise<Identifiers>;
 export {};