math-exercises 3.0.214 → 3.0.215

package/lib/exercises/math/arithmetic/pgcdFromEuclid.js

@@ -0,0 +1,123 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { gcd } from "../../../math/utils/arithmetic/gcd.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer, a, b }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(2, Math.min(a, b)).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    return gcd(a, b).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `À l'aide de l'algorithme d'Euclide, déterminer le PGCD de $${a}$ et $${b}$.`;
+};
+const getHint = () => {
+    return `Pour $a$ et $b$ deux entiers naturels non nuls, l'algorithme d'Euclide consiste à effectuer d'abord la division euclidienne de $a$ par $b$, puis successivement les divisions euclidiennes du diviseur et du reste de la division précedente, jusqu'à obtenir un reste nul.
+  
+Le PGCD de $a$ et $b$ est alors le dernier reste non nul de cette série de divisions.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    let dividend = a;
+    let divisor = b;
+    let q = Math.floor(dividend / divisor);
+    let r = a % b;
+    const coeffs = [[dividend, q, divisor, r]];
+    while (r !== 0) {
+        dividend = divisor;
+        divisor = r;
+        q = Math.floor(dividend / divisor);
+        r = dividend % divisor;
+        coeffs.push([dividend, divisor, q, r]);
+    }
+    return `On commence par écrire la division euclidienne de $${a}$ par $${b}$, puis les divisions euclidiennes successives du diviseur et du reste de la division précédent : 
+  
+${alignTex(coeffs.map((arr) => [
+        `${arr[0]}`,
+        "=",
+        `${arr[1]} \\times ${arr[2]} + ${arr[3]}`,
+    ]))}
+
+Le dernier reste non nul étant $${getAnswer(identifiers)}$, c'est le PGCD de $${a}$ et $${b}$.`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPgcdFromEuclidQuestion = () => {
+    let a = 0;
+    let b = 0;
+    let counter = 0;
+    let pgcd = 0;
+    let iter = 0;
+    do {
+        counter++;
+        if (counter > 1000)
+            throw new Error("too many iterations in getPgcdFromEuclidQuestion");
+        a = randint(500, 2000);
+        b = randint(100, a);
+        iter = 1;
+        let dividend = a;
+        let divisor = b;
+        let q = Math.floor(dividend / divisor);
+        let r = a % b;
+        const coeffs = [[dividend, q, divisor, r]];
+        while (r !== 0) {
+            iter++;
+            dividend = divisor;
+            divisor = r;
+            q = Math.floor(dividend / divisor);
+            r = dividend % divisor;
+            coeffs.push([dividend, divisor, q, r]);
+        }
+        pgcd = gcd(a, b);
+    } while (pgcd === b || iter < 3 || iter > 5);
+    const identifiers = { a, b };
+    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 pgcdFromEuclid = {
+    id: "pgcdFromEuclid",
+    connector: "=",
+    label: "Calculer un PGCD à l'aide de l'algorithme d'Euclide",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPgcdFromEuclidQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/arithmetic/solveDiophantianEquationByUsingPrimality.d.ts

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

package/lib/exercises/math/arithmetic/solveDiophantianEquationByUsingPrimality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"solveDiophantianEquationByUsingPrimality.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/solveDiophantianEquationByUsingPrimality.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AA0GF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAuB1E,CAAC"}

package/lib/exercises/math/arithmetic/solveDiophantianEquationByUsingPrimality.js

@@ -0,0 +1,117 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { pointVEA } from "../../../exercises/vea/pointVEA.js";
+import { Point } from "../../../math/geometry/point.js";
+import { isPrime } from "../../../math/utils/arithmetic/isPrime.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { doWhile } from "../../../utils/doWhile.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const x = randint(50, 100);
+        const y = randint(50, 100, [x]);
+        tryToAddWrongProp(propositions, new Point("A", x, y).toCoords());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    //2x = p+1
+    const { p } = identifiers;
+    return new Point("A", (p + 1) / 2, (p + 1) / 2 - 1).toCoords();
+};
+const getInstruction = (identifiers) => {
+    const { p } = identifiers;
+    return `On admet que $${p}$ est premier.
+  
+Déterminer le couple $(x;y)$ d'entiers naturels qui vérifie :
+
+$$
+x^2-y^2 = ${p}
+$$
+
+On donnera la solution sous la forme $(x;y)$.
+`;
+};
+const getHint = (identifiers) => {
+    const { p } = identifiers;
+    return `Puisque $${p}$ est premier, il n'admet que deux diviseurs : lesquels ?`;
+};
+const getCorrection = (identifiers) => {
+    const { p } = identifiers;
+    return `On commence par factoriser :
+  
+$$
+x^2-y^2 = ${p}\\iff (x-y)(x+y) = ${p}
+$$
+
+Or, puisque $${p}$ est premier, il n'admet que deux diviseurs : $1$ et lui-même.
+
+Cela n'implique que deux possibilités :
+
+- soit $x-y = ${p}$ et $x+y = 1$
+- soit $x-y = 1$ et $x+y = ${p}$
+
+La première possibilité est à exclure, car si $x+y=1$, alors $(x;y) = (0;1)$ ou $(x;y)=(1;0)$, car $x$ et $y$ sont positifs, ce qui ne convient pas.
+
+On a donc le système : 
+
+$$
+\\left\\{\\begin{matrix}
+x-y=1 \\\\
+x+y=${p}
+\\end{matrix}\\right.
+$$
+
+On résout ce système : on trouve $(x;y) = ${getAnswer(identifiers)}$.
+`;
+};
+const getKeys = () => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return pointVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSolveDiophantianEquationByUsingPrimalityQuestion = () => {
+    const p = doWhile(() => randint(100, 500), (x) => !isPrime(x));
+    const identifiers = {
+        p,
+    };
+    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 solveDiophantianEquationByUsingPrimality = {
+    id: "solveDiophantianEquationByUsingPrimality",
+    connector: "=",
+    label: "Résoudre $x^2-y^2 = p$ où $p$ est premier",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSolveDiophantianEquationByUsingPrimalityQuestion(opts), nb, 10),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    maxAllowedQuestions: 10,
+};

package/lib/exercises/math/arithmetic/whichDayInXDays.d.ts

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

package/lib/exercises/math/arithmetic/whichDayInXDays.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"whichDayInXDays.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/whichDayInXDays.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAyEF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAiBjD,CAAC"}

package/lib/exercises/math/arithmetic/whichDayInXDays.js

@@ -0,0 +1,81 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { random } from "../../../utils/alea/random.js";
+import { doWhile } from "../../../utils/doWhile.js";
+import { frenchDays } from "../../../utils/strings/frenchDays.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, random(frenchDays), "raw");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { currentDay, step } = identifiers;
+    const left = step % 7;
+    return frenchDays[(currentDay + left) % 7];
+};
+const getInstruction = (identifiers) => {
+    const { currentDay, step } = identifiers;
+    const day = frenchDays[currentDay];
+    return `Nous sommes ${day}. 
+  
+Quel jour serons-nous dans $${step}$ jours ?`;
+};
+const getHint = () => {
+    return `Il y a $7$ jours dans une semaine...`;
+};
+const getCorrection = (identifiers) => {
+    const { currentDay, step } = identifiers;
+    const day = frenchDays[currentDay];
+    const left = step % 7;
+    const quot = Math.floor(step / 7);
+    const answer = getAnswer(identifiers);
+    return `Il y a $7$ jours dans une semaine. On calcule donc le reste dans la division euclidienne de $${step}$ par $7$ : 
+
+$$
+${step} = 7\\times ${quot} + ${left}
+$$
+
+En ajoutant $${left}$ jours à ${day}, on obtient ${answer}.
+
+Dans $${step}$ jours, nous serons donc ${answer}.
+`;
+};
+const getWhichDayInXDaysQuestion = () => {
+    const identifiers = {
+        currentDay: randint(0, 7),
+        step: doWhile(() => randint(100, 300), (x) => x % 7 === 0),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const whichDayInXDays = {
+    id: "whichDayInXDays",
+    label: "Déterminer le jour que nous serons dans $n$ jours",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getWhichDayInXDaysQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/calcul/fractions/fractionsSumFillInTheBlank.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    denomSrc: number;
+    denom: number;
+    numOperand: number;
+    numSum: number;
+    indexBlank: number;
+};
+type Options = {
+    allowNonIrreductible: boolean;
+    denom: string;
+};
+export declare const fractionsSumFillInTheBlank: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=fractionsSumFillInTheBlank.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fractionsSumFillInTheBlank.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/fractionsSumFillInTheBlank.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA8RF,KAAK,OAAO,GAAG;IACb,oBAAoB,EAAE,OAAO,CAAC;IAC9B,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAiCF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}

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

@@ -0,0 +1,256 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { EqualNode } from "../../../../tree/nodes/equations/equalNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { rationalParser } from "../../../../tree/parsers/rationalParser.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 { numSum, numOperand, denom, indexBlank } = identifiers;
+    const [nodeOperand, nodeSum] = [numOperand, numSum].map((num) => frac(num, denom));
+    const nodeUnknown = new VariableNode("?");
+    const nodeInstructionSameDenom = new EqualNode(indexBlank === 0
+        ? add(nodeUnknown, nodeOperand)
+        : add(nodeOperand, nodeUnknown), nodeSum);
+    const nodeOperandSimplified = nodeOperand.simplify({
+        towardsDistribute: false,
+        forceAddFractions: true,
+    });
+    const nodeSumSimplified = nodeSum.simplify({
+        towardsDistribute: false,
+        forceAddFractions: true,
+    });
+    const nodeInstruction = (() => {
+        return new EqualNode(indexBlank === 0
+            ? add(nodeUnknown, nodeOperandSimplified)
+            : add(nodeOperandSimplified, nodeUnknown), nodeSumSimplified);
+    })();
+    const nodeAnswer = substract(nodeSum, nodeOperand).simplify({
+        towardsDistribute: false,
+        forceAddFractions: true,
+    });
+    const isSameDenomOperandAndSum = (() => {
+        if (isFractionNode(nodeOperandSimplified) &&
+            isFractionNode(nodeSumSimplified)) {
+            return (nodeOperandSimplified.rightChild.evaluate() ===
+                nodeSumSimplified.rightChild.evaluate());
+        }
+        else {
+            return false;
+        }
+    })();
+    return {
+        nodeOperand,
+        nodeSum,
+        nodeInstruction,
+        nodeInstructionSameDenom,
+        nodeAnswer,
+        isSameDenomOperandAndSum,
+    };
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { allowNonIrreductible } = opts;
+    const { nodeInstruction } = getHydrated(identifiers);
+    return `Compléter la somme à trou suivante ${allowNonIrreductible ? "" : "avec une fraction irréductible"}:
+    
+$$
+${nodeInstruction.toTex()}
+$$`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeAnswer } = getHydrated(identifiers);
+    return nodeAnswer.toTex();
+};
+const getHint = (_, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { allowNonIrreductible } = opts;
+    return `Commence par réécrire les fractions pour qu'elle aient toutes le même dénominateur, si ce n'est pas déjà le cas, 
+puis cherche le numérateur qui convient pour la fraction manquante.
+${allowNonIrreductible
+        ? ""
+        : "Enfin, réécris la fraction que tu as trouvé sous forme irréductible."}`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeInstruction, nodeInstructionSameDenom, isSameDenomOperandAndSum, } = getHydrated(identifiers);
+    const { numOperand, numSum, denom, indexBlank } = identifiers;
+    const [nodeOperand, nodeSum] = [numOperand, numSum].map((num) => frac(num, denom));
+    const nodeUnknown = new VariableNode("?");
+    const nodeFracUnknown = frac(nodeUnknown, denom);
+    const nodeCorrectionFractionSum = new EqualNode(indexBlank === 0
+        ? add(nodeFracUnknown, nodeOperand)
+        : add(nodeOperand, nodeFracUnknown), nodeSum);
+    const nodeCorrectionIntegerSum = new EqualNode(indexBlank === 0
+        ? add(nodeUnknown, numOperand.toTree())
+        : add(numOperand.toTree(), nodeUnknown), numSum.toTree());
+    const nodeAnswerRaw = frac(numSum - numOperand, denom);
+    return `${isSameDenomOperandAndSum
+        ? `Toutes les fractions sont au même dénominateur.`
+        : `On commence par réécrire les fractions pour qu'elle aient toutes le même dénominateur :
+  
+${alignTex([
+            ["", nodeInstruction.toTex()],
+            ["\\Leftrightarrow", nodeInstructionSameDenom.toTex()],
+        ])}
+
+`}
+
+On cherche le numérateur qui convient pour la fraction manquante :
+
+  
+${alignTex([
+        ["", nodeCorrectionFractionSum.toTex()],
+        ["\\Leftrightarrow", nodeCorrectionIntegerSum.toTex()],
+    ])}
+
+La fraction recherchée est donc $${nodeAnswerRaw.toTex()}$.
+
+${(() => {
+        const texRaw = nodeAnswerRaw.toTex();
+        const texSimplified = nodeAnswerRaw
+            .simplify({ towardsDistribute: false, forceAddFractions: true })
+            .toTex();
+        if (texSimplified !== texRaw) {
+            return `La fraction peut être réduite : 
+
+$$
+${texRaw} = ${texSimplified}
+$$
+
+`;
+        }
+        else {
+            return ``;
+        }
+    })()}`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { denomSrc } = identifiers;
+    [...Array(denomSrc).keys()]
+        .map((i) => i + 1)
+        .map((v) => frac(v, denomSrc))
+        .forEach((node) => {
+        tryToAddWrongProp(propositions, node.simplify().toTex());
+    });
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, RationalConstructor.randomIrreductible().toTree().toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
+    const { nodeAnswer } = getHydrated(identifiers);
+    const texs = nodeAnswer.toAllValidTexs();
+    if (opts?.allowNonIrreductible) {
+        try {
+            const parsed = rationalParser(ans);
+            if (!parsed)
+                return false;
+            return texs.includes(parsed.simplify().toTex());
+        }
+        catch (err) {
+            return handleVEAError(err);
+        }
+    }
+    else {
+        return texs.includes(ans);
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const denomSrc = parseInt(opts.denom);
+    const numAnswer = randint(1, denomSrc + 1);
+    const indexBlank = randint(0, 2);
+    const [denom, numOperand, numSum] = (() => {
+        const numOperandSrc = randint(1, 2 * denomSrc + 1);
+        const numSumSrc = numAnswer + numOperandSrc;
+        const nodeOperand = frac(numOperandSrc, denomSrc).simplify();
+        const nodeSum = frac(numSumSrc, denomSrc).simplify();
+        const denom = [nodeOperand, nodeSum]
+            .filter((node) => isFractionNode(node))
+            .reduce((acc, node, i) => {
+            const den = node.rightChild.evaluate();
+            if (i === 0) {
+                return den;
+            }
+            else {
+                return Math.min(den, acc);
+            }
+        }, -1);
+        const [numOperand, numSum] = [numOperandSrc, numSumSrc].map((num) => (num * denom) / denomSrc);
+        return [denom, numOperand, numSum];
+    })();
+    const identifiers = {
+        denomSrc,
+        denom,
+        numOperand,
+        numSum,
+        indexBlank,
+    };
+    return identifiers;
+};
+const getFractionsSumFillInTheBlankQuestion = (optsIn) => {
+    const arrayedOpts = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const opts = {
+        ...(optsIn ?? optsDefault),
+        denom: random(arrayedOpts.denom),
+    };
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+    };
+    return question;
+};
+const optsDefault = {
+    allowNonIrreductible: false,
+};
+const arrayedOptsDefault = {
+    denom: [4].map((v) => v.frenchify()),
+};
+const options = [
+    {
+        id: "allowNonIrreductible",
+        label: "Autoriser les fractions non réduites",
+        target: GeneratorOptionTarget.vea,
+        type: GeneratorOptionType.checkbox,
+    },
+    {
+        id: "denom",
+        label: "dénominateur de référence",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        defaultValue: arrayedOptsDefault.denom,
+        values: [3, 4, 5, 6, 7, 8].map((v) => v.frenchify()),
+    },
+];
+export const fractionsSumFillInTheBlank = {
+    id: "fractionsSumFillInTheBlank",
+    connector: "=",
+    label: "Sommes à trou (fractions)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFractionsSumFillInTheBlankQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -19,4 +19,5 @@ export * from "./simplifyToFraction.js";
 export * from "./evalFractionExpression.js";
 export * from "./fractionsMix.js";
 export * from "./fractionEquality.js";
+export * from "./fractionsSumFillInTheBlank.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,iCAAiC,CAAC"}

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

@@ -19,3 +19,4 @@ export * from "./simplifyToFraction.js";
 export * from "./evalFractionExpression.js";
 export * from "./fractionsMix.js";
 export * from "./fractionEquality.js";
+export * from "./fractionsSumFillInTheBlank.js";

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

@@ -16,4 +16,5 @@ export * from "./rationals/index.js";
 export * from "./sign/index.js";
 export * from "./ratio/index.js";
 export * from "./factorial/index.js";
+export * from "./relatives/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/calcul/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC;AACpC,cAAc,qBAAqB,CAAC;AAEpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC"}

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

@@ -17,3 +17,4 @@ export * from "./rationals/index.js";
 export * from "./sign/index.js";
 export * from "./ratio/index.js";
 export * from "./factorial/index.js";
+export * from "./relatives/index.js";

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

@@ -8,4 +8,7 @@ export * from "./mentalProgramSolve.js";
 export * from "./mentalFractionageOfInteger.js";
 export * from "./mentalFractionageOfQuantity.js";
 export * from "./mentalApplyPercentageEvolution.js";
+export * from "./mentalMultiplicationTable.js";
+export * from "./mentalMultiplication11AndFriends.js";
+export * from "./mentalMultiplication101AndFriends.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,qCAAqC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/mentalCaluls/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,sCAAsC,CAAC;AACrD,cAAc,yBAAyB,CAAC;AACxC,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,qCAAqC,CAAC;AACpD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uCAAuC,CAAC;AACtD,cAAc,wCAAwC,CAAC"}