math-exercises 2.0.44 → 2.1.1

package/lib/exercises/math/percent/reciprocalPercentage.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reciprocalPercentage = void 0;
+const randint_1 = require("../../../math/utils/random/randint");
+const exercise_1 = require("../../exercise");
+const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
+const shuffle_1 = require("../../../utils/shuffle");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const round_1 = require("../../../math/utils/round");
+const getReciprocalPercentageQuestion = () => {
+    const randPercent = (0, randint_1.randint)(1, 50);
+    let ans = 0;
+    const isUp = (0, coinFlip_1.coinFlip)();
+    let instruction = `Le prix d'un article subit une ${isUp ? "hausse" : "baisse"} de $${randPercent}\\%$. Quelle évolution devra-t-il subir pour revenir à son prix initial (arrondir au centième de pourcentage) ?`;
+    ans = isUp
+        ? (1 / (1 + randPercent / 100) - 1) * 100
+        : (1 / (1 - randPercent / 100) - 1) * 100;
+    const answer = `${(ans > 0
+        ? "+" + (0, round_1.round)(ans, 2)
+        : "" + (0, round_1.round)(ans, 2)).replace(".", ",")}\\%`;
+    const question = {
+        instruction,
+        answer,
+        keys: ["percent"],
+        answerFormat: "tex",
+        identifiers: { isUp, randPercent },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        let wrongAnswer = Number(answer.replace(",", ".").replace("+", "").replace(`\\%`, ""));
+        const deviation = Math.random() < 0.5 ? -1 : 1;
+        const percentDeviation = Math.random() * 20 + 1;
+        wrongAnswer += deviation * percentDeviation;
+        wrongAnswer = (0, round_1.round)(wrongAnswer, 2);
+        (0, exercise_1.tryToAddWrongProp)(propositions, `${(wrongAnswer > 0 ? "+" + wrongAnswer : "" + wrongAnswer).replace(".", ",")} \\%`);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const allowedTex = [answer];
+    if (answer[0] === "+")
+        allowedTex.push(answer.slice(1));
+    return allowedTex.includes(ans);
+};
+exports.reciprocalPercentage = {
+    id: "reciprocalPercentage",
+    connector: "=",
+    label: "Calculer un taux d'évolution réciproque",
+    levels: ["2nde", "1rePro", "TermPro", "1reTech", "TermTech"],
+    sections: ["Pourcentages"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getReciprocalPercentageQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/percent/valuePercent.d.ts

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

package/lib/exercises/math/percent/valuePercent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"valuePercent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/percent/valuePercent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAmCF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}

package/lib/exercises/math/percent/valuePercent.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valuePercent = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const decimal_1 = require("../../../math/numbers/decimals/decimal");
+const randint_1 = require("../../../math/utils/random/randint");
+const round_1 = require("../../../math/utils/round");
+const getValuePercentQuestion = () => {
+    const percent = (0, randint_1.randint)(1, 100);
+    const nb = (0, randint_1.randint)(1, 100);
+    const ans = (0, round_1.round)((percent * nb) / 100, 2).frenchify();
+    const question = {
+        answer: ans + "",
+        instruction: `Calculer $${percent}\\%$ de $${nb}$.`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { percent, nb },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, percent, nb }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, decimal_1.DecimalConstructor.random(0, 100).toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, percent, nb }) => {
+    return ans === answer;
+};
+exports.valuePercent = {
+    id: "valuePercent",
+    connector: "=",
+    label: "Calculer un pourcentage",
+    levels: ["3ème", "2ndPro", "2nde", "1reESM", "1rePro"],
+    isSingleStep: true,
+    sections: ["Pourcentages"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getValuePercentQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"calculateNegativePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculateNegativePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAmEF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

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

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateNegativePower = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const power_1 = require("../../../math/numbers/integer/power");
+const rational_1 = require("../../../math/numbers/rationals/rational");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const getCalculatePowerQuestion = () => {
+    const int = (0, randint_1.randint)(1, 11);
+    const power = (0, randint_1.randint)(-5, 0);
+    const statement = new powerNode_1.PowerNode(new numberNode_1.NumberNode(int), new numberNode_1.NumberNode(power)).toTex();
+    const answer = new rational_1.Rational(1, int ** Math.abs(power))
+        .simplify()
+        .toTree()
+        .toTex();
+    const question = {
+        answer,
+        instruction: `Calculer : $${statement}$`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { int, power },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, int, power }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, int * power + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, -(int ** Math.abs(power)) + "");
+    (0, exercise_1.tryToAddWrongProp)(propositions, int * power + "");
+    if (int === 1) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, power + "");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "0");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "1");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "-1");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "2");
+        (0, exercise_1.tryToAddWrongProp)(propositions, -power + "");
+    }
+    while (propositions.length < n) {
+        const wrongAnswer = new rational_1.Rational(1, int ** (0, randint_1.randint)(0, 6, [power]))
+            .simplify()
+            .toTree()
+            .toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { int, power }) => {
+    const answerTree = new rational_1.Rational(1, int ** Math.abs(power))
+        .simplify()
+        .toTree({ allowFractionToDecimal: true });
+    const secondTree = new fractionNode_1.FractionNode(new numberNode_1.NumberNode(1), new power_1.Power(int, -power).simplify());
+    const texs = [...answerTree.toAllValidTexs(), ...secondTree.toAllValidTexs()];
+    console.log(texs);
+    return texs.includes(ans);
+};
+exports.calculateNegativePower = {
+    id: "calculateNegativePower",
+    connector: "=",
+    label: "Calculer une puissance négative",
+    levels: ["4ème", "3ème", "2ndPro", "2nde", "CAP"],
+    isSingleStep: true,
+    sections: ["Puissances"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCalculatePowerQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"calculatePower.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/calculatePower.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAuDF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

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

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculatePower = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const getCalculatePowerQuestion = () => {
+    const int = (0, randint_1.randint)(-10, 11);
+    const power = (0, randint_1.randint)(0, 6);
+    const statement = new powerNode_1.PowerNode(new numberNode_1.NumberNode(int), new numberNode_1.NumberNode(power)).toTex();
+    const answer = int ** power + "";
+    const question = {
+        answer,
+        instruction: `Calculer : $${statement}$`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { int, power },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, int, power }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, int * power + "");
+    if (int < 0)
+        (0, exercise_1.tryToAddWrongProp)(propositions, -(int ** power) + "");
+    if (int === 0) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, power + "");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "1");
+        (0, exercise_1.tryToAddWrongProp)(propositions, -power + "");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "-1");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "2");
+    }
+    if (int === 1 || int === -1) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, power + "");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "0");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "1");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "-1");
+        (0, exercise_1.tryToAddWrongProp)(propositions, "2");
+        (0, exercise_1.tryToAddWrongProp)(propositions, -power + "");
+    }
+    while (propositions.length < n) {
+        const wrongAnswer = int ** (0, randint_1.randint)(0, 6, [power]) + "";
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.calculatePower = {
+    id: "calculatePower",
+    connector: "=",
+    label: "Calculer une puissance",
+    levels: ["4ème", "3ème", "2ndPro", "2nde", "CAP"],
+    isSingleStep: true,
+    sections: ["Puissances"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCalculatePowerQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,7 @@
+import { Exercise } from "../../exercise";
+type Identifiers = {
+    decimal: number;
+};
+export declare const decimalToScientific: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=decimalToScientific.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decimalToScientific.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/decimalToScientific.ts"],"names":[],"mappings":"AAaA,OAAO,EACL,QAAQ,EAST,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAqDF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CA2BrD,CAAC"}

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

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decimalToScientific = void 0;
+const decimal_1 = require("../../../math/numbers/decimals/decimal");
+const integer_1 = require("../../../math/numbers/integer/integer");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const probaFlip_1 = require("../../../utils/probaFlip");
+const exercise_1 = require("../../exercise");
+const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
+const getDecimalToScientificQuestion = () => {
+    const isZero = (0, probaFlip_1.probaFlip)(0.2);
+    let intPart, dec;
+    if (isZero) {
+        dec = decimal_1.DecimalConstructor.fromParts("0", decimal_1.DecimalConstructor.randomFracPart((0, randint_1.randint)(2, 5), (0, randint_1.randint)(1, 4)));
+    }
+    else {
+        intPart = integer_1.IntegerConstructor.random((0, randint_1.randint)(2, 5));
+        dec = decimal_1.DecimalConstructor.fromParts(intPart.toString(), decimal_1.DecimalConstructor.randomFracPart((0, randint_1.randint)(1, 5)));
+    }
+    const decTex = dec.toTree().toTex();
+    const answer = dec.toScientificNotation().toTex();
+    const question = {
+        instruction: `Donner l'écriture scientifique de : $${decTex}$`,
+        startStatement: decTex,
+        answer: answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { decimal: dec.value },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, decimal }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const dec = new decimal_1.Decimal(decimal);
+    while (propositions.length < n) {
+        const wrongAnswer = new multiplyNode_1.MultiplyNode(dec.toScientificPart(), new powerNode_1.PowerNode(new numberNode_1.NumberNode(10), new numberNode_1.NumberNode((0, randint_1.randint)(-5, 5, [0, 1])))).toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { decimal }) => {
+    const answerTree = new decimal_1.Decimal(decimal).toScientificNotation();
+    const texs = answerTree.toAllValidTexs({ forbidPowerToProduct: true });
+    console.log(ans, texs);
+    return texs.includes(ans);
+};
+exports.decimalToScientific = {
+    id: "decimalToScientific",
+    connector: "=",
+    label: "Passer d'écriture décimale à écriture scientifique",
+    levels: [
+        "5ème",
+        "4ème",
+        "3ème",
+        "2nde",
+        "CAP",
+        "2ndPro",
+        "1reESM",
+        "1rePro",
+        "1reSpé",
+        "1reTech",
+        "TermPro",
+        "TermTech",
+    ],
+    sections: ["Puissances"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDecimalToScientificQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,10 @@
+export * from "./calculateNegativePower";
+export * from "./calculatePower";
+export * from "./decimalToScientific";
+export * from "./powerDefinition";
+export * from "./powersDivision";
+export * from "./powersOfTenToDecimal";
+export * from "./powersPower";
+export * from "./powersProduct";
+export * from "./scientificToDecimal";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,iBAAiB,CAAC;AAChC,cAAc,uBAAuB,CAAC"}

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

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./calculateNegativePower"), exports);
+__exportStar(require("./calculatePower"), exports);
+__exportStar(require("./decimalToScientific"), exports);
+__exportStar(require("./powerDefinition"), exports);
+__exportStar(require("./powersDivision"), exports);
+__exportStar(require("./powersOfTenToDecimal"), exports);
+__exportStar(require("./powersPower"), exports);
+__exportStar(require("./powersProduct"), exports);
+__exportStar(require("./scientificToDecimal"), exports);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"powerDefinition.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powerDefinition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAqDF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}

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

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.powerDefinition = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const getPowerDefinitionQuestion = () => {
+    const int = (0, randint_1.randint)(2, 11);
+    const power = (0, randint_1.randint)(2, 6);
+    let statement = "";
+    for (let i = 0; i < power; i++) {
+        statement += int + "";
+        if (i < power - 1)
+            statement += "\\times";
+    }
+    const answer = new powerNode_1.PowerNode(new numberNode_1.NumberNode(int), new numberNode_1.NumberNode(power)).toTex();
+    const question = {
+        answer,
+        instruction: `Écrire sous forme de puissance : $${statement}$`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { int, power },
+    };
+    return question;
+};
+const isAnswerValid = (ans, { int, power }) => {
+    const answer = new powerNode_1.PowerNode(new numberNode_1.NumberNode(int), new numberNode_1.NumberNode(power)).toTex();
+    return ans === answer;
+};
+const getPropositions = (n, { answer, int, power }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${power}\\times${int}`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${int}\\times${power}`);
+    while (propositions.length < n) {
+        const wrongAnswer = new powerNode_1.PowerNode(new numberNode_1.NumberNode(int), new numberNode_1.NumberNode((0, randint_1.randint)(2, 7))).toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+exports.powerDefinition = {
+    id: "powerDefinition",
+    connector: "=",
+    label: "Écrire un produit sous forme de puissance",
+    levels: ["4ème", "3ème", "2ndPro", "CAP"],
+    isSingleStep: true,
+    sections: ["Puissances"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getPowerDefinitionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"powersDivision.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersDivision.ts"],"names":[],"mappings":"AAAA;;GAEG;AAQH,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmDF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CA4BhD,CAAC;AACF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

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

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * a^b/a^c
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.powersOfTenDivision = exports.powersDivision = void 0;
+const power_1 = require("../../../math/numbers/integer/power");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const fractionNode_1 = require("../../../tree/nodes/operators/fractionNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const exercise_1 = require("../../exercise");
+const getDistinctQuestions_1 = require("../../utils/getDistinctQuestions");
+const getPowersDivisionQuestion = (opts) => {
+    let a = opts.useOnlyPowersOfTen ? 10 : (0, randint_1.randint)(-11, 11, [0]);
+    const [b, c] = [1, 2].map((el) => (0, randint_1.randint)(-11, 11));
+    const statement = new fractionNode_1.FractionNode(new powerNode_1.PowerNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(b)), new powerNode_1.PowerNode(new numberNode_1.NumberNode(a), new numberNode_1.NumberNode(c)));
+    const answerTree = new power_1.Power(a, b - c).simplify();
+    const answer = answerTree.toTex();
+    const question = {
+        instruction: `Simplifier : $${statement.toTex()}$`,
+        startStatement: statement.toTex(),
+        answer,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { a, b, c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const wrongPower = b - c + (0, randint_1.randint)(-5, 6, [0, c - b]);
+        const wrongAnswerTree = new power_1.Power(a === 1 || a === -1 ? (0, randint_1.randint)(-3, 4, [-1, 1]) : a, wrongPower).simplify(); // pour éviter les 1 1 -1 1 dans propositions
+        const wrongAnswer = wrongAnswerTree.toTex();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const power = new power_1.Power(a, b - c);
+    const answerTree = power.simplify();
+    const texs = answerTree.toAllValidTexs();
+    const rawTex = power.toTree().toTex();
+    if (!texs.includes(rawTex))
+        texs.push(rawTex);
+    return texs.includes(ans);
+};
+exports.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) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getPowersDivisionQuestion({ useOnlyPowersOfTen: false }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};
+exports.powersOfTenDivision = {
+    id: "powersOfTenDivision",
+    connector: "=",
+    label: "Division de puissances de 10",
+    levels: ["4ème", "3ème", "2nde"],
+    sections: ["Puissances"],
+    isSingleStep: true,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(() => getPowersDivisionQuestion({ useOnlyPowersOfTen: true }), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,10 @@
+/**
+ * 10^(-x) into 0,0...1
+ */
+import { Exercise } from "../../exercise";
+type Identifiers = {
+    randPower: number;
+};
+export declare const powersOfTenToDecimal: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=powersOfTenToDecimal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"powersOfTenToDecimal.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/powers/powersOfTenToDecimal.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,OAAO,EACL,QAAQ,EAQT,MAAM,gBAAgB,CAAC;AAGxB,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4CF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CA4BtD,CAAC"}