math-exercises 3.0.207 → 3.0.209

package/lib/exercises/math/probaStat/exponential/exponentialLawComputeProba.js

@@ -0,0 +1,110 @@
+import { addValidProp, shuffleProps, propWhile, 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 { round } from "../../../../math/utils/round.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(0.01, 0.9, 2).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { k, lambda } = identifiers;
+    return round(substract(1, exp(-k * lambda)).evaluate(), 2).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { k, lambda } = identifiers;
+    return `Soit $X$ une variable aléatoire qui suit une loi exponentielle de paramètre $${lambda.frenchify()}$. 
+  
+Calculer $P(X\\leq ${k})$.
+
+Donner une valeur approchée au centième.`;
+};
+const getHint = () => {
+    return `Si $X$ suit une loi exponentielle de paramètre $\\lambda$, alors pour tout réel $t\\geq 0$, on a : 
+  
+$$
+P(X\\leq t) = 1-e^{-\\lambda t}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { k, lambda } = identifiers;
+    return `Si $X$ suit une loi exponentielle de paramètre $\\lambda$, alors pour tout réel $t\\geq 0$, on a : 
+  
+$$
+P(X\\leq t) = 1-e^{-\\lambda t}
+$$
+
+Ici, on a donc : 
+
+$$
+P(X\\leq ${k}) = 1-e^{${multiply(-lambda, k).toTex()}} \\approx ${getAnswer(identifiers)}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getExponentialLawComputeProbaQuestion = () => {
+    let lambda;
+    let k;
+    let rounded;
+    let counter = 0;
+    do {
+        counter++;
+        if (counter > 1000)
+            throw new Error("too many iterations in exponentialLawComputeProba");
+        lambda = randfloat(0.01, 1, 2);
+        k = randint(2, 20);
+        rounded = round(substract(1, exp(-k * lambda)).evaluate(), 2);
+    } while (rounded === 1);
+    const identifiers = {
+        lambda,
+        k,
+    };
+    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 exponentialLawComputeProba = {
+    id: "exponentialLawComputeProba",
+    connector: "=",
+    label: "Calculer une probabilité du type $P(X\\leq t)$ pour une loi exponentielle",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getExponentialLawComputeProbaQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/exponential/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./exponentialLawComputeProba.js";
+export * from "./exponentialLawComputeIntervalProba.js";
+export * from "./exponentialLawAverage.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/exponential/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/exponential/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,yCAAyC,CAAC;AACxD,cAAc,4BAA4B,CAAC"}

package/lib/exercises/math/probaStat/exponential/index.js

@@ -0,0 +1,3 @@
+export * from "./exponentialLawComputeProba.js";
+export * from "./exponentialLawComputeIntervalProba.js";
+export * from "./exponentialLawAverage.js";

package/lib/exercises/math/probaStat/geometric/geometricLawAverage.d.ts

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

package/lib/exercises/math/probaStat/geometric/geometricLawAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricLawAverage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/geometric/geometricLawAverage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;CACvB,CAAC;AA8GF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAkBrD,CAAC"}

package/lib/exercises/math/probaStat/geometric/geometricLawAverage.js

@@ -0,0 +1,124 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { RationalConstructor } from "../../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac, isFractionNode, } from "../../../../tree/nodes/operators/fractionNode.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";
+import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { pIds } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const p = reifyAlgebraic(pIds);
+    tryToAddWrongProp(propositions, p.toTex());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, coinFlip()
+            ? RationalConstructor.randomIrreductibleProba().toTree().toTex()
+            : randfloat(0.1, 1, 2).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { pIds } = identifiers;
+    const p = reifyAlgebraic(pIds);
+    if (isFractionNode(p)) {
+        return frac(1, p).simplify().toTex();
+    }
+    else {
+        return round(frac(1, p).evaluate(), 2).frenchify();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { pIds } = identifiers;
+    const p = reifyAlgebraic(pIds);
+    return `Soit $X$ une variable aléatoire qui suit une loi géométrique de paramètre $${p.toTex()}$.
+  
+Quelle est l'espérance $E(X)$ de $X$ ? Donner la valeur exacte ou une valeur arrondie au centième.`;
+};
+const getHint = () => {
+    return `Si $X$ suit une loi géométrique de paramètre $p$, alors on a : 
+  
+$$
+E(X) = \\frac{1}{p}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { pIds } = identifiers;
+    const p = reifyAlgebraic(pIds);
+    const isFrac = isFractionNode(p);
+    const ratio = frac(1, p);
+    const ratioEv = ratio.evaluate();
+    const answer = getAnswer(identifiers);
+    return `Si $X$ suit une loi géométrique de paramètre $p$, alors on a : 
+  
+$$
+E(X) = \\frac{1}{p}
+$$
+
+Ici, on a donc : 
+
+${alignTex([
+        ["E(X)", "=", ratio.toTex()],
+        isFrac ? ["", "=", answer] : ["", ...approxOrEqual(ratioEv, 2)],
+    ])}
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer: _answer, pIds }) => {
+    try {
+        const p = reifyAlgebraic(pIds);
+        const sol = frac(1, p).simplify();
+        const solEv = round(sol.evaluate(), 2);
+        return (parseAlgebraic(ans).simplify().toTex() === sol.toTex() ||
+            numberVEA(ans, solEv.frenchify(), 2));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGeometricLawAverageQuestion = () => {
+    const p = coinFlip()
+        ? RationalConstructor.randomIrreductibleProba().toTree()
+        : randfloat(0.1, 1, 2).toTree();
+    const identifiers = {
+        pIds: p.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 geometricLawAverage = {
+    id: "geometricLawAverage",
+    connector: "=",
+    label: "Déterminer l'espérane d'une loi géométrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricLawAverageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/geometric/geometricLawComputeProba.d.ts

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

package/lib/exercises/math/probaStat/geometric/geometricLawComputeProba.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricLawComputeProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/geometric/geometricLawComputeProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,eAAe,CAAC;IACtB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwGF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAmB1D,CAAC"}

package/lib/exercises/math/probaStat/geometric/geometricLawComputeProba.js

@@ -0,0 +1,121 @@
+import { addValidProp, shuffleProps, propWhile, 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 { round } from "../../../../math/utils/round.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.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 { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randfloat(0.1, 0.9, 3).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { pIds, k } = identifiers;
+    const p = reifyAlgebraic(pIds);
+    const proba = multiply(p, power(substract(1, p), substract(k, 1)));
+    return round(proba.evaluate(), 3).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { pIds, k } = identifiers;
+    const p = reifyAlgebraic(pIds);
+    return `Soit $X$ une variable aléatoire qui suit une loi géométrique de paramètre $${p.toTex()}$.
+  
+Calculer $P(X=${k})$.
+
+Donner une valeur arrondie au millième.`;
+};
+const getHint = () => {
+    return `Si $X$ suit une loi géométrique de paramètre $p$, alors pour tout entier naturel $k$ non nul, on a : 
+  
+$$
+P(X=k) = p\\times (1-p)^{k-1}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { pIds, k } = identifiers;
+    const p = reifyAlgebraic(pIds);
+    const proba = multiply(p, power(substract(1, p), substract(k, 1)));
+    return `Si $X$ suit une loi géométrique de paramètre $p$, alors pour tout entier naturel $k$ non nul, on a : 
+  
+$$
+P(X=k) = p\\times (1-p)^{k-1}
+$$
+
+Ici, on a donc : 
+
+${alignTex([
+        [`P(X=${k})`, "=", proba.toTex()],
+        ["", ...approxOrEqual(proba.evaluate(), 3)],
+    ])}
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGeometricLawComputeProbaQuestion = () => {
+    let p;
+    let k;
+    let rounded = 0;
+    let counter = 0;
+    do {
+        counter++;
+        if (counter > 1000)
+            throw new Error("too many iterations in geometricLawComputeProba");
+        p = randfloat(0.1, 1, 1);
+        k = randint(2, 10);
+        const proba = multiply(p, power(substract(1, p), substract(k, 1)));
+        rounded = round(proba.evaluate(), 3);
+    } while (rounded < 0.002);
+    const identifiers = {
+        k,
+        pIds: p.toTree().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 geometricLawComputeProba = {
+    id: "geometricLawComputeProba",
+    connector: "=",
+    label: "Calculer une probabilté $P(X=k)$ pour une variable aléatoire suivant une loi géométrique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricLawComputeProbaQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/geometric/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./geometricLawAverage.js";
+export * from "./geometricLawComputeProba.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/geometric/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAC;AACzC,cAAc,+BAA+B,CAAC"}

package/lib/exercises/math/probaStat/geometric/index.js

@@ -0,0 +1,2 @@
+export * from "./geometricLawAverage.js";
+export * from "./geometricLawComputeProba.js";

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

@@ -16,4 +16,8 @@ export * from "./conditional/index.js";
 export * from "./twoStepExperiments/index.js";
 export * from "./trees/index.js";
 export * from "./tchebychev/index.js";
+export * from "./geometric/index.js";
+export * from "./density/index.js";
+export * from "./uniform/index.js";
+export * from "./exponential/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,+BAA+B,CAAC;AAC9C,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC;AACnC,cAAc,wBAAwB,CAAC"}

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

@@ -16,3 +16,7 @@ export * from "./conditional/index.js";
 export * from "./twoStepExperiments/index.js";
 export * from "./trees/index.js";
 export * from "./tchebychev/index.js";
+export * from "./geometric/index.js";
+export * from "./density/index.js";
+export * from "./uniform/index.js";
+export * from "./exponential/index.js";

package/lib/exercises/math/probaStat/stats2var/fineAdjustementExercise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fineAdjustementExercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/fineAdjustementExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAM5C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,sBAAsB,EAAE,sBAAsB,CAAC;CAChD,CAAC;AAsIF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}
+{"version":3,"file":"fineAdjustementExercise.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/fineAdjustementExercise.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAGrC,OAAO,EAGL,sBAAsB,EACvB,MAAM,oCAAoC,CAAC;AAM5C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,OAAO,CAAC;IACrB,sBAAsB,EAAE,sBAAsB,CAAC;CAChD,CAAC;AA0JF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/probaStat/stats2var/fineAdjustementExercise.js

@@ -46,6 +46,18 @@ const getGGBOptions = (identifiers) => {
         coords: ggb.getAdaptedCoords({ xMin, xMax, yMin, yMax }),
     });
 };
+const getHint = () => {
+    return `Le coefficient de détermination indique si un ajustement affine est pertinent ou non pour la série statistique considérée. Plus il est proche de $1$, plus l'ajustement affine est pertinent. Plus il est proche de $0$, moins l'ajustement affine est pertinent.`;
+};
+const getCorrection = (identifiers) => {
+    const { isJustified, cloudPointsIdentifiers } = identifiers;
+    const cloudPoints = new CloudPoints(cloudPointsIdentifiers.pointsIdentifiers.map((i) => PointConstructor.fromIdentifiers(i)));
+    const coeff = cloudPoints.getCorrelationCoeff().value;
+    const determinationCoeff = new NumberNode(+(coeff * coeff).toFixed(2));
+    return isJustified
+        ? `Les points du nuage de points représentant cette série statistique sont "presque" alignés. Il semblerait pertinent donc d'ajuster cette série statistique par un ajustement affine. Le coefficient de détermination doit donc être proche de $1$ pour cette série statistique. Parmi les choix proposés, on en déduit donc que ce coefficient vaut $${determinationCoeff.toTex()}$. `
+        : `Ici, les points du nuage de points ne semblent pas du tout former une droite : il ne semble donc pas pertinent d'ajuster cette série statistique par un ajustement affine. Le coefficient de détermination doit donc être proche de $0$ pour cette série statistique. Parmi les choix proposés, on en conclut que ce coefficient vaut $${determinationCoeff.toTex()}$. `;
+};
 const getFineAdjustementExerciseQuestion = () => {
     const flip = coinFlip();
     const cloudPoints = flip
@@ -73,6 +85,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "raw",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -111,4 +125,5 @@ export const fineAdjustementExercise = {
     getPropositions,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/probaStat/uniform/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./uniformLawComputeProba.js";
+export * from "./uniformAverage.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/uniform/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/uniform/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qBAAqB,CAAC"}

package/lib/exercises/math/probaStat/uniform/index.js

@@ -0,0 +1,2 @@
+export * from "./uniformLawComputeProba.js";
+export * from "./uniformAverage.js";

package/lib/exercises/math/probaStat/uniform/uniformAverage.d.ts

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

package/lib/exercises/math/probaStat/uniform/uniformAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniformAverage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/uniform/uniformAverage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA2FF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAkBhD,CAAC"}

package/lib/exercises/math/probaStat/uniform/uniformAverage.js

@@ -0,0 +1,100 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const a = randint(-10, 20);
+        const b = randint(a + 1, a + 20);
+        tryToAddWrongProp(propositions, frac(a + b, 2)
+            .simplify()
+            .toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, b } = identifiers;
+    return frac(a + b, 2)
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Soit $X$ une variable aléatoire qui suit une loi uniforme sur $[${a};${b}]$.
+  
+Calculer l'espérance $E(X)$ de $X$.`;
+};
+const getHint = () => {
+    return `Si $X$ suit une loi uniforme sur $[a;b]$, alors son espérance vaut :
+  
+$$
+E(X) = \\frac{a+b}{2}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b } = identifiers;
+    return `Si $X$ suit une loi uniforme sur $[a;b]$, alors son espérance vaut :
+  
+$$
+E(X) = \\frac{a+b}{2}
+$$
+
+Ici, on a donc : 
+
+$$
+E(X) = ${frac(a + b, 2).toSimplificationTex()}
+$$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getUniformAverageQuestion = () => {
+    const a = randint(-10, 20);
+    const b = randint(a + 1, a + 20);
+    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 uniformAverage = {
+    id: "uniformAverage",
+    connector: "=",
+    label: "Calculer l'espérance d'une loi uniforme",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getUniformAverageQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/uniform/uniformLawComputeProba.d.ts

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

package/lib/exercises/math/probaStat/uniform/uniformLawComputeProba.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uniformLawComputeProba.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/uniform/uniformLawComputeProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CAEX,CAAC;AAgGF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAmBxD,CAAC"}