math-exercises 3.0.77 → 3.0.78

package/lib/exercises/math/calcul/arithmetics/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/calcul/arithmetics/calculateDistanceWithAbsoluteValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateDistanceWithAbsoluteValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/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/calcul/arithmetics/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/calcul/arithmetics/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/calcul/arithmetics/calculateWithAbsoluteValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"calculateWithAbsoluteValue.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/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,CAiB5D,CAAC"}

package/lib/exercises/math/calcul/arithmetics/calculateWithAbsoluteValue.js

@@ -0,0 +1,123 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { abs, isAbsNode } from "../../../../tree/nodes/functions/absNode.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const delta = coinFlip() ? randint(1, 5) : randfloat(1, 5, 2);
+        const direction = coinFlip() ? 1 : -1;
+        const wrongValue = Number((answer.unfrenchify() + direction * delta).toFixed(2));
+        tryToAddWrongProp(propositions, wrongValue.frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { expression } = identifiers;
+    const expressionValue = reifyAlgebraic(expression).simplify().evaluate();
+    return expressionValue.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { expression } = identifiers;
+    const expressionTex = reifyAlgebraic(expression).toTex();
+    return `Calculer et donner le résultat sans utiliser la notation de la valeur absolue : 
+  
+$$
+${expressionTex}
+$$ `;
+};
+const getHint = (identifiers) => {
+    const expressionTex = reifyAlgebraic(identifiers.expression).toTex();
+    return `Utilise la définition de la valeur absolue : 
+
+- $|x| = x$ si $x \\geq 0$;  
+- $|x| = -x$ si $x < 0$.`;
+};
+const getCorrection = (identifiers) => {
+    const { expression } = identifiers;
+    const exprNode = reifyAlgebraic(expression);
+    const absChild = isAbsNode(exprNode) ? exprNode.child : null;
+    const absChildValue = absChild ? absChild.simplify().evaluate() : "";
+    const answer = getAnswer(identifiers);
+    return `On rappelle que : 
+
+- $|x| = x$ si $x \\geq 0$;  
+- $|x| = -x$ si $x < 0$.
+
+Ici, on a donc : 
+
+${alignTex([
+        [
+            exprNode.toTex(),
+            "=",
+            isAbsNode(exprNode)
+                ? abs(exprNode.child.simplify()).toTex()
+                : exprNode.simplify({ forbidAdditions: true }).toTex(),
+        ],
+        ["", "=", answer],
+    ])}
+
+`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCalculateWithAbsoluteValueQuestion = (ops) => {
+    const a = coinFlip() ? randint(-10, 10, [0]) : randfloat(-10, 10, 2, [0]);
+    const b = coinFlip() ? randint(-10, 10, [a]) : randfloat(-10, 10, 2, [a]);
+    const expressionGenerators = [
+        () => abs(add(a, b)).toIdentifiers(), // |a + b|
+        () => abs(add(a, -b)).toIdentifiers(), // |a - b|
+        () => add(abs(a), b).toIdentifiers(), // |a| + b
+        () => add(a, abs(b)).toIdentifiers(), // a + |b|
+        () => add(abs(a), abs(b)).toIdentifiers(), // |a| + |b|
+    ];
+    const expression = random(expressionGenerators)();
+    const identifiers = { expression };
+    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 calculateWithAbsoluteValue = {
+    id: "calculateWithAbsoluteValue",
+    label: "Calculer avec des valeurs absolues",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateWithAbsoluteValueQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -20,4 +20,7 @@ export * from "./isMultipleOrDivisor.js";
 export * from "./compareInverseValues.js";
 export * from "./calculateDistanceBetweenNumbers.js";
 export * from "./compareSquaredValues.js";
+export * from "./calculateWithAbsoluteValue.js";
+export * from "./sqrtInequality.js";
+export * from "./calculateDistanceWithAbsoluteValue.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,2BAA2B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,qBAAqB,CAAC;AACpC,cAAc,yCAAyC,CAAC"}

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

@@ -20,3 +20,6 @@ export * from "./isMultipleOrDivisor.js";
 export * from "./compareInverseValues.js";
 export * from "./calculateDistanceBetweenNumbers.js";
 export * from "./compareSquaredValues.js";
+export * from "./calculateWithAbsoluteValue.js";
+export * from "./sqrtInequality.js";
+export * from "./calculateDistanceWithAbsoluteValue.js";

package/lib/exercises/math/calcul/arithmetics/sqrtInequality.d.ts

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

package/lib/exercises/math/calcul/arithmetics/sqrtInequality.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrtInequality.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/sqrtInequality.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,OAAO,CAAC;IAClB,CAAC,EAAE,eAAe,CAAC;IACnB,CAAC,CAAC,EAAE,eAAe,CAAC;CACrB,CAAC;AAsJF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAkBhD,CAAC"}

package/lib/exercises/math/calcul/arithmetics/sqrtInequality.js

@@ -0,0 +1,160 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { intervalParser } from "../../../../tree/parsers/intervalParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const allClosures = Object.values(ClosureType);
+    while (propositions.length < n) {
+        const falseInterval = new IntervalNode(randint(0, 10).toTree(), randint(0, 10).toTree(), random(allClosures)).toTex();
+        tryToAddWrongProp(propositions, "S=\\ " + falseInterval);
+    }
+    return shuffleProps(propositions, n);
+};
+const getInstruction = ({ twoSided, a, b }) => {
+    const aNode = reifyAlgebraic(a).toTex();
+    if (twoSided) {
+        const bNode = reifyAlgebraic(b).toTex();
+        return `Résoudre l'inéquation suivante, pour $x\\geq 0$  :
+
+$$
+${aNode} < \\sqrt{x} < ${bNode}
+$$`;
+    }
+    else {
+        return `Résoudre l'inéquation suivante, pour $x\\geq 0$ :  
+
+$$
+\\sqrt{x} < ${aNode}
+$$`;
+    }
+};
+const getAnswer = ({ twoSided, a, b }) => {
+    const aVal = reifyAlgebraic(a).evaluate();
+    let interval;
+    if (twoSided) {
+        const bVal = reifyAlgebraic(b).evaluate();
+        interval = new IntervalNode((aVal * aVal).toTree(), (bVal * bVal).toTree(), ClosureType.OO);
+    }
+    else {
+        interval = new IntervalNode((0).toTree(), (aVal * aVal).toTree(), ClosureType.FO);
+    }
+    return "S=\\ " + interval.simplify().toTex();
+};
+const getHint = ({ twoSided }) => {
+    if (twoSided) {
+        return `Puisque tous les termes de cette inéquations sont positifs, on peut les élèver au carré sans changer l'ordre de l'inéquation.`;
+    }
+    else {
+        return `Puisque tous les termes de cette inéquations sont positifs, on peut les élèver au carré sans changer l'ordre de l'inéquation.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { a, twoSided, b } = identifiers;
+    const aNode = reifyAlgebraic(a);
+    let steps;
+    let solTex;
+    const answer = getAnswer(identifiers);
+    if (twoSided) {
+        const bNode = reifyAlgebraic(b);
+        steps = [
+            [`${aNode.toTex()} < \\sqrt{x} < ${bNode.toTex()}`],
+            [
+                `${square(aNode).toTex()} < ${square(sqrt("x")).toTex()} < ${square(bNode).toTex()}`,
+            ],
+            [
+                `${square(aNode).simplify().toTex()} < x < ${square(bNode)
+                    .simplify()
+                    .toTex()}`,
+            ],
+        ];
+    }
+    else {
+        steps = [
+            [`\\sqrt{x} < ${aNode.toTex()}`],
+            [`${square(sqrt("x")).toTex()} < ${square(aNode).toTex()}`],
+            [`x < ${square(aNode).simplify().toTex()}`],
+        ];
+    }
+    return `Puisque tous les termes de cette inéquation sont positifs, on peut les élèver au carré sans changer l'ordre de l'inéquation (en effet, si deux nombres positifs $a$ et $b$ vérifient $a<b$, alors $a^2<b^2$).
+  
+On a donc : 
+
+${alignTex(steps)}
+  
+La solution de l'inéquation est donc :
+
+$$
+${answer}
+$$`;
+};
+const getKeys = () => [
+    "S",
+    "equal",
+    "lbracket",
+    "rbracket",
+    "semicolon",
+];
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = intervalParser(ans.replaceAll("S", "").replaceAll("=", ""));
+        if (!parsed)
+            return false;
+        return answer === "S=\\ " + parsed.simplify().toTex();
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSqrtInequalityQuestion = () => {
+    const twoSided = coinFlip();
+    let aIds;
+    let bIds;
+    if (twoSided) {
+        const aVal = randint(1, 10);
+        const bVal = randint(aVal + 1, aVal + 10);
+        aIds = aVal.toTree().toIdentifiers();
+        bIds = bVal.toTree().toIdentifiers();
+    }
+    else {
+        const aVal = randint(1, 10);
+        aIds = aVal.toTree().toIdentifiers();
+    }
+    const identifiers = { twoSided, a: aIds, b: bIds };
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const sqrtInequality = {
+    id: "sqrtInequality",
+    label: "Résoudre une inéquation du type $a<\\sqrt{x}<b$ ou $\\sqrt{x}<b$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSqrtInequalityQuestion(opts), nb),
+    freeTimer: 60,
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getPropositions,
+    getQuestionFromIdentifiers: ({ twoSided, a, b }) => getSqrtInequalityQuestion(),
+    getKeys,
+    isAnswerValid,
+    hasHintAndCorrection: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/calcul/sign/absoluteNumber.js

@@ -63,7 +63,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 };
 export const absoluteNumber = {
     id: "absoluteNumber",
-    label: "Calculer avec des valeurs absolues",
+    label: "Calculer la valeur absolue d'un nombre",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getAbsoluteNumberQuestion(opts), nb),
     qcmTimer: 60,

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

@@ -1 +1 @@
-{"version":3,"file":"absoluteValueInequations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/absoluteValueInequations.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA2GF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"absoluteValueInequations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/absolute/absoluteValueInequations.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,OAAO,CAAC;CACnB,CAAC;AA6GF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}

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

@@ -14,7 +14,11 @@ const getInstruction = (identifiers) => {
     const diff = new NumberNode(b - a);
     const add = new NumberNode(b + a);
     const poly = new Polynomial([-b, 1]);
-    return `Résoudre l'inéquation $|${poly.toTree().toTex()}|${isStrict ? "<" : "\\le"}${a}$.`;
+    return `Résoudre l'inéquation : 
+  
+$$
+|${poly.toTree().toTex()}|${isStrict ? "<" : "\\le"}${a}
+$$`;
 };
 const getAnswer = (identifiers) => {
     const { a, b, isStrict } = identifiers;

package/lib/exercises/math/functions/basics/graphicEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graphicEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/graphicEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;CAClC,CAAC;AA4HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAcjD,CAAC"}
+{"version":3,"file":"graphicEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/graphicEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC;CAClC,CAAC;AA6JF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAejD,CAAC"}

package/lib/exercises/math/functions/basics/graphicEquation.js

@@ -3,6 +3,7 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { discreteSetKeys } from "../../../../exercises/utils/keys/discreteSetKeys.js";
 import { randomColor } from "../../../../geogebra/colors.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { EquationSolutionNode } from "../../../../tree/nodes/equations/equationSolutionNode.js";
 import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
@@ -10,8 +11,36 @@ import { DiscreteSetNode, } from "../../../../tree/nodes/sets/discreteSetNode.js
 import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { pluralize } from "../../../../utils/strings/pluralize.js";
 const getInstruction = (identifiers) => {
-    return `Déterminer graphiquement les solutions de l'équation $f(x) = ${identifiers.yValue}$ où $f$ est la fonction représentée ci-dessous.`;
+    return `On considère la fonction $f$ dont la courbe représentative est tracée ci-dessous. 
+  
+Déterminer graphiquement les solutions de l'équation $f(x) = ${identifiers.yValue}$.`;
+};
+const getHint = (identifiers) => {
+    const { splinePoints, yValue } = identifiers;
+    return `Les solutions de l'équation $f(x) = ${yValue}$ sont les abscisses des points de la courbe d'ordonnée $${yValue}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { splinePoints, yValue } = identifiers;
+    const xSolutions = identifiers.splinePoints
+        .filter((p) => p[1] === identifiers.yValue)
+        .map((p) => p[0]);
+    const names = ["A", "B", "C", "D", "E"];
+    const points = xSolutions.map((x, i) => new Point(names[i], x, yValue));
+    return `Les solutions de l'équation $f(x) = ${yValue}$ sont les abscisses des points de la courbe d'ordonnée $${yValue}$. 
+  
+On trouve graphiquement $${xSolutions.length}$ ${pluralize("point", xSolutions.length)} d'ordonnée $${yValue}$ : 
+
+$$
+${points.map((e) => e.toTexWithCoords()).join(" \\ ; \\ ")}
+$$
+
+L'ensemble des solutions de l'équation $f(x) = ${yValue}$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
 };
 const getGGBOptions = (identifiers) => {
     const { splinePoints } = identifiers;
@@ -86,6 +115,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         answerFormat: "tex",
         ggbOptions: getGGBOptions(identifiers),
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -129,4 +160,5 @@ export const graphicEquation = {
     hasGeogebra: true,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/basics/twoFunctionsEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"twoFunctionsEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/twoFunctionsEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAiKF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAatD,CAAC"}
+{"version":3,"file":"twoFunctionsEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/twoFunctionsEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AA8LF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

package/lib/exercises/math/functions/basics/twoFunctionsEquation.js

@@ -9,6 +9,30 @@ import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
 import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { pluralize } from "../../../../utils/strings/pluralize.js";
+const getHint = (identifiers) => {
+    const { fSplinePoints, gSplinePoints, xSolutions, yValue } = identifiers;
+    return `Les solutions de l'équation $f(x) = g(x)$ sont les abscisses des points qui appartiennent à la fois à la courbe de $f$ et à celle de $g$.`;
+};
+const getCorrection = (identifiers) => {
+    const { fSplinePoints, gSplinePoints, xSolutions, yValue } = identifiers;
+    const names = ["A", "B", "C", "D", "E"];
+    const points = xSolutions.map((x, i) => new Point(names[i], x, yValue));
+    return `Les solutions de l'équation $f(x) = g(x)$  sont les abscisses des points qui appartiennent à la fois à la courbe de $f$ et à celle de $g$. 
+  
+On trouve graphiquement $${xSolutions.length}$ ${pluralize("point", xSolutions.length)} d'intersection des deux courbes : 
+
+$$
+${points.map((e) => e.toTexWithCoords()).join(" \\ ; \\ ")}
+$$
+
+L'ensemble des solutions de l'équation $f(x) = g(x)$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
 const getInstruction = (identifiers) => {
     return `Déterminer graphiquement les solutions de l'équation $f(x) = g(x)$ où $f$ et $g$ sont les fonctions représentées ci-dessous.`;
 };
@@ -103,6 +127,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         answerFormat: "tex",
         identifiers,
         ggbOptions: getGGBOptions(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -142,4 +168,5 @@ export const twoFunctionsEquation = {
     hasGeogebra: true,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/variations/varTableExtremaReading.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"varTableExtremaReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/varTableExtremaReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AA4JF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"varTableExtremaReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/variations/varTableExtremaReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,SAAS,EAAE,OAAO,CAAC;IACnB,WAAW,EAAE,OAAO,CAAC;IACrB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AA+LF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}