math-exercises 3.0.83 → 3.0.84

package/lib/exercises/math/probaStat/basicProbas/rouletteProbas.d.ts

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

package/lib/exercises/math/probaStat/basicProbas/rouletteProbas.d.ts.map

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

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

@@ -0,0 +1,139 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, randint(0, 36) + "");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, type } = identifiers;
+    switch (type) {
+        case 1:
+            return frac(Math.floor(36 / a) + 1, 37)
+                .simplify()
+                .toTex();
+        case 2:
+        default:
+            return frac(36 - a + 1, 37).toTex();
+    }
+};
+const getInstruction = (identifiers) => {
+    const { a, type } = identifiers;
+    const event = type === 1 ? `un multiple de $${a}$` : `un numéro supérieur à $${a}$`;
+    return `On lance une bille sur une roulette équilibrée qui comporte tous les numéros de $0$ à $36$. 
+  
+Calculer la probabilité de l'évènement "la bille s'arrête sur ${event}".`;
+};
+const getHint = (identifiers) => {
+    const { a, type } = identifiers;
+    switch (type) {
+        case 1:
+            return `N'oublie pas que $0$ est un multiple de $${a}$. De plus, n'oublie pas de compter $0$ dans le total des numéros possibles.`;
+        case 2:
+        default:
+            return `Compte les nombres supérieurs à $${a}$ et inférieurs à $36$. De plus, n'oublie pas de compter $0$ dans le total des numéros possibles.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { a, type } = identifiers;
+    switch (type) {
+        case 1:
+            const multiples = [];
+            for (let i = 0; i < 36; i++) {
+                if (i % a === 0)
+                    multiples.push(i);
+            }
+            return `Voici la liste des multiples de $${a}$ de $0$ à $36$ : 
+      
+$$
+${multiples.join(" ; ")}
+$$
+
+Il y en a donc $${multiples.length}$. Puisqu'il y a $37$ numéros possibles, et que la roulette est bien équilibrée, la probabilité recherchée est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$
+`;
+        case 2:
+        default:
+            return `Il y a $${36 - a + 1}$ numéros supérieurs à $${a}$ et inférieurs à $36$.
+      
+Puisqu'il y a $37$ numéros possibles, et que la roulette est bien équilibrée, la probabilité recherchée est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer, {
+            allowDecimal: true,
+            allowNonIrreductible: true,
+            decimalPrecision: 1,
+        });
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRouletteProbasQuestion = (ops) => {
+    const type = randint(1, 4);
+    let a;
+    switch (type) {
+        case 1: //multiple
+            a = random([3, 5, 10]);
+            break;
+        case 2: //sup à
+        default:
+            a = randint(5, 30);
+            break;
+            break;
+    }
+    const identifiers = {
+        type,
+        a,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const rouletteProbas = {
+    id: "rouletteProbas",
+    connector: "=",
+    label: "Calcul de probabilités sur une roulette",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRouletteProbasQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/events/describeEvent.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    eventA: {
+        desc: string;
+        isComplementary: boolean;
+    };
+    eventB: {
+        desc: string;
+        isComplementary: boolean;
+    };
+    question: "union" | "intersection" | "comp";
+};
+export declare const describeEvent: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=describeEvent.d.ts.map

package/lib/exercises/math/probaStat/events/describeEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describeEvent.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/events/describeEvent.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,eAAe,EAAE,OAAO,CAAC;KAC1B,CAAC;IACF,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,eAAe,EAAE,OAAO,CAAC;KAC1B,CAAC;IACF,QAAQ,EAAE,OAAO,GAAG,cAAc,GAAG,MAAM,CAAC;CAC7C,CAAC;AA0LF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAkB/C,CAAC"}

package/lib/exercises/math/probaStat/events/describeEvent.js

@@ -0,0 +1,182 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, eventA, eventB, question }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const flipComplement = (event) => ({
+        desc: event.desc,
+        isComplementary: !event.isComplementary,
+    });
+    const generateWrongAnswer = () => {
+        const templates = [
+            () => {
+                const descA = flipComplement(eventA).isComplementary
+                    ? `ne pas ${eventA.desc}`
+                    : eventA.desc;
+                const descB = eventB.isComplementary
+                    ? `ne pas ${eventB.desc}`
+                    : eventB.desc;
+                return `${descA} et ${descB}`;
+            },
+            () => {
+                const descA = eventA.isComplementary
+                    ? `ne pas ${eventA.desc}`
+                    : eventA.desc;
+                const descB = flipComplement(eventB).isComplementary
+                    ? `ne pas ${eventB.desc}`
+                    : eventB.desc;
+                return `${descA} ou ${descB}`;
+            },
+            () => {
+                const descA = flipComplement(eventA).isComplementary
+                    ? `ne pas ${eventA.desc}`
+                    : eventA.desc;
+                const descB = flipComplement(eventB).isComplementary
+                    ? `ne pas ${eventB.desc}`
+                    : eventB.desc;
+                const op = coinFlip() ? "et" : "ou";
+                return `${descA} ${op} ${descB}`;
+            },
+            () => {
+                const descA1 = eventA.isComplementary
+                    ? `ne pas ${eventA.desc}`
+                    : eventA.desc;
+                const descA2 = flipComplement(eventA).isComplementary
+                    ? `ne pas ${eventA.desc}`
+                    : eventA.desc;
+                const op = coinFlip() ? "et" : "ou";
+                return `${descA1} ${op} ${descA2}`;
+            },
+            () => {
+                return `ne pas ne pas ${eventA.desc}`.replace("ne pas ne pas", eventA.desc);
+            },
+        ];
+        return random(templates)();
+    };
+    while (propositions.length < n) {
+        const wrong = generateWrongAnswer();
+        tryToAddWrongProp(propositions, wrong, "raw");
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = ({ eventA, eventB, question }) => {
+    const describe = (e) => e.isComplementary ? `ne pas ${e.desc}` : `${e.desc}`;
+    if (question === "comp") {
+        return `ne pas ${eventA.desc}`;
+    }
+    else if (question === "union") {
+        return `${describe(eventA)} ou ${describe(eventB)}`;
+    }
+    else {
+        return `${describe(eventA)} et ${describe(eventB)}`;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { eventA, eventB, question } = identifiers;
+    let instruction = `$A$ est l'évènement "${eventA.desc}" et $B$ est l'évènement "${eventB.desc}".\n\n`;
+    if (question === "comp") {
+        return instruction + `Décrire par une phrase l'évènement $\\overline{A}$.`;
+    }
+    const overlineA = eventA.isComplementary ? "\\overline{A}" : "A";
+    const overlineB = eventB.isComplementary ? "\\overline{B}" : "B";
+    const operator = question === "union" ? "\\cup" : "\\cap";
+    return (instruction +
+        `Décrire par une phrase l'évènement $${overlineA} ${operator} ${overlineB}$.`);
+};
+const getHint = ({ question }) => {
+    switch (question) {
+        case "comp":
+            return `Le contraire ($\\overline{A})$ d'un évènement $A$ signifie que l'évènement ne se réalise pas.`;
+        case "union":
+            return `L'union ($\\cup$) de deux événements signifie que l'un ou l'autre des évènements (ou les deux) se réalisent.`;
+        case "intersection":
+            return `L'intersection ($\\cap$) de deux événements signifie que les deux évènements se réalisent en même temps.`;
+        default:
+            return "";
+    }
+};
+const getCorrection = (identifiers) => {
+    const { eventA, eventB, question } = identifiers;
+    const answer = getAnswer(identifiers);
+    if (question === "comp") {
+        return `Le contraire de l'évènement "${eventA.desc}" est l'évènement "${answer}".`;
+    }
+    else if (question === "union") {
+        return `L'union signifie que l'un ou l'autre (ou les deux) évènement(s) se produit : "${answer}".`;
+    }
+    else {
+        return `L'intersection signifie que les deux évènements se produisent en même temps : "${answer}".`;
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getDescribeEventQuestion = (ops) => {
+    const allEvents = [
+        "trouver des mures",
+        "trouver des fraises",
+        "trouver des pommes",
+        "perdre son parapluie",
+        "rater le bus",
+        "avoir un bonbon",
+        "avoir un bonbon au chocolat",
+        "avoir un bonbon à la menthe",
+        "avoir un bonbon à la fraise",
+    ];
+    const eventA = {
+        desc: random(allEvents),
+        isComplementary: coinFlip(),
+    };
+    const eventB = {
+        desc: random(allEvents.filter((e) => e !== eventA.desc)),
+        isComplementary: coinFlip(),
+    };
+    const questionTypes = [
+        "union",
+        "intersection",
+        "comp",
+    ];
+    const question = random(questionTypes);
+    const identifiers = { eventA, eventB, question };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const describeEvent = {
+    id: "describeEvent",
+    label: "Décrire un évènement en une phrase à partir de sa notation",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getDescribeEventQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/probaStat/events/eventNotation.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    eventA: {
+        desc: string;
+        isComplementary: boolean;
+    };
+    eventB: {
+        desc: string;
+        isComplementary: boolean;
+    };
+    question: "union" | "intersection" | "comp";
+};
+export declare const eventNotation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=eventNotation.d.ts.map

package/lib/exercises/math/probaStat/events/eventNotation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eventNotation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/events/eventNotation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,eAAe,EAAE,OAAO,CAAC;KAC1B,CAAC;IACF,MAAM,EAAE;QACN,IAAI,EAAE,MAAM,CAAC;QACb,eAAe,EAAE,OAAO,CAAC;KAC1B,CAAC;IACF,QAAQ,EAAE,OAAO,GAAG,cAAc,GAAG,MAAM,CAAC;CAC7C,CAAC;AA4JF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAkB/C,CAAC"}

package/lib/exercises/math/probaStat/events/eventNotation.js

@@ -0,0 +1,156 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, eventA, eventB, question }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const events = [
+        "\\overline{A}",
+        "\\overline{B}",
+        "A\\cup B",
+        "A\\cap B",
+        "A\\cap \\overline{B}",
+        "A\\cup \\overline{B}",
+        "\\overline{A}\\cap B",
+        "\\overline{A}\\cup B",
+        "\\overline{A}\\cap \\overline{B}",
+        "\\overline{A}\\cup \\overline{B}",
+    ];
+    while (propositions.length < n) {
+        tryToAddWrongProp(propositions, random(events));
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = ({ eventA, eventB, question }) => {
+    const describe = (letter, isComplementary) => isComplementary ? `\\overline{${letter}}` : `${letter}`;
+    if (question === "comp") {
+        return `\\overline{A}`;
+    }
+    else if (question === "union") {
+        return `${describe("A", eventA.isComplementary)}\\cup ${describe("B", eventB.isComplementary)}`;
+    }
+    else {
+        return `${describe("A", eventA.isComplementary)}\\cap ${describe("B", eventB.isComplementary)}`;
+    }
+};
+const getInstruction = (identifiers) => {
+    const { eventA, eventB, question } = identifiers;
+    const describe = (e) => e.isComplementary ? `ne pas ${e.desc}` : `${e.desc}`;
+    let sentence = "";
+    if (question === "comp") {
+        sentence = `ne pas ${eventA.desc}`;
+    }
+    else if (question === "union") {
+        sentence = `${describe(eventA)} ou ${describe(eventB)}`;
+    }
+    else {
+        sentence = `${describe(eventA)} et ${describe(eventB)}`;
+    }
+    let instruction = `$A$ est l'évènement "${eventA.desc}" et $B$ est l'évènement "${eventB.desc}".\n\n`;
+    return instruction + `Comment se note l'événement "${sentence}" ?`;
+};
+const getHint = ({ question }) => {
+    switch (question) {
+        case "comp":
+            return `Le contraire ($\\overline{A})$ d'un évènement $A$ signifie que l'évènement ne se réalise pas.`;
+        case "union":
+            return `L'union ($\\cup$) de deux événements signifie que l'un ou l'autre des évènements (ou les deux) se réalisent.`;
+        case "intersection":
+            return `L'intersection ($\\cap$) de deux événements signifie que les deux évènements se réalisent en même temps.`;
+        default:
+            return "";
+    }
+};
+const getCorrection = (identifiers) => {
+    const { eventA, eventB, question } = identifiers;
+    const answer = getAnswer(identifiers);
+    if (question === "comp") {
+        return `Le contraire de l'évènement "${eventA.desc}" est l'évènement $${answer}$.`;
+    }
+    else if (question === "union") {
+        return `L'union signifie que l'un ou l'autre (ou les deux) évènement(s) se produit. Ici, l'évènement se note donc : 
+    
+$$
+${answer}
+$$`;
+    }
+    else {
+        return `L'intersection signifie que les deux évènements se produisent en même temps. Ici, l'évènement se note donc : 
+    
+
+$$
+${answer}
+$$`;
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getEventNotationQuestion = (ops) => {
+    const allEvents = [
+        "trouver des mures",
+        "trouver des fraises",
+        "trouver des pommes",
+        "perdre son parapluie",
+        "rater le bus",
+        "avoir un bonbon",
+        "avoir un bonbon au chocolat",
+        "avoir un bonbon à la menthe",
+        "avoir un bonbon à la fraise",
+    ];
+    const eventA = {
+        desc: random(allEvents),
+        isComplementary: coinFlip(),
+    };
+    const eventB = {
+        desc: random(allEvents.filter((e) => e !== eventA.desc)),
+        isComplementary: coinFlip(),
+    };
+    const questionTypes = [
+        "union",
+        "intersection",
+        "comp",
+    ];
+    const question = random(questionTypes);
+    const identifiers = { eventA, eventB, question };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const eventNotation = {
+    id: "eventNotation",
+    label: "Donner la notation d'un évènement à partir d'une phrase",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getEventNotationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

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

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

@@ -0,0 +1,2 @@
+export * from "./describeEvent.js";
+export * from "./eventNotation.js";

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

@@ -1,8 +1,4 @@
-export * from "./averageLinearity.js";
-export * from "./ballsBasicProbas.js";
-export * from "./cardBasicProbas.js";
 export * from "./conditionalProbability.js";
-export * from "./diceBasicProbas.js";
 export * from "./probabilityTree.js";
 export * from "./stats1var/index.js";
 export * from "./stats2var/index.js";
@@ -13,13 +9,9 @@ export * from "./probaFromTableWithContext.js";
 export * from "./binomial/index.js";
 export * from "./basicStats/index.js";
 export * from "./randomVariable/index.js";
-export * from "./getMissingProbabilityValue.js";
-export * from "./getComplementaryProbability.js";
 export * from "./unionIntersectionProba.js";
-export * from "./calculateMeanFromFrequencies.js";
-export * from "./mostLeastProbable.js";
 export * from "./checkEquiprobability.js";
 export * from "./getSampleCountAndSize.js";
-export * from "./describeEvent.js";
-export * from "./cumulativeSum.js";
+export * from "./events/index.js";
+export * from "./basicProbas/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,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,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,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,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,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC"}

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

@@ -1,8 +1,4 @@
-export * from "./averageLinearity.js";
-export * from "./ballsBasicProbas.js";
-export * from "./cardBasicProbas.js";
 export * from "./conditionalProbability.js";
-export * from "./diceBasicProbas.js";
 export * from "./probabilityTree.js";
 export * from "./stats1var/index.js";
 export * from "./stats2var/index.js";
@@ -13,12 +9,8 @@ export * from "./probaFromTableWithContext.js";
 export * from "./binomial/index.js";
 export * from "./basicStats/index.js";
 export * from "./randomVariable/index.js";
-export * from "./getMissingProbabilityValue.js";
-export * from "./getComplementaryProbability.js";
 export * from "./unionIntersectionProba.js";
-export * from "./calculateMeanFromFrequencies.js";
-export * from "./mostLeastProbable.js";
 export * from "./checkEquiprobability.js";
 export * from "./getSampleCountAndSize.js";
-export * from "./describeEvent.js";
-export * from "./cumulativeSum.js";
+export * from "./events/index.js";
+export * from "./basicProbas/index.js";

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

@@ -1 +1 @@
-{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA6JF,KAAK,OAAO,GAAG,EAEd,CAAC;AA2JF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBpE,CAAC"}
+{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA6JF,KAAK,OAAO,GAAG,EAEd,CAAC;AA6HF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBpE,CAAC"}