math-exercises 3.0.145 → 3.0.147

package/lib/exercises/math/calcul/ratio/partUsingRatio.js

@@ -0,0 +1,388 @@
+import { shuffleProps, GeneratorOptionType, GeneratorOptionTarget, tryToAddWrongProp, addValidProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { primes } from "../../../../math/numbers/integer/primes.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { add } from "../../../../tree/nodes/operators/addNode.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getStrRatio = (ratio) => {
+    return `${ratio.join(" : ")}`;
+};
+const getFractionNodeFromRatio = (ratio, indexPart) => {
+    const denNode = ratio
+        .map((v) => v.toTree())
+        .reduce((acc, x) => add(acc, x));
+    return frac(ratio[indexPart], denNode);
+};
+const situationsDict = {
+    "2": [
+        //tulipes
+        {
+            instruction: (total, ratio, indexPart) => `Issa et Jérémie vont planter des tulipes. 
+Ils en ont $${total}$ à planter. 
+Ils se sont mis d'accord pour se partager la tâche suivant le ratio $${getStrRatio(ratio)}$. 
+Combien ${indexPart === 0 ? `Issa` : `Jérémie`} a-t-il de tulipes à planter ?`,
+            correction: (total, ratio, indexPart) => {
+                const fractionNode = getFractionNodeFromRatio(ratio, indexPart);
+                const partNode = multiply(fractionNode, total).simplify();
+                return `Le ratio est $${getStrRatio(ratio)}$. La fraction du total que ${indexPart === 0 ? `Issa` : `Jérémie`} doit planter est donc :
+        
+$$
+${fractionNode.toTex()} = ${fractionNode.simplify().toTex()}
+$$
+
+On calcule la part qu'il lui revient en multipliant cette fraction par la quantité totale :
+
+$$
+${fractionNode
+                    .simplify()
+                    .toTex()} \\times ${total.frenchify()} = ${partNode.toTex()}
+$$
+
+${indexPart === 0 ? `Issa` : `Jérémie`} doit planter $${partNode.toTex()}$ tulipes.
+`;
+            },
+            randValues: () => {
+                const primePool = primes.filter((n) => 10 < n && n < 60);
+                const indexPrime1 = randint(0, primePool.length - 2);
+                const [num1, num2] = shuffle([
+                    primePool[indexPrime1],
+                    primePool[indexPrime1 + randint(1, 3)],
+                ]);
+                const divisor = num1 + num2;
+                const total = randint(5, 30) * divisor;
+                const indexPart = randint(0, 2);
+                return {
+                    ratio: [num1, num2],
+                    total,
+                    indexPart,
+                };
+            },
+        },
+        //frites
+        {
+            instruction: (total, ratio, indexPart) => `Dany et Guy se partagent des frites. 
+Ils ont compté qu'ils en avaient au total $${total}$. 
+Ils se sont mis d'accord pour se les partager suivant le ratio $${getStrRatio(ratio)}$. 
+Combien ${indexPart === 0 ? `Dany` : `Guy`} a-t-il de frites à manger ?`,
+            correction: (total, ratio, indexPart) => {
+                const fractionNode = getFractionNodeFromRatio(ratio, indexPart);
+                const partNode = multiply(fractionNode, total).simplify();
+                return `Le ratio est $${getStrRatio(ratio)}$. La fraction du total que ${indexPart === 0 ? `Dany` : `Guy`} a est donc :
+        
+$$
+${fractionNode.toTex()} = ${fractionNode.simplify().toTex()}
+$$
+
+On calcule la part qu'il lui revient en multipliant cette fraction par la quantité totale :
+
+$$
+${fractionNode
+                    .simplify()
+                    .toTex()} \\times ${total.frenchify()} = ${partNode.toTex()}
+$$
+
+${indexPart === 0 ? `Dany` : `Guy`} a $${partNode.toTex()}$ frites.
+`;
+            },
+            randValues: () => {
+                const primePool = primes.filter((n) => n < 30);
+                const indexPrime1 = randint(0, primePool.length - 3);
+                const [num1, num2] = shuffle([
+                    primePool[indexPrime1],
+                    primePool[indexPrime1 + randint(2, 4)],
+                ]);
+                const divisor = num1 + num2;
+                const total = randint(5, 20) * divisor;
+                const indexPart = randint(0, 2);
+                return {
+                    ratio: [num1, num2],
+                    total,
+                    indexPart,
+                };
+            },
+        },
+        //supporters
+        {
+            instruction: (total, ratio, indexPart) => `Dans un stade, l'équipe bleue et l'équipe rouge se rencontrent. 
+Il y a $${total}$ supporters au total dans les gradins. 
+Les supporters de chaque équipe sont présents suivant le ratio $${getStrRatio(ratio)}$. 
+Combien y a-t-il de supporters ${indexPart === 0 ? `bleus` : `rouges`} ?`,
+            correction: (total, ratio, indexPart) => {
+                const fractionNode = getFractionNodeFromRatio(ratio, indexPart);
+                const partNode = multiply(fractionNode, total).simplify();
+                return `Le ratio est $${getStrRatio(ratio)}$. La fraction du total que représentent les ${indexPart === 0 ? `bleus` : `rouges`} est donc :
+        
+$$
+${fractionNode.toTex()} = ${fractionNode.simplify().toTex()}
+$$
+
+On calcule le nombre qu'ils sont en multipliant cette fraction par la quantité totale :
+
+$$
+${fractionNode
+                    .simplify()
+                    .toTex()} \\times ${total.frenchify()} = ${partNode.toTex()}
+$$
+
+Les ${indexPart === 0 ? `bleus` : `rouges`} sont au nombre de $${partNode.toTex()}$.
+`;
+            },
+            randValues: () => {
+                const primePool = primes;
+                const [num1, num2] = randomMany(primePool, 2);
+                const divisor = num1 + num2;
+                const total = randint(50, 300) * divisor;
+                const indexPart = randint(0, 2);
+                return {
+                    ratio: [num1, num2],
+                    total,
+                    indexPart,
+                };
+            },
+        },
+    ],
+    "3": [
+        //rgb
+        {
+            instruction: (total, ratio, indexPart) => `Aline crée une image en pixel art en utilisant uniquement trois couleurs : rouge, vert et bleu.  
+L'image est composée de $${total}$ pixels.  
+Les couleurs sont distribuées suivant le ratio $${getStrRatio(ratio)}$. 
+Combien y a-t-il de pixels ${[`rouges`, `verts`, `bleus`][indexPart]} ?`,
+            correction: (total, ratio, indexPart) => {
+                const fractionNode = getFractionNodeFromRatio(ratio, indexPart);
+                const partNode = multiply(fractionNode, total).simplify();
+                return `Le ratio est $${getStrRatio(ratio)}$. La fraction du total que représentent les pixels ${[`rouges`, `verts`, `bleus`][indexPart]} est donc :
+        
+$$
+${fractionNode.toTex()} = ${fractionNode.simplify().toTex()}
+$$
+
+On calcule leur nombre en multipliant cette fraction par la quantité totale :
+
+$$
+${fractionNode
+                    .simplify()
+                    .toTex()} \\times ${total.frenchify()} = ${partNode.toTex()}
+$$
+
+Il y a $${partNode.toTex()}$ pixels ${[`rouges`, `verts`, `bleus`][indexPart]}.
+`;
+            },
+            randValues: () => {
+                const primePool = primes;
+                const [num1, num2, num3] = randomMany(primePool, 3);
+                const divisor = num1 + num2 + num3;
+                const total = power(randint(5, 30), 2).evaluate() * divisor;
+                const indexPart = randint(0, 3);
+                return {
+                    ratio: [num1, num2, num3],
+                    total,
+                    indexPart,
+                };
+            },
+        },
+        //salade de fruits
+        {
+            instruction: (total, ratio, indexPart) => `Un industriel produit de la salade de fruits en mélangeant des morceaux de poire, d'abricot et de cerise.  
+Dans un pot standard pour la restauration collective, il y a $${total}$ morceaux.  
+Les morceaux sont distribués suivant le ratio $${getStrRatio(ratio)}$. 
+Combien y a-t-il de morceaux ${[`de poire`, `d'abricot`, `de cerise`][indexPart]} ?`,
+            correction: (total, ratio, indexPart) => {
+                const fractionNode = getFractionNodeFromRatio(ratio, indexPart);
+                const partNode = multiply(fractionNode, total).simplify();
+                return `Le ratio est $${getStrRatio(ratio)}$. La fraction du total que représentent les morceaux ${[`de poire`, `d'abricot`, `de cerise`][indexPart]} est donc :
+        
+$$
+${fractionNode.toTex()} = ${fractionNode.simplify().toTex()}
+$$
+
+On calcule leur nombre en multipliant cette fraction par la quantité totale :
+
+$$
+${fractionNode
+                    .simplify()
+                    .toTex()} \\times ${total.frenchify()} = ${partNode.toTex()}
+$$
+
+Il y a $${partNode.toTex()}$ morceaux ${[`de poire`, `d'abricot`, `de cerise`][indexPart]}.
+`;
+            },
+            randValues: () => {
+                const primePool = primes.filter((n) => n > 30);
+                const indexPrime1 = randint(0, primePool.length - 3);
+                const [num1, num2] = shuffle([
+                    primePool[indexPrime1],
+                    primePool[indexPrime1 + randint(1, 4)],
+                ]);
+                const num3 = random(primes.filter((n) => n < 10));
+                const divisor = num1 + num2 + num3;
+                const total = randint(50, 100) * divisor;
+                const indexPart = randint(0, 3);
+                return {
+                    ratio: [num1, num2, num3],
+                    total,
+                    indexPart,
+                };
+            },
+        },
+        //clé usb
+        {
+            instruction: (total, ratio, indexPart) => `Danièle a $${total}$ fichiers multimédia sur sa clé USB.  
+Les musiques, photos, vidéos sont distribuées suivant le ratio $${getStrRatio(ratio)}$. 
+Combien y a-t-il de ${[`musiques`, `photos`, `vidéos`][indexPart]} sur sa clé ?`,
+            correction: (total, ratio, indexPart) => {
+                const fractionNode = getFractionNodeFromRatio(ratio, indexPart);
+                const partNode = multiply(fractionNode, total).simplify();
+                return `Le ratio est $${getStrRatio(ratio)}$. La fraction du total que représentent les ${[`musiques`, `photos`, `vidéos`][indexPart]} est donc :
+        
+$$
+${fractionNode.toTex()} = ${fractionNode.simplify().toTex()}
+$$
+
+On calcule leur nombre en multipliant cette fraction par la quantité totale :
+
+$$
+${fractionNode
+                    .simplify()
+                    .toTex()} \\times ${total.frenchify()} = ${partNode.toTex()}
+$$
+
+Il y a $${partNode.toTex()}$ ${[`musiques`, `photos`, `vidéos`][indexPart]}.
+`;
+            },
+            randValues: () => {
+                const [num1, num2, num3] = randomMany(primes, 3);
+                const divisor = num1 + num2 + num3;
+                const total = randint(10, 20) * divisor;
+                const indexPart = randint(0, 3);
+                return {
+                    ratio: [num1, num2, num3],
+                    total,
+                    indexPart,
+                };
+            },
+        },
+    ],
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { ratio, total, indexPart, ratioType } = identifiers;
+    const propositions = [];
+    const answerNode = getAnswerNode(identifiers);
+    addValidProp(propositions, answerNode.toTex());
+    //wrong indexPart
+    const arrIndexPart = ratioType === "2" ? [0, 1] : [0, 1, 2];
+    arrIndexPart
+        .filter((i) => i !== indexPart)
+        .forEach((i) => {
+        const fractionNode = getFractionNodeFromRatio(ratio, i);
+        const nodeWrong = multiply(fractionNode, total).simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    });
+    //ratio[indexPart] is percentage
+    ratio.map((v) => {
+        const fractionNode = frac(v, 100);
+        const nodeWrong = round(multiply(fractionNode, total).simplify().evaluate(), 0).toTree();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    });
+    //random around
+    const valueAnswer = answerNode.evaluate();
+    const vWrong = randint(valueAnswer, valueAnswer + (total - valueAnswer) * 0.2);
+    tryToAddWrongProp(propositions, vWrong.frenchify());
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers) => {
+    const { ratio, total, indexPart } = identifiers;
+    const fractionNode = getFractionNodeFromRatio(ratio, indexPart);
+    return multiply(fractionNode, total).simplify();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getInstruction = (identifiers) => {
+    const { ratioType, situationIndex, total, ratio, indexPart } = identifiers;
+    const situation = situationsDict[ratioType][situationIndex];
+    return situation.instruction(total, ratio, indexPart);
+};
+const getHint = () => {
+    return `Cherche à quelle fraction du total correspond chaque part.`;
+};
+const getCorrection = (identifiers) => {
+    const { ratioType, situationIndex, total, ratio, indexPart } = identifiers;
+    const situation = situationsDict[ratioType][situationIndex];
+    return situation.correction(total, ratio, indexPart);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const [nodeAns, nodeAnswer] = [ans, answer].map((str) => parseAlgebraic(str));
+        return substract(nodeAns, nodeAnswer).simplify().evaluate() === 0;
+    }
+    catch (_) {
+        return false;
+    }
+};
+const getPartUsingRatioQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const ratioType = random(opts.ratioTypes);
+    const arrSituation = situationsDict[ratioType];
+    const situationIndex = randint(0, arrSituation.length);
+    const situation = arrSituation[situationIndex];
+    const { total, ratio, indexPart } = situation.randValues();
+    const identifiers = {
+        ratioType,
+        situationIndex,
+        total,
+        ratio,
+        indexPart,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, options) => {
+    return {
+        answer: getAnswer(identifiers, options),
+        instruction: getInstruction(identifiers, options),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, options),
+        correction: getCorrection(identifiers, options),
+        options,
+    };
+};
+const options = [
+    {
+        id: "ratioTypes",
+        label: "Longueur du ratio",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["2", "3"],
+        defaultValue: ["2", "3"],
+    },
+];
+const optsDefault = {
+    ratioTypes: ["2", "3"],
+};
+export const partUsingRatio = {
+    id: "partUsingRatio",
+    label: "Calculer une partie en utilisant un ratio",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPartUsingRatioQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    isAnswerValid,
+};

package/lib/exercises/math/calcul/ratio/ratioFromParts.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    parts: number[];
+};
+type Options = {
+    ratioTypes: string[];
+};
+export declare const ratioFromParts: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=ratioFromParts.d.ts.map

package/lib/exercises/math/calcul/ratio/ratioFromParts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ratioFromParts.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ratio/ratioFromParts.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AA2DrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAiLF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAiBF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBzD,CAAC"}

package/lib/exercises/math/calcul/ratio/ratioFromParts.js

@@ -0,0 +1,198 @@
+import { shuffleProps, GeneratorOptionType, GeneratorOptionTarget, tryToAddWrongProp, addValidProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const isEquivalentRatios = (ratio1, ratio2) => {
+    const fractionNode0 = frac(ratio1[0], ratio2[0]).simplify();
+    return ratio1.slice(1).every((n1, i) => {
+        const fractionNodeI = frac(n1, ratio2[i]).simplify();
+        return substract(fractionNode0, fractionNodeI).simplify().evaluate() === 0;
+    });
+};
+const getRatioFromParts = (parts) => {
+    const minPart = Math.min(...parts);
+    const nodesAfterFrac = parts.map((v) => frac(v, minPart).simplify());
+    const densDistinctSortedDesc = [
+        ...new Set(nodesAfterFrac
+            .filter((node) => isFractionNode(node))
+            .map((fractionNode) => fractionNode.rightChild.evaluate())),
+    ].toSorted((den1, den2) => -(den1 - den2));
+    if (densDistinctSortedDesc.length > 0) {
+        const arrNodes = densDistinctSortedDesc
+            .reduce((acc, den) => {
+            const nodesLatest = acc[acc.length - 1];
+            return [
+                ...acc,
+                nodesLatest.map((node) => multiply(den, node).simplify()),
+            ];
+        }, [nodesAfterFrac])
+            .slice(1);
+        const ratio = arrNodes
+            .find((nodes) => nodes.every((node) => !isFractionNode(node)))
+            .map((node) => node.evaluate());
+        return ratio;
+    }
+    else {
+        return nodesAfterFrac.map((node) => node.evaluate());
+    }
+};
+const getInstruction = (identifiers) => {
+    const { parts } = identifiers;
+    return `À quel ratio obéissent les valeurs ci-dessous ? 
+  
+- ${parts.map((v) => `$${v}$`).join(" ; ")}
+
+`;
+};
+const getHint = () => {
+    return `Cherche le rapport entre chaque valeur et la plus petite des valeurs.`;
+};
+const getCorrection = (identifiers) => {
+    const { parts } = identifiers;
+    const minPart = Math.min(...parts);
+    const nodesAfterFrac = parts.map((v) => frac(v, minPart).simplify());
+    const densDistinctSortedDesc = [
+        ...new Set(nodesAfterFrac
+            .filter((node) => isFractionNode(node))
+            .map((fractionNode) => fractionNode.rightChild.evaluate())),
+    ].toSorted((den1, den2) => -(den1 - den2));
+    const arrNodes = densDistinctSortedDesc
+        .reduce((acc, den) => {
+        const nodesLatest = acc[acc.length - 1];
+        return [
+            ...acc,
+            nodesLatest.map((node) => multiply(den, node).simplify()),
+        ];
+    }, [nodesAfterFrac])
+        .slice(1);
+    return `On calcule le rapport entre chaque valeur et la plus petite : 
+  
+$$
+${nodesAfterFrac.map((node) => node.toTex()).join("\\text{ ; }")}
+$$
+
+${(() => {
+        if (densDistinctSortedDesc.length > 0) {
+            const indexRatio = [...Array(arrNodes.length).keys()].find((i) => arrNodes[i].every((node) => !isFractionNode(node)));
+            const arrNodesSteps = arrNodes.filter((_, i) => i <= indexRatio);
+            return `On classe les dénominateurs par ordre décroissant : $${densDistinctSortedDesc
+                .map((den) => den.frenchify())
+                .join(">")}$
+
+Avec chaque dénominateur, on multiplie tous les nombres jusqu'à ne plus avoir que des entiers :
+
+${arrNodesSteps.map((nodes) => `
+  
+$$
+${nodes.map((node) => node.toTex()).join("\\text{ ; }")}
+$$
+  
+`).join(`
+  
+`)}
+
+Le ratio recherché est $${arrNodes[indexRatio]
+                .map((node) => node.toTex())
+                .join(`:`)}$.`;
+        }
+        else {
+            return `Le ratio recherché est $${nodesAfterFrac
+                .map((node) => node.toTex())
+                .join(`:`)}$.`;
+        }
+    })()}
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { parts } = identifiers;
+    return getRatioFromParts(parts)
+        .map((n) => n.frenchify())
+        .join(":");
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { parts } = identifiers;
+    const propositions = [];
+    const ratio = getRatioFromParts(parts);
+    addValidProp(propositions, ratio.map((n) => n.frenchify()).join(":"));
+    const arrOffsetsExcluded = parts.map(() => [0]);
+    propWhile(propositions, n, () => {
+        const offsets = parts.map((_, i) => randint(-10, 11, arrOffsetsExcluded[i]));
+        offsets.forEach((offset, i) => {
+            arrOffsetsExcluded[i].push(offset);
+        });
+        const ratioWrongCandidate = ratio.map((n, i) => n + offsets[i]);
+        if (ratioWrongCandidate.some((v) => v < 1) ||
+            isEquivalentRatios(ratioWrongCandidate, ratio)) {
+            //ignore
+        }
+        else {
+            const ratioWrong = ratioWrongCandidate;
+            tryToAddWrongProp(propositions, ratioWrong.map((n) => n.frenchify()).join(":"));
+        }
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getKeys = () => {
+    return ["colon"];
+};
+const getRatioFromPartsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const ratioType = random(opts.ratioTypes);
+    const ratio = randomMany([...Array(100).keys()].map((i) => i + 1), +ratioType);
+    const k = randint(20, 50);
+    const parts = ratio.map((n) => n * k);
+    const identifiers = {
+        parts,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, options) => {
+    return {
+        answer: getAnswer(identifiers, options),
+        instruction: getInstruction(identifiers, options),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, options),
+        correction: getCorrection(identifiers, options),
+        options,
+    };
+};
+const options = [
+    {
+        id: "ratioTypes",
+        label: "Longueur du ratio",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["2", "3"],
+        defaultValue: ["2", "3"],
+    },
+];
+const optsDefault = {
+    ratioTypes: ["2", "3"],
+};
+export const ratioFromParts = {
+    id: "ratioFromParts",
+    label: "Calculer un ratio",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRatioFromPartsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    isAnswerValid,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"equationFromSentenceExercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromSentenceExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,YAAY,CAAC;CACpB,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AA2PF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAY9D,CAAC"}
+{"version":3,"file":"equationFromSentenceExercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromSentenceExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,YAAY,CAAC;CACpB,CAAC;AAEF,KAAK,YAAY,GAAG;IAClB,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,CAAC;AAkTF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}

package/lib/exercises/math/calculLitteral/equation/equationFromSentenceExercise.js

@@ -84,6 +84,53 @@ const getEquationFromSentenceExerciseQuestion = () => {
     };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = () => {
+    return `Cherche à traduire chaque mot de la phrase en une opération mathématiques, en partant d'un nombre $x$.`;
+};
+const getCorrection = (identifiers) => {
+    const { type, vars } = identifiers;
+    const { flip, randAdd, op2 } = vars;
+    switch (type) {
+        case 1:
+            return `${flip ? `Le double` : `La moitié`} de $x$ se note : 
+        
+$$
+${flip ? "2x" : "\\frac{x}{2}"}
+$$
+
+La phrase se traduit donc par l'équation suivante : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+        case 2:
+            return `${flip ? `La somme` : `La différence`} de $x$ et de $${randAdd}$ se note : 
+        
+$$
+x${flip ? "+" : "-"}${randAdd}
+$$
+
+La phrase se traduit donc par l'équation suivante : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+        case 3:
+        default:
+            return `${flip ? `Le double` : `La moitié`} de $x$ ${flip ? op2 : op2 + "e"} de $${randAdd}$ se note : 
+
+$$
+${flip ? "2x" : "\\frac{x}{2}"}${flip ? "-" : "+"}${randAdd}
+$$
+
+La phrase se traduit donc par l'équation suivante : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+    }
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -91,6 +138,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["x", "equal"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -169,4 +218,5 @@ export const equationFromSentenceExericse = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/calculLitteral/simplifying/compareMinusA.js

@@ -14,7 +14,7 @@ const getCorrection = () => {
     return `
 
 $$
--a = (−1) \\times a = a \\times (−1) = \\frac{a}{-1} = -\\frac{a}{1}
+-a = (-1) \\times a = a \\times (-1) = \\frac{a}{-1} = -\\frac{a}{1}
 $$
 
 `;