math-exercises 3.0.125 → 3.0.127

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

@@ -0,0 +1,327 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { permute } from "../../../../utils/arrays/permutations.js";
+const getTexForA10N = (a10N) => {
+    const { a, n } = a10N;
+    return `${a.frenchify()} \\times 10^{${n}}`;
+};
+const getSciMultNodeForA10N = (a10N) => {
+    const { a, n } = a10N;
+    const sign = Math.sign(a);
+    const sciMultNodeA = getSciMultNodeForA(sign * a);
+    const factor = sign * sciMultNodeA.leftChild.evaluate();
+    const nodePower10 = sciMultNodeA.rightChild;
+    const exponent = nodePower10.rightChild.evaluate() + n;
+    return multiply(factor, power(10, exponent));
+};
+const getSciMultNodeForA = (a) => {
+    //a must be positive
+    const exponent = Math.floor(Math.log10(a));
+    const factor = round(frac(a, power(10, exponent)).evaluate(), 2);
+    const sciMultNode = multiply(factor, power(10, exponent));
+    return sciMultNode;
+};
+const compareFuncForA10N = (a10N1, a10N2) => {
+    const { a: a1, n: n1 } = a10N1;
+    const { a: a2, n: n2 } = a10N2;
+    const [sign1, sign2] = [a1, a2].map((a) => Math.sign(a));
+    if (sign1 !== sign2) {
+        return sign1 - sign2;
+    }
+    else {
+        const sign = sign1;
+        const [nodeSciA1, nodeSciA2] = [a1, a2].map((a) => getSciMultNodeForA(sign * a));
+        const [factorA1, factorA2] = [nodeSciA1, nodeSciA2].map((nodeSciA) => nodeSciA.leftChild.evaluate());
+        const [nA1, nA2] = [nodeSciA1, nodeSciA2].map((nodeSciA) => nodeSciA.rightChild.rightChild.evaluate());
+        const exponent1 = n1 + nA1;
+        const exponent2 = n2 + nA2;
+        if (exponent1 !== exponent2) {
+            return sign * (exponent1 - exponent2);
+        }
+        else {
+            return sign * (factorA1 - factorA2);
+        }
+    }
+};
+const getInstruction = (identifiers) => {
+    const { items } = identifiers;
+    return `Ranger par ordre croissant les nombres suivants :
+
+$$
+${items.map((item) => getTexForA10N(item)).join(" ; ")}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { signType } = identifiers;
+    return `Même si on a l'impression que les nombres sont écris en écriture scientifique, ce n'est pas le cas. 
+Il faut les convertir en écriture scientifique et utiliser cette écriture pour les ranger dans l'ordre croissant.
+${(() => {
+        switch (signType) {
+            case "positifs":
+                return `Ici, tous les nombres sont positifs, donc
+on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
+C'est un double tri.`;
+            case "négatifs":
+                return `Ici, tous les nombres sont négatifs, donc
+on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
+C'est un double tri.`;
+            case "mélange":
+                return `Ici, il y a des nombres négatifs et des nombres positifs.
+On commence par les négatifs :
+On range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
+Puis on range les positifs :
+On range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.`;
+        }
+    })()}
+`;
+};
+const getCorrection = (identifiers) => {
+    const { signType, items } = identifiers;
+    return `Même si on a l'impression que les nombres sont écris en écriture scientifique, ce n'est pas le cas. 
+Il faut les convertir en écriture scientifique et utiliser cette écriture pour les ranger dans l'ordre croissant.
+
+${items
+        .map((item) => `
+  
+$$
+${getTexForA10N(item)} = ${getSciMultNodeForA10N(item).toTex()}
+$$
+
+`)
+        .join("")}
+
+${(() => {
+        switch (signType) {
+            case "positifs": {
+                const positive = items.toSorted(compareFuncForA10N);
+                return `Ici, tous les nombres sont positifs, donc
+on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
+C'est un double tri.
+
+$$
+${positive.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+$$
+
+Conclusion :
+
+$$
+${positive.map((item) => getTexForA10N(item)).join("<")}
+$$
+
+`;
+            }
+            case "négatifs": {
+                const negative = items.toSorted(compareFuncForA10N);
+                return `Ici, tous les nombres sont négatifs, donc
+on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
+C'est un double tri.
+
+$$
+${negative.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+$$
+
+Conclusion :
+
+$$
+${negative.map((item) => getTexForA10N(item)).join("<")}
+$$
+`;
+            }
+            case "mélange": {
+                const positive = items
+                    .filter(({ a }) => a >= 0)
+                    .toSorted(compareFuncForA10N);
+                const negative = items
+                    .filter(({ a }) => a < 0)
+                    .toSorted(compareFuncForA10N);
+                return `Ici, il y a des nombres négatifs et des nombres positifs.
+On commence par les négatifs :
+on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
+
+$$
+${negative.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+$$
+
+Puis on range les positifs :
+on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
+
+$$
+${positive.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+$$
+
+Conclusion :
+
+$$
+${[...negative, ...positive].map((item) => getTexForA10N(item)).join("<")}
+$$
+`;
+            }
+        }
+    })()}
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { items } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    permute(items)
+        .slice(0, 5)
+        .forEach((permutedItems) => {
+        const arrayOfTex = permutedItems.map((item) => getTexForA10N(item));
+        tryToAddWrongProp(propositions, arrayOfTex.join("<"));
+        tryToAddWrongProp(propositions, arrayOfTex.join(">"));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { items } = identifiers;
+    const answer = items
+        .toSorted(compareFuncForA10N)
+        .map((item) => getTexForA10N(item))
+        .join("<");
+    return answer;
+};
+const isAnswerValid = (ans, { answer, items }) => {
+    const nbItems = items.length;
+    const [ansNodes, answerNodes] = [ans, answer].map((str) => str.split("<").map((tex) => parseAlgebraic(tex)));
+    return (ansNodes.length === nbItems &&
+        [...Array(nbItems).keys()].every((i) => ansNodes[i].equals(answerNodes[i])));
+};
+const getKeys = (identifiers) => {
+    const { items } = identifiers;
+    return [
+        "sup",
+        "inf",
+        ...items.map((item) => {
+            const tex = getTexForA10N(item);
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const getCompareA10NQuestion = (optsIn) => {
+    const opts = optsIn ? Object.assign(optsIn, optsDefault) : optsDefault;
+    const signType = random(opts.signTypes);
+    const nbCollisions = random(opts.nbCollisions);
+    const nbItems = 4;
+    let arrayOfA = [...Array(nbItems).keys()].map(() => {
+        const pow10 = random([0, 1, 2]);
+        const nbDigits = probaLawFlip([
+            [0, 0.5],
+            [1, 0.3],
+            [2, 0.2],
+        ]);
+        return round(randfloat(0, 10, 2, [10]) * Math.pow(10, pow10) +
+            randfloat(0, 1, nbDigits), 2);
+    });
+    switch (signType) {
+        case "négatifs":
+            arrayOfA = arrayOfA.map((a) => -1 * a);
+            break;
+        case "mélange":
+            {
+                const nbRandomSign = nbItems - 2;
+                const signs = shuffle([
+                    +1,
+                    -1,
+                    ...[...Array(nbRandomSign).keys()].map(() => (coinFlip() ? +1 : -1)),
+                ]);
+                arrayOfA = arrayOfA.map((a, i) => signs[i] * a);
+            }
+            break;
+        default:
+            break;
+    }
+    const nMin = -90;
+    const nMax = +90;
+    const combStep = 5;
+    const combOffset = randint(0, combStep);
+    const poolOfN = [...Array(nMax - nMin + 1).keys()]
+        .map((i) => i + nMin)
+        .filter((n) => n % combStep === combOffset);
+    const subPoolOfN = randomMany(poolOfN, nbItems - nbCollisions);
+    let arrayOfN = subPoolOfN;
+    for (let i = 0; i < nbCollisions; i++) {
+        arrayOfN.push(random(subPoolOfN) + random([-2, -1, 0, 1, 2]));
+    }
+    arrayOfN = shuffle(arrayOfN);
+    const items = [...Array(nbItems).keys()].map((i) => {
+        return {
+            a: arrayOfA[i],
+            n: arrayOfN[i],
+        };
+    });
+    return getQuestionFromIdentifiers({
+        signType,
+        items,
+    });
+};
+const optsDefault = {
+    signTypes: ["positifs", "négatifs", "mélange"],
+    nbCollisions: [0, 1, 2, 3],
+};
+const options = [
+    {
+        id: "signTypes",
+        label: "Signes des nombres",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["positifs", "négatifs", "mélange"],
+        defaultValue: optsDefault.signTypes,
+    },
+    {
+        id: "nbCollisions",
+        label: "Nombre de collisions",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: [0, 1, 2, 3],
+        defaultValue: optsDefault.nbCollisions,
+    },
+];
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+export const compareA10N = {
+    id: "compareA10N",
+    label: "Comparer des nombres de la forme $a \\times 10^n$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareA10NQuestion(opts), nb, 30),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    orderedNodeIds: NodeIdentifiers[];
+};
+export declare const compareABUsingQuotient: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareABUsingQuotient.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compareABUsingQuotient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareABUsingQuotient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,eAAe,EAAE,CAAC;CACnC,CAAC;AA+IF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAiBxD,CAAC"}

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

@@ -0,0 +1,123 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getInstruction = (identifiers) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    return `Sachant que $\\frac{${B}}{${A}} > 1$,
+  
+comparer $${B}$ et $${A}$.;`;
+};
+const getHint = (identifiers) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    return `En partant de 
+
+$$
+\\frac{${B}}{${A}} > 1
+$$
+  
+essaye d’isoler chaque expression de chaque côté de l’inégalité.`;
+};
+const getCorrection = (identifiers) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    return `On a :
+
+$$
+\\frac{${B}}{${A}} > 1
+$$
+
+On multiplie par $${A}$ des deux côtés. $${A} > 0$ donc on ne renverse pas l'inégalité :
+
+$$
+${B} > ${A}
+$$
+`;
+};
+const getAnswer = (identifiers) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    return `${B} > ${A}`;
+};
+const isAnswerValid = (ans, { ...identifiers }) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    const compSymbol = ans.includes(">")
+        ? ">"
+        : ans.includes("<")
+            ? "<"
+            : undefined;
+    if (!compSymbol) {
+        return false;
+    }
+    else {
+        return (compSymbol === ">" ? [B, A] : [A, B]).every((tex, i) => tex === ans.split(compSymbol)[i]);
+    }
+};
+const getPropositions = (nbProps, { ...identifiers }) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    const propositions = [];
+    addValidProp(propositions, coinFlip() ? `${A}<${B}` : `${B}>${A}`);
+    tryToAddWrongProp(propositions, coinFlip() ? `${B}<${A}` : `${A}>${B}`);
+    return shuffleProps(propositions, nbProps);
+};
+const getKeys = (identifiers) => {
+    const { orderedNodeIds } = identifiers;
+    const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
+    return [
+        "inf",
+        "sup",
+        ...[A, B].map((tex) => {
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const getCompareABUsingQuotientQuestion = () => {
+    const n = randint(2, 150);
+    const orderedNodesIncreasing = [add(1, sqrt(add(1, n))), add(2, sqrt(n))];
+    return getQuestionFromIdentifiers({
+        orderedNodeIds: orderedNodesIncreasing.map((node) => node.toIdentifiers()),
+    });
+};
+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 compareABUsingQuotient = {
+    id: "compareABUsingQuotient",
+    label: "Comparer deux nombres strictement positifs par le calcul de leur quotient",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getCompareABUsingQuotientQuestion(), 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/compareFracABWithFracAPlusCBPlusC.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIds: NodeIdentifiers[];
+    texAnswers: string[];
+};
+export declare const compareFracABWithFracAPlusCBPlusC: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareFracABWithFracAPlusCBPlusC.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compareFracABWithFracAPlusCBPlusC.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracABWithFracAPlusCBPlusC.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,eAAe,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA4LF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAoBnE,CAAC"}

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

@@ -0,0 +1,149 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { lcm } from "../../../../math/utils/arithmetic/lcm.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodes = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Comparer $${nodes[0].toTex()}$ et $${nodes[1].toTex()}$.`;
+};
+const getHint = () => {
+    return `Pour comparer deux fractions on peut les mettre au même dénominateur.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodes = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodesSimplified = nodes.map((node) => node.simplify());
+    const [den1, den2] = nodesSimplified.map((nodeSimplified) => {
+        return isFractionNode(nodeSimplified)
+            ? nodeSimplified.rightChild
+            : (1).toTree();
+    });
+    const sameDen = lcm(den1.evaluate(), den2.evaluate());
+    const nodesSameDenMult = nodesSimplified.map((node) => isFractionNode(node)
+        ? frac(multiply(node.leftChild.simplify(), frac(sameDen, node.rightChild).simplify()), multiply(node.rightChild.simplify(), frac(sameDen, node.rightChild).simplify()))
+        : frac(multiply(node, sameDen), multiply(1, sameDen)));
+    const nodesSameDen = nodes.map((node) => isFractionNode(node)
+        ? frac(multiply(node.leftChild.simplify(), frac(sameDen, node.rightChild)).simplify(), sameDen)
+        : frac(multiply(node, sameDen).simplify(), sameDen));
+    const answer = getAnswer(identifiers);
+    return `On a : 
+
+$$
+${nodes[1].toSimplificationTex()}
+$$
+
+On veut donc comparer $${nodesSimplified[0].toTex()}$ et $${nodesSimplified[1].toTex()}$.
+
+On peut choisir $${sameDen.frenchify()}$ comme dénominateur commun.
+
+${nodes
+        .map((node, i) => node.rightChild.evaluate() !== sameDen
+        ? `
+
+$$
+${(i === 0 ? nodes[i] : nodes[i].simplify()).toTex()} = ${[
+            ...new Set([
+                nodesSameDenMult[i].toTex(),
+                nodesSameDen[i].toTex(),
+            ]).values(),
+        ].join("=")}
+$$`
+        : ``)
+        .join("")}
+
+Conclusion :
+
+$$
+${answer}
+$$
+
+`;
+};
+/*
+Plus généralement :
+Si  $a<b$ alors  $\\frac{a}{b} < \\frac{a+c}{b+c}$ sinon c'est l'inverse.
+*/
+const getPropositions = (_, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, answer
+        .replace(">", "TMP(>)")
+        .replace("<", "TMP(<)")
+        .replace("TMP(>)", "<")
+        .replace("TMP(<)", ">"));
+    return shuffle(propositions);
+};
+const getAnswer = (identifiers) => {
+    const { texAnswers } = identifiers;
+    return texAnswers[0];
+};
+const isAnswerValid = (ans, { texAnswers }) => {
+    return texAnswers.includes(ans);
+};
+const getCompareFracABWithFracAPlusCBPlusCQuestion = () => {
+    const a = randint(1, 10);
+    const b = randint(1, 10, [a]);
+    const c = randint(1, 10);
+    const nodes = [frac(a, b), frac(add(a, c), add(b, c))];
+    const isOrderAsc = coinFlip();
+    const sortedNodes = nodes.toSorted((node1, node2) => (isOrderAsc ? +1 : -1) * (node1.evaluate() - node2.evaluate()));
+    const texAnswers = [
+        `${sortedNodes[0].toTex()}${isOrderAsc ? "<" : ">"}${sortedNodes[1].toTex()}`,
+        `${sortedNodes[1].toTex()}${isOrderAsc ? ">" : "<"}${sortedNodes[0].toTex()}`,
+    ];
+    return getQuestionFromIdentifiers({
+        nodeIds: nodes.map((node) => node.toIdentifiers()),
+        texAnswers,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [
+            "sup",
+            "inf",
+            ...identifiers.nodeIds.map((nodeIds) => {
+                const node = NodeConstructor.fromIdentifiers(nodeIds);
+                const tex = node.toTex();
+                return {
+                    id: "custom",
+                    label: tex,
+                    labelType: "tex",
+                    mathfieldInstructions: {
+                        method: "write",
+                        content: tex,
+                    },
+                };
+            }),
+        ],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+export const compareFracABWithFracAPlusCBPlusC = {
+    id: "compareFracABWithFracAPlusCBPlusC",
+    label: "Effectuer des comparaisons entre des fractions simples (de la forme $\\frac{a}{b}$ et $\\frac{a+c}{b+c}$)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareFracABWithFracAPlusCBPlusCQuestion(opts), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,29 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type QCMItem = {
+    tex: string;
+    isValidAnswer: boolean;
+};
+type QuestionParam = {
+    fakeName: string;
+    trueName: string;
+    tex: string;
+    nodeIds: NodeIdentifiers;
+    explainTex: string;
+};
+type Identifiers = {
+    sign: number;
+    a: number;
+    b: number;
+    c: number;
+    dictFakeNameToQuestionParam: Record<string, QuestionParam>;
+    items: QCMItem[];
+};
+type Options = {
+    isUseABC: boolean;
+    nbDecimalFormat: number;
+    isAllowingNegativeNumbers: boolean;
+};
+export declare const compareFracAndDec: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=compareFracAndDec.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compareFracAndDec.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracAndDec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,OAAO,GAAG;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC3D,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AAkYF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,OAAO,CAAC;CACpC,CAAC;AA+BF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB5D,CAAC"}