math-exercises 3.0.214 → 3.0.216

package/lib/exercises/math/calcul/relatives/relativesAddAndSub.js

@@ -0,0 +1,448 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { isOppositeNode } from "../../../../tree/nodes/functions/oppositeNode.js";
+import { isNumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
+const getStatementNode = (identifiers) => {
+    const { a, b, opType } = identifiers;
+    switch (opType) {
+        case "addition": {
+            return add(a, b);
+        }
+        case "soustraction": {
+            return substract(a, b);
+        }
+        default:
+            throw new Error("Unsupported opType: " + opType);
+    }
+};
+const getStartStatement = (identifiers) => {
+    const { explicitWriting } = identifiers;
+    return getStatementNode(identifiers).toTex({
+        explicitNumberWriting: explicitWriting,
+    });
+};
+const getInstruction = (identifiers, opts) => {
+    return `Calculer : 
+  
+$$
+${getStartStatement(identifiers, opts)}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { explicitWriting } = identifiers;
+    const nodeInstruction = getStatementNode(identifiers);
+    return nodeInstruction
+        .simplify({ towardsDistribute: true })
+        .toTex({ explicitNumberWriting: explicitWriting });
+};
+const getHint = (identifiers) => {
+    const { a, b, opType } = identifiers;
+    const [texA, texB] = [a, b].map((v) => v.toTree().toTex({ explicitNumberWriting: true }));
+    switch (opType) {
+        case "addition": {
+            if (a > 0 && b > 0) {
+                return `Les nombres $${texA}$ et $${texB}$ sont tous les deux positifs. 
+Tu peux effectuer l'opération comme avec des entiers naturels, puisque $${texA}=${a}$ et que $${texB}=${b}$.`;
+            }
+            else if (a < 0 && b < 0) {
+                return `Les nombres $${texA}$ et $${texB}$ sont tous les deux négatifs. 
+Quand on ajoute un nombre négatif à un nombre négatif, le résultat est davantage négatif.
+Exemple : 
+
+$$
+(-10) \\ + \\ (-6) \\ = \\ (-16)
+$$
+
+`;
+            }
+            else if (a < 0 && b > 0) {
+                const [vAbsA, vAbsB] = [a, b].map((v) => Math.abs(v));
+                if (vAbsA > vAbsB) {
+                    return `Les nombres $${texA}$ et $${texB}$ sont de signes différents. 
+$${vAbsA} > ${vAbsB}$ donc le résultat sera négatif.`;
+                }
+                else if (vAbsA < vAbsB) {
+                    return `Les nombres $${texA}$ et $${texB}$ sont de signes différents. 
+$${vAbsA} < ${vAbsB}$ donc le résultat sera positif.`;
+                }
+                else {
+                    return `La somme d'un nombre et de son opposé vaut $0$.`;
+                }
+                // } else  if (a > 0 && b < 0) {
+            }
+            else {
+                const [vAbsA, vAbsB] = [a, b].map((v) => Math.abs(v));
+                if (vAbsA > vAbsB) {
+                    return `Les nombres $${texA}$ et $${texB}$ sont de signes différents. 
+$${vAbsA} > ${vAbsB}$ donc le résultat sera positif.`;
+                }
+                else if (vAbsA < vAbsB) {
+                    return `Les nombres $${texA}$ et $${texB}$ sont de signes différents. 
+$${vAbsA} < ${vAbsB}$ donc le résultat sera négatif.`;
+                }
+                else {
+                    return `La somme d'un nombre et de son opposé vaut $0$.`;
+                }
+            }
+        }
+        case "soustraction": {
+            if (a > 0 && b > 0) {
+                if (a > b) {
+                    return `Les nombres $${texA}$ et $${texB}$ sont tous les deux positifs. 
+Tu peux effectuer l'opération comme avec des entiers naturels, puisque $${texA}=${a}$, que $${texB}=${b}$ et que $${a}>${b}$.`;
+                }
+                else {
+                    return `Les nombres $${texA}$ et $${texB}$ sont tous les deux positifs. 
+On a $${texA}=${a}$, que $${texB}=${b}$ et que $${a}<${b}$. Le résultat sera donc négatif.
+Utilise le fait que $${b} = ${a} + ${b - a}$ pour trouver le résultat.`;
+                }
+            }
+            else if (a < 0 && b < 0) {
+                const [vAbsA, vAbsB] = [a, b].map((v) => Math.abs(v));
+                if (vAbsA > vAbsB) {
+                    return `Les nombres $${texA}$ et $${texB}$ sont tous les deux négatifs.
+On a $${vAbsA}>${vAbsB}$. Le résultat sera donc négatif (comme $${texA}$), mais sa valeur absolue sera moins grande que $${vAbsA}$.
+
+Voici un exemple :
+$$
+(-16) \\ - \\ (-6) \\ = \\ (-10)
+$$
+
+`;
+                }
+                else {
+                    return `Les nombres $${texA}$ et $${texB}$ sont tous les deux négatifs.
+On a $${vAbsA}<${vAbsB}$. Le résultat sera donc positif.
+
+Voici un exemple :
+$$
+(-10) \\ - \\ (-16) \\ = \\ (+6)
+$$
+
+`;
+                }
+            }
+            else {
+                return `Soustraire un nombre, c'est ajouter son opposé. 
+Autrement dit, soustraire $${b}$, c'est ajouter $${-b}$.`;
+            }
+        }
+        default:
+            throw new Error("Unsupported opType: " + opType);
+    }
+};
+const getCorrection = (identifiers) => {
+    const { a, b, opType, explicitWriting } = identifiers;
+    const [texA, texB] = [a, b].map((v) => v.toTree().toTex({ explicitNumberWriting: true }));
+    return `${(() => {
+        switch (opType) {
+            case "addition": {
+                if (a > 0 && b > 0) {
+                    return `Les nombres $${texA}$ et $${texB}$ sont tous les deux positifs. 
+On peut effectuer l'opération comme avec des entiers naturels, puisque $${texA}=${a}$ et que $${texB}=${b}$.
+
+$$
+${getStatementNode(identifiers).toTex({
+                        explicitNumberWriting: explicitWriting,
+                    })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                }
+                else if (a < 0 && b < 0) {
+                    return `Les nombres $${texA}$ et $${texB}$ sont tous les deux négatifs. 
+Quand on ajoute un nombre négatif à un nombre négatif, le résultat est davantage négatif.
+
+$$
+${getStatementNode(identifiers).toTex({
+                        explicitNumberWriting: explicitWriting,
+                    })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                }
+                else if (a < 0 && b > 0) {
+                    const [vAbsA, vAbsB] = [a, b].map((v) => Math.abs(v));
+                    if (vAbsA > vAbsB) {
+                        return `Les nombres $${texA}$ et $${texB}$ sont de signes différents. 
+$${vAbsA} > ${vAbsB}$ donc le résultat sera négatif.
+
+$$
+${getStatementNode(identifiers).toTex({
+                            explicitNumberWriting: explicitWriting,
+                        })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                    }
+                    else if (vAbsA < vAbsB) {
+                        return `Les nombres $${texA}$ et $${texB}$ sont de signes différents. 
+$${vAbsA} < ${vAbsB}$ donc le résultat sera positif.
+
+$$
+${getStatementNode(identifiers).toTex({
+                            explicitNumberWriting: explicitWriting,
+                        })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                    }
+                    else {
+                        return `La somme d'un nombre et de son opposé vaut $0$.
+            
+$$
+${getStatementNode(identifiers).toTex({
+                            explicitNumberWriting: explicitWriting,
+                        })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                    }
+                    // } else  if (a > 0 && b < 0) {
+                }
+                else {
+                    const [vAbsA, vAbsB] = [a, b].map((v) => Math.abs(v));
+                    if (vAbsA > vAbsB) {
+                        return `Les nombres $${texA}$ et $${texB}$ sont de signes différents. 
+$${vAbsA} > ${vAbsB}$ donc le résultat sera positif.
+
+$$
+${getStatementNode(identifiers).toTex({
+                            explicitNumberWriting: explicitWriting,
+                        })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                    }
+                    else if (vAbsA < vAbsB) {
+                        return `Les nombres $${texA}$ et $${texB}$ sont de signes différents. 
+$${vAbsA} < ${vAbsB}$ donc le résultat sera négatif.
+
+$$
+${getStatementNode(identifiers).toTex({
+                            explicitNumberWriting: explicitWriting,
+                        })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                    }
+                    else {
+                        return `La somme d'un nombre et de son opposé vaut $0$.
+
+$$
+${getStatementNode(identifiers).toTex({
+                            explicitNumberWriting: explicitWriting,
+                        })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                    }
+                }
+            }
+            case "soustraction": {
+                if (a > 0 && b > 0) {
+                    if (a > b) {
+                        return `Les nombres $${texA}$ et $${texB}$ sont tous les deux positifs. 
+On peut effectuer l'opération comme avec des entiers naturels, puisque $${texA}=${a}$, que $${texB}=${b}$ et que $${a}>${b}$.
+
+$$
+${getStatementNode(identifiers).toTex({
+                            explicitNumberWriting: explicitWriting,
+                        })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                    }
+                    else {
+                        return `Les nombres $${texA}$ et $${texB}$ sont tous les deux positifs. 
+On a $${texA}=${a}$, que $${texB}=${b}$ et que $${a}<${b}$. Le résultat sera donc négatif.
+On utilise le fait que $${b} = ${a} + ${b - a}$ pour trouver le résultat :
+
+$$
+${getStatementNode(identifiers).toTex({
+                            explicitNumberWriting: explicitWriting,
+                        })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                    }
+                }
+                else if (a < 0 && b < 0) {
+                    const [vAbsA, vAbsB] = [a, b].map((v) => Math.abs(v));
+                    if (vAbsA > vAbsB) {
+                        return `Les nombres $${texA}$ et $${texB}$ sont tous les deux négatifs.
+On a $${vAbsA}>${vAbsB}$. Le résultat sera donc négatif (comme $${texA}$), mais sa valeur absolue sera moins grande que $${vAbsA}$.
+
+$$
+${getStatementNode(identifiers).toTex({
+                            explicitNumberWriting: explicitWriting,
+                        })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                    }
+                    else {
+                        return `Les nombres $${texA}$ et $${texB}$ sont tous les deux négatifs.
+On a $${vAbsA}<${vAbsB}$. Le résultat sera donc positif.
+
+$$
+${getStatementNode(identifiers).toTex({
+                            explicitNumberWriting: explicitWriting,
+                        })} = ${getAnswer(identifiers)}
+$$
+
+`;
+                    }
+                }
+                else {
+                    return `Soustraire un nombre, c'est ajouter son opposé. 
+Autrement dit, soustraire $${b}$, c'est ajouter $${-b}$.
+
+${alignTex([
+                        [
+                            getStatementNode(identifiers).toTex({
+                                explicitNumberWriting: explicitWriting,
+                            }),
+                            "=",
+                            getStatementNode({ ...identifiers, opType: "addition", b: -b }).toTex({
+                                explicitNumberWriting: true,
+                            }),
+                        ],
+                        ["", "=", getAnswer(identifiers)],
+                    ])}
+
+`;
+                }
+            }
+            default:
+                throw new Error("Unsupported opType: " + opType);
+        }
+    })()}`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //student: add <-> sub
+    {
+        const { opType } = identifiers;
+        const opTypeWrong = opType === "addition" ? "soustraction" : "addition";
+        const identifiersWrong = {
+            ...identifiers,
+            opType: opTypeWrong,
+        };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    }
+    //student: a -> |a|, b -> |b|
+    {
+        const { a, b } = identifiers;
+        const aWrong = Math.abs(a);
+        const bWrong = Math.abs(b);
+        const identifiersWrong = {
+            ...identifiers,
+            a: aWrong,
+            b: bWrong,
+        };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    }
+    propWhile(propositions, n, () => {
+        const { explicitWriting } = identifiers;
+        const randomOffset = randint(-9, 10, [0]);
+        const wrongAnswer = parseAlgebraic(answer).evaluate() + randomOffset;
+        tryToAddWrongProp(propositions, wrongAnswer.toTree().toTex({ explicitNumberWriting: explicitWriting }));
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    if (ans === answer) {
+        return true;
+    }
+    else {
+        const nodeAns = parseAlgebraic(ans);
+        const isCandidateAns = (nodeAns) => {
+            return (isNumberNode(nodeAns) ||
+                (isOppositeNode(nodeAns) && isNumberNode(nodeAns.child)));
+        };
+        if (!isCandidateAns(nodeAns)) {
+            return false;
+        }
+        const nodeAnswer = parseAlgebraic(answer);
+        return NodeComparator.isEqualViaSub(nodeAns, nodeAnswer);
+    }
+};
+const getRelativesAddAndSubQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        ...(optsIn ?? optsDefault),
+        opType: random(arrayedOpts.opType),
+    };
+    const explicitWriting = opts.explicitWriting === "Explicite (parenthèses autour de chaque nombre)";
+    const a = randint(-9, 10, [0]);
+    const b = !explicitWriting && opts.opType === "addition"
+        ? randint(1, 10, [0])
+        : randint(-9, 10, [0]);
+    const identifiers = { a, b, opType: opts.opType, explicitWriting };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        startStatement: getStartStatement(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const optsDefault = {
+    explicitWriting: "Explicite (parenthèses autour de chaque nombre)",
+};
+const arrayedOptsDefault = {
+    opType: ["addition"],
+};
+const options = [
+    {
+        id: "explicitWriting",
+        label: "Type d'écriture",
+        target: GeneratorOptionTarget.instruction,
+        type: GeneratorOptionType.select,
+        values: ["Explicite (parenthèses autour de chaque nombre)", "Simplifiée"],
+        defaultValue: optsDefault.explicitWriting,
+    },
+    {
+        id: "opType",
+        label: "Type d'opération",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["addition", "soustraction"],
+        defaultValue: arrayedOptsDefault.opType,
+    },
+];
+export const relativesAddAndSub = {
+    id: "relativesAddAndSub",
+    connector: "=",
+    label: "Addition ou soustraction de nombres relatifs",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRelativesAddAndSubQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getAnswer,
+    getStartStatement,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"factoByXK.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/factoByXK.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;IACX,CAAC,EAAE,MAAM,CAAC;IACV,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AA4MF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}

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

@@ -0,0 +1,190 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { gcd } from "../../../../math/utils/arithmetic/gcd.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.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";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { a, b, k1, k2 } = identifiers;
+    const nodeMonomA = multiply(a, power("x".toTree(), k1)).simplify();
+    const nodeMonomB = multiply(b, power("x".toTree(), k2)).simplify();
+    const nodeSum = add(nodeMonomA, nodeMonomB);
+    return {
+        nodeMonomA,
+        nodeMonomB,
+        nodeSum,
+    };
+};
+const getStatementNode = (identifiers) => {
+    const { nodeSum } = getHydrated(identifiers);
+    return nodeSum;
+};
+const getInstruction = (identifiers) => {
+    const statement = getStatementNode(identifiers);
+    return `Factoriser : 
+  
+$$
+${statement.toTex()}
+$$`;
+};
+const getAnswerNode = (identifiers) => {
+    const { a, b, k1, k2 } = identifiers;
+    let pgcd = gcd(a, b);
+    if (a < 0 && b < 0)
+        pgcd = -pgcd;
+    const strK1K2 = `${k1}${k2}`;
+    switch (strK1K2) {
+        case "11": {
+            return multiply(a + b, "x");
+        }
+        case "12": {
+            const affine = add(a / pgcd, multiply(b / pgcd, "x"));
+            return multiply(multiply(pgcd, "x"), affine);
+        }
+        case "21": {
+            const affine = add(multiply(a / pgcd, "x"), b / pgcd);
+            return multiply(multiply(pgcd, "x"), affine);
+        }
+        case "22": {
+            return multiply(a + b, power("x", 2));
+        }
+        default:
+            throw new Error("Unsupported strK1K2: " + strK1K2);
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { nodeMonomA, nodeMonomB } = getHydrated(identifiers);
+    return `Repère le facteur commun : c'est le terme qui apparaît à la fois dans $${nodeMonomA.toTex()}$ et dans $${nodeMonomB.toTex()}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, k1, k2 } = identifiers;
+    const { nodeMonomA, nodeMonomB } = getHydrated(identifiers);
+    const answer = getAnswer(identifiers);
+    const statement = getStatementNode(identifiers).toTex();
+    let pgcd = gcd(a, b);
+    if (a < 0 && b < 0)
+        pgcd = -pgcd;
+    const [nodeCommon, nodeDetailed] = (() => {
+        const strK1K2 = `${k1}${k2}`;
+        switch (strK1K2) {
+            case "11": {
+                const nodeCommon = "x".toTree();
+                const nodeDetailed = multiply(nodeCommon, add(a, b));
+                return [nodeCommon, nodeDetailed];
+            }
+            case "12": {
+                const nodeCommon = multiply(pgcd, "x");
+                const nodeDetailed = add(multiply(nodeCommon, a / pgcd), multiply(nodeCommon, multiply(b / pgcd, "x").simplify(), {
+                    toTexOptions: { forceTimesSign: true, noPropagation: true },
+                }));
+                return [nodeCommon, nodeDetailed];
+            }
+            case "21": {
+                const nodeCommon = multiply(pgcd, "x");
+                const nodeDetailed = add(multiply(nodeCommon, multiply(a / pgcd, "x").simplify(), {
+                    toTexOptions: { forceTimesSign: true, noPropagation: true },
+                }), multiply(nodeCommon, b / pgcd));
+                return [nodeCommon, nodeDetailed];
+            }
+            case "22": {
+                const nodeCommon = power("x", 2);
+                const nodeDetailed = multiply(nodeCommon, add(a, b));
+                return [nodeCommon, nodeDetailed];
+            }
+            default:
+                throw new Error("Unsupported strK1K2: " + strK1K2);
+        }
+    })();
+    const detailed = nodeDetailed.toTex();
+    return `Le terme $${nodeCommon.toTex()}$ apparaît à la fois dans $${nodeMonomA.toTex()}$ et dans $${nodeMonomB.toTex()}$. 
+
+On peut donc factoriser l'expression par $${nodeCommon.toTex()}$ :
+
+${alignTex([
+        ["", "", statement],
+        ["", "=", detailed],
+        ["", "=", answer],
+    ])}
+  `;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    [
+        [1, 1],
+        [1, 2],
+        [2, 1],
+        [2, 2],
+    ].forEach(([k1, k2]) => {
+        const identifiersWrong = { ...identifiers, k1, k2 };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, multiply("x", AffineConstructor.random().toTree()).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["x"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAnswer = parseAlgebraic(answer);
+        return nodeAnswer.toAllValidTexs().some((tex) => ans === tex);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFactoByXKQuestion = () => {
+    const a = randint(-10, 10, [0], { favor: { value: 1, proba: 0.3 } });
+    const b = randint(-10, 10, [0, -a, a], a !== 1 ? { favor: { value: 1, proba: 0.3 } } : undefined);
+    const [k1, k2] = random([
+        [1, 1],
+        [1, 2],
+        [2, 1],
+        [2, 2],
+    ]);
+    const identifiers = {
+        a,
+        b,
+        k1,
+        k2,
+    };
+    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),
+    };
+    return question;
+};
+export const factoByXK = {
+    id: "factoByXK",
+    connector: "=",
+    label: "Factorisation du type $ax^k + bx^{k'}$",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getFactoByXKQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -8,4 +8,5 @@ export * from "./factoType2.js";
 export * from "./factoByX.js";
 export * from "./factoType3.js";
 export * from "./factoType4.js";
+export * from "./factoByXK.js";
 //# sourceMappingURL=index.d.ts.map

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

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

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

@@ -9,3 +9,4 @@ export * from "./factoByX.js";
 // export * from "./factorizeAX2PlusBX.js"; //! existe déjà
 export * from "./factoType3.js";
 export * from "./factoType4.js";
+export * from "./factoByXK.js";

package/lib/exercises/math/complex/algebraic/addComplex.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    z1Re: number;
+    z1Im: number;
+    z2Re: number;
+    z2Im: number;
+};
+export declare const addComplex: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=addComplex.d.ts.map

package/lib/exercises/math/complex/algebraic/addComplex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"addComplex.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/complex/algebraic/addComplex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAwHF,eAAO,MAAM,UAAU,EAAE,QAAQ,CAAC,WAAW,CAa5C,CAAC"}