math-exercises 3.0.150 → 3.0.152

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

@@ -1,6 +1,7 @@
 import { randint } from "../../../../math/utils/random/randint.js";
 import { median } from "../../../../math/utils/stats/median.js";
 import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
 import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
 const getInstruction = (identifiers) => {
@@ -15,16 +16,37 @@ Déterminer la médiane de cette liste de valeurs.`;
 };
 const getAnswer = (identifiers) => {
     const { sortedValues } = identifiers;
-    return median(sortedValues).frenchify();
+    return median([...sortedValues].sort((a, b) => a - b)).frenchify();
 };
-const getHint = () => {
-    return `La médiane est la valeur centrale de la série : il y a autant de valeur inférieures à la médiane que de valeurs supérieures à la médiane.`;
+const getHint = (_, opts) => {
+    return `La médiane est la valeur centrale de la série : il y a autant de valeur inférieures à la médiane que de valeurs supérieures à la médiane.
+
+${opts?.isOrdered
+        ? "Les valeurs sont déjà rangées par ordre croissant."
+        : "Commence par ranger les valeurs dans l'ordre croissant."}`;
 };
-const getCorrection = (identifiers) => {
+const getCorrection = (identifiers, opts) => {
     const { sortedValues } = identifiers;
     const total = sortedValues.length;
     const rank = total / 2;
-    return `Il y a $${total}$ valeurs dans la liste. 
+    return `${(() => {
+        if (!opts?.isOrdered) {
+            const sorted = sortedValues.sort((a, b) => a - b);
+            return `On range les valeurs de la liste par ordre croissant : 
+      
+$$
+${sorted.join(";\\ ")}
+$$
+
+`;
+        }
+        else {
+            return `Les valeurs de la liste sont rangées dans l'ordre croissant.
+`;
+        }
+    })()}
+  
+Il y a $${total}$ valeurs dans la liste. 
   
 Puisque $\\frac{${total}}{2} = ${rank.frenchify()}$, la médiane est ${rank % 1 === 0
         ? `entre la $${rank}$ème et la $${rank + 1}$ème valeur.`
@@ -45,16 +67,33 @@ const isAnswerValid = (ans, { answer }) => {
     return ans === answer;
 };
 const getMedianList = (optsIn) => {
-    const arrayedOptions = optsIn ?? optsDefault;
+    const arrayedOptions = optsIn;
     const opts = {
-        nbValues: random(arrayedOptions.nbValues),
+        nbValues: random(arrayedOptions.nbValues ?? optsDefault.nbValues),
+        isOrdered: optsIn?.isOrdered ?? true,
     };
-    const randomValues = [];
     const length = Number(opts.nbValues);
-    for (let i = 0; i < length; i++)
-        randomValues.push(randint(1, 20));
+    const randomValues = [...Array(length).keys()].map(() => randint(1, 20));
     const sortedValues = randomValues.sort((a, b) => a - b);
-    const identifiers = { sortedValues };
+    let values;
+    if (opts.isOrdered) {
+        values = sortedValues;
+    }
+    else {
+        //ensure unordered
+        let counter = -1;
+        let isValid = false;
+        while (!isValid && counter < 100) {
+            counter++;
+            values = shuffle(randomValues);
+            isValid = !randomValues.every((v, i) => v === sortedValues[i]);
+        }
+        if (!isValid) {
+            const randomValuesDesperateCall = [...Array(length).keys()].map(() => randint(1, 20));
+            values = randomValuesDesperateCall;
+        }
+    }
+    const identifiers = { sortedValues: values };
     return getQuestionFromIdentifiers(identifiers);
 };
 const getQuestionFromIdentifiers = (identifiers, opts) => {
@@ -64,8 +103,8 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
         options: opts,
     };
     return question;
@@ -88,7 +127,7 @@ export const medianWithList = {
     connector: "=",
     label: "Calcul de la médiane d'une liste de valeurs",
     isSingleStep: false,
-    generator: (nb, opts) => getDistinctQuestions(() => getMedianList(opts), nb),
+    generator: (nb, opts) => getDistinctQuestions(() => getMedianList(Object.assign({}, opts, { isOrdered: true })), nb),
     options,
     qcmTimer: 60,
     freeTimer: 60,
@@ -98,3 +137,17 @@ export const medianWithList = {
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
 };
+export const medianWithListUnorderedVariant = {
+    id: "medianWithListUnorderedVariant",
+    connector: "=",
+    label: "Calcul de la médiane d'une liste de valeurs non ordonnée",
+    isSingleStep: false,
+    generator: (nb, opts) => getDistinctQuestions(() => getMedianList(Object.assign({}, opts, { isOrdered: false })), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -1 +1 @@
-{"version":3,"file":"medianWithTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithTable.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AA2HF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}
+{"version":3,"file":"medianWithTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/medianWithTable.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;CAC5B,CAAC;AAiIF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,CAajD,CAAC"}

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

@@ -79,7 +79,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
-        style: { tableHasNoHeader: true },
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
+        },
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
     };

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

@@ -1 +1 @@
-{"version":3,"file":"quartiles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartiles.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAgIF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}
+{"version":3,"file":"quartiles.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/quartiles.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAsIF,eAAO,MAAM,SAAS,EAAE,QAAQ,CAAC,WAAW,CAc3C,CAAC"}

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

@@ -86,7 +86,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: [],
         answerFormat: "tex",
         identifiers,
-        style: { tableHasNoHeader: true },
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
+        },
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
     };

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

@@ -1 +1 @@
-{"version":3,"file":"standardDeviationTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/standardDeviationTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAkJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"standardDeviationTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/standardDeviationTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAsJF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

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

@@ -123,7 +123,11 @@ const getQuestionFromIdentifiers = (identifiers) => {
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
         style: {
-            tableHasNoHeader: true,
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
         },
     };
     return question;

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

@@ -1 +1 @@
-{"version":3,"file":"varianceTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/varianceTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA+HF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAc/C,CAAC"}
+{"version":3,"file":"varianceTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/varianceTable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAmIF,eAAO,MAAM,aAAa,EAAE,QAAQ,CAAC,WAAW,CAc/C,CAAC"}

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

@@ -112,7 +112,11 @@ const getQuestionFromIdentifiers = (identifiers) => {
         hint: getHint(identifiers),
         correction: getCorrection(identifiers),
         style: {
-            tableHasNoHeader: true,
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
         },
     };
     return question;

package/lib/exercises/math/probaStat/stats2var/averagePoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"averagePoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/averagePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAmEF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}
+{"version":3,"file":"averagePoint.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/averagePoint.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAyEF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}

package/lib/exercises/math/probaStat/stats2var/averagePoint.js

@@ -41,7 +41,13 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["semicolon"],
         answerFormat: "tex",
         identifiers,
-        style: { tableHasNoHeader: true },
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
+        },
     };
     return question;
 };

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.d.ts

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

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headsOrTailsTwiceOutcomes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAS9B,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA+MF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAa3D,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceOutcomes.js

@@ -0,0 +1,171 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { random } from "../../../../utils/alea/random.js";
+function highlighted(str) {
+    return `{ \\color{green} ${str} }`;
+}
+const arrStrOutcomeSmall = [`P`, `F`];
+const getInstruction = (identifiers) => {
+    const { arrIndex } = identifiers;
+    const strRand = arrIndex.join("");
+    return `On tire deux fois à pile ou face avec une pièce de monnaie.
+On note les issues de cette expérience aléatoire dans le tableau ci-dessous. 
+
+${(() => {
+        switch (strRand) {
+            case "00":
+                {
+                    return random([
+                        `${mdTable([
+                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
+                            ["\\text{Lancer 1 : } P", "\\text{...}", "(P,F)"],
+                            ["\\text{Lancer 1 : } F", "\\text{}", "\\text{}"],
+                        ], true)}`,
+                        `${mdTable([
+                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
+                            ["\\text{Lancer 1 : } P", "\\text{...}", "\\text{}"],
+                            ["\\text{Lancer 1 : } F", "(F,P)", "\\text{}"],
+                        ], true)}`,
+                    ]);
+                }
+                break;
+            case "01":
+                {
+                    return random([
+                        `${mdTable([
+                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
+                            ["\\text{Lancer 1 : } P", "(P,P)", "\\text{...}"],
+                            ["\\text{Lancer 1 : } F", "\\text{}", "\\text{}"],
+                        ], true)}`,
+                        `${mdTable([
+                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
+                            ["\\text{Lancer 1 : } P", "\\text{}", "\\text{...}"],
+                            ["\\text{Lancer 1 : } F", "\\text{}", "(F,F)"],
+                        ], true)}`,
+                    ]);
+                }
+                break;
+            case "10":
+                {
+                    return random([
+                        `${mdTable([
+                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
+                            ["\\text{Lancer 1 : } P", "(P,P)", "\\text{}"],
+                            ["\\text{Lancer 1 : } F", "\\text{...}", "\\text{}"],
+                        ], true)}`,
+                        `${mdTable([
+                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
+                            ["\\text{Lancer 1 : } P", "\\text{}", "\\text{}"],
+                            ["\\text{Lancer 1 : } F", "\\text{...}", "(F,F)"],
+                        ], true)}`,
+                    ]);
+                }
+                break;
+            case "11":
+                {
+                    return random([
+                        `${mdTable([
+                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
+                            ["\\text{Lancer 1 : } P", "\\text{}", "(P,F)"],
+                            ["\\text{Lancer 1 : } F", "\\text{}", "\\text{...}"],
+                        ], true)}`,
+                        `${mdTable([
+                            ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
+                            ["\\text{Lancer 1 : } P", "\\text{}", "\\text{}"],
+                            ["\\text{Lancer 1 : } F", "(F,P)", "\\text{...}"],
+                        ], true)}`,
+                    ]);
+                }
+                break;
+            default:
+                throw new Error("Unsupported strRand: " + strRand);
+        }
+    })()}
+
+Que doit-on écrire dans la case avec "..." ?`;
+};
+const getAnswer = (identifiers) => {
+    const { arrIndex } = identifiers;
+    return `\\left(${arrIndex
+        .map((v) => arrStrOutcomeSmall[v])
+        .join(";")}\\right)`;
+};
+const getHint = () => {
+    return `Inspire toi de l'élément déjà écrit dans le tableau. Regarde sa ligne et sa colonne.`;
+};
+const getCorrection = (identifiers) => {
+    const { arrIndex } = identifiers;
+    const arrOutcome = getCartesiansProducts([
+        [0, 1],
+        [0, 1],
+    ]);
+    const arrStr = arrOutcome.map(([v1, v2]) => {
+        const strEventSmall = `(${arrStrOutcomeSmall[v1]};${arrStrOutcomeSmall[v2]})`;
+        return v1 === arrIndex[0] && v2 === arrIndex[1]
+            ? highlighted(strEventSmall)
+            : strEventSmall;
+    });
+    return `Dans le tableau ci-dessous, 
+le premier élément dans la parenthèse désigne le résultat du premier lancer 
+et le deuxième élémént le résultat du deuxième lancer.
+
+$P$ désigne $Pile$ et $F$ désigne $Face$.
+  
+${mdTable([
+        ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
+        ["\\text{Lancer 1 : } P", arrStr[0], arrStr[2]],
+        ["\\text{Lancer 1 : } F", arrStr[1], arrStr[3]],
+    ], true)}
+`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const arrOutcome = getCartesiansProducts([
+        [0, 1],
+        [0, 1],
+    ]);
+    const arrStr = arrOutcome.map(([v1, v2]) => `(${arrStrOutcomeSmall[v1]};${arrStrOutcomeSmall[v2]})`);
+    arrStr.forEach((str) => {
+        tryToAddWrongProp(propositions, str);
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+const getHeadsOrTailsTwiceOutcomesQuestion = () => {
+    const arrOutcome = getCartesiansProducts([
+        [0, 1],
+        [0, 1],
+    ]);
+    const arrIndex = random(arrOutcome);
+    const identifiers = { arrIndex };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: ["F", "P", "semicolon"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const headsOrTailsTwiceOutcomes = {
+    id: "headsOrTailsTwiceOutcomes",
+    label: "Désigner une issue dans une expérience aléatoire à deux épreuves",
+    isSingleStep: true,
+    generator: (nb) => [...Array(nb).keys()].map(() => getHeadsOrTailsTwiceOutcomesQuestion()),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.d.ts

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

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headsOrTailsTwiceProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAY9B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAuLF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/probaStat/twoStepExperiments/headsOrTailsTwiceProbas.js

@@ -0,0 +1,155 @@
+import { randint } from "../../../../math/utils/random/randint.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+function highlighted(str) {
+    return `{ \\color{green} ${str} }`;
+}
+const arrStrOutcome = [`Pile`, `Face`];
+const events = [
+    //elem
+    ...getCartesiansProducts([
+        [0, 1],
+        [0, 1],
+    ]).flatMap(([i1, i2]) => {
+        return {
+            str: `On obtient $${arrStrOutcome[i1]}$ puis $${arrStrOutcome[i2]}$`,
+            isRealizingEvent: (v1, v2) => v1 === i1 && v2 === i2,
+        };
+    }),
+    //at least one
+    ...[0, 1].map((i) => {
+        return {
+            str: `On obtient au moins un $${arrStrOutcome[i]}$`,
+            isRealizingEvent: (v1, v2) => v1 === i || v2 === i,
+        };
+    }),
+    //none
+    ...[0, 1].map((i) => {
+        return {
+            str: `On obtient aucun $${arrStrOutcome[i]}$`,
+            isRealizingEvent: (v1, v2) => v1 !== i && v2 !== i,
+        };
+    }),
+    //exactly one
+    ...[0, 1].map((i) => {
+        return {
+            str: `On obtient exactement un $${arrStrOutcome[i]}$`,
+            isRealizingEvent: (v1, v2) => (v1 === i && v2 !== i) || (v1 !== i && v2 === i),
+        };
+    }),
+];
+const getInstruction = (identifiers) => {
+    const { indexEvent } = identifiers;
+    const event = events[indexEvent];
+    return `On tire deux fois à pile ou face avec une pièce de monnaie.
+Quelle est la probabilité de l'évènement "${event.str}" ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { indexEvent } = identifiers;
+    const event = events[indexEvent];
+    const arrOutcome = getCartesiansProducts([
+        [0, 1],
+        [0, 1],
+    ]);
+    const arrRealized = arrOutcome.filter(([v1, v2]) => event.isRealizingEvent(v1, v2));
+    return frac(arrRealized.length, arrOutcome.length);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).simplify().toTex();
+};
+const getHint = () => {
+    return `Tu peux dresser un tableau à deux entrées avec les différentes issues et compter combien réalisent l'évènement demandé.`;
+};
+const getCorrection = (identifiers) => {
+    const { indexEvent } = identifiers;
+    const event = events[indexEvent];
+    const fractionNode = getAnswerNode(identifiers);
+    const nbRealized = fractionNode.leftChild.evaluate();
+    const nbOutcomes = fractionNode.rightChild.evaluate();
+    const arrOutcome = getCartesiansProducts([
+        [0, 1],
+        [0, 1],
+    ]);
+    const arrStr = arrOutcome.map(([v1, v2]) => {
+        const arrStrOutcomeSmall = arrStrOutcome.map((str) => str[0]);
+        const strEventSmall = `(${arrStrOutcomeSmall[v1]};${arrStrOutcomeSmall[v2]})`;
+        return event.isRealizingEvent(v1, v2)
+            ? highlighted(strEventSmall)
+            : strEventSmall;
+    });
+    return `Dans le tableau ci-dessous, on a indiqué en vert les issues qui réalisent l'évènement "${event.str}" : 
+  
+${mdTable([
+        ["\\text{}", "\\text{Lancer 2 :} P", "\\text{Lancer 2 :} F"],
+        ["\\text{Lancer 1 : } P", arrStr[0], arrStr[2]],
+        ["\\text{Lancer 1 : } F", arrStr[1], arrStr[3]],
+    ], true)}
+
+Sur les $${nbOutcomes.frenchify()}$ issues possibles, ${nbRealized === 1 ? "une seule réalise" : `$${nbRealized}$ réalisent`} l'évènement "${event.str}".
+
+La probabilité de l'évènement "${event.str}" est donc $${fractionNode.toTex()}$.
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    [...Array(events.length).keys()].map((indexEvent) => {
+        const identifiersWrong = Object.assign({}, identifiers, { indexEvent });
+        const tex = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, tex);
+    });
+    //P=0 and P=1
+    [0, 1]
+        .map((i) => i.toTree())
+        .map((nodeProba) => {
+        tryToAddWrongProp(propositions, nodeProba.toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = getAnswerNode(identifiers);
+        return (substract(nodeAns.simplify(), nodeAnswer.simplify())
+            .simplify()
+            .evaluate() === 0);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getHeadsOrTailsTwiceProbasQuestion = () => {
+    const indexEvent = randint(0, events.length);
+    const identifiers = { indexEvent };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const headsOrTailsTwiceProbas = {
+    id: "headsOrTailsTwiceProbas",
+    label: "Calculer la probabilité d'un évènement dans une expérience à deux épreuves (Pile ou Face)",
+    isSingleStep: true,
+    generator: (nb) => [...Array(nb).keys()].map(() => getHeadsOrTailsTwiceProbasQuestion()),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -1,3 +1,6 @@
 export * from "./countIssuesTwoStepExperiment.js";
 export * from "./twoStepExperimentProbas.js";
+export * from "./headsOrTailsTwiceProbas.js";
+export * from "./headsOrTailsTwiceOutcomes.js";
+export * from "./numberPoolTwiceProbas.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/index.ts"],"names":[],"mappings":"AAAA,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC"}

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

@@ -1,2 +1,5 @@
 export * from "./countIssuesTwoStepExperiment.js";
 export * from "./twoStepExperimentProbas.js";
+export * from "./headsOrTailsTwiceProbas.js";
+export * from "./headsOrTailsTwiceOutcomes.js";
+export * from "./numberPoolTwiceProbas.js";

package/lib/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.d.ts

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

package/lib/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numberPoolTwiceProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAiB9B,KAAK,WAAW,GAAG;IAEjB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA6NF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}