math-exercises 3.0.77 → 3.0.79

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    total: number;
+    distribution: number[];
+    observe: boolean;
+};
+export declare const checkEquiprobability: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=checkEquiprobability.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"checkEquiprobability.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/checkEquiprobability.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAsIF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CAkBtD,CAAC"}

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

@@ -0,0 +1,129 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const wrong = answer === "Oui" ? "Non" : "Oui";
+    tryToAddWrongProp(propositions, wrong, "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { observe, distribution } = identifiers;
+    if (observe) {
+        return "Oui";
+    }
+    else {
+        return distribution.every((v) => v === distribution[0]) ? "Oui" : "Non";
+    }
+};
+const getInstruction = ({ total, distribution, observe, }) => {
+    const colors = ["rouges", "vertes", "bleues", "jaunes"];
+    const colorLines = distribution
+        .map((count, i) => `$${count}$ cartes sont ${colors[i]}`)
+        .join(", ");
+    return `Un jeu est constitué de $${total}$ cartes numérotées de $1$ à $${total}$.
+
+${colorLines}.
+
+On tire une carte au hasard.
+
+On observe ${observe ? "le numéro" : "la couleur"} de la carte tirée.  
+
+Les issues sont-elles équiprobables ?`;
+};
+const getHint = ({ observe }) => {
+    if (observe) {
+        return `Pense à combien de cartes portent chaque numéro.  
+Y a-t-il autant de cartes pour chaque numéro possible ?`;
+    }
+    else {
+        return `Regarde le nombre de cartes de chaque couleur.  
+A-t-on autant de chances d'obtenir toutes les couleurs ?`;
+    }
+};
+const getCorrection = ({ total, distribution, observe, }) => {
+    const colors = ["rouge", "vert", "bleu", "jaune"];
+    const probs = distribution
+        .map((count, i) => `$$
+P(\\text{${colors[i]}}) = ${frac(count, total).toTex()}
+$$`)
+        .join("\n \n");
+    const explanation = observe
+        ? `Chaque carte a un numéro distinct entre $1$ et $${total}$, donc chaque numéro a une probabilité d'être tiré égale à $${frac(1, total).toTex()}$.  
+Toutes les issues sont donc équiprobables.`
+        : `Les probabilités associées à chaque couleur sont : \n\n ${probs} \n\n
+${distribution.every((v) => v === distribution[0])
+            ? "Puisqu'il y autant de cartes de chaque couleur, les issues sont équiprobables."
+            : "Les couleurs n'ont pas toutes le même nombre de cartes, donc les issues ne sont pas équiprobables."}`;
+    return `${explanation}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCheckEquiprobabilityQuestion = (ops) => {
+    let total;
+    let distribution;
+    const isEquiprobable = coinFlip();
+    const observe = coinFlip();
+    if (isEquiprobable) {
+        total = 4 * randint(10, 30);
+        const value = total / 4;
+        distribution = [value, value, value, value];
+    }
+    else {
+        total = randint(30, 61);
+        const a = randint(2, total - 6);
+        const b = randint(2, total - a - 4);
+        const c = randint(2, total - a - b - 2);
+        const d = total - a - b - c;
+        distribution = [a, b, c, d];
+    }
+    const identifiers = {
+        total,
+        distribution,
+        observe,
+    };
+    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 checkEquiprobability = {
+    id: "checkEquiprobability",
+    label: "Reconnaître une situation équiprobable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCheckEquiprobabilityQuestion(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/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/describeEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"describeEvent.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/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/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/getSampleCountAndSize.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    expCount: number;
+    repCount: number;
+    isSize: boolean;
+};
+export declare const getSampleCountAndSize: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=getSampleCountAndSize.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"getSampleCountAndSize.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/getSampleCountAndSize.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AA4FF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAiBvD,CAAC"}

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

@@ -0,0 +1,95 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, expCount, isSize, repCount }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, expCount.frenchify());
+    tryToAddWrongProp(propositions, repCount.frenchify());
+    while (propositions.length < n) {
+        let wrongValue;
+        wrongValue = randint(1, 200);
+        tryToAddWrongProp(propositions, wrongValue.frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { expCount, repCount, isSize } = identifiers;
+    const answer = isSize ? expCount.frenchify() : repCount.frenchify();
+    return answer;
+};
+const getInstruction = (identifiers) => {
+    const { expCount, repCount, isSize } = identifiers;
+    const qst = isSize
+        ? "Quelle est la taille de chaque échantillon ?"
+        : "Quel est le nombre d'échantillons obtenus?";
+    return `On lance $${expCount}$ fois trois pièces simultanément.\n\n
+  On répète l'expérience $${repCount}$ fois.\n\n
+  ${qst}`;
+};
+const getHint = ({ isSize }) => {
+    return isSize
+        ? `La taille d'un échantillon correspond au nombre de répétitions à l'intérieur d'une même expérience.`
+        : `Le nombre d'échantillons correspond au nombre de fois qu'on répète l'expérience entière.`;
+};
+const getCorrection = ({ expCount, repCount, isSize, }) => {
+    if (isSize) {
+        return `Chaque fois qu'on répète l'expérience, on lance $${expCount}$ fois trois pièces.  
+La taille de chaque échantillon est donc $${expCount}$.`;
+    }
+    else {
+        return `On répète l'expérience complète $${repCount}$ fois.  
+On obtient donc $${repCount}$ échantillons.`;
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        return answerNode.simplify().equals(ansNode.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGetSampleCountAndSizeQuestion = (ops) => {
+    const expCount = randint(1, 301);
+    const repCount = randint(1, 51);
+    const isSize = coinFlip();
+    const identifiers = { expCount, repCount, isSize };
+    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 getSampleCountAndSize = {
+    id: "getSampleCountAndSize",
+    label: "Distinguer taille et nombre d'échantillons",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGetSampleCountAndSizeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -16,4 +16,8 @@ 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";
 //# 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,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,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"}

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

@@ -16,3 +16,7 @@ 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";

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+export type Identifiers = {
+    numericValues: NodeIdentifiers[];
+    isMax: boolean;
+};
+export declare const mostLeastProbable: Exercise<Identifiers>;
+//# sourceMappingURL=mostLeastProbable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mostLeastProbable.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/mostLeastProbable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,MAAM,MAAM,WAAW,GAAG;IACxB,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA2HF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}

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

@@ -0,0 +1,114 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { reifyAlgebraic, } from "../../../tree/nodes/nodeConstructor.js";
+import { round } from "../../../math/utils/round.js";
+import { approxOrEqual } from "../../../utils/latex/approxOrEqual.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+const getPropositions = (n, { answer }) => {
+    const allLabels = ["J", "R", "V"];
+    const props = [];
+    addValidProp(props, answer);
+    for (const label of allLabels) {
+        tryToAddWrongProp(props, label);
+    }
+    return shuffleProps(props, n);
+};
+const getAnswer = ({ numericValues, isMax }) => {
+    const numericValuesParsed = numericValues.map((v) => reifyAlgebraic(v).evaluate());
+    const targetValue = isMax
+        ? Math.max(...numericValuesParsed)
+        : Math.min(...numericValuesParsed);
+    const index = numericValuesParsed.indexOf(targetValue);
+    return ["J", "R", "V"][index];
+};
+const getInstruction = ({ numericValues, isMax, }) => {
+    const labels = ["$J$", "$R$", "$V$"];
+    const displayValues = numericValues.map((v, i) => {
+        if (labels[i] === "$R$") {
+            const pct = round(reifyAlgebraic(v).evaluate() * 100, 6);
+            return `${pct.frenchify()}\\%`;
+        }
+        else {
+            return reifyAlgebraic(v).toTex();
+        }
+    });
+    const header = `Une expérience aléatoire a trois issues : ${labels.join(", ")}.
+  
+Leurs probabilités sont respectivement $${displayValues[0]}$ , $${displayValues[1]}$ et $${displayValues[2]}$.\n\n`;
+    return header + `Quelle issue est la ${isMax ? "plus" : "moins"} probable ?`;
+};
+const getHint = () => {
+    return "Convertis les probabilités dans le même format pour les comparer.";
+};
+const getCorrection = ({ numericValues, isMax, }) => {
+    const fraction = reifyAlgebraic(numericValues[0]);
+    const percent = reifyAlgebraic(numericValues[1]);
+    const evaluatedValues = numericValues.map((v) => round(reifyAlgebraic(v).evaluate(), 2));
+    const sortedAsc = [...evaluatedValues].sort((a, b) => a - b);
+    const target = isMax ? "plus" : "moins";
+    const result = getAnswer({ numericValues, isMax });
+    return `On convertit le pourcentage et la fraction en nombres décimaux (éventuellement avec une valeur approchée) pour pouvoir les comparer : 
+  
+- $${fraction.toTex()} ${approxOrEqual(fraction.evaluate(), 2).join("")}$
+
+- $${multiply(percent, 100).simplify().toTex()}\\% = ${percent.toTex()}$
+
+Puisque $${sortedAsc
+        .map((e) => e.frenchify())
+        .join("\\leq")}$, l'issue la ${target} probable est donc $${result}$.`;
+};
+const getKeys = () => [];
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans.trim() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getMostLeastProbableQuestion = (opts) => {
+    let numericValues = [];
+    do {
+        numericValues = [
+            RationalConstructor.randomIrreductibleProba().toTree(),
+            randfloat(0.1, 0.9, 2).toTree(),
+            randfloat(0.1, 0.9, 2).toTree(),
+        ];
+    } while (numericValues.some((e, i) => numericValues.some((e2, i2) => i2 !== i && round(e2.evaluate(), 2) === round(e.evaluate(), 2))));
+    const isMax = coinFlip();
+    return getQuestionFromIdentifiers({
+        numericValues: numericValues.map((e) => e.toIdentifiers()),
+        isMax,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => ({
+    answer: getAnswer(identifiers),
+    instruction: getInstruction(identifiers),
+    keys: getKeys(identifiers),
+    answerFormat: "tex",
+    identifiers,
+    hint: getHint(identifiers),
+    correction: getCorrection(identifiers),
+});
+export const mostLeastProbable = {
+    id: "mostLeastProbable",
+    label: "Identifier l'issue la plus ou la moins probable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMostLeastProbableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -1,4 +1,5 @@
 export * from "./intervals/index.js";
 export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
+export * from "./subsetsOfKnownSets.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sets/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/index.ts"],"names":[],"mappings":"AAAA,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC"}

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

@@ -1,3 +1,4 @@
 export * from "./intervals/index.js";
 export * from "./setBelonging.js";
 export * from "./nameOfNumberSets.js";
+export * from "./subsetsOfKnownSets.js";

package/lib/exercises/math/sets/subsetsOfKnownSets.d.ts

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

package/lib/exercises/math/sets/subsetsOfKnownSets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subsetsOfKnownSets.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sets/subsetsOfKnownSets.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAiGF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAiBpD,CAAC"}