math-exercises 3.0.85 → 3.0.87

package/lib/exercises/math/calculLitteral/inequations/isInequalityTrue.js

@@ -0,0 +1,143 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { x, inequalitySign, left, right } = identifiers;
+    const leftValue = reifyAlgebraic(left)
+        .toDetailedEvaluation({ x: x.toTree() })
+        .evaluate();
+    const rightValue = reifyAlgebraic(right)
+        .toDetailedEvaluation({ x: x.toTree() })
+        .evaluate();
+    const isTrue = inequalitySign
+        ? leftValue < rightValue
+        : leftValue > rightValue;
+    return isTrue ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { x, inequalitySign, left, right } = identifiers;
+    const leftNode = reifyAlgebraic(left);
+    const rightNode = reifyAlgebraic(right);
+    return `On considère l'inéquation suivante :
+  
+$$
+${leftNode.toTex()} ${inequalitySign ? "<" : ">"} ${rightNode.toTex()}
+$$
+
+Cette inéquation est-elle vraie pour $x = ${x}$ ?`;
+};
+const getHint = (identifiers) => {
+    return `Remplace $x$ par $${identifiers.x}$ dans les deux membres. Ensuite, vérifie si l'inégalité est vraie ou non.`;
+};
+const reverseSign = (sign) => {
+    let x = "";
+    if (sign === "<") {
+        x = ">";
+    }
+    else if (sign === ">") {
+        x = "<";
+    }
+    return x;
+};
+const getCorrection = (identifiers) => {
+    const { x, inequalitySign, left, right } = identifiers;
+    const leftNode = reifyAlgebraic(left);
+    const rightNode = reifyAlgebraic(right);
+    const detailedLeft = leftNode.toDetailedEvaluation({ x: x.toTree() });
+    const simplifiedLeft = detailedLeft.simplify();
+    const detailedRight = rightNode.toDetailedEvaluation({ x: x.toTree() });
+    const simplifiedRight = detailedRight.simplify();
+    const leftDetTex = detailedLeft.toTex();
+    const leftSimTex = simplifiedLeft.toTex();
+    const rightDetTex = detailedRight.toTex();
+    const rightSimTex = simplifiedRight.toTex();
+    const isTrue = getAnswer(identifiers) === "Oui";
+    const sign = inequalitySign ? "<" : ">";
+    return `Pour $x = ${x}$, le membre de gauche vaut :
+
+$$
+${leftDetTex} = ${leftSimTex}
+$$
+
+Le membre de droite vaut :
+
+$$
+${rightDetTex} = ${rightSimTex}
+$$
+
+Puisque $${leftSimTex} ${isTrue ? sign : reverseSign(sign)} ${rightSimTex}$, l'inéquation ${isTrue ? "est bien verifiée" : "n'est pas vérifiée"} pour $x = ${x}$.`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getIsInequalityTrueQuestion = (ops) => {
+    const a = randint(-10, 10, [0]);
+    const b = randint(-10, 10, [0]);
+    const c = randint(-10, 10, [0]);
+    const d = randint(-10, 10, [0]);
+    const x = randint(-10, 10);
+    const inequalitySign = coinFlip();
+    const left = add(multiply(a, "x"), b).toIdentifiers();
+    const right = add(multiply(c, "x"), -d).toIdentifiers();
+    const identifiers = {
+        a,
+        b,
+        c,
+        d,
+        x,
+        inequalitySign,
+        left,
+        right,
+    };
+    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 isInequalityTrue = {
+    id: "isInequalityTrue",
+    label: "Vérifier si une inégalité est vraie",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsInequalityTrueQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/calculLitteral/inequations/minNumberInequality.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    aLimit: number;
+    bLimit: number;
+    x: number;
+    y: number;
+    case: "lt" | "lte" | "lt_gt";
+    expressionToCheck: NodeIdentifiers;
+};
+export declare const minNumberInequality: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=minNumberInequality.d.ts.map

package/lib/exercises/math/calculLitteral/inequations/minNumberInequality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minNumberInequality.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/inequations/minNumberInequality.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAS7C,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,IAAI,EAAE,IAAI,GAAG,KAAK,GAAG,OAAO,CAAC;IAC7B,iBAAiB,EAAE,eAAe,CAAC;CACpC,CAAC;AA4NF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

package/lib/exercises/math/calculLitteral/inequations/minNumberInequality.js

@@ -0,0 +1,192 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { add, isAddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { InequationNode } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../utils/alea/random.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const randomNumber = randint(0, 100).frenchify();
+        tryToAddWrongProp(propositions, randomNumber);
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aLimit, bLimit, expressionToCheck: formulaIdentifier } = identifiers;
+    const formulaNode = reifyAlgebraic(formulaIdentifier).toDetailedEvaluation({
+        a: aLimit.toTree(),
+        b: bLimit.toTree(),
+    });
+    const answer = formulaNode.simplify().toTex();
+    return answer;
+};
+const getInstruction = (identifiers) => {
+    const { aLimit, bLimit, case: inequalityCase, expressionToCheck, } = identifiers;
+    const modeSymbolsMap = {
+        lt: ["<", "<"],
+        lte: ["\\le", "\\le"],
+        lt_gt: ["<", ">"],
+    };
+    const symbols = modeSymbolsMap[inequalityCase];
+    if (!symbols)
+        throw new Error(`Unhandled mode: ${inequalityCase}`);
+    const [aSymbol, bSymbol] = symbols;
+    const a = new VariableNode("a");
+    const b = new VariableNode("b");
+    const aLimitNode = new NumberNode(aLimit);
+    const bLimitNode = new NumberNode(bLimit);
+    const aCondition = new InequationNode([a, aLimitNode], aSymbol);
+    const bCondition = new InequationNode([b, bLimitNode], bSymbol);
+    const v = new VariableNode("...");
+    const exprCondition = new InequationNode([reifyAlgebraic(expressionToCheck), v], aSymbol);
+    return `Compléter par le plus petit nombre réel possible : 
+  
+"Si $a$ et $b$ sont deux nombres réels verifiant $${aCondition.toTex()}$ et $${bCondition.toTex()}$, alors $${exprCondition.toTex()}$" 
+  
+  `;
+};
+const getHint = (identifiers) => {
+    return `On peut additionner deux inégalités si elles sont de même sens :
+
+Si $a < b$ et $c < d$, alors $a + c < b + d$.`;
+};
+const getCorrection = (identifiers) => {
+    const { aLimit, bLimit, x, y, case: inequalityCase, expressionToCheck, } = identifiers;
+    const exprNode = reifyAlgebraic(expressionToCheck);
+    let left;
+    let right;
+    if (isAddNode(exprNode)) {
+        left = exprNode.leftChild;
+        right = exprNode.rightChild;
+    }
+    else {
+        const exprNode = reifyAlgebraic(expressionToCheck);
+        const nominator = exprNode.leftChild;
+        const denominator = exprNode.rightChild;
+        left = frac(nominator.leftChild, denominator);
+        right = frac(nominator.rightChild, denominator);
+    }
+    const leftValue = left
+        .toDetailedEvaluation({ a: aLimit.toTree() })
+        .simplify()
+        .toTex();
+    const rightValue = right
+        .toDetailedEvaluation({ b: bLimit.toTree() })
+        .simplify()
+        .toTex();
+    const answer = getAnswer(identifiers);
+    const symbolMap = {
+        lt: "<",
+        lte: "\\le",
+        lt_gt: "<",
+    };
+    const finalSymbol = symbolMap[inequalityCase] ?? "<";
+    const leftCondition = new InequationNode(["a".toTree(), aLimit.toTree()], finalSymbol);
+    const leftExpr = new InequationNode([left, leftValue.toTree()], finalSymbol);
+    const rightCondition = new InequationNode(["b".toTree(), bLimit.toTree()], inequalityCase === "lt_gt" ? ">" : finalSymbol);
+    const rightExpr = new InequationNode([right, rightValue.toTree()], finalSymbol);
+    const exprInequality = new InequationNode([exprNode, add(leftValue.toTree(), rightValue.toTree())], finalSymbol);
+    const finishedExprInequality = new InequationNode([exprNode, answer.toTree()], finalSymbol);
+    const shouldWorkOnA = inequalityCase !== "lt_gt" && x !== 1;
+    const shouldWorkOnB = y !== 1 || inequalityCase === "lt_gt";
+    return `${shouldWorkOnA
+        ? `Puisque $${leftCondition.toTex()}$ alors $${leftExpr.toTex()}$.`
+        : ""}
+
+${shouldWorkOnB
+        ? `Puisque $${rightCondition.toTex()}$, alors $${rightExpr.toTex()}$. `
+        : ""}
+  
+  On peut ${shouldWorkOnA || shouldWorkOnB ? "alors" : ""} additionner les deux inégalités : 
+  
+$$
+${exprInequality.toTex()}
+$$
+
+donc 
+
+$$
+${finishedExprInequality.toTex()}
+$$`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getMinNumberInequalityQuestion = (ops) => {
+    const aLimit = randint(1, 10);
+    const bLimit = randint(1, 10);
+    const x = randint(1, 10);
+    const y = randint(1, 10);
+    const cases = ["lt", "lte", "lt_gt"];
+    const randomCase = random(cases);
+    const addNode = add(multiply(x, "a"), multiply(y, "b"));
+    const subNode = add("a", multiply(-1, "b"));
+    const Denominator = add(multiply(x, aLimit), multiply(y, bLimit)).simplify();
+    const fracNode = frac(add(multiply(x, "a"), multiply(y, "b")), Denominator);
+    let formulaNode;
+    if (randomCase === "lt") {
+        coinFlip() ? (formulaNode = addNode) : (formulaNode = fracNode);
+    }
+    else if (randomCase === "lte") {
+        formulaNode = addNode;
+    }
+    else if (randomCase === "lt_gt") {
+        formulaNode = subNode;
+    }
+    const identifiers = {
+        aLimit,
+        bLimit,
+        x,
+        y,
+        case: randomCase,
+        expressionToCheck: formulaNode.toIdentifiers(),
+    };
+    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 minNumberInequality = {
+    id: "minNumberInequality",
+    label: "Compléter une inégalité par le plus petit nombre possible",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMinNumberInequalityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calculLitteral/systems/verifySystemSolution.js

@@ -111,7 +111,7 @@ const getPropositions = (n, { answer, ...identifiers }) => {
 };
 export const verifySystemSolution = {
     id: "verifySystemSolution",
-    label: "Vérifier si un couple est solution d'un système",
+    label: "Vérifier si un couple est solution d'un système d'équations",
     levels: ["2nde", "1reSpé"],
     isSingleStep: true,
     sections: ["Systèmes"],

package/lib/exercises/math/functions/absolute/calculateDistanceBetweenNumbers.d.ts

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

package/lib/exercises/math/functions/absolute/calculateDistanceBetweenNumbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateDistanceBetweenNumbers.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/calculateDistanceBetweenNumbers.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyFF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAoBjE,CAAC"}

package/lib/exercises/math/functions/absolute/calculateDistanceBetweenNumbers.js

@@ -0,0 +1,102 @@
+import { 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 { abs } from "../../../../tree/nodes/functions/absNode.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 { coinFlip } from "../../../../utils/alea/coinFlip.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);
+    // Au cas où l'élève répond à la question en inversant les deux nombres
+    tryToAddWrongProp(propositions, add(b, -a).simplify().evaluate().frenchify());
+    // Au cas où l'élève répond à la question en ajoutant les deux nombres
+    tryToAddWrongProp(propositions, add(a, b).simplify().evaluate().frenchify());
+    while (propositions.length < n) {
+        const randomAnswer = coinFlip() ? randint(-10, 10) : randfloat(-10, 10, 2);
+        tryToAddWrongProp(propositions, randomAnswer.frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    const sub = add(a, -b);
+    const absNode = abs(sub).simplify().evaluate();
+    return absNode.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Calculer la distance entre $${a.frenchify()}$ et $${b.frenchify()}$.`;
+};
+const getHint = (identifiers) => {
+    return `La distance entre deux nombres $a$ et $b$ est 
+  : 
+  
+$$
+|a - b|
+$$
+`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    const sub = substract(a, b);
+    const absNode = abs(sub);
+    const answer = getAnswer(identifiers);
+    return `La distance entre $${a.frenchify()}$ et $${b.frenchify()}$ est : 
+  
+${alignTex([
+        [absNode.toTex(), "=", abs(sub.simplify()).toTex()],
+        ["", "=", answer],
+    ])}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        return ansNode.equals(answerNode);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCalculateDistanceBetweenNumbersQuestion = (ops) => {
+    const a = coinFlip() ? randint(-10, 10) : randfloat(-10, 10, 2);
+    const b = coinFlip() ? randint(-10, 10, [a]) : randfloat(-10, 10, 2, [a]);
+    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 calculateDistanceBetweenNumbers = {
+    id: "calculateDistanceBetweenNumbers",
+    label: "Calculer la distance entre deux nombres",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateDistanceBetweenNumbersQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/absolute/calculateDistanceWithAbsoluteValue.d.ts

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

package/lib/exercises/math/functions/absolute/calculateDistanceWithAbsoluteValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateDistanceWithAbsoluteValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/calculateDistanceWithAbsoluteValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IAEjB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAsHF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAqBpE,CAAC"}

package/lib/exercises/math/functions/absolute/calculateDistanceWithAbsoluteValue.js

@@ -0,0 +1,112 @@
+import { 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 { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { NodeIds } from "../../../../tree/nodes/node.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, substract(abs(b), abs(reifyAlgebraic(a))).toTex() + "=" + c.frenchify());
+    tryToAddWrongProp(propositions, substract(abs(reifyAlgebraic(a)), abs(b)).toTex() + "=" + c.frenchify());
+    tryToAddWrongProp(propositions, add(abs(b), reifyAlgebraic(a)).toTex() + "=" + c.frenchify());
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b, c } = identifiers;
+    return `${abs(substract(b, reifyAlgebraic(a))).toTex()}=${c.frenchify()}`;
+};
+const getInstruction = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const proposition = a.id === NodeIds.variable
+        ? `la distance entre $${reifyAlgebraic(a).toTex()}$ et $${b.frenchify()}$ est égale à $${c.frenchify()}$`
+        : `$${reifyAlgebraic(a).toTex()}$ et $${b.frenchify()}$ sont situés à une distance de $${c.frenchify()}$ l'un de l'autre`;
+    return `Traduire par une égalité avec une valeur absolue la phrase suivante :  
+
+"${proposition}".`;
+};
+const getHint = (identifiers) => {
+    return `La distance entre deux nombres $a$ et $b$ est égale à : 
+  
+$$
+${abs(substract("b", "a")).toTex()}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    return `La distance entre $${reifyAlgebraic(a).toTex()}$ et $${b.frenchify()}$ est égale à $${abs(substract(b, reifyAlgebraic(a))).toTex()}$.
+  
+Ici, on a donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = (identifiers) => {
+    return ["abs", "x", "equal"];
+};
+const isAnswerValid = (ans, { answer, a, b, c }) => {
+    const aNode = reifyAlgebraic(a);
+    return [
+        `${abs(substract(b, aNode)).toTex()}=${c.frenchify()}`,
+        `${abs(substract(aNode, b)).toTex()}=${c.frenchify()}`,
+    ].includes(ans);
+};
+const getCalculateDistanceWithAbsoluteValueQuestion = (ops) => {
+    const containsVariable = coinFlip();
+    let a;
+    let b;
+    let c;
+    if (containsVariable) {
+        a = new VariableNode("x");
+        b = coinFlip() ? randint(-10, 10) : randfloat(-10, 10, 2);
+        c = coinFlip() ? randint(1, 10, [b]) : randfloat(0, 10, 2, [b, 0]);
+    }
+    else {
+        const aNb = coinFlip() ? randint(-10, 10) : randfloat(-10, 10, 2);
+        a = aNb.toTree();
+        b = randint(-10, 10, [aNb]);
+        c = round(Math.abs(b - aNb), 4);
+    }
+    const identifiers = {
+        a: a.toIdentifiers(),
+        b,
+        c,
+    };
+    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 calculateDistanceWithAbsoluteValue = {
+    id: "calculateDistanceWithAbsoluteValue",
+    connector: "=",
+    label: "Traduire une distance par une valeur absolue",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateDistanceWithAbsoluteValueQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/absolute/calculateWithAbsoluteValue.d.ts

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

package/lib/exercises/math/functions/absolute/calculateWithAbsoluteValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateWithAbsoluteValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/calculateWithAbsoluteValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,eAAe,CAAC;CAC7B,CAAC;AAmHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}