math-exercises 3.0.124 → 3.0.126

package/lib/exercises/math/calcul/ordering/comparePowersOfFracs.js

@@ -0,0 +1,164 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.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) => {
+    const { items } = identifiers;
+    return `Voici quatre nombres :  
+
+${items
+        .map((item) => `
+
+$$
+${item.name} = ${NodeConstructor.fromIdentifiers(item.nodeIds).toTex()}
+$$
+
+`)
+        .join("")}
+
+Le plus grand de ces quatre nombres est :`;
+};
+const getHint = () => {
+    return `Ecris chaque nombre sous la forme d'une fraction.`;
+};
+const getCorrection = (identifiers) => {
+    const { items } = identifiers;
+    const nodes = items.map((item) => NodeConstructor.fromIdentifiers(item.nodeIds));
+    const sortedIndexes = [...Array(nodes.length).keys()].toSorted((i1, i2) => substract(nodes[i1], nodes[i2]).simplify().evaluate());
+    const compareSigns = [...Array(sortedIndexes.length).keys()]
+        .slice(0, -1)
+        .map((i) => {
+        const difference = substract(nodes[sortedIndexes[i]], nodes[sortedIndexes[i + 1]])
+            .simplify()
+            .evaluate();
+        const comparison = difference > 0 ? 1 : difference < 0 ? -1 : 0;
+        const compSymbol = comparison == 1 ? ">" : comparison == -1 ? "<" : "=";
+        return compSymbol;
+    });
+    const itemGreatest = sortedIndexes.map((sortedI) => items[sortedI])[items.length - 1];
+    return `On a : 
+
+${items
+        .toSorted((item1, item2) => item1.name.localeCompare(item2.name))
+        .map((item) => {
+        const node = NodeConstructor.fromIdentifiers(item.nodeIds);
+        return `
+
+$$
+${item.name} = ${node.toTex()} = ${node
+            .simplify({ calculatePowers: true, distributePowersOnFrac: true })
+            .toTex()}
+$$
+
+`;
+    })
+        .join("")}
+
+Dans l'ordre croissant :
+
+$$
+${sortedIndexes
+        .map((sortedI, i) => `${nodes[sortedI]
+        .simplify({ calculatePowers: true, distributePowersOnFrac: true })
+        .toTex()} ${i < sortedIndexes.length - 1 ? compareSigns[i] : ""}`)
+        .join("")}
+$$
+
+Le plus grand de ces $${items.length}$ nombres est $${itemGreatest.name}$.
+`;
+};
+const getPropositions = (_, { answer, items }) => {
+    const propositions = [];
+    items
+        .toSorted((item1, item2) => item1.name.localeCompare(item2.name))
+        .forEach((item) => {
+        if (item.name === answer) {
+            addValidProp(propositions, answer);
+        }
+        else {
+            tryToAddWrongProp(propositions, item.name);
+        }
+    });
+    return propositions;
+};
+const getAnswer = (identifiers) => {
+    const { items } = identifiers;
+    const nodes = items.map((item) => NodeConstructor.fromIdentifiers(item.nodeIds));
+    const sortedIndexes = [...Array(items.length).keys()].toSorted((i1, i2) => substract(nodes[i1], nodes[i2]).simplify().evaluate());
+    const itemGreatest = sortedIndexes.map((i) => items[i])[items.length - 1];
+    return itemGreatest.name;
+};
+const getComparePowersOfFracsQuestion = () => {
+    function generateNodes() {
+        const a = coinFlip() ? 2 : 3;
+        const b = randint(a, 6);
+        const c = a + 1;
+        const nodes = [
+            power(frac(1, a), b),
+            power(frac(1, b), a),
+            frac(a, 100),
+            power(frac(1, c), c),
+        ];
+        return nodes;
+    }
+    function checkNodes(nodes) {
+        const sortedIndexes = [...Array(nodes.length).keys()].toSorted((i1, i2) => substract(nodes[i1], nodes[i2]).simplify().evaluate());
+        const compareSigns = [...Array(sortedIndexes.length).keys()]
+            .slice(0, -1)
+            .map((i) => {
+            const difference = substract(nodes[sortedIndexes[i]], nodes[sortedIndexes[i + 1]])
+                .simplify()
+                .evaluate();
+            const comparison = difference > 0 ? 1 : difference < 0 ? -1 : 0;
+            const compSymbol = comparison == 1 ? ">" : comparison == -1 ? "<" : "=";
+            return compSymbol;
+        });
+        return compareSigns[compareSigns.length - 1] !== "=";
+    }
+    let nodes;
+    do {
+        nodes = generateNodes();
+    } while (!checkNodes(nodes));
+    const names = ["A", "B", "C", "D"];
+    const items = shuffle(nodes).map((node, i) => {
+        return {
+            name: names[i],
+            nodeIds: node.toIdentifiers(),
+        };
+    });
+    return getQuestionFromIdentifiers({
+        items,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+export const comparePowersOfFracs = {
+    id: "comparePowersOfFracs",
+    label: "Comparer des puissances de fractions",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComparePowersOfFracsQuestion(opts), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/ordering/compareWithSquareRoots.d.ts

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

package/lib/exercises/math/calcul/ordering/compareWithSquareRoots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareWithSquareRoots.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareWithSquareRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAqKF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}

package/lib/exercises/math/calcul/ordering/compareWithSquareRoots.js

@@ -0,0 +1,140 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { a, b, isAdd } = identifiers;
+    return `Sachant que  $\\sqrt{${a}} < \\sqrt{${a + 1}}$,
+  
+comparer $${b} ${isAdd ? "+" : "-"} \\sqrt{${a}}$ et $${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}$.`;
+};
+const getHint = (identifiers) => {
+    const { a, b, isAdd } = identifiers;
+    return `En partant de $\\sqrt{${a}} < \\sqrt{${a + 1}}$,
+  
+essaie de te ramener à $${b} ${isAdd ? "+" : "-"} \\sqrt{${a}}$ <(ou >) $${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}$
+
+par des opérations que l'on effectue à droite et à gauche de l'inégalité. 
+
+Attention si tu multiplies à droite et à gauche d'une inégalité par un nombre négatif, l'inégalité se renverse.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, isAdd } = identifiers;
+    return `
+
+$$
+\\sqrt{${a}} < \\sqrt{${a + 1}}
+$$
+
+${isAdd
+        ? ``
+        : `On multiplie par $-1$ des deux côtés et on renverse l'inégalité :
+    
+$$
+-\\sqrt{${a}} > -\\sqrt{${a + 1}}
+$$
+
+`}
+On ajoute $${b}$ de chaque côté de l'inégalité :
+
+$$
+${b} ${isAdd ? "+" : "-"} \\sqrt{${a}} ${isAdd ? "<" : ">"} ${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, isAdd } = identifiers;
+    return `${b} ${isAdd ? "+" : "-"} \\sqrt{${a}} ${isAdd ? "<" : ">"} ${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    function getOrderedNodesFromTex(tex, compSymbol) {
+        return tex
+            .split(compSymbol)
+            .map((str) => parseAlgebraic(str))
+            .toSorted(() => (compSymbol === "<" ? -1 : +1));
+    }
+    try {
+        const compSymbol = ans.includes("<")
+            ? "<"
+            : ans.includes(">")
+                ? ">"
+                : undefined;
+        if (compSymbol) {
+            const [ansNode1, ansNode2] = getOrderedNodesFromTex(ans, compSymbol);
+            const [answerNode1, answerNode2] = getOrderedNodesFromTex(answer, "<");
+            return (ansNode1.simplify().equals(answerNode1.simplify()) &&
+                ansNode2.simplify().equals(answerNode2.simplify()));
+        }
+        else {
+            return false;
+        }
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPropositions = (nbProps, { answer, ...identifiers }) => {
+    const { a, b, isAdd } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, `${b} ${isAdd ? "+" : "-"} \\sqrt{${a}} ${isAdd ? "<" : ">"} ${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}`, "tex");
+    tryToAddWrongProp(propositions, `${b} ${!isAdd ? "+" : "-"} \\sqrt{${a}} ${!isAdd ? "<" : ">"} ${b} ${!isAdd ? "+" : "-"} \\sqrt{${a + 1}}`, "tex");
+    return shuffleProps(propositions, nbProps);
+};
+const getKeys = (identifiers) => {
+    const { a, b, isAdd } = identifiers;
+    return [
+        "inf",
+        "sup",
+        ...[
+            `${b} ${isAdd ? "+" : "-"} \\sqrt{${a}}`,
+            `${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}`,
+        ].map((tex) => {
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const getCompareWithSquareRootsQuestion = () => {
+    const a = randint(2, 150);
+    const b = randint(1, 100);
+    const isAdd = coinFlip();
+    return getQuestionFromIdentifiers({ a, b, isAdd });
+};
+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;
+};
+export const compareWithSquareRoots = {
+    id: "compareWithSquareRoots",
+    label: "Comparer deux nombres directement (avec des racines carrées)",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getCompareWithSquareRootsQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    getAnswer,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/ordering/index.d.ts

@@ -2,4 +2,10 @@ export * from "./integerOrdering.js";
 export * from "./decimalOrdering.js";
 export * from "./framing.js";
 export * from "./decimalOrderingNoRelatives.js";
+export * from "./compareFracAndDec.js";
+export * from "./compareA10N.js";
+export * from "./compareABUsingQuotient.js";
+export * from "./comparePowersOfFracs.js";
+export * from "./compareFracABWithFracAPlusCBPlusC.js";
+export * from "./compareWithSquareRoots.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/ordering/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,cAAc,CAAC;AAC7B,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,kBAAkB,CAAC;AACjC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wCAAwC,CAAC;AACvD,cAAc,6BAA6B,CAAC"}

package/lib/exercises/math/calcul/ordering/index.js

@@ -2,3 +2,9 @@ export * from "./integerOrdering.js";
 export * from "./decimalOrdering.js";
 export * from "./framing.js";
 export * from "./decimalOrderingNoRelatives.js";
+export * from "./compareFracAndDec.js";
+export * from "./compareA10N.js";
+export * from "./compareABUsingQuotient.js";
+export * from "./comparePowersOfFracs.js";
+export * from "./compareFracABWithFracAPlusCBPlusC.js";
+export * from "./compareWithSquareRoots.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"estimateAroundPow10NTimesAroundPow10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/estimateAroundPow10NTimesAroundPow10N.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;CACX,CAAC;AA+EF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAoBvE,CAAC"}

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

@@ -0,0 +1,84 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { toSeperatedThousands } from "../../../../utils/numberPrototype/toSeparatedThousands.js";
+const toPrettyString = (node) => {
+    return toSeperatedThousands("" + node.evaluate().toFixed(0));
+};
+const getInstruction = (identifiers) => {
+    const { n, c, d } = identifiers;
+    const [tex1, tex2] = [c, d].map((k) => toPrettyString(add(power(10, n), k)));
+    return `Laquelle de ces propositions est un ordre de grandeur de $${tex1} \\times ${tex2}$ ?`;
+};
+const getHint = (identifiers) => {
+    const { n } = identifiers;
+    return `Les deux facteurs sont tous les deux proches de $10^{${n}}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { n, c, d } = identifiers;
+    const [tex1, tex2] = [c, d].map((k) => toPrettyString(add(power(10, n), k)));
+    return `$(${tex1} \\times ${tex2})$ est proche de $(10^{${n}} \\times 10^{${n}})$ et donc de $10^{${2 * n}}$ `;
+};
+const getAnswer = (identifiers) => {
+    const { n } = identifiers;
+    return `10^{${2 * n}}`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        return ansNode
+            .simplify({ calculatePowers: true })
+            .equals(answerNode.simplify({ calculatePowers: true }));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPropositions = (nbProps, { answer, ...identifiers }) => {
+    const { n } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, toPrettyString(power(10, 2 * n)), "tex");
+    tryToAddWrongProp(propositions, toPrettyString(power(10, n)), "tex");
+    tryToAddWrongProp(propositions, toPrettyString(power(10, n + 1)), "tex");
+    tryToAddWrongProp(propositions, toPrettyString(power(10, 2 * n + 2)), "tex");
+    return shuffleProps(propositions, nbProps);
+};
+const getEstimatePow10NPlusPow10MinusNQuestion = () => {
+    const n = randint(1, 5);
+    const [c, d] = [0, 1].map(() => (coinFlip() ? 1 : -1) * randint(1, 3));
+    return getQuestionFromIdentifiers({ n, c, d });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const estimateAroundPow10NTimesAroundPow10N = {
+    id: "estimateAroundPow10NTimesAroundPow10N",
+    label: "Donner un ordre de grandeur de ($10^{n}+c)(10^{n}+c')$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getEstimatePow10NPlusPow10MinusNQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    getAnswer,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    n: number;
+    varName: string;
+};
+export declare const estimatePow10NPlusPow10MinusN: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=estimatePow10NPlusPow10MinusN.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"estimatePow10NPlusPow10MinusN.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/estimatePow10NPlusPow10MinusN.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAwFF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAoB/D,CAAC"}

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

@@ -0,0 +1,90 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { n, varName } = identifiers;
+    const A = varName;
+    return `On considère  $${A}=10^{${n}}+10^{-${n}}$. 
+  
+À quoi $A$ est-il environ égal ?`;
+};
+const getHint = (identifiers) => {
+    const { n } = identifiers;
+    return `Combien vaut $10^{${n}}$ ? et $10^{-${n}}$ ?`;
+};
+const getCorrection = (identifiers) => {
+    const { n, varName } = identifiers;
+    const A = varName;
+    return `
+$$
+10^{${n}} = ${("" + power(10, n).evaluate().toFixed(0)).replace(".", ",")}
+$$
+
+$$
+10^{${-n}} = ${("" + power(10, -n).evaluate().toFixed(n)).replace(".", ",")}
+$$
+  
+Comme $10^{${n}}$ est largement supérieur à $10^{-${n}}$, un ordre de grandeur de $${A}$ est $10^{${n}}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { n } = identifiers;
+    return `10^{${n}}`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        return ansNode.simplify().equals(answerNode.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPropositions = (nbProps, { answer, ...identifiers }) => {
+    const { n } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, `10^{${n}}`, "tex");
+    tryToAddWrongProp(propositions, `${(0).frenchify()}`, "tex");
+    tryToAddWrongProp(propositions, `10^0`, "tex");
+    tryToAddWrongProp(propositions, `100^0`, "tex");
+    tryToAddWrongProp(propositions, `20^{-{${n}^2}}`, "tex");
+    tryToAddWrongProp(propositions, `20^{${n}}`, "tex");
+    return shuffleProps(propositions, nbProps);
+};
+const getEstimatePow10NPlusPow10MinusNQuestion = () => {
+    const n = randint(0, 15, [0]);
+    const varName = random(["A", "B", "C", "D", "E"]);
+    return getQuestionFromIdentifiers({ n, varName });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const estimatePow10NPlusPow10MinusN = {
+    id: "estimatePow10NPlusPow10MinusN",
+    label: "Estimer $10^{n}+10^{-n}$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getEstimatePow10NPlusPow10MinusNQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    getAnswer,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -1,3 +1,5 @@
 export * from "./rounding.js";
 export * from "./getPhysicalOrderOfMagnitude.js";
+export * from "./estimatePow10NPlusPow10MinusN.js";
+export * from "./estimateAroundPow10NTimesAroundPow10N.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,kCAAkC,CAAC;AACjD,cAAc,oCAAoC,CAAC;AACnD,cAAc,4CAA4C,CAAC"}

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

@@ -1,2 +1,4 @@
 export * from "./rounding.js";
 export * from "./getPhysicalOrderOfMagnitude.js";
+export * from "./estimatePow10NPlusPow10MinusN.js";
+export * from "./estimateAroundPow10NTimesAroundPow10N.js";

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { AlgebraicNode } from "../../../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    problemSkeletonIndex: number;
+    groupNameToVarNameToValue: Record<string, Record<string, AlgebraicNode>>;
+    mysteryVarPath: string;
+    shuffleArrays: number[][];
+    equalNodeIds: NodeIdentifiers;
+};
+export declare const equationFromProblem: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=equationFromProblem.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"equationFromProblem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromProblem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AActE,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA0mBF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAarD,CAAC"}