math-exercises 3.0.152 → 3.0.154

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

@@ -0,0 +1,136 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { probaWheelGGBCommands } from "../../../../geogebra/probas/probaWheelGGBCommands.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+//on note le numéro du secteur obtenu
+//on note la couleur du secteur obtenu
+//on note la parité du numéro obtenu
+const getPropositions = (n, { answer, items }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const colors = [0, 0, 0, 0];
+    const nums = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    const pars = [0, 0];
+    for (let i = 0; i < items.length; i++) {
+        colors[items[i].indexColor]++;
+        nums[items[i].value]++;
+        if (items[i].value % 2 === 0)
+            pars[0]++;
+        else
+            pars[1]++;
+    }
+    if (colors.filter((e) => !!e).every((i) => i === colors[0]))
+        addValidProp(propositions, "On note la couleur du secteur obtenu", "raw");
+    else
+        tryToAddWrongProp(propositions, "On note la couleur du secteur obtenu", "raw");
+    if (nums.filter((e) => !!e).every((i) => i === nums[0]))
+        addValidProp(propositions, "On note le numéro du secteur obtenu", "raw");
+    else
+        tryToAddWrongProp(propositions, "On note le numéro du secteur obtenu", "raw");
+    if (pars.every((i) => i === pars[0]))
+        addValidProp(propositions, "On note la parité du secteur obtenu (pair ou impair)", "raw");
+    else
+        tryToAddWrongProp(propositions, "On note la parité du secteur obtenu (pair ou impair)", "raw");
+    return shuffleProps(propositions, n);
+};
+const getInstruction = (identifiers) => {
+    const { items } = identifiers;
+    return `On fait tourner la roue ci-dessous, dont les $${items.length}$ secteurs ont la même aire.
+  
+Parmi les situations proposées, laquelle ou lesquelles sont des situations d'équiprobabilité ?`;
+};
+const getHint = () => {
+    return "On est dans une situation d'équiprobabilité lorsque toutes les issues ont la même probabilité de se réaliser.";
+};
+const getCorrection = (identifiers) => {
+    const { items } = identifiers;
+    const colors = [0, 0, 0, 0];
+    const nums = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    const pars = [0, 0];
+    for (let i = 0; i < items.length; i++) {
+        colors[items[i].indexColor]++;
+        nums[items[i].value]++;
+        if (items[i].value % 2 === 0)
+            pars[0]++;
+        else
+            pars[1]++;
+    }
+    return `On détaille chaque situation : 
+  
+- 
+- 
+- `;
+};
+const getGGBOptions = (identifiers) => {
+    const { items } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [...probaWheelGGBCommands(items)],
+        hideAxes: true,
+        hideGrid: true,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: [-15, 15, -15, 15],
+    });
+};
+const hasRightAnswer = (items) => {
+    const colors = [0, 0, 0, 0];
+    const nums = [0, 0, 0, 0, 0, 0, 0, 0, 0];
+    const pars = [0, 0];
+    for (let i = 0; i < items.length; i++) {
+        colors[items[i].indexColor]++;
+        nums[items[i].value]++;
+        if (items[i].value % 2 === 0)
+            pars[0]++;
+        else
+            pars[1]++;
+    }
+    return (colors.filter((e) => !!e).every((i) => i === colors[0]) ||
+        nums
+            .filter((e) => !!e)
+            .every((i) => i === nums[0] || pars.every((i) => i === pars[0])));
+};
+const getPickEquiprobableSituationsQuestion = () => {
+    let items = [];
+    do {
+        items = [];
+        for (let i = 0; i < 9; i++) {
+            items.push({
+                value: randint(1, 10),
+                indexColor: randint(0, 4),
+            });
+        }
+    } while (!hasRightAnswer(items));
+    const identifiers = { items };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const pickEquiprobableSituations = {
+    id: "pickEquiprobableSituations",
+    label: "Déterminer les situations d'équiprobabilité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPickEquiprobableSituationsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+};

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

@@ -1 +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"}
+{"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;AAgBrC,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

@@ -1,13 +1,9 @@
 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 { blueMain, 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 { probaWheelGGBCommands } from "../../../../geogebra/probas/probaWheelGGBCommands.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";
@@ -15,78 +11,6 @@ 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 = [
@@ -356,7 +280,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
 export const pickEquiprobableTo = {
     id: "pickEquiprobableTo",
     connector: "=",
-    label: "Déterminer les situations équiprobables",
+    label: "Déterminer les situations équiprobables à une situation donnée",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getPickEquiprobableToQuestion(opts), nb),
     qcmTimer: 60,

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"}

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

@@ -0,0 +1,140 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { averageWithEffectifs } from "../../../../utils/average.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { approxOrEqual } from "../../../../utils/latex/approxOrEqual.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const nbAnwer = answer.unfrenchify();
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, round(nbAnwer + randfloat(-5, 5, 1), 4).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { bounds, effectifs } = identifiers;
+    const centers = bounds
+        .slice(0, bounds.length - 1)
+        .map((b, i) => round((b + bounds[i + 1]) / 2, 4));
+    return round(averageWithEffectifs(centers, effectifs), 1).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { bounds, effectifs } = identifiers;
+    const n = effectifs.reduce((acc, curr) => acc + curr, 0);
+    return `Un agriculteur a classé les $${n}$ oeufs pondus par ses poules selon leur calibre :
+  
+${mdTable([
+        [
+            "Masse $m$ (en $\\textrm{g})$",
+            ...bounds
+                .slice(0, bounds.length - 1)
+                .map((b, i) => `$${b}\\leq m < ${bounds[i + 1]}$`),
+        ],
+        ["Effectif", ...effectifs.map((e) => `$${e}$`)],
+    ])}
+
+Quel est le poids moyen des oeufs ?
+
+Arrondir au dixième.`;
+};
+const getHint = () => {
+    return `Calcule le centre de chaque classe en faisant la moyenne des valeurs extrêmes de la classe. Puis, calcule la moyenne de la série en prenant comme valeurs les centres des classes.`;
+};
+const getCorrection = (identifiers) => {
+    const { bounds, effectifs } = identifiers;
+    const centers = bounds
+        .slice(0, bounds.length - 1)
+        .map((b, i) => round((b + bounds[i + 1]) / 2, 4));
+    const n = effectifs.reduce((acc, curr) => acc + curr, 0);
+    const avg = averageWithEffectifs(centers, effectifs);
+    const sum = centers.reduce((acc, curr, i) => acc + curr * effectifs[i], 0);
+    return `On calcule d'abord le centre de chaque classe : 
+  
+${bounds
+        .slice(0, bounds.length - 1)
+        .map((b, i) => `$$
+${frac(add(b, bounds[i + 1]), 2).toTex()} = ${round((b + bounds[i + 1]) / 2, 4).frenchify()}
+$$`)
+        .join("\n \n")}
+  
+On calcule alors la moyenne en multipliant le centre de chaque classe par l'effectif correspondant : 
+
+${alignTex([
+        [
+            "",
+            frac(operatorComposition(AddNode, centers.map((c, i) => multiply(c, effectifs[i]))), n).toTex(),
+        ],
+        ["=", frac(sum, n).toTex()],
+        approxOrEqual(avg, 1),
+    ])}
+
+Le poids moyen des oeufs est donc de $${round(avg, 1).frenchify()} \\textrm{g}$.
+
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getAverageWithClassesQuestion = () => {
+    const effectifs = [randint(5, 20)];
+    const bounds = [randint(30, 50)];
+    for (let i = 0; i < 3; i++) {
+        effectifs.push(randint(5, 20));
+        bounds.push(bounds[i] + randint(2, 7));
+    }
+    bounds.push(bounds[bounds.length - 1] + randint(2, 7));
+    const identifiers = {
+        situation: 0,
+        effectifs: effectifs,
+        bounds,
+    };
+    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 averageWithClasses = {
+    id: "averageWithClasses",
+    connector: "=",
+    label: "Calculer la moyenne d'une série regroupée en classes",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAverageWithClassesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"averageWithTableWithContext.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageWithTableWithContext.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAQ9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AA4HF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAe7D,CAAC"}

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

@@ -0,0 +1,113 @@
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercise.js";
+import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+const getHint = () => {
+    return `Multiplie chaque note par son coefficient, puis additionne les résultats obtenus, et divise le tout par la somme des coefficients.`;
+};
+const getCorrection = (identifiers) => {
+    const { randomEffectives, randomValues } = identifiers;
+    const sumEff = operatorComposition(AddNode, randomEffectives.map((e) => e.toTree()));
+    const sumProd = operatorComposition(AddNode, randomValues.map((e, i) => multiply(randomEffectives[i].toTree(), e.toTree())));
+    const fraction = frac(sumProd, sumEff);
+    return `La moyenne est égale à :
+  
+$$
+${fraction.toSimplificationTex()}
+$$
+`;
+};
+const getInstruction = ({ randomEffectives, randomValues, }) => {
+    return `Voici les notes en mathématiques d'un élève au premier trimestre : 
+
+${mdTable([
+        ["Note sur $20$", ...randomValues.map((e) => dollarize(e))],
+        ["Coefficient", ...randomEffectives.map((e) => dollarize(e))],
+    ])}
+
+Calculer la moyenne (arrondir au centième).`;
+};
+const getAnswer = (identifiers) => {
+    const { randomEffectives, randomValues } = identifiers;
+    let average = 0;
+    for (let i = 0; i < randomValues.length; i++)
+        average += randomValues[i] * randomEffectives[i];
+    const sumEffectives = randomEffectives.reduce((sum, value) => sum + value, 0);
+    average /= sumEffectives;
+    average = round(average, 2);
+    const answer = (average + "").replace(".", ",");
+    return answer;
+};
+const getAverageWithTableQuestion = () => {
+    const getRandomUniqueValues = (count, min, max) => {
+        let counter = 0;
+        const uniqueValues = new Set();
+        while (uniqueValues.size < count) {
+            counter++;
+            if (counter > 1000)
+                throw new Error("Too many iterations in averageWithTable");
+            uniqueValues.add(randint(min, max));
+        }
+        return Array.from(uniqueValues).sort((a, b) => a - b);
+    };
+    const randomValues = getRandomUniqueValues(4, 1, 20);
+    const randomEffectives = [1, 2, 3, 4].map(() => randint(1, 6));
+    const identifiers = { randomEffectives, randomValues };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
+        },
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const average = Number(answer.replace(",", "."));
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, round(average + randint(-average, 20 - average, [0]) + randint(1, 100) / 100, 2)
+            .toString()
+            .replace(".", ","));
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+export const averageWithTableWithContext = {
+    id: "averageWithTableWithContext",
+    connector: "=",
+    label: "Calcul de la moyenne de notes coefficientées",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getAverageWithTableQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
+};

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

@@ -21,4 +21,6 @@ export * from "./getQuartileProportionQuestion.js";
 export * from "./interpretIndicatorsForLists.js";
 export * from "./plausibilityOfAverage.js";
 export * from "./etendueTable.js";
+export * from "./averageWithClasses.js";
+export * from "./averageWithTableWithContext.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;AACnD,cAAc,kCAAkC,CAAC;AACjD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,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;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,kCAAkC,CAAC"}

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

@@ -21,3 +21,5 @@ export * from "./getQuartileProportionQuestion.js";
 export * from "./interpretIndicatorsForLists.js";
 export * from "./plausibilityOfAverage.js";
 export * from "./etendueTable.js";
+export * from "./averageWithClasses.js";
+export * from "./averageWithTableWithContext.js";

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

@@ -70,7 +70,7 @@ const getMedianList = (optsIn) => {
     const arrayedOptions = optsIn;
     const opts = {
         nbValues: random(arrayedOptions.nbValues ?? optsDefault.nbValues),
-        isOrdered: optsIn?.isOrdered ?? true,
+        isOrdered: optsIn?.isOrdered ?? false,
     };
     const length = Number(opts.nbValues);
     const randomValues = [...Array(length).keys()].map(() => randint(1, 20));
@@ -123,9 +123,9 @@ const options = [
     },
 ];
 export const medianWithList = {
-    id: "medianWithList",
+    id: "medianWithListOrdered",
     connector: "=",
-    label: "Calcul de la médiane d'une liste de valeurs",
+    label: "Calcul de la médiane d'une liste de valeurs ordonnée",
     isSingleStep: false,
     generator: (nb, opts) => getDistinctQuestions(() => getMedianList(Object.assign({}, opts, { isOrdered: true })), nb),
     options,
@@ -138,7 +138,7 @@ export const medianWithList = {
     hasHintAndCorrection: true,
 };
 export const medianWithListUnorderedVariant = {
-    id: "medianWithListUnorderedVariant",
+    id: "medianWithList",
     connector: "=",
     label: "Calcul de la médiane d'une liste de valeurs non ordonnée",
     isSingleStep: false,

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

@@ -12,4 +12,7 @@ export * from "./scratchStringLoopCond.js";
 export * from "./scratchStringLoopCond2.js";
 export * from "./scratchStringLoopCond3.js";
 export * from "./scratchCond1.js";
+export * from "./scratchListElemAtIndex.js";
+export * from "./scratchListElemAtIndex2.js";
+export * from "./scratchListFilter.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC;AAElC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,wBAAwB,CAAC"}

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

@@ -13,3 +13,6 @@ export * from "./scratchStringLoopCond2.js";
 export * from "./scratchStringLoopCond3.js";
 export * from "./scratchCond1.js";
 // export * from "./scratchFunction1.js";
+export * from "./scratchListElemAtIndex.js";
+export * from "./scratchListElemAtIndex2.js";
+export * from "./scratchListFilter.js";

package/lib/exercises/math/scratch/scratchListElemAtIndex.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Insertion<T> = {
+    index: number;
+    value: T;
+};
+type Identifiers = {
+    isUsingLetters: boolean;
+    arrInsertion: Insertion<number>[] | Insertion<string>[];
+    indexAsked: number;
+};
+export declare const scratchListElemAtIndex: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=scratchListElemAtIndex.d.ts.map

package/lib/exercises/math/scratch/scratchListElemAtIndex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scratchListElemAtIndex.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/scratch/scratchListElemAtIndex.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,SAAS,CAAC,CAAC,IAAI;IAClB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,CAAC,CAAC;CACV,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,OAAO,CAAC;IACxB,YAAY,EAAE,SAAS,CAAC,MAAM,CAAC,EAAE,GAAG,SAAS,CAAC,MAAM,CAAC,EAAE,CAAC;IACxD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA0MF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}