math-exercises 3.0.82 → 3.0.84

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iCAAiC,CAAC;AAChD,cAAc,kCAAkC,CAAC;AACjD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,mBAAmB,CAAC;AAClC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,qBAAqB,CAAC;AACpC,cAAc,uBAAuB,CAAC;AACtC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC"}

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

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

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

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

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

@@ -117,8 +117,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
-        // hint: getHint(identifiers),
-        // correction: getCorrection(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -150,12 +150,12 @@ const getHint = (identifiers) => {
     const { aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre, probaFrac, type, event, } = identifiers;
     switch (type) {
         case "singleEvent":
-            return `Lit le total d'issues de l'évènement demandé, puis divise par le total des issues.`;
+            return `Lit le total d'élèves correspondant au cas demandé, puis divise par le total des élèves.`;
         case "union":
-            return `Compte toutes les issues qui sont soit dans le premier événement, soit dans le second (ou à la fois dans les deux). Attention à ne pas compter certaines issues en double.`;
+            return `Compte tous les élèves qui sont soit dans le premier cas, soit dans le second (ou à la fois dans les deux). Attention à ne pas compter certains élèves en double.`;
         case "intersection":
         default:
-            return `Lit la case qui correspond aux issues appartenant à la fois aux deux événements demandés.`;
+            return `Lit la case des élèves correspondant à la fois aux deux cas demandés.`;
     }
 };
 const getCorrection = (identifiers) => {
@@ -167,68 +167,51 @@ const getCorrection = (identifiers) => {
     switch (type) {
         case "singleEvent":
             const singleEvnmt = event === "une fille"
-                ? "A"
+                ? "Filles"
                 : event === "un garçon"
-                    ? "\\overline{A}"
+                    ? "Garçons"
                     : event === "un élève qui porte des lunettes"
-                        ? "B"
-                        : "\\overline{B}";
-            return `On lit le total de la ligne $${singleEvnmt}$ : c'est $${probaFrac[0]}$. La probabilité recherchée vaut donc :
+                        ? "Porte des lunettes"
+                        : "Ne porte pas de lunettes";
+            const isLine = event === "une fille" || event === "un garçon";
+            return `On lit le total de la ${isLine ? "ligne" : "colonne"} "${singleEvnmt}" : c'est $${probaFrac[0]}$. La probabilité recherchée vaut donc :
 
 $$
 ${frac(probaFrac[0], probaFrac[1]).toSimplificationTex()}
 $$`;
         case "union":
-            const unionEvements = event === "P(A\\cup B)"
-                ? ["A", "B"]
-                : event === "P(A\\cup \\overline B)"
-                    ? ["A", "\\overline{B}"]
-                    : event === "P(\\overline A \\cup B)"
-                        ? ["\\overline{A}", "B"]
-                        : ["\\overline{A}", "\\overline{B}"];
-            const rowTotal = unionEvements[0] === "A" ? aTotal : aBarreTotal;
-            const columnTotal = unionEvements[1] === "B" ? bTotal : bBarreTotal;
-            return `On additionne les totaux de la ligne $${unionEvements[0]}$ et de la colonne $${unionEvements[1]}$ : cela donne $${rowTotal} + ${columnTotal} = ${rowTotal + columnTotal}$. On doit ensuite soustraire la case à l'intersection de la ligne $${unionEvements[0]}$ et de la colonne $${unionEvements[1]}$, car on l'a compté deux fois dans les totaux. Cela donne $${rowTotal + columnTotal} - ${rowTotal + columnTotal - probaFrac[0]} = ${probaFrac[0]}
+            const unionEvements = event.split(" ou ");
+            const rowTotal = unionEvements[0] === "une fille" ? aTotal : aBarreTotal;
+            const columnTotal = unionEvements[1] === "un élève qui porte des lunettes"
+                ? bTotal
+                : bBarreTotal;
+            unionEvements[0] = unionEvements[0]
+                .replace("une", "")
+                .replace("un", "")
+                .trim();
+            unionEvements[1] = unionEvements[1].replace("un élève qui ", "");
+            return `On additionne les totaux de la ligne "${unionEvements[0]}" et de la colonne "${unionEvements[1]}" : cela donne $${rowTotal} + ${columnTotal} = ${rowTotal + columnTotal}$. 
+      
+On doit ensuite soustraire la case à l'intersection de la ligne "${unionEvements[0]}" et de la colonne "${unionEvements[1]}", car on l'a compté deux fois dans les totaux. Cela donne $${rowTotal + columnTotal} - ${rowTotal + columnTotal - probaFrac[0]} = ${probaFrac[0]}
       $.
 
-La probabilité $${event}$ vaut donc :
+La probabilité de tomber sur ${event} vaut donc :
 
 $$
-${event} = ${frac(probaFrac[0], probaFrac[1]).toSimplificationTex()}
+${frac(probaFrac[0], probaFrac[1]).toSimplificationTex()}
 $$`;
         case "intersection":
         default:
-            const interEvemnts = event === "P(A\\cup B)"
-                ? ["A", "B"]
-                : event === "P(A\\cup \\overline B)"
-                    ? ["A", "\\overline{B}"]
-                    : event === "P(\\overline A \\cup B)"
-                        ? ["\\overline{A}", "B"]
-                        : ["\\overline{A}", "\\overline{B}"];
-            return `On lit la case à l'intersection de la colonne $${interEvemnts[1]}$ et de la ligne $${interEvemnts[0]}$ : c'est $${probaFrac[0]}$. La probabilité $${event}$ vaut donc :
+            const interEvemnts = event.split(" qui ");
+            return `On lit la case à l'intersection de la colonne "${interEvemnts[1]}"  et de la ligne "${interEvemnts[0]
+                .replace("une", "")
+                .replace("un", "")
+                .trim()}s" : c'est $${probaFrac[0]}$. 
+      
+La probabilité de tomber sur ${event} vaut donc :
 
 $$
-${event} = ${frac(probaFrac[0], probaFrac[1]).toSimplificationTex()}
-$$`;
-            const condEvents = event === "P_A(B)"
-                ? ["A", "B"]
-                : event === "P_{\\overline A}(B)"
-                    ? ["\\overline{A}", "B"]
-                    : event === "P_A(\\overline B)"
-                        ? ["A", "\\overline{B}"]
-                        : event === "P_{\\overline B}(A)"
-                            ? ["\\overline{B}", "A"]
-                            : event === "P_B(A)"
-                                ? ["B", "A"]
-                                : event === "P_B(\\overline{A})"
-                                    ? ["B", "\\overline{A}"]
-                                    : event === "P_{\\overline A}(\\overline B)"
-                                        ? ["\\overline{A}", "\\overline{B}"]
-                                        : ["\\overline{B}", "\\overline{A}"];
-            return `On cherche la probabilité de $${condEvents[1]}$ sachant que $${condEvents[0]}$ est vrai. On lit la case à l'intersection de  $${condEvents[1]}$ et  $${condEvents[0]}$ : c'est $${probaFrac[0]}$. On doit ensuite diviser par le total de l'évènement $${condEvents[0]}$. La probabilité $${event}$ vaut donc :
-
-$$
-${event} = ${frac(probaFrac[0], probaFrac[1]).toSimplificationTex()}
+${frac(probaFrac[0], probaFrac[1]).toSimplificationTex()}
 $$`;
     }
 };
@@ -244,5 +227,5 @@ export const probaFromTableWithContext = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
-    // hasHintAndCorrection: true,
+    hasHintAndCorrection: true,
 };

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

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Operators = "multiplication" | "division" | "soustraction" | "addition";
+type Identifiers = {
+    kind: "factor";
+    a: number;
+    operator: Operators;
+    factor: number;
+} | {
+    kind: "series";
+    series: number[];
+    operator: Operators;
+    factor: number;
+};
+export declare const averageLinearity: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=averageLinearity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"averageLinearity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/averageLinearity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAarC,KAAK,SAAS,GAAG,gBAAgB,GAAG,UAAU,GAAG,cAAc,GAAG,UAAU,CAAC;AAC7E,KAAK,WAAW,GACZ;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,CAAC,EAAE,MAAM,CAAC;IACV,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB,GACD;IACE,IAAI,EAAE,QAAQ,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,SAAS,CAAC;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAmON,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAkBlD,CAAC"}

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

@@ -0,0 +1,217 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { divide } from "../../../../tree/nodes/operators/divideNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.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, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const moyenne = isSeriesQuestion(identifiers)
+        ? (identifiers.series[0] +
+            identifiers.series[1] +
+            identifiers.series[2] +
+            identifiers.series[3]) /
+            4
+        : identifiers.a;
+    const { operator, factor } = identifiers;
+    switch (operator) {
+        case "addition":
+            tryToAddWrongProp(propositions, (moyenne + factor + 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne + factor - 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne + factor + factor).frenchify());
+            tryToAddWrongProp(propositions, (moyenne + factor - 2).frenchify());
+            break;
+        case "soustraction":
+            tryToAddWrongProp(propositions, (moyenne - factor + 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne - factor - 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne - factor - factor).frenchify());
+            tryToAddWrongProp(propositions, (moyenne - factor - 2).frenchify());
+            break;
+        case "multiplication":
+            tryToAddWrongProp(propositions, (moyenne * factor + 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne * factor - 1).frenchify());
+            tryToAddWrongProp(propositions, (moyenne * factor + 2).frenchify());
+            tryToAddWrongProp(propositions, (moyenne * factor - 2).frenchify());
+            break;
+        case "division":
+            tryToAddWrongProp(propositions, frac(moyenne + 1, factor).toTex());
+            tryToAddWrongProp(propositions, frac(moyenne - 1, factor).toTex());
+            tryToAddWrongProp(propositions, frac(moyenne, factor + 1).toTex());
+            tryToAddWrongProp(propositions, frac(moyenne, factor - 1).toTex());
+            break;
+    }
+    return shuffleProps(propositions, n);
+};
+const isSeriesQuestion = (identifiers) => {
+    return identifiers.kind === "series";
+};
+const getAnswer = (identifiers) => {
+    const moyenne = isSeriesQuestion(identifiers)
+        ? (identifiers.series[0] +
+            identifiers.series[1] +
+            identifiers.series[2] +
+            identifiers.series[3]) /
+            4
+        : identifiers.a;
+    const { operator, factor } = identifiers;
+    switch (operator) {
+        case "addition":
+            return add(moyenne, factor).simplify().toTex();
+        case "soustraction":
+            return substract(moyenne, factor).simplify().toTex();
+        case "multiplication":
+            return multiply(moyenne, factor).simplify().toTex();
+        case "division":
+        default:
+            return frac(moyenne, factor).simplify().toTex();
+    }
+};
+const getInstruction = (identifiers) => {
+    if (isSeriesQuestion(identifiers)) {
+        const { series: [a, b, c, d], operator, factor, } = identifiers;
+        let factorResult = (x) => {
+            switch (operator) {
+                case "addition":
+                    return x + factor;
+                case "soustraction":
+                    return x - factor;
+                case "multiplication":
+                    return x * factor;
+                case "division":
+                default:
+                    return x / factor;
+            }
+        };
+        return `La moyenne de la série ${[a, b, c, d]
+            .map((x) => `$${x.frenchify()}$`)
+            .join(" ; ")} vaut $${((a + b + c + d) / 4).frenchify()}$. 
+    
+Que vaut la moyenne de la série ${[a, b, c, d]
+            .map((x) => `$${factorResult(x).frenchify()}$`)
+            .join(" ; ")} ?`;
+    }
+    else {
+        const { a, operator, factor } = identifiers;
+        const text = operator === "division"
+            ? "divisées par"
+            : operator === "multiplication"
+                ? "multipliées par"
+                : operator === "soustraction"
+                    ? "diminuées de"
+                    : "augmentées de";
+        return `La moyenne d'une série statistique vaut $${a.frenchify()}$. Calculer la nouvelle moyenne de la série si toutes ses valeurs sont ${text} $${factor.frenchify()}$.`;
+    }
+};
+const getHint = (identifiers) => {
+    return `Si on effectue une ${identifiers.operator} sur toutes les valeurs d'une série par un nombre $a$, alors la nouvelle moyenne de la série est obtenue en faisant une ${identifiers.operator} par ce même nombre sur la moyenne précédente.`;
+};
+const getCorrection = (identifiers) => {
+    const moyenne = isSeriesQuestion(identifiers)
+        ? (identifiers.series[0] +
+            identifiers.series[1] +
+            identifiers.series[2] +
+            identifiers.series[3]) /
+            4
+        : identifiers.a;
+    const { operator, factor } = identifiers;
+    let latexFormula = "";
+    switch (operator) {
+        case "addition":
+            latexFormula = `${add(moyenne, factor).toTex()} = ${(moyenne + factor).frenchify()}`;
+            break;
+        case "soustraction":
+            latexFormula = `${substract(moyenne, factor).toTex()} = ${(moyenne - factor).frenchify()}`;
+            break;
+        case "multiplication":
+            latexFormula = `${multiply(moyenne, factor).toTex()} = ${(moyenne * factor).frenchify()}`;
+            break;
+        case "division":
+        default:
+            latexFormula = `${divide(moyenne, factor).toTex()} = ${frac(moyenne, factor).toTex()}`;
+            break;
+    }
+    return `Il y a eu une ${operator} de $${factor.frenchify()}$ sur les valeurs de la série, donc la moyenne devient :
+    
+$$
+${latexFormula}
+$$`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getAverageLinearityQuestion = (ops) => {
+    const isSeries = coinFlip();
+    if (isSeries) {
+        const a = randint(1, 10);
+        const b = randint(10, 20);
+        const c = randint(20, 30);
+        const d = randint(30, 40);
+        const operator = random([
+            "multiplication",
+            "division",
+            "soustraction",
+            "addition",
+        ]);
+        const factor = randint(2, 5);
+        const identifiers = {
+            kind: "series",
+            series: [a, b, c, d],
+            operator,
+            factor,
+        };
+        return getQuestionFromIdentifiers(identifiers);
+    }
+    else {
+        const a = randint(2, 20);
+        const operator = random([
+            "multiplication",
+            "division",
+            "soustraction",
+            "addition",
+        ]);
+        const factor = randint(2, 10, [a, 7, 9]);
+        const identifiers = { kind: "factor", a, operator, factor };
+        return getQuestionFromIdentifiers(identifiers);
+    }
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const averageLinearity = {
+    id: "averageLinearity",
+    label: "Calculer la moyenne d'une série à partir de la moyenne d'une autre série en utilisant la linéarité de la moyenne",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAverageLinearityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"calculateMeanFromFrequencies.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/calculateMeanFromFrequencies.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAwGF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAoB9D,CAAC"}

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

@@ -0,0 +1,108 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { round } from "../../../../math/utils/round.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const offset = randfloat(0.1, 1, 2);
+        tryToAddWrongProp(propositions, round(answer.unfrenchify() + offset, 2).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const sum = xValues.reduce((sum, v, i) => sum + v * yValues[i], 0);
+    const mean = round(sum, 2);
+    return mean.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    return `Un film a été noté par les spectateurs : 
+
+  
+${mdTable([
+        ["Note", ...xValues.map((v) => dollarize(v))],
+        ["Fréquence", ...yValues.map((v) => dollarize(`${round(v * 100, 2)} \\%`))],
+    ])}
+
+Quelle est la note moyenne du film ?`;
+};
+const getHint = (identifiers) => {
+    return `Pour calculer la moyenne, multiplie chaque valeur $x_i$ par sa fréquence correspondante $f_i$, puis additionne ces produits.`;
+};
+const getCorrection = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const products = xValues.map((v, i) => round(v * yValues[i], 2));
+    const total = getAnswer(identifiers);
+    return `On calcule les produits des notes par leur fréquence : \n\n
+  
+${xValues
+        .map((v, i) => `$$
+${v} \\times ${yValues[i].frenchify()} = ${products[i].frenchify()}
+$$`)
+        .join("\n\n")}
+  
+En additionnant ces produits, on obtient la moyenne $\\overline{x}$ :
+
+$$
+\\overline x = ${total}
+$$`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        return ansNode.simplify().equals(answerNode.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCalculateMeanFromFrequenciesQuestion = (ops) => {
+    const xValues = [0, 1, 2, 3, 4];
+    const raw = xValues.map(() => Math.random());
+    const total = raw.reduce((sum, v) => sum + v, 0);
+    const yValues = raw.map((v) => round(v / total, 2));
+    const sumRounded = yValues.reduce((sum, v) => sum + v, 0);
+    const diff = round(1 - sumRounded, 2);
+    yValues[yValues.length - 1] = round(yValues[yValues.length - 1] + diff, 2);
+    const identifiers = { xValues, yValues };
+    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 calculateMeanFromFrequencies = {
+    id: "calculateMeanFromFrequencies",
+    label: "Calculer une moyenne à partir de fréquences",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCalculateMeanFromFrequenciesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"compareSeriesDispersion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/compareSeriesDispersion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA8JF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAqBzD,CAAC"}