math-exercises 3.0.200 → 3.0.201

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

@@ -0,0 +1,47 @@
+import { TreeDiagram } from "../../../../../exercises/exercise.js";
+import { AlgebraicNode } from "../../../../../tree/nodes/algebraicNode.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+import { KeyId } from "../../../../../types/keyIds.js";
+import { KeyProps } from "../../../../../types/keyProps.js";
+type BinomialSituation = {
+    id: string;
+    nodeN: AlgebraicNode;
+    strContext: string;
+    strEventSuccess: string;
+    strEventFailure: string;
+    nodeProbaSuccess: AlgebraicNode;
+    keys: (KeyId | KeyProps)[];
+    tree: TreeDiagram;
+    specifics?: Record<string, unknown>;
+};
+type RedBallsBlueBallsUrnParams = {
+    nbBallsRed: number;
+    nbBallsBlue: number;
+};
+type IllPeopleSamplingParams = {
+    nodeIdsPIll: NodeIdentifiers;
+};
+type JapaneseExamParams = {
+    nbItemsPerQuestion: number;
+};
+type ElectronicComponentsParams = {
+    nodeIdsPIll: NodeIdentifiers;
+};
+type DartsParams = {
+    nodeIdsP: NodeIdentifiers;
+};
+export type BinomialSituationParams = (RedBallsBlueBallsUrnParams & {
+    id: "redBallsBlueBallsUrn";
+}) | (IllPeopleSamplingParams & {
+    id: "illPeopleSampling";
+}) | (JapaneseExamParams & {
+    id: "japaneseExam";
+}) | (ElectronicComponentsParams & {
+    id: "electronicComponents";
+}) | (DartsParams & {
+    id: "darts";
+});
+export declare const getHydratedBinomialSituation: (params: BinomialSituationParams, nodeN: AlgebraicNode) => BinomialSituation;
+export declare const getRandomBinomialSituationParams: () => BinomialSituationParams;
+export {};
+//# sourceMappingURL=binomialSituations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"binomialSituations.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/binomial/fromSituation/binomialSituations.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAG1D,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAClE,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,OAAO,EAAE,KAAK,EAAE,MAAM,uBAAuB,CAAC;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAqBnD,KAAK,iBAAiB,GAAG;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,aAAa,CAAC;IAChC,IAAI,EAAE,CAAC,KAAK,GAAG,QAAQ,CAAC,EAAE,CAAC;IAC3B,IAAI,EAAE,WAAW,CAAC;IAElB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACrC,CAAC;AAEF,KAAK,0BAA0B,GAAG;IAChC,UAAU,EAAE,MAAM,CAAC;IACnB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AA4CF,KAAK,uBAAuB,GAAG;IAC7B,WAAW,EAAE,eAAe,CAAC;CAC9B,CAAC;AAyCF,KAAK,kBAAkB,GAAG;IACxB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAwCF,KAAK,0BAA0B,GAAG;IAChC,WAAW,EAAE,eAAe,CAAC;CAC9B,CAAC;AAyCF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAwCF,MAAM,MAAM,uBAAuB,GAC/B,CAAC,0BAA0B,GAAG;IAAE,EAAE,EAAE,sBAAsB,CAAA;CAAE,CAAC,GAC7D,CAAC,uBAAuB,GAAG;IAAE,EAAE,EAAE,mBAAmB,CAAA;CAAE,CAAC,GACvD,CAAC,kBAAkB,GAAG;IAAE,EAAE,EAAE,cAAc,CAAA;CAAE,CAAC,GAC7C,CAAC,0BAA0B,GAAG;IAAE,EAAE,EAAE,sBAAsB,CAAA;CAAE,CAAC,GAC7D,CAAC,WAAW,GAAG;IAAE,EAAE,EAAE,OAAO,CAAA;CAAE,CAAC,CAAC;AAEpC,eAAO,MAAM,4BAA4B,GACvC,QAAQ,uBAAuB,EAC/B,OAAO,aAAa,sBAcrB,CAAC;AAEF,eAAO,MAAM,gCAAgC,QAAO,uBAQnD,CAAC"}

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

@@ -0,0 +1,184 @@
+import { randfloat } from "../../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { isVariableNode } from "../../../../../tree/nodes/variables/variableNode.js";
+import { random } from "../../../../../utils/alea/random.js";
+const buildTreeForBinomialSituation = (strEventSuccess, strEventFailure, nodeProbaSuccess, n) => {
+    const arrBranch = [
+        [`${nodeProbaSuccess.simplify().toTex()}`, strEventSuccess],
+        [`${substract(1, nodeProbaSuccess).simplify().toTex()}`, strEventFailure],
+    ];
+    return [
+        [arrBranch],
+        [arrBranch, arrBranch],
+        [arrBranch, arrBranch, arrBranch, arrBranch],
+    ].slice(0, n);
+};
+const buildRedBallsBlueBallsUrnParams = () => {
+    const nbBallsRed = randint(7, 30);
+    const nbBallsBlue = randint(7, 30, [nbBallsRed]);
+    return {
+        nbBallsRed,
+        nbBallsBlue,
+    };
+};
+const getBlueBallsRedBallsUrnSituation = (params, nodeN) => {
+    const { nbBallsRed, nbBallsBlue } = params;
+    const strEventSuccess = "R";
+    const strEventFailure = "B";
+    const nodeProbaSuccess = frac(nbBallsRed, add(nbBallsRed, nbBallsBlue).simplify());
+    return {
+        id: "redBallsBlueBallsUrn",
+        nodeN,
+        strContext: `On tire avec remise $${nodeN.toTex()}$ boules dans une urne contenant $${nbBallsRed.frenchify()}$ boules rouges et $${nbBallsBlue.frenchify()}$ boules bleues. 
+On note $X$ la variable aléatoire qui donne le nombre de boules rouges obtenues après ces $${nodeN.toTex()}$ tirages.`,
+        strEventSuccess,
+        strEventFailure,
+        keys: [strEventSuccess, strEventFailure],
+        nodeProbaSuccess,
+        tree: !isVariableNode(nodeN)
+            ? buildTreeForBinomialSituation(strEventSuccess, strEventFailure, nodeProbaSuccess, nodeN.evaluate())
+            : [],
+        specifics: {
+            nbBallsRed,
+            nbBallsBlue,
+        },
+    };
+};
+const buildIllPeopleSamplingParams = () => {
+    const valuePIll = randfloat(0.1, 0.6, 2);
+    return {
+        nodeIdsPIll: valuePIll.toTree().toIdentifiers(),
+    };
+};
+const getIllPeopleSamplingSituation = (params, nodeN) => {
+    const { nodeIdsPIll } = params;
+    const strEventSuccess = "M";
+    const strEventFailure = "S";
+    const nodeProbaSuccess = reifyAlgebraic(nodeIdsPIll);
+    const nodeProbaSuccessTimes100 = multiply(nodeProbaSuccess, 100).simplify();
+    return {
+        id: "illPeopleSampling",
+        nodeN,
+        strContext: `Dans la populaiton d'un pays, on sait que $${nodeProbaSuccessTimes100.toTex()} \\%$ d'une population est atteinte d'une certaine maladie. 
+On constitue un échantillon de $${nodeN.toTex()}$ personnes choisies au hasard dans la population. 
+L'effectif de la population est suffisamment grand pour admettre que la constitution de cet échantillon est assimilable à un tirage avec remise. 
+On note $X$ la variable aléatoire qui à chaque échantillon associe le nombre de personnes malades dans cet échantillon.`,
+        strEventSuccess,
+        strEventFailure,
+        keys: [strEventSuccess, strEventFailure],
+        nodeProbaSuccess,
+        tree: !isVariableNode(nodeN)
+            ? buildTreeForBinomialSituation(strEventSuccess, strEventFailure, nodeProbaSuccess, nodeN.evaluate())
+            : [],
+    };
+};
+const buildJapaneseExamParams = () => {
+    const nbItemsPerQuestion = randint(2, 7);
+    return {
+        nbItemsPerQuestion,
+    };
+};
+const getJapaneseExamSituation = (params, nodeN) => {
+    const { nbItemsPerQuestion } = params;
+    const strEventSuccess = "V";
+    const strEventFailure = "F";
+    const nodeProbaSuccess = frac(1, nbItemsPerQuestion);
+    return {
+        id: "japaneseExam",
+        nodeN,
+        strContext: `Pour répondre à un QCM de japonais, un candidat qui n'a jamais appris cette langue répond au hasard à chaque question. 
+Pour chacune des $${nodeN.toTex()}$ questions, $${nbItemsPerQuestion.frenchify()}$ réponses sont proposées et une seule est exacte.
+Une réponse juste rapporte un point et une réponse fausse ne rapporte ou n'enlève aucun point. 
+On note $X$ la variable aléatoire égale au nombre de points obtenus sur l'ensemble du QCM.`,
+        strEventSuccess,
+        strEventFailure,
+        keys: [strEventSuccess, strEventFailure],
+        nodeProbaSuccess,
+        tree: !isVariableNode(nodeN)
+            ? buildTreeForBinomialSituation(strEventSuccess, strEventFailure, nodeProbaSuccess, nodeN.evaluate())
+            : [],
+        specifics: { nbItemsPerQuestion },
+    };
+};
+const buildElectronicComponentsParams = () => {
+    const valuePIll = randfloat(0.1, 0.6, 2);
+    return {
+        nodeIdsPIll: valuePIll.toTree().toIdentifiers(),
+    };
+};
+const getElectronicComponentsSituation = (params, nodeN) => {
+    const { nodeIdsPIll } = params;
+    const strEventSuccess = "D";
+    const strEventFailure = "B";
+    const nodeProbaSuccess = reifyAlgebraic(nodeIdsPIll);
+    const nodeProbaSuccessTimes100 = multiply(nodeProbaSuccess, 100).simplify();
+    return {
+        id: "electronicComponents",
+        nodeN,
+        strContext: `Une entreprise produit des composants électroniques. 
+Sur l'ensemble de la production, $${nodeProbaSuccessTimes100.toTex()} \\%$ des composants sont défectueux. 
+Pour être expédiés, ils sont conditionnés par lot de $${nodeN.toTex()}$ composants, la constitution d'un lot pouvant être assimilée à un tirage avec remise. 
+On note $X$ la variable aléatoire qui, à chaque lot, associe le nombre de composants défectueux qu'il contient.`,
+        strEventSuccess,
+        strEventFailure,
+        keys: [strEventSuccess, strEventFailure],
+        nodeProbaSuccess,
+        tree: !isVariableNode(nodeN)
+            ? buildTreeForBinomialSituation(strEventSuccess, strEventFailure, nodeProbaSuccess, nodeN.evaluate())
+            : [],
+    };
+};
+const buildDartsParams = () => {
+    const valueP = randfloat(0.1, 0.6, 2);
+    return {
+        nodeIdsP: valueP.toTree().toIdentifiers(),
+    };
+};
+const getDartsSituation = (params, nodeN) => {
+    const { nodeIdsP } = params;
+    const strEventSuccess = "I";
+    const strEventFailure = "E";
+    const nodeProbaSuccess = reifyAlgebraic(nodeIdsP);
+    return {
+        id: "darts",
+        nodeN,
+        strContext: `Pour jouer aux fléchettes, un joueur effectue des séries de $${nodeN.toTex()}$ lancers.
+À chaque lancer la probabilité qu'il atteigne la cible est $${nodeProbaSuccess.toTex()}$, indépendamment des résultats des lancers précédents. 
+On note $X$ la variable qui donne le nombre de cibles atteintes à la fin d'une série.`,
+        strEventSuccess,
+        strEventFailure,
+        keys: [strEventSuccess, strEventFailure],
+        nodeProbaSuccess,
+        tree: !isVariableNode(nodeN)
+            ? buildTreeForBinomialSituation(strEventSuccess, strEventFailure, nodeProbaSuccess, nodeN.evaluate())
+            : [],
+    };
+};
+export const getHydratedBinomialSituation = (params, nodeN) => {
+    switch (params.id) {
+        case "redBallsBlueBallsUrn":
+            return getBlueBallsRedBallsUrnSituation(params, nodeN);
+        case "illPeopleSampling":
+            return getIllPeopleSamplingSituation(params, nodeN);
+        case "japaneseExam":
+            return getJapaneseExamSituation(params, nodeN);
+        case "electronicComponents":
+            return getElectronicComponentsSituation(params, nodeN);
+        case "darts":
+            return getDartsSituation(params, nodeN);
+    }
+};
+export const getRandomBinomialSituationParams = () => {
+    return random([
+        { ...buildRedBallsBlueBallsUrnParams(), id: "redBallsBlueBallsUrn" },
+        { ...buildIllPeopleSamplingParams(), id: "illPeopleSampling" },
+        { ...buildJapaneseExamParams(), id: "japaneseExam" },
+        { ...buildElectronicComponentsParams(), id: "electronicComponents" },
+        { ...buildDartsParams(), id: "darts" },
+    ]);
+};

package/lib/exercises/math/probaStat/binomial/fromSituation/buildTreeBernoulliFromSituation.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 buildTreeBernoulliFromSituation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=buildTreeBernoulliFromSituation.d.ts.map

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

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

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

@@ -0,0 +1,120 @@
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { treeTableVEA } from "../../../../../exercises/vea/treeTableVEA.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.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());
+    return {
+        binomialSituation,
+    };
+};
+const getAnswerTreeTable = (identifiers) => {
+    const { binomialSituation } = getHydrated(identifiers);
+    return binomialSituation.tree;
+};
+const getInstruction = (identifiers) => {
+    const { binomialSituation } = getHydrated(identifiers);
+    return `${binomialSituation.strContext}
+
+On va noter respectivement $${binomialSituation.strEventSuccess}$ et $${binomialSituation.strEventFailure}$ les évènement succès et échec. 
+
+Donner l'arbre pondéré qui permet de représenter cette situation.`;
+};
+const getHint = () => {
+    return `Dans une épreuve de Bernoulli, les probabilités des $2$ seules issues possibles, succès et échec, sont respectivement $p$ et $1-p$.
+
+Un schéma de Bernoulli de paramètres $n$ et $p$ est la répétitions de $n$ épreuves de Bernoulli identiques et indépendantes (toutes ayant la même probabilité de succès $p$).
+
+Commence donc par réprésenter les branches correspondant à la première épreuve, puis celles de la deuxième à partir des branches de la première, etc.`;
+};
+const getCorrection = (identifiers) => {
+    const { binomialSituation } = getHydrated(identifiers);
+    return `Puisque c'est la même épreuve que l'on réalise $${binomialSituation.nodeN.toTex()}$ fois, l'arbre va comporter un motif qui va se répéter.
+
+Ce motif est constitué des $2$ branches correspondant l'épreuve de Bernoulli : 
+  
+- la branche de l'issue succès $S$ avec une probabilité de $${binomialSituation.nodeProbaSuccess
+        .simplify()
+        .toTex()}$
+- la branche de l'issue échec $\\overline{S}$ avec une probabilité de $${substract(1, binomialSituation.nodeProbaSuccess)
+        .simplify()
+        .toTex()}$
+
+On inscrit ce motif $1$ fois pour la première épreuve, 
+$2$ fois pour la deuxième épreuve (car la première épreuve a $2$ issues), 
+$4$ fois pour la troisième épreuve (car la séquence "première épreuve puis deuxième épreuve" a $4$ issues), ..., $2^{k-1}$ fois pour la $k$-ième épreuve.`;
+};
+const getKeys = (identifiers) => {
+    const { binomialSituation } = getHydrated(identifiers);
+    return [...binomialSituation.keys];
+};
+const isAnswerTreeTableValid = (ans, { answerTreeTable }) => {
+    try {
+        return treeTableVEA(ans, answerTreeTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getBuildTreeBernoulliFromSituationQuestion = () => {
+    const n = coinFlip() ? 2 : 3;
+    const situationParams = getRandomBinomialSituationParams();
+    const identifiers = {
+        n,
+        situationParams,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const { n } = identifiers;
+    return {
+        answerTreeTable: getAnswerTreeTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTreeTable: (() => {
+            const arrBranch = [
+                ["", ""],
+                ["", ""],
+            ];
+            switch (n) {
+                case 2: {
+                    return [[arrBranch], [arrBranch, arrBranch]];
+                }
+                case 3: {
+                    return [
+                        [arrBranch],
+                        [arrBranch, arrBranch],
+                        [arrBranch, arrBranch, arrBranch, arrBranch],
+                    ];
+                }
+                default: {
+                    throw new Error("Unsupported n: " + n);
+                }
+            }
+        })(),
+    };
+};
+export const buildTreeBernoulliFromSituation = {
+    id: "buildTreeBernoulliFromSituation",
+    label: "Donner l'arbre qui permet de représenter un schéma de Bernoulli à partir d'une situation",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBuildTreeBernoulliFromSituationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTreeTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTreeTable,
+    getQuestionFromIdentifiers,
+    answerType: "treeDiagram",
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,7 @@
+export * from "./binomialFindParamsFromSituation.js";
+export * from "./buildTreeBernoulliFromSituation.js";
+export * from "./binomialFindProbaOfAtLeastOneSuccessFromSituation.js";
+export * from "./binomialFindProbaOfXCompKFromSituation.js";
+export * from "./binomialExpectedValueFromSituation.js";
+export * from "./binomialFindThresholdForNFromSituation.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/binomial/fromSituation/index.ts"],"names":[],"mappings":"AAAA,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,wDAAwD,CAAC;AACvE,cAAc,6CAA6C,CAAC;AAC5D,cAAc,yCAAyC,CAAC;AACxD,cAAc,6CAA6C,CAAC"}

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

@@ -0,0 +1,6 @@
+export * from "./binomialFindParamsFromSituation.js";
+export * from "./buildTreeBernoulliFromSituation.js";
+export * from "./binomialFindProbaOfAtLeastOneSuccessFromSituation.js";
+export * from "./binomialFindProbaOfXCompKFromSituation.js";
+export * from "./binomialExpectedValueFromSituation.js";
+export * from "./binomialFindThresholdForNFromSituation.js";

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

@@ -2,4 +2,5 @@ export * from "./calculateProbaOfBinomialDistribution.js";
 export * from "./expectedValueOfBinomialProba.js";
 export * from "./varianceOfBinomialProba.js";
 export * from "./binomialInequation.js";
+export * from "./fromSituation/index.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/binomial/index.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/binomial/index.ts"],"names":[],"mappings":"AAAA,cAAc,2CAA2C,CAAC;AAC1D,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC"}

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

@@ -2,3 +2,4 @@ export * from "./calculateProbaOfBinomialDistribution.js";
 export * from "./expectedValueOfBinomialProba.js";
 export * from "./varianceOfBinomialProba.js";
 export * from "./binomialInequation.js";
+export * from "./fromSituation/index.js";

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

@@ -15,4 +15,5 @@ export * from "./probaAsSumOfProbas.js";
 export * from "./conditional/index.js";
 export * from "./twoStepExperiments/index.js";
 export * from "./trees/index.js";
+export * from "./tchebychev/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"}
+{"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"}

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

@@ -15,3 +15,4 @@ export * from "./probaAsSumOfProbas.js";
 export * from "./conditional/index.js";
 export * from "./twoStepExperiments/index.js";
 export * from "./trees/index.js";
+export * from "./tchebychev/index.js";

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

@@ -0,0 +1,5 @@
+export * from "./tchebychevMajorizeProbaOfXOutOfCenteredInterval.js";
+export * from "./tchebychevMinorizeProbaOfXInCenteredInterval.js";
+export * from "./tchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredInterval.js";
+export * from "./mean/index.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/tchebychev/index.ts"],"names":[],"mappings":"AAAA,cAAc,sDAAsD,CAAC;AACrE,cAAc,mDAAmD,CAAC;AAClE,cAAc,kEAAkE,CAAC;AACjF,cAAc,iBAAiB,CAAC"}

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

@@ -0,0 +1,4 @@
+export * from "./tchebychevMajorizeProbaOfXOutOfCenteredInterval.js";
+export * from "./tchebychevMinorizeProbaOfXInCenteredInterval.js";
+export * from "./tchebychevFindRadiusToMajorizeProbaOfXOutOfCenteredInterval.js";
+export * from "./mean/index.js";

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

@@ -0,0 +1,4 @@
+export * from "./tchebychevMajorizeProbaOfMeanOutOfCenteredInterval.js";
+export * from "./tchebychevMinorizeProbaOfMeanInCenteredInterval.js";
+export * from "./tchebychevFindRadiusToMinorizeProbaOfMeanInCenteredInterval.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/tchebychev/mean/index.ts"],"names":[],"mappings":"AAAA,cAAc,yDAAyD,CAAC;AACxE,cAAc,sDAAsD,CAAC;AACrE,cAAc,kEAAkE,CAAC"}

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

@@ -0,0 +1,3 @@
+export * from "./tchebychevMajorizeProbaOfMeanOutOfCenteredInterval.js";
+export * from "./tchebychevMinorizeProbaOfMeanInCenteredInterval.js";
+export * from "./tchebychevFindRadiusToMinorizeProbaOfMeanInCenteredInterval.js";

package/lib/exercises/math/probaStat/tchebychev/mean/tchebychevFindRadiusToMinorizeProbaOfMeanInCenteredInterval.d.ts

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

package/lib/exercises/math/probaStat/tchebychev/mean/tchebychevFindRadiusToMinorizeProbaOfMeanInCenteredInterval.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tchebychevFindRadiusToMinorizeProbaOfMeanInCenteredInterval.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/probaStat/tchebychev/mean/tchebychevFindRadiusToMinorizeProbaOfMeanInCenteredInterval.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,WAAW,EAAE,eAAe,CAAC;CAC9B,CAAC;AA4SF,eAAO,MAAM,2DAA2D,EAAE,QAAQ,CAAC,WAAW,CAyB3F,CAAC"}