math-exercises 3.0.125 → 3.0.126

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

@@ -0,0 +1,548 @@
+import { randint } from "../../../math/utils/random/randint.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../exercise.js";
+import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
+import { NodeConstructor, } from "../../../tree/nodes/nodeConstructor.js";
+import { random, randomMany } from "../../../utils/alea/random.js";
+import { AddNode } from "../../../tree/nodes/operators/addNode.js";
+import { operatorComposition } from "../../../tree/utilities/operatorComposition.js";
+import { getAllPicks } from "../../../utils/arrays/getAllPicks.js";
+import { primes } from "../../../math/numbers/integer/primes.js";
+import { multiply, MultiplyNode, } from "../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+class Event {
+    type;
+    id;
+    str;
+    p;
+    index;
+    arrSubEvent;
+    isTailoredStr;
+    constructor(type, id, str, p, index, arrSubEvent, isTailoredStr) {
+        this.type = type;
+        this.id = id;
+        this.str = str;
+        this.p = p;
+        this.index = index;
+        this.arrSubEvent = arrSubEvent;
+        this.isTailoredStr = isTailoredStr;
+    }
+    toIdentifiers() {
+        const p = this.p.toIdentifiers();
+        switch (this.type) {
+            case "elementary":
+                return {
+                    type: this.type,
+                    id: this.id,
+                    str: this.str,
+                    p,
+                    index: this.index,
+                };
+            case "union": {
+                const arrSubEvent = this.arrSubEvent.map((event) => event.toIdentifiers());
+                return {
+                    type: this.type,
+                    id: this.id,
+                    str: this.str,
+                    p,
+                    arrSubEvent,
+                    isTailoredStr: this.isTailoredStr,
+                };
+            }
+        }
+    }
+    getArrElem() {
+        switch (this.type) {
+            case "elementary":
+                return [this];
+            case "union":
+                return this.arrSubEvent.flatMap((event) => event.getArrElem());
+        }
+    }
+}
+class EventConstructor {
+    static elementary(str, p, index) {
+        return new Event("elementary", `E_{${index}}`, str, p, index);
+    }
+    static union(str, arrSubEvent, isTailoredStr = false) {
+        const arrElemSorted = arrSubEvent
+            .flatMap((event) => event.getArrElem())
+            .toSorted((ev1, ev2) => ev1.index - ev2.index);
+        return new Event("union", `{${arrElemSorted
+            .map((evElem) => evElem.index)
+            .map((i) => `E_{${i}}`)
+            .join(" \\cup ")}}`, str, operatorComposition(AddNode, arrSubEvent.map((ev) => ev.p)).simplify({
+        //nbMaxSteps: 100,
+        }), undefined, arrSubEvent, isTailoredStr);
+    }
+    static fromIdentifiers(eventIds) {
+        const p = NodeConstructor.fromIdentifiers(eventIds.p);
+        switch (eventIds.type) {
+            case "elementary":
+                return EventConstructor.elementary(eventIds.str, p, eventIds.index);
+            case "union": {
+                const arrSubEvent = eventIds.arrSubEvent.map((eventIds) => EventConstructor.fromIdentifiers(eventIds));
+                return EventConstructor.union(eventIds.str, arrSubEvent, eventIds.isTailoredStr);
+            }
+        }
+    }
+}
+class Situation {
+    str;
+    strElem;
+    allElem;
+    someElem;
+    someUnion;
+    //There can be multiple events with the same .id in someUnion: everything is the same except .str
+    constructor(str, strElem, allElem, someElem, someUnion) {
+        this.str = str;
+        this.strElem = strElem;
+        this.allElem = allElem;
+        this.someElem = someElem;
+        this.someUnion = someUnion;
+    }
+    getRandomUnionEvent(unionLength) {
+        return random(this.someUnion.filter((evUnion) => evUnion.getArrElem().length === unionLength));
+    }
+}
+class SituationConstructor {
+    static createDiceSituation(nbSides) {
+        const str = `On lance un dé à $${nbSides}$ faces numérotées de $1$ à $${nbSides}$. 
+    Le dé n'est pas équilibré.`;
+        const strElem = `Pour $i$ allant de $1$ à $${nbSides}$, on note $E_i$ l'évènement:
+"Le résultat est $i$.".`;
+        const nbPickSomeElem = Math.min(nbSides, 6);
+        const allIndexesElem = [...Array(nbSides).keys()].map((i) => i + 1);
+        const dictAllElem = Object.fromEntries(allIndexesElem.map((index) => [
+            index,
+            EventConstructor.elementary(`Le résultat est $${index}$.`, `p_{E_{${index}}}`.toTree(), index),
+        ]));
+        //we only pick some events to build unions with, because number of unions grows exponentially
+        const someIndexesElem = randomMany(allIndexesElem, nbPickSomeElem).toSorted((i1, i2) => i1 - i2);
+        const dictSomeElem = Object.fromEntries(someIndexesElem.map((index) => [index, dictAllElem[index]]));
+        const arrayOfUnionsAsArrayOfIndexes = getAllPicks(someIndexesElem)
+            .filter((arr) => arr.length > 1)
+            .map((arrayOfIndexes) => arrayOfIndexes.toSorted((i1, i2) => i1 - i2));
+        const arrayOfUnionEventsInTheFormEitherOr = arrayOfUnionsAsArrayOfIndexes.map((arrayOfIndexes) => {
+            return EventConstructor.union(`Le résultat est soit ${arrayOfIndexes
+                .map((i) => `$${i}$`)
+                .join(" soit ")}.`, arrayOfIndexes.map((i) => dictSomeElem[i]), false);
+        });
+        const arrayOfUnionEventsInTheFormTailoredString = [
+            //"i ou j"
+            ...arrayOfUnionsAsArrayOfIndexes
+                .filter((arrayOfIndexes) => arrayOfIndexes.length == 2)
+                .map((arrayOfIndexes) => EventConstructor.union(`Le résultat est ${arrayOfIndexes
+                .map((i) => `$${i}$`)
+                .join(" ou ")}.`, arrayOfIndexes.map((i) => dictSomeElem[i]), true)),
+        ];
+        //"est un chiffre du nombre ABAACDB"
+        for (let j = 0; j < arrayOfUnionsAsArrayOfIndexes.length; j++) {
+            const arrayOfCandidateIndexes = arrayOfUnionsAsArrayOfIndexes[j];
+            if (arrayOfCandidateIndexes.every((i) => i < 10)) {
+                const nbFiller = randint(0, 3);
+                const arrayOfDigits = shuffle([
+                    ...arrayOfCandidateIndexes,
+                    ...[...Array(nbFiller).keys()].map((_) => random(arrayOfCandidateIndexes)),
+                ]);
+                const unionEventInTheFormDigitOfNumber = EventConstructor.union(`Le résultat est un chiffre du nombre $${arrayOfDigits
+                    .map((digit) => digit.frenchify())
+                    .join("")}$`, arrayOfCandidateIndexes.map((i) => dictSomeElem[i]), true);
+                arrayOfUnionEventsInTheFormTailoredString.push(unionEventInTheFormDigitOfNumber);
+            }
+        }
+        //strictement inférieur à n
+        function isStrictlyBelowN(arrayOfIndexes) {
+            const n = someIndexesElem[someIndexesElem.length - 1] + 1;
+            return (arrayOfIndexes.length === n - 1 && arrayOfIndexes.every((i) => i < n));
+        }
+        if (isStrictlyBelowN(someIndexesElem)) {
+            const n = someIndexesElem[someIndexesElem.length - 1] + 1;
+            arrayOfUnionEventsInTheFormTailoredString.push(EventConstructor.union(`Le résultat est strictement inférieur à $${n}$.`, someIndexesElem.map((i) => dictSomeElem[i]), true));
+        }
+        //inférieur ou égal à n
+        function isBelowOrN(arrayOfIndexes) {
+            const n = someIndexesElem[someIndexesElem.length - 1];
+            return arrayOfIndexes.length === n && arrayOfIndexes.every((i) => i <= n);
+        }
+        if (isBelowOrN(someIndexesElem)) {
+            const n = someIndexesElem[someIndexesElem.length - 1];
+            arrayOfUnionEventsInTheFormTailoredString.push(EventConstructor.union(`Le résultat est inférieur ou égal à $${n}$.`, someIndexesElem.map((i) => dictSomeElem[i]), true));
+        }
+        return new Situation(str, strElem, Object.values(dictAllElem).toSorted((ev1, ev2) => ev1.index - ev2.index), Object.values(dictSomeElem).toSorted((ev1, ev2) => ev1.index - ev2.index), [
+            ...arrayOfUnionEventsInTheFormEitherOr,
+            ...arrayOfUnionEventsInTheFormTailoredString,
+        ]);
+    }
+}
+const arrayOfSituations = [
+    SituationConstructor.createDiceSituation(4),
+    SituationConstructor.createDiceSituation(6),
+    SituationConstructor.createDiceSituation(10),
+    SituationConstructor.createDiceSituation(12),
+];
+class FiniteProbDistrUtils {
+    static createRandomArrProbaPrimeBased(n, nbUnique) {
+        const arrayOfUniqueNumbers = randomMany(primes.filter((prime) => prime <= 13), //au delà, fractionNode.simplify() crashe car le dénominateur dépasse Number.MAX_SAFE_INTEGER
+        nbUnique);
+        const arrayOfUnscaled = [
+            ...arrayOfUniqueNumbers,
+            ...[...Array(n - nbUnique).keys()].map((_) => random(arrayOfUniqueNumbers)),
+        ];
+        const sum = arrayOfUnscaled.reduce((acc, x) => acc + x);
+        const arrProba = arrayOfUnscaled.map((v) => frac(v, sum));
+        return arrProba;
+    }
+}
+class FiniteProbDistrConstructor {
+    static randomDistr(n, nbUnique) {
+        const arrProba = FiniteProbDistrUtils.createRandomArrProbaPrimeBased(n, nbUnique);
+        const arrProbaShuffled = shuffle(arrProba);
+        return new FiniteProbDistr(arrProbaShuffled);
+    }
+    static fromArrProba(arrProba) {
+        return new FiniteProbDistr(arrProba);
+    }
+}
+class FiniteProbDistr {
+    arrProba;
+    dictIndexToP;
+    dictPToArrayOfIndexes;
+    constructor(arrProba) {
+        this.arrProba = arrProba;
+        this.dictIndexToP = Object.fromEntries(arrProba.map((p, i) => [i + 1, p]));
+        const dictPToArrayOfIndexes = {};
+        for (let i = 0; i < arrProba.length; i++) {
+            const p = arrProba[i];
+            console.log("will simplify", p);
+            const tex = p.simplify().toTex();
+            if (dictPToArrayOfIndexes[tex] === undefined) {
+                dictPToArrayOfIndexes[tex] = [];
+            }
+            dictPToArrayOfIndexes[tex].push(i + 1);
+        }
+        this.dictPToArrayOfIndexes = dictPToArrayOfIndexes;
+    }
+    getPForIndex(index) {
+        const p = this.dictIndexToP[index];
+        if (!p) {
+            throw new Error("p not found at index" + index);
+        }
+        return p;
+    }
+    getArrIndexForP(p) {
+        return this.dictPToArrayOfIndexes[p.simplify().toTex()];
+    }
+    getArrFrenchStrings(isDisplayingValue) {
+        return Object.entries(this.dictPToArrayOfIndexes)
+            .filter(([_, arrayOfIndexes]) => isDisplayingValue ? true : arrayOfIndexes.length > 1)
+            .map(([tex, arrayOfIndexes]) => {
+            return `${[
+                ...arrayOfIndexes.map((i) => `p_{E_{${i}}}`),
+                ...(isDisplayingValue ? [`${tex}`] : []),
+            ].join("=")}`;
+        });
+    }
+    toString() {
+        return this.dictPToArrayOfIndexes.toString();
+    }
+}
+const getInstruction = (identifiers) => {
+    const { indexSituation, eventIds, arrProba, isProbasAreNumbers } = identifiers;
+    const situation = arrayOfSituations[indexSituation];
+    const finiteProbDistr = FiniteProbDistrConstructor.fromArrProba(arrProba.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)));
+    let instruction = `${situation.str}`;
+    instruction += ` ${situation.strElem}`;
+    instruction += ` On a : 
+${finiteProbDistr
+        .getArrFrenchStrings(isProbasAreNumbers)
+        .map((tex) => `
+  
+$$
+${tex}
+$$`)
+        .join("")}`;
+    instruction += `
+Calcule la probabilité de l'évènement "${eventIds.str}".`;
+    return instruction;
+};
+const getAnswerValueNode = (identifiers) => {
+    const { eventIds, arrProba } = identifiers;
+    const evUnion = EventConstructor.fromIdentifiers(eventIds);
+    const finiteProbDistr = FiniteProbDistrConstructor.fromArrProba(arrProba.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)));
+    const nodeSumSimplified = operatorComposition(AddNode, evUnion
+        .getArrElem()
+        .map((evElem) => finiteProbDistr.getPForIndex(evElem.index))).simplify({
+    //!TODO Sebastien : ne doit pas être nécessaire, à fix
+    //nbMaxSteps: 100,
+    });
+    return nodeSumSimplified;
+};
+const getAnswerNode = (identifiers) => {
+    const { eventIds, isProbasAreNumbers } = identifiers;
+    const evUnion = EventConstructor.fromIdentifiers(eventIds);
+    if (isProbasAreNumbers) {
+        return getAnswerValueNode(identifiers);
+    }
+    else {
+        return evUnion.p;
+    }
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Les issues élémentaires sont mutuellement exclusives : Elles ne peuvent pas se produire en même temps.
+Si on prend deux issues élémentaires $E_1$ et $E_2$, alors:
+
+$$
+P(E_1 \\cap E_2) = 0
+$$
+
+Cela permet de calculer facilement la probabilité de l'union d'évènements élémentaires.`;
+};
+const getCorrection = (identifiers) => {
+    const { eventIds, arrProba, isProbasAreNumbers } = identifiers;
+    const evUnion = EventConstructor.fromIdentifiers(eventIds);
+    let strCorrection = `Les issues élémentaires sont mutuellement exclusives.
+La probabilité de l'évènement "${eventIds.str}" est la somme des probabilités des issues élémentaires dont il est l'union.`;
+    strCorrection += `
+
+$$
+p_{${evUnion.id}} = ${evUnion
+        .getArrElem()
+        .map((evElem) => `p_{${evElem.id}}`)
+        .join(" + ")}
+$$`;
+    if (isProbasAreNumbers) {
+        const finiteProbDistr = FiniteProbDistrConstructor.fromArrProba(arrProba.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)));
+        strCorrection += `
+Or: ${evUnion.getArrElem().map((evElem) => `
+$$
+p_{${evElem.id}} = ${finiteProbDistr.getPForIndex(evElem.index).toTex()}
+$$`).join(`
+`)}`;
+        const nodeSumSimplified = operatorComposition(AddNode, evUnion
+            .getArrElem()
+            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index))).simplify({
+        //nbMaxSteps: 100,
+        });
+        strCorrection += `
+Donc: 
+
+$$
+p_{${evUnion.id}} = ${evUnion
+            .getArrElem()
+            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index).toTex())
+            .join(" + ")}
+$$
+
+$$
+p_{${evUnion.id}} = ${nodeSumSimplified.toTex()}
+$$`;
+    }
+    return strCorrection;
+};
+const optsDefault = {
+    nbElem: [4, 6, 10, 12],
+    unionLength: [2, 3, 4, 5],
+    isProbasAreNumbers: [true, false],
+};
+const options = [
+    {
+        id: "nbElem",
+        label: "Nombre d'évènements élémentaires",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: [4, 6, 10, 12],
+        defaultValue: optsDefault.nbElem,
+    },
+    {
+        id: "unionLength",
+        label: "Longueur de l'union",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: [2, 3, 4, 5, 6],
+        defaultValue: optsDefault.unionLength,
+    },
+    {
+        id: "isProbasAreNumbers",
+        label: "Probabilités sous forme de nombres ?",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: [true, false],
+        defaultValue: optsDefault.isProbasAreNumbers,
+    },
+];
+const getKeys = (identifiers) => {
+    const { indexSituation, arrProba, isProbasAreNumbers } = identifiers;
+    const situation = arrayOfSituations[indexSituation];
+    return [
+        ...[
+            ...new Set(situation.someElem
+                .map((event) => {
+                if (isProbasAreNumbers) {
+                    const finiteProbDistr = FiniteProbDistrConstructor.fromArrProba(arrProba.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)));
+                    return finiteProbDistr.getPForIndex(event.index).simplify();
+                }
+                else {
+                    return event.p;
+                }
+            })
+                .map((node) => node.toTex())),
+        ].map((tex) => {
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { eventIds, arrProba, isProbasAreNumbers } = identifiers;
+    const evUnion = EventConstructor.fromIdentifiers(eventIds);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    if (isProbasAreNumbers) {
+        const finiteProbDistr = FiniteProbDistrConstructor.fromArrProba(arrProba.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)));
+        tryToAddWrongProp(propositions, operatorComposition(MultiplyNode, evUnion
+            .getArrElem()
+            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index)))
+            .simplify({
+        //nbMaxSteps: 100,
+        })
+            .toTex());
+        tryToAddWrongProp(propositions, substract(1, operatorComposition(MultiplyNode, evUnion
+            .getArrElem()
+            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index))))
+            .simplify({
+        //nbMaxSteps: 100,
+        })
+            .toTex());
+        tryToAddWrongProp(propositions, substract(1, operatorComposition(AddNode, evUnion
+            .getArrElem()
+            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index))).simplify({
+        //nbMaxSteps: 100,
+        })).toTex());
+        tryToAddWrongProp(propositions, operatorComposition(AddNode, evUnion
+            .getArrElem()
+            .map((evElem) => multiply(evElem.index, finiteProbDistr.getPForIndex(evElem.index))))
+            .simplify({
+        //nbMaxSteps: 100,
+        })
+            .toTex());
+        tryToAddWrongProp(propositions, multiply(frac(1, evUnion.getArrElem().length), operatorComposition(AddNode, evUnion
+            .getArrElem()
+            .map((evElem) => finiteProbDistr.getPForIndex(evElem.index))))
+            .simplify({
+        //nbMaxSteps: 100,
+        })
+            .toTex());
+    }
+    else {
+        tryToAddWrongProp(propositions, operatorComposition(MultiplyNode, evUnion.getArrElem().map((evElem) => evElem.p))
+            .simplify({
+        //nbMaxSteps: 100,
+        })
+            .toTex());
+        tryToAddWrongProp(propositions, substract(1, operatorComposition(MultiplyNode, evUnion.getArrElem().map((evElem) => evElem.p)))
+            .simplify({
+        //nbMaxSteps: 100,
+        })
+            .toTex());
+        tryToAddWrongProp(propositions, substract(1, evUnion.p).toTex());
+        tryToAddWrongProp(propositions, operatorComposition(AddNode, evUnion.getArrElem().map((evElem) => multiply(evElem.index, evElem.p)))
+            .simplify({
+        //nbMaxSteps: 100,
+        })
+            .toTex());
+        tryToAddWrongProp(propositions, multiply(frac(1, evUnion.getArrElem().length), evUnion.p)
+            .simplify({
+        //nbMaxSteps: 100,
+        })
+            .toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getValueNode = (tex, arrProba) => {
+    const finiteProbDistr = FiniteProbDistrConstructor.fromArrProba(arrProba.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds)));
+    const arrayOfIndexes = tex.split("+").map((texVar) => {
+        if (!texVar.includes("E_{")) {
+            return parseInt(texVar.substring(texVar.indexOf("E_") + 2));
+        }
+        else {
+            return parseInt(texVar.substring(texVar.indexOf("E_{") + 3, texVar.indexOf("}}")));
+        }
+    });
+    const arrayOfNodes = arrayOfIndexes.map((i) => finiteProbDistr.getPForIndex(i));
+    return operatorComposition(AddNode, arrayOfNodes).simplify({
+    //nbMaxSteps: 100,
+    });
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    const { arrProba, isProbasAreNumbers } = identifiers;
+    const nodeAnswer = getAnswerValueNode(identifiers);
+    let nodeAns;
+    if (isProbasAreNumbers) {
+        nodeAns = parseAlgebraic(ans);
+    }
+    else {
+        nodeAns = getValueNode(ans, arrProba);
+    }
+    return substract(nodeAns, nodeAnswer).simplify().evaluate() === 0;
+};
+const getProbaAsSumOfProbasQuestion = (optsIn) => {
+    const opts = Object.assign(optsDefault, optsIn) ?? optsDefault;
+    const unionLength = random(opts.unionLength);
+    const indexSituation = random([...Array(arrayOfSituations.length).keys()].filter((indexSituation) => {
+        const situation = arrayOfSituations[indexSituation];
+        return situation.someElem.length >= unionLength;
+    }));
+    const situation = arrayOfSituations[indexSituation];
+    const evUnion = situation.getRandomUnionEvent(unionLength);
+    const eventIds = evUnion.toIdentifiers();
+    const nbUnique = Math.min(randint(3, 7), situation.allElem.length - 1);
+    const finiteProbDistr = FiniteProbDistrConstructor.randomDistr(situation.allElem.length, nbUnique);
+    const isProbasAreNumbers = random(opts.isProbasAreNumbers);
+    const identifiers = {
+        indexSituation,
+        eventIds,
+        arrProba: finiteProbDistr.arrProba.map((node) => node.toIdentifiers()),
+        isProbasAreNumbers,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, options) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options,
+    };
+    return question;
+};
+export const probaAsSumOfProbas = {
+    id: "probaAsSumOfProbas",
+    label: "Calculer la probabilité d’un événement comme somme des probabilités des événements qui le composent",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbaAsSumOfProbasQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -18,4 +18,6 @@ export * from "./averageLinearity.js";
 export * from "./calculateMeanFromFrequencies.js";
 export * from "./cumulativeSum.js";
 export * from "./getQuartileProportionQuestion.js";
+export * from "./interpretIndicatorsForLists.js";
+export * from "./plausibilityOfAverage.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mCAAmC,CAAC;AAClD,cAAc,oBAAoB,CAAC;AACnC,cAAc,oCAAoC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sCAAsC,CAAC;AACrD,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC;AACnC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iCAAiC,CAAC;AAChD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uBAAuB,CAAC;AACtC,cAAc,mCAAmC,CAAC;AAClD,cAAc,oBAAoB,CAAC;AACnC,cAAc,oCAAoC,CAAC;AACnD,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC"}

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

@@ -18,3 +18,5 @@ export * from "./averageLinearity.js";
 export * from "./calculateMeanFromFrequencies.js";
 export * from "./cumulativeSum.js";
 export * from "./getQuartileProportionQuestion.js";
+export * from "./interpretIndicatorsForLists.js";
+export * from "./plausibilityOfAverage.js";

package/lib/exercises/math/probaStat/stats1var/interpretIndicatorsForLists.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    dictNameForSerie: Record<string, number[]>;
+    answerName: string;
+    isLess: boolean;
+};
+export declare const interpretIndicatorsForLists: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=interpretIndicatorsForLists.d.ts.map

package/lib/exercises/math/probaStat/stats1var/interpretIndicatorsForLists.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interpretIndicatorsForLists.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/interpretIndicatorsForLists.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,QAAQ,EACT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;IAC3C,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AA2GF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAiB7D,CAAC"}

package/lib/exercises/math/probaStat/stats1var/interpretIndicatorsForLists.js

@@ -0,0 +1,90 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { dictNameForSerie, isLess } = identifiers;
+    const series = Object.entries(dictNameForSerie);
+    return `On considère les séries suivantes :
+
+${series.map(([name, values]) => {
+        return `Série ${name} : ${values
+            .map((value) => `$${value.frenchify()}$`)
+            .join(" ; ")}`;
+    }).join(`
+    
+`)}
+ 
+Quelle série a l'écart-type le plus ${isLess ? `petit` : `grand`} ?`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { dictNameForSerie, answerName } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, `la série $${answerName}$`, "raw");
+    Object.keys(dictNameForSerie)
+        .toSorted((name1, name2) => name1.localeCompare(name2))
+        .forEach((name) => {
+        tryToAddWrongProp(propositions, `la série $${name}$`, "raw");
+    });
+    tryToAddWrongProp(propositions, `aucune des deux car leurs écart-type sont égaux`, "raw");
+    return propositions;
+};
+const getHint = () => {
+    return `L'écart-type est un indicateur de dispersion. 
+Plus il est important, plus les valeurs sont éparpillées. 
+Plus il est petit, plus les valeurs sont regroupées autour de la moyenne.`;
+};
+const getCorrection = (identifiers) => {
+    const { answerName, isLess } = identifiers;
+    const wrongName = answerName === "A" ? "B" : "A";
+    return `Ici les deux séries ont une moyenne de $10$ 
+mais les valeurs de la série $${answerName}$ sont ${isLess ? `moins` : `plus`} éparpillées autour de $10$ que les valeurs de la série $${wrongName}$. 
+Ainsi la série $${answerName}$ a l'écart-type le plus ${isLess ? `petit` : `grand`}.`;
+};
+const getInterpretIndicatorsForListsQuestion = () => {
+    const a = randint(1, 4);
+    const b = randint(2, 5) * a;
+    const series = [
+        [10 - a, 10, 10, 10 + a],
+        [10 - b, 10, 10, 10 + b],
+    ];
+    const isLess = coinFlip();
+    const answerIndexUnshuffled = isLess ? 0 : 1;
+    const shuffleArray = randomMany([...Array(series.length).keys()], series.length);
+    const shuffledSeries = shuffleArray.map((i) => series[i]);
+    const answerIndexShuffled = shuffleArray.indexOf(answerIndexUnshuffled);
+    const names = ["A", "B"];
+    const dictNameForSerie = Object.fromEntries(names.map((name, i) => [name, shuffledSeries[i]]));
+    const answerName = names[answerIndexShuffled];
+    return getQuestionFromIdentifiers({
+        dictNameForSerie,
+        answerName,
+        isLess,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const interpretIndicatorsForLists = {
+    id: "interpretIndicatorsForLists",
+    label: "Interpréter des indicateurs statistiques pour une série statistique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getInterpretIndicatorsForListsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    hasHintAndCorrection: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+};

package/lib/exercises/math/probaStat/stats1var/plausibilityOfAverage.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    values: number[];
+    isAboveA: boolean;
+    isQuestionIsAboveA: boolean;
+};
+export declare const plausibilityOfAverage: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=plausibilityOfAverage.d.ts.map