math-exercises 3.0.199 → 3.0.201

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

@@ -0,0 +1,386 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { EqualNode } from "../../../../../tree/nodes/equations/equalNode.js";
+import { InequationNode } from "../../../../../tree/nodes/inequations/inequationNode.js";
+import { reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { binom } from "../../../../../tree/nodes/operators/binomialCoefficientNode.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 { isVariableNode, VariableNode, } from "../../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { getHydratedBinomialSituation, getRandomBinomialSituationParams, } from "./binomialSituations.js";
+const createNodeProbaKN = (nodeK, nodeN, nodeProbaSuccess) => {
+    return multiply(binom(nodeN, nodeK), multiply(power(nodeProbaSuccess, nodeK), power(substract(1, nodeProbaSuccess), substract(nodeN, nodeK).simplify())));
+};
+const getHydratedMini = (identifiers) => {
+    const { situationParams, nodeIdsN, nodeIdsBounds } = identifiers;
+    const [nodeN, nodeBoundLow, nodeBoundHigh] = [nodeIdsN, ...nodeIdsBounds].map((nodeIds) => reifyAlgebraic(nodeIds));
+    const [probaType, nodeComp] = (() => {
+        const nodeX = new VariableNode("X");
+        if (NodeComparator.isEqualViaSub(nodeBoundLow, nodeBoundHigh)) {
+            //P( X = k )
+            const nodeK = nodeBoundLow;
+            return ["$P( X = k )$", new EqualNode(nodeX, nodeK)];
+        }
+        else if (NodeComparator.isEqualViaSub(nodeBoundHigh, nodeN)) {
+            //P( a \\leq X )
+            return [
+                "$P( a \\leq X )$",
+                new InequationNode([nodeBoundLow, nodeX], "\\le"),
+            ];
+        }
+        else if (NodeComparator.isEqualViaSub(nodeBoundLow, (0).toTree())) {
+            //P( X \\leq b )
+            return [
+                "$P( X \\leq b )$",
+                new InequationNode([nodeX, nodeBoundHigh], "\\le"),
+            ];
+        }
+        else {
+            //P( a \\leq X \\leq b )
+            return [
+                "$P( a \\leq X \\leq b )$",
+                new InequationNode([nodeBoundLow, nodeX, nodeBoundHigh], "\\le"),
+            ];
+        }
+    })();
+    const binomialSituation = getHydratedBinomialSituation(situationParams, nodeN);
+    return {
+        binomialSituation,
+        nodeN,
+        nodeBoundLow,
+        nodeBoundHigh,
+        nodeComp,
+        probaType,
+    };
+};
+const getHydrated = (identifiers) => {
+    const { binomialSituation, nodeN, nodeBoundLow, nodeBoundHigh, nodeComp, probaType, } = getHydratedMini(identifiers);
+    const { nodeProbaSuccess } = binomialSituation;
+    const nodeAnswer = (() => {
+        switch (probaType) {
+            case "$P( X = k )$": {
+                const nodeK = nodeBoundLow;
+                return createNodeProbaKN(nodeK, nodeN, nodeProbaSuccess);
+            }
+            case "$P( a \\leq X )$": {
+                const valueBoundLow = nodeBoundLow.evaluate();
+                return [...Array(valueBoundLow + 1).keys()].reduce((acc, v, i) => {
+                    const nodeK = v.toTree();
+                    if (i === 0) {
+                        return createNodeProbaKN(nodeK, nodeN, nodeProbaSuccess);
+                    }
+                    else {
+                        return add(acc, createNodeProbaKN(nodeK, nodeN, nodeProbaSuccess));
+                    }
+                }, (0).toTree());
+            }
+            case "$P( X \\leq b )$": {
+                const nMinusB = substract(nodeN, nodeBoundHigh).evaluate();
+                const nodeProba1 = [...Array(nMinusB).keys()].reduce((acc, v, i) => {
+                    const nodeK = add(nodeBoundHigh, v + 1).simplify();
+                    if (i === 0) {
+                        return createNodeProbaKN(nodeK, nodeN, nodeProbaSuccess);
+                    }
+                    else {
+                        return add(acc, createNodeProbaKN(nodeK, nodeN, nodeProbaSuccess));
+                    }
+                }, (0).toTree());
+                return substract(1, nodeProba1);
+            }
+            case "$P( a \\leq X \\leq b )$": {
+                console.log("nodeBoundLow", nodeBoundLow.toTex());
+                console.log("nodeBoundHigh", nodeBoundHigh.toTex());
+                const bMinusA = substract(nodeBoundHigh, nodeBoundLow).evaluate();
+                return [...Array(bMinusA + 1).keys()].reduce((acc, v, i) => {
+                    const nodeK = add(nodeBoundLow, v).simplify();
+                    if (i === 0) {
+                        return createNodeProbaKN(nodeK, nodeN, nodeProbaSuccess);
+                    }
+                    else {
+                        return add(acc, createNodeProbaKN(nodeK, nodeN, nodeProbaSuccess));
+                    }
+                }, (0).toTree());
+            }
+            default:
+                throw new Error("Unsupported probaType: " + probaType);
+        }
+    })();
+    return {
+        binomialSituation,
+        nodeN,
+        nodeBoundLow,
+        nodeBoundHigh,
+        nodeComp,
+        probaType,
+        nodeAnswer,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { binomialSituation, nodeComp } = getHydratedMini(identifiers);
+    return `${binomialSituation.strContext}
+  
+Calculer la probabilité $P( ${nodeComp.toTex()} )$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeAnswer } = getHydrated(identifiers);
+    return nodeAnswer.toTex();
+};
+const getHint = () => {
+    return `Pour $k$ compris entre $0$ et $n$, avec $p$ la probabilité d'un succès :
+  
+$$
+P( X = k ) = \\binom{n}{k} p^{k} (1-p)^{n-k}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeComp, nodeAnswer, probaType, nodeBoundHigh } = getHydrated(identifiers);
+    switch (probaType) {
+        case "$P( X = k )$": {
+            return `On calcule la probabilité de l'issue "$X = ${nodeBoundHigh.toTex()} $".
+    
+On a donc : 
+
+$$
+P( ${nodeComp.toTex()} ) = ${nodeAnswer.toTex()}
+$$
+
+`;
+        }
+        case "$P( a \\leq X )$": {
+            return `On décompose l'évènement "$${nodeComp.toTex()}$" en une union d'issues.
+    
+On a donc : 
+
+$$
+P( ${nodeComp.toTex()} ) = ${nodeAnswer.toTex()}
+$$
+
+`;
+        }
+        case "$P( X \\leq b )$": {
+            return `Le contraire de l'évènement "$${nodeComp.toTex()}$" est l'évènement "$${nodeBoundHigh.toTex()} \\leq X$".
+On décompose l'évènement "$${nodeBoundHigh.toTex()} \\leq X$" en une union d'issues.
+
+On a donc : 
+
+$$
+P( ${nodeComp.toTex()} ) = ${nodeAnswer.toTex()}
+$$
+
+`;
+        }
+        case "$P( a \\leq X \\leq b )$": {
+            return `On décompose l'évènement "$${nodeComp.toTex()}$" en une union d'issues.
+    
+On a donc : 
+
+$$
+P( ${nodeComp.toTex()} ) = ${nodeAnswer.toTex()}
+$$
+
+`;
+        }
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { nodeBoundLow, nodeBoundHigh, probaType } = getHydratedMini(identifiers);
+    function myTryToAddWrongProp(nodeBoundLowWrong, nodeBoundHighWrong) {
+        const identifiersWrong = {
+            ...identifiers,
+            nodeIdsBounds: [nodeBoundLowWrong, nodeBoundHighWrong].map((node) => node.toIdentifiers()),
+        };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    }
+    if (probaType === "$P( a \\leq X \\leq b )$") {
+        myTryToAddWrongProp(nodeBoundLow, nodeBoundLow);
+        myTryToAddWrongProp(nodeBoundHigh, nodeBoundHigh);
+    }
+    {
+        const [nodeBoundLowWrong, nodeBoundHighWrong] = (() => {
+            return [nodeBoundLow, add(nodeBoundHigh, 1).simplify()];
+        })();
+        myTryToAddWrongProp(nodeBoundLowWrong, nodeBoundHighWrong);
+    }
+    {
+        const [nodeBoundLowWrong, nodeBoundHighWrong] = (() => {
+            return [
+                add(nodeBoundLow, 1).simplify(),
+                add(nodeBoundHigh, 1).simplify(),
+            ];
+        })();
+        myTryToAddWrongProp(nodeBoundLowWrong, nodeBoundHighWrong);
+    }
+    {
+        const [nodeBoundLowWrong, nodeBoundHighWrong] = (() => {
+            return [
+                add(nodeBoundHigh, 1).simplify(),
+                add(nodeBoundHigh, 1).simplify(),
+            ];
+        })();
+        myTryToAddWrongProp(nodeBoundLowWrong, nodeBoundHighWrong);
+    }
+    /*
+    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 getBinomialFindProbaOfXCompKFromSituationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const situationParams = getRandomBinomialSituationParams();
+    const nodeN = (() => {
+        switch (opts.typeN) {
+            case "nombre": {
+                const n = randint(5, 12);
+                return n.toTree();
+            }
+            case "lettre": {
+                return new VariableNode("n");
+            }
+            default:
+                throw new Error("Unsupported opts.typeN: " + opts.typeN);
+        }
+    })();
+    const [nodeBoundLow, nodeBoundHigh] = (() => {
+        const nodeK = isVariableNode(nodeN)
+            ? randint(3, 9).toTree()
+            : substract(nodeN, randint(1, 4)).simplify();
+        switch (opts.probaType) {
+            case "$P( X = k )$": {
+                return [nodeK, nodeK];
+            }
+            case "$P( a \\leq X )$": {
+                const nodeBoundLow = randint(1, 3).toTree();
+                const nodeBoundHigh = nodeN;
+                return [nodeBoundLow, nodeBoundHigh];
+            }
+            case "$P( X \\leq b )$": {
+                const nodeBoundLow = (0).toTree();
+                const nodeBoundHigh = substract(nodeN, randint(1, 3).toTree()).simplify();
+                return [nodeBoundLow, nodeBoundHigh];
+            }
+            case "$P( a \\leq X \\leq b )$": {
+                const [vOffsetLow, vOffsetHigh] = random([
+                    [-2, 0],
+                    [-1, 0],
+                    [0, 1],
+                    [0, 2],
+                    [-1, 1],
+                ]);
+                const [nodeBoundLow, nodeBoundHigh] = [vOffsetLow, vOffsetHigh].map((vOffset) => add(nodeK, vOffset).simplify());
+                return [nodeBoundLow, nodeBoundHigh];
+            }
+            default:
+                throw new Error("Unsupported opts.probaType: " + opts.probaType);
+        }
+    })();
+    const identifiers = {
+        situationParams,
+        nodeIdsN: nodeN.toIdentifiers(),
+        nodeIdsBounds: [nodeBoundLow, nodeBoundHigh].map((node) => node.toIdentifiers()),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    probaType: "$P( X = k )$",
+    typeN: "nombre",
+};
+const options = [
+    {
+        id: "probaType",
+        label: "Type de probabilité",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: [
+            "$P( X = k )$",
+            "$P( a \\leq X )$",
+            "$P( X \\leq b )$",
+            "$P( a \\leq X \\leq b )$",
+        ],
+        defaultValue: optsDefault.probaType,
+    },
+    {
+        id: "typeN",
+        label: "Format de $n$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["nombre", "lettre"],
+        defaultValue: optsDefault.typeN,
+    },
+];
+export const binomialFindProbaOfXCompKFromSituation = {
+    id: "binomialFindProbaOfXCompKFromSituation",
+    label: "Exprimer la probabilité de $X$ par rapport à $k$ dans un schéma de Bernoulli à partir d'une situation",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBinomialFindProbaOfXCompKFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+import { BinomialSituationParams } from "./binomialSituations.js";
+type Identifiers = {
+    situationParams: BinomialSituationParams;
+    nodeIdsP: NodeIdentifiers;
+    thresholdType: string;
+};
+type Options = {
+    thresholdType: string;
+};
+export declare const binomialFindThresholdForNFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=binomialFindThresholdForNFromSituation.d.ts.map

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

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

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

@@ -0,0 +1,248 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { LogNode } from "../../../../../tree/nodes/functions/logNode.js";
+import { InequationNode } from "../../../../../tree/nodes/inequations/inequationNode.js";
+import { reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.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 { VariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { NodeComparator } from "../../../../../tree/utilities/nodeComparator.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+import { getHydratedBinomialSituation, getRandomBinomialSituationParams, } from "./binomialSituations.js";
+const _createNodeProbaKN = (nodeK, nodeN, nodeProbaSuccess) => {
+    return multiply(binom(nodeN, nodeK), multiply(power(nodeProbaSuccess, nodeK), power(substract(1, nodeProbaSuccess), substract(nodeN, nodeK).simplify())));
+};
+const getHydratedMini = (identifiers) => {
+    const { situationParams, nodeIdsP, thresholdType } = identifiers;
+    const [nodeP] = [nodeIdsP].map((nodeIds) => reifyAlgebraic(nodeIds));
+    const nodeComp1 = (() => {
+        switch (thresholdType) {
+            case "$P( X \\geq 1 ) > p$": {
+                return new InequationNode([new VariableNode("P( X \\geq 1 )"), nodeP], ">");
+            }
+            case "$P( X = 0 ) < p$": {
+                return new InequationNode([new VariableNode("P( X = 0 )"), nodeP], "<");
+            }
+            case "$P( X = n ) < p$": {
+                return new InequationNode([new VariableNode("P( X = n )"), nodeP], "<");
+            }
+            default:
+                throw new Error("Unsupported thresholdType: " + thresholdType);
+        }
+    })();
+    const binomialSituation = getHydratedBinomialSituation(situationParams, new VariableNode("n"));
+    return {
+        binomialSituation,
+        nodeP,
+        thresholdType,
+        nodeComp1,
+    };
+};
+const getHydrated = (identifiers) => {
+    const { binomialSituation, nodeComp1, nodeP, thresholdType } = getHydratedMini(identifiers);
+    const { nodeProbaSuccess } = binomialSituation;
+    const [arrNodeComp, nodeAnswer] = (() => {
+        const nodeN = new VariableNode("n");
+        switch (thresholdType) {
+            case "$P( X \\geq 1 ) > p$": {
+                const nodeComp2 = new InequationNode([substract(1, power(substract(1, nodeProbaSuccess), nodeN)), nodeP], ">");
+                const nodeComp3 = new InequationNode([substract(1, nodeP), power(substract(1, nodeProbaSuccess), nodeN)], ">");
+                const nodeComp4 = new InequationNode([
+                    new LogNode(substract(1, nodeP)),
+                    multiply(nodeN, new LogNode(substract(1, nodeProbaSuccess))),
+                ], ">");
+                const nodeFrac = frac(new LogNode(substract(1, nodeP)), new LogNode(substract(1, nodeProbaSuccess)));
+                const nodeComp5 = new InequationNode([nodeFrac, nodeN], "<");
+                const nodeAnswer = Math.ceil(nodeFrac.evaluate()).toTree();
+                return [
+                    [nodeComp1, nodeComp2, nodeComp3, nodeComp4, nodeComp5],
+                    nodeAnswer,
+                ];
+            }
+            case "$P( X = 0 ) < p$": {
+                const nodeComp2 = new InequationNode([power(substract(1, nodeProbaSuccess), nodeN), nodeP], "<");
+                const nodeComp3 = new InequationNode([
+                    multiply(nodeN, new LogNode(substract(1, nodeProbaSuccess))),
+                    new LogNode(nodeP),
+                ], "<");
+                const nodeFrac = frac(new LogNode(nodeP), new LogNode(substract(1, nodeProbaSuccess)));
+                const nodeComp4 = new InequationNode([nodeN, nodeFrac], ">");
+                const nodeAnswer = Math.ceil(nodeFrac.evaluate()).toTree();
+                return [[nodeComp1, nodeComp2, nodeComp3, nodeComp4], nodeAnswer];
+            }
+            case "$P( X = n ) < p$": {
+                const nodeComp2 = new InequationNode([power(nodeProbaSuccess, nodeN), nodeP], "<");
+                const nodeComp3 = new InequationNode([multiply(nodeN, new LogNode(nodeProbaSuccess)), new LogNode(nodeP)], "<");
+                const nodeFrac = frac(new LogNode(nodeP), new LogNode(nodeProbaSuccess));
+                const nodeComp4 = new InequationNode([nodeN, nodeFrac], ">");
+                const nodeAnswer = Math.ceil(nodeFrac.evaluate()).toTree();
+                return [[nodeComp1, nodeComp2, nodeComp3, nodeComp4], nodeAnswer];
+            }
+            default:
+                throw new Error("Unsupported thresholdType: " + thresholdType);
+        }
+    })();
+    return {
+        binomialSituation,
+        arrNodeComp,
+        nodeAnswer,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { binomialSituation, nodeComp1 } = getHydratedMini(identifiers);
+    return `${binomialSituation.strContext}
+  
+Déterminer le plus petit entier $n$ tel que $${nodeComp1.toTex()}$.`;
+};
+const getAnswer = (identifiers) => {
+    const { nodeAnswer } = getHydrated(identifiers);
+    return nodeAnswer.toTex();
+};
+const getHint = () => {
+    return `Pour $k$ compris entre $0$ et $n$, avec $p$ la probabilité d'un succès :
+  
+$$
+P( X = k ) = \\binom{n}{k} p^{k} (1-p)^{n-k}
+$$
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeAnswer, arrNodeComp } = getHydrated(identifiers);
+    return `
+
+${alignTex(arrNodeComp.map((node) => [node.toTex()]))}
+
+L'entier recherché est donc $${nodeAnswer.toTex()}$.
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    ["$P( X \\geq 1 ) > p$", "$P( X = 0 ) < p$", "$P( X = n ) < p$"].forEach((thresholdType) => {
+        const identifiersWrong = { ...identifiers, thresholdType };
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    propWhile(propositions, n, () => {
+        const n = randint(20, 200);
+        tryToAddWrongProp(propositions, n.frenchify());
+    });
+    /*
+    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 ["epower", "ln"];
+};
+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 = (opts) => {
+    const situationParams = getRandomBinomialSituationParams();
+    const nodeP = (() => {
+        switch (opts.thresholdType) {
+            case "$P( X \\geq 1 ) > p$": {
+                return random([0.95, 0.99, 0.999]).toTree();
+            }
+            case "$P( X = n ) < p$":
+            case "$P( X = 0 ) < p$": {
+                return random([0.05, 0.01, 0.001]).toTree();
+            }
+            default:
+                throw new Error("Unsupported opts.thresholdType: " + opts.thresholdType);
+        }
+    })();
+    const identifiers = {
+        situationParams,
+        nodeIdsP: nodeP.toIdentifiers(),
+        thresholdType: opts.thresholdType,
+    };
+    return identifiers;
+};
+const getBinomialFindThresholdForNFromSituationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiers(opts);
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+    return question;
+};
+const optsDefault = {
+    thresholdType: "$P( X = 0 ) < p$",
+};
+const options = [
+    {
+        id: "thresholdType",
+        label: "Type de seuil",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["$P( X \\geq 1 ) > p$", "$P( X = 0 ) < p$", "$P( X = n ) < p$"],
+        defaultValue: optsDefault.thresholdType,
+    },
+];
+export const binomialFindThresholdForNFromSituation = {
+    id: "binomialFindThresholdForNFromSituation",
+    label: "Déterminer un seuil pour $n$ dans un schéma de Bernoulli à partir d'une situation",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBinomialFindThresholdForNFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};