math-exercises 3.0.56 → 3.0.58

package/lib/exercises/math/powers/powersDivision.js

@@ -5,62 +5,90 @@ import { Power } from "../../../math/numbers/integer/power.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { frac } from "../../../tree/nodes/operators/fractionNode.js";
 import { power } from "../../../tree/nodes/operators/powerNode.js";
-import { SubstractNode } from "../../../tree/nodes/operators/substractNode.js";
+import { substract, } from "../../../tree/nodes/operators/substractNode.js";
 import { alignTex } from "../../../utils/latex/alignTex.js";
 import { shuffle } from "../../../utils/alea/shuffle.js";
 import { addValidProp, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
 import { rationalParser } from "../../../tree/parsers/rationalParser.js";
 import { powerParser } from "../../../tree/parsers/powerParser.js";
-const getPowersDivisionQuestion = (opts) => {
-    let a = opts.useOnlyPowersOfTen ? 10 : randint(-11, 11, [0]);
-    const [b, c] = [1, 2].map((el) => randint(-11, 11));
-    const statement = frac(power(a, b), power(a, c));
-    const answerTree = power(a, b - c).simplify();
-    const answer = answerTree.toTex();
-    const statementTex = statement.toTex();
-    const question = {
-        instruction: `Simplifier : 
+const getInstruction = (identifiers) => {
+    return `Simplifier : 
     
 $$
-${statementTex}
-$$`,
-        startStatement: statementTex,
-        answer,
-        keys: [],
-        hint: `${opts?.useOnlyPowersOfTen
-            ? `Pour diviser deux puissances de $10$, on utilise la propriété : 
+${getStartStatement(identifiers)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const answerTree = power(a, b - c).simplify();
+    const answer = answerTree.toTex();
+    return answer;
+};
+const getHint = (identifiers, opts) => {
+    return `${opts?.useOnlyPowersOfTen
+        ? `Pour diviser deux puissances de $10$, on utilise la propriété : 
 
 $\\frac{10^a}{10^b} = 10^{a-b}$`
-            : `Pour diviser deux puissances d'un même nombre $x$, on utilise la propriété : 
+        : `Pour diviser deux puissances d'un même nombre $x$, on utilise la propriété : 
+
+$\\frac{x^a}{x^b} = x^{a-b}$`}`;
+};
+const getCorrection = (identifiers, opts) => {
+    const statementTex = getStartStatement(identifiers);
+    const answer = getAnswer(identifiers);
+    const { a, b, c } = identifiers;
+    if (opts?.useOnlyPowersOfTen) {
+        return `On utilise la propriété : 
+    
+$$
+\\frac{10^a}{10^b} = 10^{a-b}
+$$
 
-$\\frac{x^a}{x^b} = x^{a-b}$`}`,
-        correction: `${opts?.useOnlyPowersOfTen
-            ? `On utilise la propriété : $\\frac{10^a}{10^b} = 10^{a-b}$. On a alors : 
+On a alors : 
         
 ${alignTex([
-                [
-                    statementTex,
-                    "=",
-                    `10^{${new SubstractNode(b.toTree(), c.toTree()).toTex()}}`,
-                ],
-                ["", "=", answer],
-            ])}`
-            : `On utilise la propriété : $\\frac{x^a}{x^b} = x^{a-b}$. On a alors : 
+            [statementTex, "=", power(10, substract(b, c)).toTex()],
+            ["", "=", answer],
+        ])}`;
+    }
+    return `On utilise la propriété : 
+  
+$$
+\\frac{x^a}{x^b} = x^{a-b}
+$$
+
+On a alors : 
 
 ${alignTex([
-                [
-                    statementTex,
-                    "=",
-                    `${a.toTree().toTex()}^{${new SubstractNode(b.toTree(), c.toTree()).toTex()}}`,
-                ],
-                ["", "=", answer],
-            ])}`} `,
+        [statementTex, "=", power(a, substract(b, c)).toTex()],
+        ["", "=", answer],
+    ])}`;
+};
+const getStartStatement = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const statement = frac(power(a, b), power(a, c));
+    return statement.toTex();
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: [],
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
         answerFormat: "tex",
-        identifiers: { a, b, c },
+        identifiers,
     };
     return question;
 };
+const getPowersDivisionQuestion = (opts) => {
+    let a = opts.useOnlyPowersOfTen ? 10 : randint(-11, 11, [0]);
+    const [b, c] = [1, 2].map((el) => randint(-11, 11));
+    const identifiers = { a, b, c };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
 const getPropositions = (n, { answer, a, b, c }) => {
     const propositions = [];
     addValidProp(propositions, answer);
@@ -88,34 +116,20 @@ export const powersDivision = {
     id: "powersDivision",
     connector: "=",
     label: "Division de puissances",
-    levels: [
-        "4ème",
-        "3ème",
-        "2nde",
-        "2ndPro",
-        "1reESM",
-        "1rePro",
-        "1reSpé",
-        "1reTech",
-        "TermPro",
-        "TermTech",
-    ],
-    sections: ["Puissances"],
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(() => getPowersDivisionQuestion({ useOnlyPowersOfTen: false }), nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getPowersDivisionQuestion({ useOnlyPowersOfTen: false }), nb),
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };
 export const powersOfTenDivision = {
     id: "powersOfTenDivision",
     connector: "=",
     label: "Division de puissances de $10$",
-    levels: ["4ème", "3ème", "2nde"],
-    sections: ["Puissances"],
     isSingleStep: true,
     generator: (nb) => getDistinctQuestions(() => getPowersDivisionQuestion({ useOnlyPowersOfTen: true }), nb),
     qcmTimer: 60,
@@ -124,4 +138,5 @@ export const powersOfTenDivision = {
     isAnswerValid,
     subject: "Mathématiques",
     hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/powers/powersMixOperations.d.ts

@@ -5,6 +5,7 @@ type Identifiers = {
     k: number;
     l: number;
     m: number;
+    n: number | undefined;
 };
 export declare const powersMixOperations: Exercise<Identifiers>;
 export {};

package/lib/exercises/math/powers/powersMixOperations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powersMixOperations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersMixOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwFF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAgBrD,CAAC"}
+{"version":3,"file":"powersMixOperations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersMixOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAwBrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACvB,CAAC;AA2KF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}

package/lib/exercises/math/powers/powersMixOperations.js

@@ -1,16 +1,19 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../math/utils/random/randint.js";
-import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { frac, isFractionNode, } from "../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
 import { power } from "../../../tree/nodes/operators/powerNode.js";
 import { powerParser } from "../../../tree/parsers/powerParser.js";
+import { valueParser } from "../../../tree/parsers/valueParser.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
 import { doWhile } from "../../../utils/doWhile.js";
 import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { isInt } from "../../../utils/isInt.js";
 const getStatementNode = (identifiers) => {
-    const { a, b, k, l, m } = identifiers;
-    const n = k + l * m;
-    return frac(multiply(power(a, k), power(power(a, l), m)), power(b, n));
+    const { a, b, k, l, m, n } = identifiers;
+    const nPower = n ?? k + l * m;
+    return frac(multiply(power(a, k), power(power(a, l), m)), power(b, nPower));
 };
 const getPropositions = (n, { answer, ...identifiers }) => {
     const propositions = [];
@@ -25,7 +28,18 @@ const getPropositions = (n, { answer, ...identifiers }) => {
 };
 const getAnswer = (identifiers) => {
     const statement = getStatementNode(identifiers);
-    return statement.simplify({ keepPowers: true }).toTex();
+    const { a, b, k, l, m, n } = identifiers;
+    if (a !== b) {
+        const pow = k + l * m;
+        const fraction = frac(a, b).simplify();
+        if (isFractionNode(fraction) && fraction.leftChild.evaluate() === 1) {
+            return power(fraction.rightChild, -pow).toTex();
+        }
+        return power(fraction, pow).toTex();
+    }
+    return power(a, k + l * m - n)
+        .simplify({ keepPowers: true })
+        .toTex();
 };
 const getInstruction = (identifiers) => {
     return `Écrire sous la forme d'une seule puissance : 
@@ -34,17 +48,58 @@ $$
 ${getStatementNode(identifiers).toTex()}
 $$`;
 };
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return ``;
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   return ``;
-// };
+const getHint = (identifiers) => {
+    return `On utilise les propriétés suivantes :
+
+- $a^x \\times a^y = a^{x+y}$
+
+- $(a^x)^y = a^{xy}$
+
+- $\\frac{a^x}{a^y} = a^{x-y}$
+`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, k, l, m, n } = identifiers;
+    const statement = getStatementNode(identifiers);
+    const num = multiply(power(a, k), power(power(a, l), m));
+    const firstStep = multiply(power(a, k), power(power(a, l), m).simplify({ keepPowers: true }));
+    const numSimp = num.simplify({ keepPowers: true });
+    let corr = `On simplifie le numérateur :
+
+$$
+${multiply(power(a, k), power(power(a, l), m)).toTex()} = ${firstStep.toTex()} = ${numSimp.toTex()}
+$$
+
+`;
+    if (a === b) {
+        corr += `On a donc : 
+
+$$
+${statement.toTex()} = ${frac(numSimp, power(a, n)).toTex()} = ${getAnswer(identifiers)}
+$$`;
+        return corr;
+    }
+    const pow = k + l * m;
+    const denum = power(b, pow);
+    return (corr +
+        `On a donc :
+
+$$
+${statement.toTex()} = ${frac(numSimp, denum).toTex()} = ${getAnswer(identifiers)}
+$$
+  `);
+};
 const getKeys = (identifiers) => {
     return [];
 };
 const isAnswerValid = (ans, { answer }) => {
     try {
+        if (isInt(Number(answer))) {
+            const parsed = valueParser(ans);
+            if (parsed !== false) {
+                return parsed === Number(answer);
+            }
+        }
         const parsed = powerParser(ans);
         if (!parsed)
             return false;
@@ -57,25 +112,39 @@ const isAnswerValid = (ans, { answer }) => {
 const getPowersMixOperationsQuestion = (ops) => {
     const finalPower = randint(2, 10);
     const a = randint(2, 10);
-    const b = randint(2, 10, [a]);
-    const l = randint(-5, 6, [0, 1]);
-    const m = doWhile(() => randint(2, 6), (x) => x * l === finalPower);
-    const k = finalPower - l * m;
+    const bEqualsA = coinFlip();
+    const b = bEqualsA ? a : randint(2, 10, [a]);
+    let l, m, k, n;
+    if (!bEqualsA) {
+        l = randint(-5, 6, [0, 1]);
+        m = doWhile(() => randint(2, 6), (x) => x * l === finalPower);
+        k = finalPower - l * m;
+    }
+    else {
+        l = randint(-5, 6);
+        m = randint(-5, 6);
+        k = randint(-5, 6);
+        n = randint(-5, 6);
+    }
     const identifiers = {
         a,
         b,
         k,
         l,
         m,
+        n,
     };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -94,4 +163,6 @@ export const powersMixOperations = {
     // getHint,
     // getCorrection,
     getAnswer,
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
 };

package/lib/exercises/math/powers/powersOfTenMixOperations.d.ts

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

package/lib/exercises/math/powers/powersOfTenMixOperations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"powersOfTenMixOperations.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersOfTenMixOperations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,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;AAuHF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAkB1D,CAAC"}

package/lib/exercises/math/powers/powersOfTenMixOperations.js

@@ -0,0 +1,129 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../tree/nodes/operators/powerNode.js";
+import { powerParser } from "../../../tree/parsers/powerParser.js";
+import { valueParser } from "../../../tree/parsers/valueParser.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { isInt } from "../../../utils/isInt.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, power(10, randint(-9, 10)).simplify({ keepPowers: true }).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    return power(10, a + b - c * d)
+        .simplify({ keepPowers: true })
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    return `Écrire sous la forme d'une seule puissance de $10$ :
+  
+$$
+${frac(multiply(power(10, a), power(10, b)), power(power(10, c), d)).toTex()}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    return `On utilise les propriétés suivantes : 
+  
+- $10^a \\times 10^b = 10^{a+b}$
+
+- $(10^a)^b = 10^{ab}$
+
+- $\\frac{10^a}{10^b} = 10^{a-b}$
+`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c, d } = identifiers;
+    const statement = frac(multiply(power(10, a), power(10, b)), power(power(10, c), d));
+    const num = power(10, a + b).simplify({ keepPowers: true });
+    const denum = power(10, c * d).simplify({ keepPowers: true });
+    return `On simplifie le numérateur : 
+  
+$$
+${multiply(power(10, a), power(10, b)).toTex()} = ${num.toTex()}
+$$
+
+Puis le dénumérateur : 
+
+$$
+${power(power(10, c), d).toTex()} = ${denum.toTex()}
+$$
+
+On a donc : 
+
+$$
+${statement.toTex()} = ${frac(num, denum).toTex()} = ${getAnswer(identifiers)}
+$$
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        if (isInt(Number(answer))) {
+            const parsed = valueParser(ans);
+            if (parsed !== false) {
+                return parsed === Number(answer);
+            }
+        }
+        const parsed = powerParser(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify({ keepPowers: true }).toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPowersOfTenMixOperationsQuestion = (ops) => {
+    const a = randint(-9, 10);
+    const b = randint(-9, 10);
+    const c = randint(-9, 10);
+    const d = randint(-9, 10);
+    const identifiers = {
+        a,
+        b,
+        c,
+        d,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const powersOfTenMixOperations = {
+    id: "powersOfTenMixOperations",
+    connector: "=",
+    label: "Calcul avec des puissances de $10$ : mélange d'opérations",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPowersOfTenMixOperationsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    // getHint,
+    // getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/powers/powersOfTenToDecimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powersOfTenToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersOfTenToDecimal.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,EACL,QAAQ,EAYT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyEF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAiBtD,CAAC"}
+{"version":3,"file":"powersOfTenToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersOfTenToDecimal.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,EACL,QAAQ,EAcT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoGF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC"}

package/lib/exercises/math/powers/powersOfTenToDecimal.js

@@ -32,10 +32,36 @@ const getAnswer = (identifiers) => {
     return answer;
 };
 const getPowersOfTenToDecimalQuestion = () => {
-    const randPower = randint(-9, 10);
+    const randPower = randint(-6, 7);
     const identifiers = { randPower };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = (identifiers) => {
+    return `Si $x$ est un entier positif, alors $10^x$ est le nombre composé d'un $1$ suivi de $x$ zéros. 
+  
+Si $x$ est un entier négatif, alors $10^x$ est le nombre composé d'un $1$ précédé de $x$ zéros.
+
+Enfin, tout nombre élevé à la puissance $0$ est égal à $1$.`;
+};
+const getCorrection = (identifiers) => {
+    const { randPower } = identifiers;
+    const order = randPower < 0 ? "précédé" : "suivi";
+    let corr = "";
+    if (randPower === 0) {
+        corr = `Tout nombre élevé à la puissance $0$ est égal à $1$ : `;
+    }
+    else if (randPower === 1) {
+        corr = `Un nombre élevé à la puissance $1$ est égal à lui-même :`;
+    }
+    else {
+        corr = `$10^{${randPower}}$ est le nombre composé d'un $1$ ${order} de $${Math.abs(randPower)}$ zéros :`;
+    }
+    const final = `
+$$
+${getStartStatement(identifiers)}=${getAnswer(identifiers)}
+$$`;
+    return corr + final;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
@@ -44,6 +70,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -68,10 +96,10 @@ export const powersOfTenToDecimal = {
     connector: "=",
     label: "Écriture décimale d'une puissance de $10$",
     isSingleStep: true,
-    generator: (nb) => getDistinctQuestions(getPowersOfTenToDecimalQuestion, nb, 19),
+    generator: (nb) => getDistinctQuestions(getPowersOfTenToDecimalQuestion, nb, 12),
     qcmTimer: 60,
     freeTimer: 60,
-    maxAllowedQuestions: 19,
+    maxAllowedQuestions: 12,
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
@@ -79,4 +107,5 @@ export const powersOfTenToDecimal = {
     getAnswer,
     getStartStatement,
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/powers/powersProduct.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"powersProduct.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersProduct.ts"],"names":[],"mappings":"AAAA;;GAEG;AAaH,OAAO,EACL,QAAQ,EAiBT,MAAM,mBAAmB,CAAC;AAM3B,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AA4IF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuB7D,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyBxD,CAAC"}
+{"version":3,"file":"powersProduct.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersProduct.ts"],"names":[],"mappings":"AAAA;;GAEG;AAaH,OAAO,EACL,QAAQ,EAiBT,MAAM,mBAAmB,CAAC;AAM3B,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,OAAO,GAAG;IACb,kBAAkB,EAAE,OAAO,CAAC;IAC5B,mBAAmB,CAAC,EAAE,OAAO,CAAC;CAC/B,CAAC;AA6IF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAuB7D,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAyBxD,CAAC"}

package/lib/exercises/math/powers/powersProduct.js

@@ -85,6 +85,7 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
 const getPropositions = (n, { answer, a, b, c }) => {
     const propositions = [];
     addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, power(a, add(b, c)).simplify().toTex());
     while (propositions.length < n) {
         const wrongExponent = b + c + randint(-11, 11, [0, -b - c]);
         const wrongAnswerTree = new Power(a === 1 || a === -1 ? randint(-3, 4, [-1, 1]) : a, wrongExponent).simplify();

package/lib/exercises/math/powers/scientificToDecimal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"scientificToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/scientificToDecimal.ts"],"names":[],"mappings":"AAAA;;MAEM;AAYN,OAAO,EACL,QAAQ,EAST,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAiDF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAYrD,CAAC"}
+{"version":3,"file":"scientificToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/scientificToDecimal.ts"],"names":[],"mappings":"AAAA;;MAEM;AAaN,OAAO,EACL,QAAQ,EAeT,MAAM,mBAAmB,CAAC;AAE3B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA8FF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/math/powers/scientificToDecimal.js

@@ -1,6 +1,7 @@
 /**
  * a*10^x vers décimal
  *  */
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
 import { Decimal, DecimalConstructor, } from "../../../math/numbers/decimals/decimal.js";
 import { randint } from "../../../math/utils/random/randint.js";
 import { NumberNode } from "../../../tree/nodes/numbers/numberNode.js";
@@ -8,22 +9,59 @@ import { MultiplyNode } from "../../../tree/nodes/operators/multiplyNode.js";
 import { PowerNode } from "../../../tree/nodes/operators/powerNode.js";
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../exercise.js";
 import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
-const getScientificToDecimalQuestion = () => {
-    const decScientific = DecimalConstructor.randomScientific(randint(1, 4));
-    const tenPower = randint(-5, 6, [0, 1]);
+const getInstruction = (identifiers) => {
+    return `Donner l'écriture décimale du nombre suivant : 
+
+$$
+${getStartStatement(identifiers)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { decimal, tenPower } = identifiers;
+    const decScientific = new Decimal(decimal);
     const answer = decScientific.multiplyByPowerOfTen(tenPower).toTree().toTex();
-    const statement = new MultiplyNode(new NumberNode(decScientific.value), new PowerNode(new NumberNode(10), new NumberNode(tenPower)));
-    const statementTex = statement.toTex();
+    return answer;
+};
+const getHint = (identifiers) => {
+    const { decimal, tenPower } = identifiers;
+    return `Si $x$ est un entier négatif, alors multiplier par $10^x$ revient à déplacer la virgule de $x$ rangs vers la gauche. 
+  
+Si $x$ est un entier positif, alors multiplier par $10^x$ revient à déplacer la virgule de $x$ rangs vers la droite.`;
+};
+const getCorrection = (identifiers) => {
+    const { decimal, tenPower } = identifiers;
+    return `On déplace la virgule de $${Math.abs(tenPower)}$ rangs vers la ${tenPower < 0 ? "gauche" : "droite"} : 
+  
+$$
+${getStartStatement(identifiers)} = ${getAnswer(identifiers)}
+$$`;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const { decimal, tenPower } = identifiers;
     const question = {
-        instruction: `Donner l'écriture décimale de : $${statementTex}$`,
-        startStatement: statementTex,
-        answer: answer,
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
         keys: [],
         answerFormat: "tex",
-        identifiers: { decimal: decScientific.value, tenPower },
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
+const getStartStatement = (identifiers) => {
+    const { decimal, tenPower } = identifiers;
+    const statement = new MultiplyNode(new NumberNode(decimal), new PowerNode(new NumberNode(10), new NumberNode(tenPower)));
+    const statementTex = statement.toTex();
+    return statementTex;
+};
+const getScientificToDecimalQuestion = () => {
+    const decScientific = DecimalConstructor.randomScientific(randint(1, 4));
+    const tenPower = randint(-5, 6, [0, 1]);
+    const identifiers = { decimal: decScientific.value, tenPower };
+    return getQuestionFromIdentifiers(identifiers);
+};
 const getPropositions = (n, { answer, tenPower, decimal }) => {
     const propositions = [];
     const decScientific = new Decimal(decimal);
@@ -39,7 +77,7 @@ const getPropositions = (n, { answer, tenPower, decimal }) => {
     return shuffleProps(propositions, n);
 };
 const isAnswerValid = (ans, { answer }) => {
-    return ans === answer;
+    return numberVEA(ans, answer);
 };
 export const scientificToDecimal = {
     id: "scientificToDecimal",
@@ -52,4 +90,6 @@ export const scientificToDecimal = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };