math-exercises 3.0.199 → 3.0.201

package/lib/exercises/math/probaStat/basicProbas/varianceOfMean.js

@@ -0,0 +1,171 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, GeneratorOptionTarget, GeneratorOptionType, } 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 { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../tree/nodes/operators/powerNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getHydrated = (identifiers) => {
+    const { nodeIdsE, nodeIdsV, nodeIdsN } = identifiers;
+    const [nodeE, nodeV, nodeN] = [nodeIdsE, nodeIdsV, nodeIdsN].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const nodeVMn = frac(nodeV, nodeN);
+    return {
+        nodeE,
+        nodeV,
+        nodeN,
+        nodeVMn,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nodeE, nodeV, nodeN } = getHydrated(identifiers);
+    return `Soit $(X_{${nodeN.toTex()}})$ un échantillon d'une variable aléatoire $X$ d'espérance $${nodeE.toTex()}$ et de variance $${nodeV.toTex()}$. On note :
+
+$$
+M_{${nodeN.toTex()}} = \\frac{1}{${nodeN.toTex()}} \\displaystyle \\sum_{i=1}^{${nodeN.toTex()}} X_{i}
+$$
+
+Que vaut $V(M_{n})$ ?`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeVMn } = getHydrated(identifiers);
+    return nodeVMn.simplify().toTex();
+};
+const getHint = () => {
+    return `Soit $a$ et $b$ deux réels. Soient $X$ et $Y$ deux variables aléatoires.
+
+$$
+V(aX+bY) = a^2 \\ V(X) + b^2 \\ V(Y)
+$$
+
+Pour un échantillon $(X_{2})$ de $X$, on a donc :
+
+${alignTex([
+        ["", `V(\\frac{1}{2} X_{1}+\\frac{1}{2} X_{2})`],
+        ["=", `\\frac{1}{4} V(X_{1}) + \\frac{1}{4} V(X_{2})`],
+        ["=", `\\frac{1}{4} V(X) + \\frac{1}{4} V(X)`],
+        ["=", `\\frac{1}{2} V(X)`],
+    ])}
+  
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeN, nodeVMn } = getHydrated(identifiers);
+    const texN = nodeN.toTex();
+    return `
+  
+${alignTex([
+        ["", `V(M_{${texN}})`],
+        ["=", `V(\\frac{1}{${texN}} (X_{1} + ... + X_{${texN}}))`],
+        ["=", `\\frac{1}{${texN}^2} V(X_{1} + ... + X_{${texN}})`],
+        ["=", `\\frac{1}{${texN}^2} (V(X_{1}) + ... + V(X_{${texN}}))`],
+        ["=", `\\frac{1}{${texN}^2} (${texN} V(X))`],
+        ["=", `\\frac{V(X)}{${nodeN.toTex()}}`],
+        ["=", nodeVMn.simplify().toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeV, nodeN } = getHydrated(identifiers);
+    //student: V(X)
+    {
+        tryToAddWrongProp(propositions, nodeV.simplify().toTex());
+    }
+    //student: V(X)/n²
+    {
+        tryToAddWrongProp(propositions, frac(nodeV, square(nodeN)).simplify().toTex());
+    }
+    //student: n V(X)
+    {
+        tryToAddWrongProp(propositions, multiply(nodeN, nodeV).simplify().toTex());
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers(opts);
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiers = (opts) => {
+    const nodeE = randfloat(-10, 10, 2).toTree();
+    const nodeV = randfloat(1, 10, 2).toTree();
+    const nodeN = opts.typeN === "nombre"
+        ? (randint(1, 11) * 10).toTree()
+        : new VariableNode("n");
+    const identifiers = {
+        nodeIdsE: nodeE.toIdentifiers(),
+        nodeIdsV: nodeV.toIdentifiers(),
+        nodeIdsN: nodeN.toIdentifiers(),
+    };
+    return identifiers;
+};
+const getVarianceOfMeanQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+const optsDefault = {
+    typeN: "nombre",
+};
+const options = [
+    {
+        id: "typeN",
+        label: "Type de la taille $n$ de l'échantillon",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["nombre", "lettre"],
+        defaultValue: optsDefault.typeN,
+    },
+];
+export const varianceOfMean = {
+    id: "varianceOfMean",
+    connector: "=",
+    label: "Calculer la variance d'une moyenne",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getVarianceOfMeanQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/binomial/fromSituation/binomialExpectedValueFromSituation.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { BinomialSituationParams } from "./binomialSituations.js";
+type Identifiers = {
+    n: number;
+    situationParams: BinomialSituationParams;
+};
+export declare const binomialExpectedValueFromSituation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=binomialExpectedValueFromSituation.d.ts.map

package/lib/exercises/math/probaStat/binomial/fromSituation/binomialExpectedValueFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binomialExpectedValueFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/binomial/fromSituation/binomialExpectedValueFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAYrC,OAAO,EACL,uBAAuB,EAGxB,MAAM,yBAAyB,CAAC;AAEjC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,eAAe,EAAE,uBAAuB,CAAC;CAC1C,CAAC;AA8JF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAapE,CAAC"}

package/lib/exercises/math/probaStat/binomial/fromSituation/binomialExpectedValueFromSituation.js

@@ -0,0 +1,125 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { binom } from "../../../../../tree/nodes/operators/binomialCoefficientNode.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 { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { getHydratedBinomialSituation, getRandomBinomialSituationParams, } from "./binomialSituations.js";
+const getHydrated = (identifiers) => {
+    const { n, situationParams } = identifiers;
+    const binomialSituation = getHydratedBinomialSituation(situationParams, n.toTree());
+    const { nodeProbaSuccess } = binomialSituation;
+    const nodeAnswer = multiply(n, nodeProbaSuccess).simplify();
+    return {
+        binomialSituation,
+        nodeAnswer,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { binomialSituation } = getHydrated(identifiers);
+    return `${binomialSituation.strContext}
+  
+Donner l'espérance de $X$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeAnswer } = getHydrated(identifiers);
+    return nodeAnswer.toTex();
+};
+const getHint = () => {
+    return `L'espérance d'une loi binomiale de paramètre $p$ est $p$.
+On répète $n$ expériences aléatoires suivant une loi binomiale de paramètre $p$, toutes indépendantes les unes des autres : l'espérance est donc $np$.`;
+};
+const getCorrection = (identifiers) => {
+    const { binomialSituation, nodeAnswer } = getHydrated(identifiers);
+    const { nodeProbaSuccess, nodeN } = binomialSituation;
+    return `Si on réalise une fois l'expérience, l'espérance est $${nodeProbaSuccess.toTex()}$.
+On répète $${nodeN.toTex()}$ fois l'expérience, tous les essais étant indépendant les uns des autres : l'espérance est donc $${nodeAnswer.toTex()}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { binomialSituation } = getHydrated(identifiers);
+    const { nodeProbaSuccess } = binomialSituation;
+    const createNodeProbaKN = (nodeK, nodeN, nodeProbaSuccess) => {
+        return multiply(binom(nodeN, nodeK), multiply(power(nodeProbaSuccess, nodeK), power(substract(1, nodeProbaSuccess), substract(nodeN, nodeK).simplify())));
+    };
+    {
+        const nodeK = (1).toTree();
+        const nodeN = n.toTree();
+        const nodeWrong = multiply(n, createNodeProbaKN(nodeK, nodeN, nodeProbaSuccess)).simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    {
+        const nodeK = (1).toTree();
+        const nodeN = n.toTree();
+        const nodeWrong = createNodeProbaKN(nodeK, nodeN, nodeProbaSuccess).simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    {
+        const nodeWrong = frac(multiply(nodeProbaSuccess, substract(1, nodeProbaSuccess)), n).simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiers();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { binomialSituation } = getHydrated(identifiers);
+    return [...binomialSituation.keys];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const [nodeAns, nodeAnswer] = [ans, answer].map((str) => parseAlgebraic(str));
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const createRandomIdentifiers = () => {
+    const n = randint(4, 8);
+    const situationParams = getRandomBinomialSituationParams();
+    const identifiers = {
+        n,
+        situationParams,
+    };
+    return identifiers;
+};
+const getBinomialExpectedValueFromSituationQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const binomialExpectedValueFromSituation = {
+    id: "binomialExpectedValueFromSituation",
+    label: "Donner l'espérance d'un schéma de Bernoulli à partir d'une situation",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getBinomialExpectedValueFromSituationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/probaStat/binomial/fromSituation/binomialFindParamsFromSituation.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { BinomialSituationParams } from "./binomialSituations.js";
+type Identifiers = {
+    n: number;
+    situationParams: BinomialSituationParams;
+};
+export declare const binomialFindParamsFromSituation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=binomialFindParamsFromSituation.d.ts.map

package/lib/exercises/math/probaStat/binomial/fromSituation/binomialFindParamsFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binomialFindParamsFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/binomial/fromSituation/binomialFindParamsFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,uBAAuB,EAGxB,MAAM,yBAAyB,CAAC;AAEjC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,eAAe,EAAE,uBAAuB,CAAC;CAC1C,CAAC;AAwLF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}

package/lib/exercises/math/probaStat/binomial/fromSituation/binomialFindParamsFromSituation.js

@@ -0,0 +1,126 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.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 { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { getHydratedBinomialSituation, getRandomBinomialSituationParams, } from "./binomialSituations.js";
+const getHydrated = (identifiers) => {
+    const { n, situationParams } = identifiers;
+    const binomialSituation = getHydratedBinomialSituation(situationParams, n.toTree());
+    return {
+        binomialSituation,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { binomialSituation } = getHydrated(identifiers);
+    return `${binomialSituation.strContext}
+  
+Donner les paramètres de la loi de probabilité de $X$.`;
+};
+const getAnswer = (identifiers) => {
+    const { binomialSituation } = getHydrated(identifiers);
+    return `${binomialSituation.nodeN.toTex()} \\ ; \\ ${binomialSituation.nodeProbaSuccess.toTex()}`;
+};
+const getHint = () => {
+    return `Si une expérience aléatoire avec seulement deux issues, succès et échec, avec les probabilités respectives $p$ et $1-p$ est répétée $n$ fois, 
+alors on peut la désigner plus simplement comme un schéma de Bernoulli de paramètres $n$ et $p$.`;
+};
+const getCorrection = (identifiers) => {
+    const { binomialSituation } = getHydrated(identifiers);
+    return `On répète $${binomialSituation.nodeN.toTex()}$ fois une expérience dont l'issue "succès" a une probabilité de $${binomialSituation.nodeProbaSuccess.toTex()}$. 
+    
+C'est donc un schéma de Bernoulli de paramètres $${binomialSituation.nodeN.toTex()}$ et $${binomialSituation.nodeProbaSuccess.toTex()}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { binomialSituation } = getHydrated(identifiers);
+    const { nodeN, nodeProbaSuccess } = binomialSituation;
+    switch (binomialSituation.id) {
+        case "redBallsBlueBallsUrn":
+            {
+                const { nbBallsRed, nbBallsBlue } = binomialSituation.specifics;
+                tryToAddWrongProp(propositions, `${nodeN.toTex()} ; ${nbBallsRed.frenchify()}`);
+                tryToAddWrongProp(propositions, `${nodeN.toTex()} ; ${frac(nodeN, nbBallsRed).toTex()}`);
+                tryToAddWrongProp(propositions, `${nodeN.toTex()} ; ${frac(nbBallsRed, nbBallsBlue).toTex()}`);
+                tryToAddWrongProp(propositions, `${frac(1, nbBallsRed).toTex()} ; ${frac(1, nbBallsBlue).toTex()}`);
+            }
+            break;
+        case "illPeopleSampling":
+        case "electronicComponents":
+            {
+                tryToAddWrongProp(propositions, `${nodeProbaSuccess.simplify().toTex()} ; ${substract(1, nodeProbaSuccess)
+                    .simplify()
+                    .toTex()}`);
+                tryToAddWrongProp(propositions, `${nodeN.toTex()} ; ${multiply(nodeProbaSuccess, 100)
+                    .simplify()
+                    .toTex()}`);
+                tryToAddWrongProp(propositions, `${nodeN.toTex()} ; ${power(nodeProbaSuccess, nodeN).toTex()}`);
+            }
+            break;
+        case "japaneseExam":
+            {
+                const { nbItemsPerQuestion } = binomialSituation.specifics;
+                tryToAddWrongProp(propositions, `${nodeProbaSuccess.simplify().toTex()} ; ${substract(1, nodeProbaSuccess)
+                    .simplify()
+                    .toTex()}`);
+                tryToAddWrongProp(propositions, `${nodeN.toTex()} ; ${power(nodeProbaSuccess, nodeN).toTex()}`);
+                tryToAddWrongProp(propositions, `${nodeN.toTex()} ; ${nbItemsPerQuestion.frenchify()}`);
+            }
+            break;
+        case "darts":
+            {
+                tryToAddWrongProp(propositions, `${nodeProbaSuccess.simplify().toTex()} ; ${substract(1, nodeProbaSuccess)
+                    .simplify()
+                    .toTex()}`);
+                tryToAddWrongProp(propositions, `${frac(1, nodeN).toTex()} ; ${substract(1, nodeProbaSuccess)
+                    .simplify()
+                    .toTex()}`);
+                tryToAddWrongProp(propositions, `${frac(1, nodeN).toTex()} ; ${nodeProbaSuccess.simplify().toTex()}`);
+            }
+            break;
+        default:
+            throw new Error("Unsupported binomialSituation.id: " + binomialSituation.id);
+    }
+    return shuffleProps(propositions, n);
+};
+const getKeys = (identifiers) => {
+    const { binomialSituation } = getHydrated(identifiers);
+    return [...binomialSituation.keys];
+};
+const getBinomialFindParamsFromSituationQuestion = () => {
+    const n = coinFlip() ? 2 : 3;
+    const situationParams = getRandomBinomialSituationParams();
+    const identifiers = {
+        n,
+        situationParams,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const binomialFindParamsFromSituation = {
+    id: "binomialFindParamsFromSituation",
+    label: "Donner les paramètres d'un schéma de Bernoulli à partir d'une situation",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getBinomialFindParamsFromSituationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+};

package/lib/exercises/math/probaStat/binomial/fromSituation/binomialFindProbaOfAtLeastOneSuccessFromSituation.d.ts

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

package/lib/exercises/math/probaStat/binomial/fromSituation/binomialFindProbaOfAtLeastOneSuccessFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binomialFindProbaOfAtLeastOneSuccessFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/binomial/fromSituation/binomialFindProbaOfAtLeastOneSuccessFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,OAAO,EACL,uBAAuB,EAGxB,MAAM,yBAAyB,CAAC;AAEjC,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,uBAAuB,CAAC;CAC1C,CAAC;AAwKF,eAAO,MAAM,iDAAiD,EAAE,QAAQ,CAAC,WAAW,CAkBjF,CAAC"}

package/lib/exercises/math/probaStat/binomial/fromSituation/binomialFindProbaOfAtLeastOneSuccessFromSituation.js

@@ -0,0 +1,150 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.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 { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { getHydratedBinomialSituation, getRandomBinomialSituationParams, } from "./binomialSituations.js";
+const getHydratedMini = (identifiers) => {
+    const { situationParams } = identifiers;
+    const binomialSituation = getHydratedBinomialSituation(situationParams, new VariableNode("n"));
+    return {
+        binomialSituation,
+    };
+};
+const getHydrated = (identifiers) => {
+    const { binomialSituation } = getHydratedMini(identifiers);
+    const { nodeN, nodeProbaSuccess } = binomialSituation;
+    const nodeProbaOnlyFailures = power(substract(1, nodeProbaSuccess), nodeN);
+    const nodeAnswer = substract(1, nodeProbaOnlyFailures);
+    return {
+        binomialSituation,
+        nodeProbaOnlyFailures,
+        nodeAnswer,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { binomialSituation } = getHydratedMini(identifiers);
+    return `${binomialSituation.strContext}
+  
+Exprimer en fonction de $n$ la probabilité d'obtenir au moins un succès.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeAnswer } = getHydrated(identifiers);
+    return nodeAnswer.toTex();
+};
+const getHint = () => {
+    return `Le contraire de l'évènement "obtenir au moins un succès" est l'évènement "n'obtenir que des échecs".
+Détermine donc la probabilité de l'évènement "n'obtenir que des échecs" pour en déduire la probabilité recherchée.`;
+};
+const getCorrection = (identifiers) => {
+    const { binomialSituation, nodeProbaOnlyFailures, nodeAnswer } = getHydrated(identifiers);
+    return `Le contraire de l'évènement "obtenir au moins un succès" est l'évènement "n'obtenir que des échecs".
+  
+On répète $${binomialSituation.nodeN.toTex()}$ fois une expérience dont l'issue "succès" a une probabilité de $${binomialSituation.nodeProbaSuccess.toTex()}$.
+
+On répète donc $${binomialSituation.nodeN.toTex()}$ fois une expérience dont l'issue "échec" a une probabilité de $${substract(1, binomialSituation.nodeProbaSuccess).toTex()}$.
+
+
+L'évènement "n'obtenir que des échecs" a la probabilité $${nodeProbaOnlyFailures.toTex()}$.
+
+
+L'évènement "obtenir au moins un succès" a la probabilité $${nodeAnswer.toTex()}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { binomialSituation, nodeProbaOnlyFailures } = getHydrated(identifiers);
+    const { nodeN, nodeProbaSuccess } = binomialSituation;
+    //student: at least one success has proba p_S
+    {
+        tryToAddWrongProp(propositions, nodeProbaSuccess.toTex());
+    }
+    //student: at least one success has proba n p_S
+    {
+        tryToAddWrongProp(propositions, multiply(nodeN, nodeProbaSuccess).toTex());
+    }
+    //student: forgets to flip at the end
+    {
+        tryToAddWrongProp(propositions, nodeProbaOnlyFailures.toTex());
+    }
+    /*
+    switch (binomialSituation.id) {
+      case "redBallsBlueBallsUrn":
+        {
+  
+        }
+        break;
+      case "illPeopleSampling":
+      case "electronicComponents":
+        {
+  
+        }
+        break;
+      case "japaneseExam":
+        {
+  
+        }
+        break;
+      case "darts":
+        {
+  
+        }
+        break;
+      default:
+        throw new Error(
+          "Unsupported binomialSituation.id: " + binomialSituation.id,
+        );
+    }
+    */
+    return shuffleProps(propositions, n);
+};
+const getKeys = (_identifiers) => {
+    return ["n"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const [nodeAns, nodeAnswer] = [ans, answer].map((str) => parseAlgebraic(str));
+        return (NodeComparator.isEqualViaSub(nodeAns, nodeAnswer) ||
+            NodeComparator.isEqualViaFrac(nodeAns, nodeAnswer));
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getBinomialFindProbaOfAtLeastOneSuccessFromSituationQuestion = () => {
+    const situationParams = getRandomBinomialSituationParams();
+    const identifiers = {
+        situationParams,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const binomialFindProbaOfAtLeastOneSuccessFromSituation = {
+    id: "binomialFindProbaOfAtLeastOneSuccessFromSituation",
+    label: "Exprimer en fonction de $n$ la probabilité d'obtenir au moins un succès dans un schéma de Bernoulli à partir d'une situation",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getBinomialFindProbaOfAtLeastOneSuccessFromSituationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/probaStat/binomial/fromSituation/binomialFindProbaOfXCompKFromSituation.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+import { BinomialSituationParams } from "./binomialSituations.js";
+type Identifiers = {
+    situationParams: BinomialSituationParams;
+    nodeIdsN: NodeIdentifiers;
+    nodeIdsBounds: NodeIdentifiers[];
+};
+type Options = {
+    probaType: string;
+    typeN: string;
+};
+export declare const binomialFindProbaOfXCompKFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=binomialFindProbaOfXCompKFromSituation.d.ts.map

package/lib/exercises/math/probaStat/binomial/fromSituation/binomialFindProbaOfXCompKFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"binomialFindProbaOfXCompKFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/binomial/fromSituation/binomialFindProbaOfXCompKFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAc7C,OAAO,EACL,uBAAuB,EAGxB,MAAM,yBAAyB,CAAC;AAgBjC,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,uBAAuB,CAAC;IACzC,QAAQ,EAAE,eAAe,CAAC;IAC1B,aAAa,EAAE,eAAe,EAAE,CAAC;CAClC,CAAC;AAqYF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AA+BF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAC3D,WAAW,EACX,OAAO,CAmBR,CAAC"}