math-exercises 3.0.151 → 3.0.153

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

@@ -0,0 +1,120 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+const getPropositions = (n, { answer }) => {
+    const props = [];
+    addValidProp(props, answer);
+    propWhile(props, n, () => {
+        const numeric = answer.unfrenchify();
+        const offset = randfloat(-0.2, 0.2, 2);
+        const candidate = round(numeric + offset, 2).frenchify();
+        tryToAddWrongProp(props, candidate);
+    });
+    return shuffleProps(props, n);
+};
+const getAnswer = ({ pValues, missingIndex }) => {
+    return pValues[missingIndex].frenchify();
+};
+const getInstruction = ({ labels, pValues, missingIndex, }) => {
+    return `Un sac contient des jetons. Chaque jeton est rouge ou vert ou bleu. On tire un jeton au hasard et on regarde sa couleur.
+
+On a les informations suivantes :
+
+${mdTable([
+        ["Issue", ...labels.map((l) => dollarize(l))],
+        [
+            "Probabilité",
+            ...pValues.map((p, i) => i === missingIndex ? "..." : dollarize(p.frenchify())),
+        ],
+    ])}
+
+Quelle est la probabilité manquante ?`;
+};
+const getHint = () => {
+    return `La somme des probabilités des issues élémentaires est égale à $1$.`;
+};
+const getCorrection = ({ labels, pValues, missingIndex, }) => {
+    const knownTerms = labels
+        .map((_l, i) => (i === missingIndex ? null : pValues[i].frenchify()))
+        .filter(Boolean)
+        .join("+");
+    const sumKnown = round(pValues.filter((_, i) => i !== missingIndex).reduce((s, v) => s + v, 0), 2);
+    const missing = round(1 - sumKnown, 2);
+    return `
+On additionne les probabilités connues :
+
+$$
+${knownTerms} = ${sumKnown.frenchify()}
+$$
+
+Puisque la somme des probabilités des issues élémentaires vaut $1$, on peut en déduire la probabilité manquante : 
+
+
+$$
+P(${labels[missingIndex]}) = 1 - ${sumKnown.frenchify()} = ${missing.frenchify()}
+$$
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const a = parseAlgebraic(ans);
+        const b = parseAlgebraic(answer);
+        return a.simplify().equals(b.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getMissingProbabilityValueMiddleSchoolQuestion = () => {
+    const labels = ["rouge", "vert", "bleu"];
+    const raw = labels.map(() => Math.random());
+    const total = raw.reduce((s, v) => s + v, 0);
+    const pValues = raw.map((v) => round(v / total, 2));
+    // ajustement pour que la somme fasse exactement 1
+    const sumRounded = pValues.reduce((s, v) => s + v, 0);
+    const diff = round(1 - sumRounded, 2);
+    pValues[pValues.length - 1] = round(pValues[pValues.length - 1] + diff, 2);
+    const missingIndex = Math.floor(Math.random() * labels.length);
+    return getQuestionFromIdentifiers({ labels, pValues, missingIndex });
+};
+const getQuestionFromIdentifiers = (identifiers) => ({
+    answer: getAnswer(identifiers),
+    instruction: getInstruction(identifiers),
+    keys: getKeys(identifiers),
+    answerFormat: "tex",
+    identifiers,
+    hint: getHint(identifiers),
+    correction: getCorrection(identifiers),
+    style: {
+        tableOptions: {
+            firstColumnIsHeader: true,
+            firstCellIsDivided: false,
+            firstRowIsHeader: false,
+        },
+    },
+});
+export const getMissingProbabilityValueMiddleSchool = {
+    id: "getMissingProbabilityValueMiddleSchool",
+    label: "Déterminer la probabilité manquante",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMissingProbabilityValueMiddleSchoolQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -7,6 +7,8 @@ export * from "./mostLeastProbable.js";
 export * from "./rouletteProbas.js";
 export * from "./possibleValuesForProba.js";
 export * from "./rangeBasicProbas.js";
+export * from "./pickEquiprobableTo.js";
+export * from "./getMissingProbabilityValueMiddleSchool.js";
 export * from "./findEffectifFromProba.js";
 export * from "./calculateProbaFromProbaLaw.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,qBAAqB,CAAC;AACpC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC"}

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

@@ -7,5 +7,7 @@ export * from "./mostLeastProbable.js";
 export * from "./rouletteProbas.js";
 export * from "./possibleValuesForProba.js";
 export * from "./rangeBasicProbas.js";
+export * from "./pickEquiprobableTo.js";
+export * from "./getMissingProbabilityValueMiddleSchool.js";
 export * from "./findEffectifFromProba.js";
 export * from "./calculateProbaFromProbaLaw.js";

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type WheelItem = {
+    value: number;
+    indexColor: number;
+};
+type Identifiers = {
+    arrItem: WheelItem[];
+    typeAsked: string;
+};
+export declare const pickEquiprobableTo: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pickEquiprobableTo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pickEquiprobableTo.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/pickEquiprobableTo.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAqKrC,KAAK,SAAS,GAAG;IACf,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAgIF,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,SAAS,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA2NF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAmBpD,CAAC"}

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

@@ -0,0 +1,374 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueMain, colorWithOpacity, greenLight, orange, red, } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { Vector } from "../../../../math/geometry/vector.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const colors = [red, blueMain, greenLight, orange];
+const colorNames = ["rouge", "bleu", "vert", "orange"];
+const createVector = (from, to, name, precision = 5) => {
+    return new Vector(name, round(substract(to.x, from.x).evaluate(), precision).toTree(), round(substract(to.y, from.y).evaluate(), precision).toTree());
+};
+const createPoint = (x, y, name, precision = 5) => {
+    return new Point(name, round(x, precision), round(y, precision));
+};
+const rotatePoint = (target, angle, center, name, precision = 2) => {
+    const vSrc = createVector(center, target, "vSrc", precision);
+    const vRotated = vSrc.rotate(angle, "vRotated");
+    return createPoint(add(center.x, vRotated.x).evaluate(), add(center.y, vRotated.y).evaluate(), name, precision);
+};
+const createPointWithWeights = (arrPointAndWeight) => {
+    return arrPointAndWeight.reduce((acc, [p, w]) => {
+        return new Point("acc", acc.x.evaluate() + w * p.x.evaluate(), acc.y.evaluate() + w * p.y.evaluate());
+    }, new Point("O", 0, 0));
+};
+const probaWheelGGBCommands = (arrItem) => {
+    const radius = 12;
+    const point0 = new Point("O", 0, 0);
+    function createWheelItemGGBCommands(wheelItem, i, angleInDegreesSector) {
+        const angleInRadiansSector = (angleInDegreesSector * PiNode.evaluate()) / 180.0;
+        const point1Raw = new Point("P1", radius, 0);
+        const point2Raw = new Point("P2", radius * Math.cos(angleInRadiansSector), radius * Math.sin(angleInRadiansSector));
+        const angleInRadiansRotate = (2 * PiNode.evaluate() * (1.0 * i + 0.5)) / arrItem.length + //center wrt sector
+            (PiNode.evaluate() * 3.0) / 2.0; //put first sector on top
+        const [point1, point2] = [point1Raw, point2Raw].map((pointRaw) => {
+            return rotatePoint(pointRaw, -angleInRadiansRotate, point0, "rotated", 3);
+        });
+        const pointForLabel = createPointWithWeights([
+            [point0, 0.24],
+            [point1, 0.38],
+            [point2, 0.38],
+        ]);
+        return [
+            //circular sector
+            `C_${i} = CircularSector(${point0.toMathString()}, ${point1.toMathString()}, ${point2.toMathString()})`,
+            `SetFixed(C_${i}, true, false)`,
+            `SetColor(C_${i}, "${colorWithOpacity(colors[wheelItem.indexColor], 80)}")`,
+            `SetLineThickness(C_${i}, 1)`,
+            //border
+            `Cb_${i} = CircularSector(${point0.toMathString()}, ${point1.toMathString()}, ${point2.toMathString()})`,
+            `SetFixed(Cb_${i}, true, false)`,
+            `SetColor(Cb_${i}, "#FF000000")`,
+            `SetLineThickness(Cb_${i}, 1)`,
+            //label
+            `L_${i} = Text("$\\large \\text{${wheelItem.value}}$", ${pointForLabel.toMathString()}, false, true, 0, 0)`,
+            `SetFixed(L_${i}, true, false)`,
+        ];
+    }
+    return [
+        ...arrItem.flatMap((wheelItem, i) => {
+            const angleInDegreesSector = 360.0 * (1.0 / arrItem.length);
+            const itemCommands = createWheelItemGGBCommands(wheelItem, i, angleInDegreesSector);
+            return [...itemCommands];
+        }),
+        //circle border
+        `C = Circle(${point0.toMathString()}, ${radius * 1.05})`,
+        `SetFixed(C, true, false)`,
+        //triangle
+        ...(() => {
+            const pointTL = new Point("TL", -0.03 * radius, radius + 0.03 * radius);
+            const pointTR = new Point("TR", +0.03 * radius, radius + 0.03 * radius);
+            const pointB = new Point("TB", 0, radius - 0.03 * radius);
+            return [
+                `T = Polygon(${pointTL.toMathString()},${pointTR.toMathString()},${pointB.toMathString()})`,
+                `SetFilling(T, 1)`,
+                `SetColor(T, "#FF000000")`,
+                `SetFixed(T, true, false)`,
+            ];
+        })(),
+    ];
+};
+const getDictEventsAndProba = (arrItem) => {
+    const outDict = {};
+    const indexesColorsUsed = [
+        ...new Set(arrItem.map((wheelItem) => wheelItem.indexColor)),
+    ];
+    //couleur
+    {
+        const dictColor = indexesColorsUsed.reduce((acc, i) => {
+            const nbIssues = arrItem.filter((itemX) => itemX.indexColor === i).length;
+            const nodeProba = frac(nbIssues, arrItem.length);
+            acc[i] = nodeProba;
+            return acc;
+        }, {});
+        outDict["couleur"] = dictColor;
+    }
+    const valuesUsed = [...new Set(arrItem.map((wheelItem) => wheelItem.value))];
+    //numéro
+    {
+        const dictValue = valuesUsed.reduce((acc, i) => {
+            const nbIssues = arrItem.filter((itemX) => itemX.value === i).length;
+            const nodeProba = frac(nbIssues, arrItem.length);
+            acc[i] = nodeProba;
+            return acc;
+        }, {});
+        outDict["numéro"] = dictValue;
+    }
+    //parité
+    {
+        const dictColor = [0, 1].reduce((acc, i) => {
+            const nbIssues = arrItem.filter((itemX) => itemX.value % 2 === i).length;
+            const nodeProba = frac(nbIssues, arrItem.length);
+            acc[i] = nodeProba;
+            return acc;
+        }, {});
+        outDict["parité"] = dictColor;
+    }
+    return outDict;
+};
+const getStrEvent = (typeAsked, indexEvent) => {
+    switch (typeAsked) {
+        case "couleur":
+            return `Le secteur obtenu est ${colorNames[indexEvent]}`;
+        case "numéro":
+            return `Le secteur obtenu a pour numéro $${indexEvent.frenchify()}$`;
+        case "parité":
+            return `Le secteur obtenu a un numéro ${indexEvent === 0 ? "pair" : "impair"}`;
+        default:
+            throw new Error("Unsupported typeAsked: " + typeAsked);
+    }
+};
+const getIndexEvent = (wheelItem, typeAsked) => {
+    switch (typeAsked) {
+        case "couleur":
+            return wheelItem.indexColor;
+        case "numéro":
+            return wheelItem.value;
+        case "parité":
+            return wheelItem.value % 2;
+        default:
+            throw new Error("Unsupported typeAsked: " + typeAsked);
+    }
+};
+const getValidInvalidPools = (identifiers) => {
+    const { arrItem, typeAsked } = identifiers;
+    const dictEventsAndProba = getDictEventsAndProba(arrItem);
+    const wheelItemAsked = arrItem[0];
+    const indexAsked = getIndexEvent(wheelItemAsked, typeAsked);
+    const nodeProbaAsked = dictEventsAndProba[typeAsked][indexAsked].simplify();
+    const arrOtherEventAndProba = Object.entries(dictEventsAndProba).reduce((acc, [typeEvent, dictProba]) => {
+        acc.push(...Object.entries(dictProba).flatMap(([s, nodeProba]) => {
+            const indexEvent = +s;
+            if (typeEvent === typeAsked && indexEvent === indexAsked) {
+                return [];
+            }
+            else {
+                return [{ typeEvent, indexEvent, nodeProba }];
+            }
+        }));
+        return acc;
+    }, []);
+    const [validPool, invalidPool] = arrOtherEventAndProba.reduce((acc, miniDict) => {
+        const isSameAsProbaAsked = substract(miniDict.nodeProba.simplify(), nodeProbaAsked)
+            .simplify()
+            .evaluate() === 0;
+        acc[isSameAsProbaAsked ? 0 : 1].push(miniDict);
+        return acc;
+    }, [[], []]);
+    return [validPool, invalidPool];
+};
+const getInstruction = (identifiers) => {
+    const { arrItem, typeAsked } = identifiers;
+    const wheelItemAsked = arrItem[0];
+    return `On fait tourner la roue ci-dessous, dont les $${arrItem.length}$ secteurs ont la même aire.
+
+On réalise l'événement "${getStrEvent(typeAsked, getIndexEvent(wheelItemAsked, typeAsked))}".
+
+Parmi les évènements proposés, lesquels sont équiprobables à l'évènement réalisé ?`;
+};
+const getGGBOptions = (identifiers) => {
+    const { arrItem } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [...probaWheelGGBCommands(arrItem)],
+        hideAxes: true,
+        hideGrid: true,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [-15, 15, -15, 15],
+    });
+};
+const getHint = () => {
+    return `Compte le nombre d'issues réalisent chaque évènement et cherche lesquels sont égaux entre eux.`;
+};
+const getCorrection = (identifiers) => {
+    const { arrItem, typeAsked } = identifiers;
+    const wheelItemAsked = arrItem[0];
+    const dictEventsAndProba = getDictEventsAndProba(arrItem);
+    const indexAsked = getIndexEvent(wheelItemAsked, typeAsked);
+    const nodeProbaAsked = dictEventsAndProba[typeAsked][indexAsked];
+    const [validPool] = getValidInvalidPools(identifiers);
+    return `Pour cette roue de $${arrItem.length}$ secteurs, voici quelques événèments réalisables avec leur probabilité : 
+
+${mdTable([
+        ["Évènement", "Probabilité"],
+        ["", ""],
+        ...Object.entries(dictEventsAndProba["couleur"]).map(([s, nodeProba]) => {
+            const indexEvent = +s;
+            return [getStrEvent("couleur", indexEvent), `$${nodeProba.toTex()}$`];
+        }),
+        ["", ""],
+        ...Object.entries(dictEventsAndProba["numéro"]).map(([s, nodeProba]) => {
+            const indexEvent = +s;
+            return [getStrEvent("numéro", indexEvent), `$${nodeProba.toTex()}$`];
+        }),
+        ["", ""],
+        ...Object.entries(dictEventsAndProba["parité"]).map(([s, nodeProba]) => {
+            const indexEvent = +s;
+            return [getStrEvent("parité", indexEvent), `$${nodeProba.toTex()}$`];
+        }),
+        ["", ""],
+    ])}
+
+L'évènement "${getStrEvent(typeAsked, getIndexEvent(wheelItemAsked, typeAsked))}" a pour probabilité $${nodeProbaAsked.toTex()}$.
+
+Voici les autres évènements du tableau ayant pour probabilité $${nodeProbaAsked.toTex()}$ : 
+
+${validPool
+        .map(({ typeEvent, indexEvent }) => {
+        return getStrEvent(typeEvent, indexEvent);
+    })
+        .map((str) => `- ${str}`).join(`
+`)}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const [validPool, invalidPool] = getValidInvalidPools(identifiers);
+    const nbValid = randint(1, validPool.length);
+    shuffle(validPool)
+        .slice(0, nbValid)
+        .forEach((miniDict) => {
+        const strEvent = getStrEvent(miniDict.typeEvent, miniDict.indexEvent);
+        addValidProp(propositions, strEvent, "raw");
+    });
+    const nbInvalid = n - nbValid;
+    shuffle(invalidPool)
+        .slice(0, nbInvalid)
+        .forEach((miniDict) => {
+        const strEvent = getStrEvent(miniDict.typeEvent, miniDict.indexEvent);
+        tryToAddWrongProp(propositions, strEvent, "raw");
+    });
+    return shuffleProps(propositions, n);
+};
+const getPickEquiprobableToQuestion = () => {
+    const typeAsked = random(["couleur", "numéro", "parité"]);
+    const nbWheelItems = randint(5, 11);
+    function createRandomArrItem(nbWheelItems) {
+        function* genFuncWheelItemValue() {
+            const nbDifferent = randint(3, nbWheelItems);
+            const arrValue = randomMany([...Array(10).keys()], nbDifferent);
+            yield* shuffle([...arrValue]);
+            while (true) {
+                yield random(arrValue);
+            }
+        }
+        const generateWheelItemValue = genFuncWheelItemValue();
+        function* genFuncWheelItemColor() {
+            const arrColor = [...Array(colors.length).keys()];
+            yield* shuffle([...arrColor]);
+            while (true) {
+                yield random(arrColor);
+            }
+        }
+        const generateWheelItemColor = genFuncWheelItemColor();
+        const arrItem = [...Array(nbWheelItems).keys()].map(() => {
+            return {
+                value: generateWheelItemValue.next().value,
+                indexColor: generateWheelItemColor.next().value,
+            };
+        });
+        return arrItem;
+    }
+    let identifiers;
+    let counter = -1;
+    let isValid = false;
+    while (!isValid && counter < 100) {
+        counter++;
+        const arrItem = createRandomArrItem(nbWheelItems);
+        const identifiersCandidate = {
+            arrItem,
+            typeAsked,
+        };
+        const [validPool] = getValidInvalidPools(identifiersCandidate);
+        isValid = validPool.length > 0;
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        identifiers = {
+            arrItem: [
+                {
+                    value: 0,
+                    indexColor: 0,
+                },
+                {
+                    value: 1,
+                    indexColor: 0,
+                },
+                {
+                    value: 2,
+                    indexColor: 0,
+                },
+                {
+                    value: 3,
+                    indexColor: 1,
+                },
+                {
+                    value: 4,
+                    indexColor: 0,
+                },
+                {
+                    value: 5,
+                    indexColor: 1,
+                },
+                {
+                    value: 6,
+                    indexColor: 2,
+                },
+            ],
+            typeAsked: "numéro",
+        };
+    }
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const pickEquiprobableTo = {
+    id: "pickEquiprobableTo",
+    connector: "=",
+    label: "Déterminer les situations équiprobables",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPickEquiprobableToQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+    hasGeogebra: true,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"probaFromTableNoContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableNoContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAarC,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;AA2TF,KAAK,OAAO,GAAG;IAEb,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AA+BF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBlE,CAAC"}
+{"version":3,"file":"probaFromTableNoContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableNoContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAarC,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;AAkUF,KAAK,OAAO,GAAG;IAEb,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B,CAAC;AA+BF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBlE,CAAC"}

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

@@ -226,6 +226,13 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         identifiers,
         hint: getHint(identifiers, opts),
         correction: getCorrection(identifiers, opts),
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: true,
+            },
+        },
     };
     return question;
 };

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,EAmBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE;QACN,WAAW,EAAE,MAAM,CAAC;QACpB,uBAAuB,EAAE,MAAM,CAAC;QAChC,uBAAuB,EAAE,MAAM,CAAC;QAChC,mCAAmC,EAAE,MAAM,CAAC;KAC7C,CAAC;IACF,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAqpBF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAsBF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBpE,CAAC"}
+{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE;QACN,WAAW,EAAE,MAAM,CAAC;QACpB,uBAAuB,EAAE,MAAM,CAAC;QAChC,uBAAuB,EAAE,MAAM,CAAC;QAChC,mCAAmC,EAAE,MAAM,CAAC;KAC7C,CAAC;IACF,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AA4pBF,KAAK,OAAO,GAAG;IACb,cAAc,EAAE,MAAM,EAAE,CAAC;CAC1B,CAAC;AAsBF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBpE,CAAC"}

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

@@ -329,6 +329,13 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
         options: opts,
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: true,
+            },
+        },
     };
     return question;
 };

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"averageWithClasses.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageWithClasses.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAqIF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAkBpD,CAAC"}