math-exercises 3.0.200 → 3.0.201

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"}