math-exercises 3.0.145 → 3.0.146

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/math/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,uBAAuB,CAAC;AACtC,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qBAAqB,CAAC;AACpC,cAAc,sBAAsB,CAAC;AACrC,cAAc,qBAAqB,CAAC;AACpC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,qBAAqB,CAAC;AACpC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,oBAAoB,CAAC"}

package/lib/exercises/math/index.js

@@ -24,3 +24,4 @@ export * from "./sampling/index.js";
 export * from "./dataRepresentations/index.js";
 export * from "./tests/index.js";
 export * from "./pcExosInMath.js";
+export * from "./scratch/index.js";

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

@@ -6,4 +6,5 @@ export * from "./getMissingProbabilityValue.js";
 export * from "./mostLeastProbable.js";
 export * from "./rouletteProbas.js";
 export * from "./possibleValuesForProba.js";
+export * from "./rangeBasicProbas.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"}
+{"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"}

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

@@ -6,3 +6,4 @@ export * from "./getMissingProbabilityValue.js";
 export * from "./mostLeastProbable.js";
 export * from "./rouletteProbas.js";
 export * from "./possibleValuesForProba.js";
+export * from "./rangeBasicProbas.js";

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    min: number;
+    max: number;
+    target: number;
+    isIncluded: boolean;
+};
+export declare const rangeBasicProbas: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=rangeBasicProbas.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"rangeBasicProbas.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/basicProbas/rangeBasicProbas.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAqHF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}

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

@@ -0,0 +1,113 @@
+import { shuffleProps, tryToAddWrongProp, addValidProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getInstruction = (identifiers) => {
+    const { min, max, target, isIncluded } = identifiers;
+    return `Sur un ordinateur, on exécute un programme qui retourne au hasard 
+un nombre entier compris entre $${min.frenchify()}$ et $${max.frenchify()}$ 
+${isIncluded ? "inclus" : "exclu"}.  
+
+Quelle est la probabilité que le programme retourne $${target.frenchify()}$ ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { min, max, isIncluded } = identifiers;
+    const nbIssues = (isIncluded ? max : max - 1) - min + 1;
+    return frac(1, nbIssues);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Détermine combien de nombres différents le programme peut retourner.`;
+};
+const getCorrection = (identifiers) => {
+    const { min, max, isIncluded, target } = identifiers;
+    const nbIssues = (isIncluded ? max : max - 1) - min + 1;
+    const answerTex = getAnswer(identifiers);
+    return `Entre $${min}$ et $${max}$ ${isIncluded ? "inclus" : "exclu"}, on a les nombres $${min}$, $${min + 1}$, $${min + 2}$, ..., $${max - 2}$, $${max - 1}$${isIncluded ? `, $${max}$` : ``}.
+  
+Cela fait $${nbIssues}$ issues possibles.
+Il est sous-entendu qu'elles sont toutes équiprobables.
+La probabilité que le programme retourne le nombre $${target}$ est donc $${answerTex}$.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { min, max, isIncluded, target } = identifiers;
+    const answerNode = getAnswerNode(identifiers);
+    const nbIssues = (isIncluded ? max : max - 1) - min + 1;
+    const propositions = [];
+    addValidProp(propositions, answerNode.toTex());
+    //isIncluded
+    [+1, -1]
+        .map((offset) => nbIssues + offset)
+        .forEach((nbIssuesWrong) => {
+        const wrongNode = frac(1, nbIssuesWrong);
+        tryToAddWrongProp(propositions, wrongNode.toTex());
+    });
+    //frac{issue}{nbIssues} + terror
+    {
+        const nbIssuesTerror = nbIssues + randint(-1, 2);
+        const wrongNode = frac(target, nbIssuesTerror);
+        tryToAddWrongProp(propositions, wrongNode.toTex());
+    }
+    //frac{1}{issue}
+    {
+        if (target !== 0) {
+            const wrongNode = frac(1, target);
+            tryToAddWrongProp(propositions, wrongNode.toTex());
+        }
+        else {
+            const wrongNode = nbIssues.toTree();
+            tryToAddWrongProp(propositions, wrongNode.toTex());
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = getAnswerNode(identifiers);
+        return substract(nodeAns, nodeAnswer).simplify().evaluate() === 0;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getBallsBasicProbasQuestion = () => {
+    const min = randint(0, 31);
+    const max = randint(min + 6, min + 30);
+    const target = randint(min, max);
+    const isIncluded = coinFlip();
+    const identifiers = { min, max, target, isIncluded };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const rangeBasicProbas = {
+    id: "rangeBasicProbas",
+    connector: "=",
+    label: "Calculer la probabilité de piocher un nombre entre $a$ et $b$",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getBallsBasicProbasQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

@@ -15,4 +15,5 @@ export * from "./events/index.js";
 export * from "./basicProbas/index.js";
 export * from "./probaAsSumOfProbas.js";
 export * from "./conditionalProbaWriteFromFrench.js";
+export * from "./twoStepExperiments/index.js";
 //# sourceMappingURL=index.d.ts.map

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,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,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,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,mBAAmB,CAAC;AAClC,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,sCAAsC,CAAC;AACrD,cAAc,+BAA+B,CAAC"}

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

@@ -15,3 +15,4 @@ export * from "./events/index.js";
 export * from "./basicProbas/index.js";
 export * from "./probaAsSumOfProbas.js";
 export * from "./conditionalProbaWriteFromFrench.js";
+export * from "./twoStepExperiments/index.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"etendueTable.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/etendueTable.ts"],"names":[],"mappings":"AAIA,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;AAuGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}

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

@@ -0,0 +1,89 @@
+import { randint } from "../../../../math/utils/random/randint.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercise.js";
+import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
+const getInstruction = ({ randomValues, randomEffectives, }) => {
+    return `On considère le tableau d'effectifs suivant : 
+
+${mdTable([
+        ["Valeur", ...randomValues.map((e) => dollarize(e))],
+        ["Effectif", ...randomEffectives.map((e) => dollarize(e))],
+    ])}
+  
+Déterminer l'étendue de cette série de valeurs.`;
+};
+const getAnswer = (identifiers) => {
+    const { randomValues } = identifiers;
+    return (randomValues[randomValues.length - 1] - randomValues[0]).frenchify();
+};
+const getEtendueTable = () => {
+    const getRandomUniqueValues = (count, min, max) => {
+        const uniqueValues = new Set();
+        let counter = 0;
+        while (uniqueValues.size < count) {
+            counter++;
+            if (counter > 1000)
+                throw new Error("Too many iterations in medianWithTable");
+            uniqueValues.add(randint(min, max));
+        }
+        return Array.from(uniqueValues).sort((a, b) => a - b);
+    };
+    const randomValues = getRandomUniqueValues(5, 1, 20);
+    const randomEffectives = [1, 2, 3, 4, 5].map((_el) => randint(1, 6));
+    const sortedValues = [];
+    for (let i = 0; i < randomEffectives.length; i++)
+        for (let j = 0; j < randomEffectives[i]; j++)
+            sortedValues.push(randomValues[i]);
+    const identifiers = { randomValues, randomEffectives };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getHint = () => {
+    return `L'étendue d'une série est la différence entre la plus grande valeur et la plus petite valeur de la série.`;
+};
+const getCorrection = (identifiers) => {
+    const { randomValues } = identifiers;
+    return `La plus grande valeur de cette série est $${randomValues[randomValues.length - 1]}$ et la plus petite est $${randomValues[0]}$.
+  
+L'étendue de la série est donc $${randomValues[randomValues.length - 1] - randomValues[0]}$.
+  `;
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        style: { tableHasNoHeader: true },
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer, randomValues }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randomValues[randint(0, randomValues.length)] + "");
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const etendueTable = {
+    id: "etendueTable",
+    connector: "=",
+    label: "Calcul de l'étendue d'un tableau d'effectifs",
+    isSingleStep: false,
+    generator: (nb) => getDistinctQuestions(getEtendueTable, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -20,4 +20,5 @@ export * from "./cumulativeSum.js";
 export * from "./getQuartileProportionQuestion.js";
 export * from "./interpretIndicatorsForLists.js";
 export * from "./plausibilityOfAverage.js";
+export * from "./etendueTable.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"}
+{"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"}

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

@@ -20,3 +20,4 @@ export * from "./cumulativeSum.js";
 export * from "./getQuartileProportionQuestion.js";
 export * from "./interpretIndicatorsForLists.js";
 export * from "./plausibilityOfAverage.js";
+export * from "./etendueTable.js";

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"countIssuesTwoStepExperiment.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/twoStepExperiments/countIssuesTwoStepExperiment.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAiB9B,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AA0QF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAa9D,CAAC"}

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

@@ -0,0 +1,244 @@
+import { randint } from "../../../../math/utils/random/randint.js";
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
+import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const situations = [
+    //independent
+    //{
+    //pulls et pantalons
+    {
+        instruction: (values) => {
+            return `Coralie doit s'habiller en vitesse. 
+Elle prend un pull au hasard dans l'armoire qui en contient $${values[0]}$, tous différents. 
+Dans la commode où il y a $${values[1]}$ pantalons, tous différents également, elle en attrape un, toujours au hasard. 
+Combien cette expérience aléatoire comporte-t-elle d'issues ?`;
+        },
+        correction: (values) => {
+            return `Les issues de cette expérience sont les différentes tenues (pull;pantalon). 
+Pour un pull donné, il y a $${values[1]}$ tenues possibles car il y a $${values[1]}$ pantalons possibles.
+Or il y a $${values[0]}$ pulls. 
+Le nombre d'issues de cette expérience aléatoire est donc : 
+
+$$
+${values[0]} \\times ${values[1]} = ${(values[0] * values[1]).frenchify()}
+$$`;
+        },
+        randValues: () => {
+            return [randint(3, 10), randint(3, 10)];
+        },
+        answerValue: (values) => values[0] * values[1],
+    },
+    //magicien: carte et feutre
+    {
+        instruction: (values) => {
+            return `Un magicien demande à quelqu'un du public de choisir une carte au hasard dans un paquet de $${values[0]}$ cartes 
+et un feutre pour écrire dessus, parmi $${values[1]}$ feutres de couleurs différentes. 
+Combien cette expérience aléatoire comporte-t-elle d'issues ?`;
+        },
+        correction: (values) => {
+            return `Les issues de cette expérience sont les couples (carte;feutre). 
+Pour une carte donnée, il y a $${values[1]}$ feutres possibles.
+Or il y a $${values[0]}$ cartes. 
+Le nombre d'issues de cette expérience aléatoire est donc : 
+
+$$
+${values[0]} \\times ${values[1]} = ${(values[0] * values[1]).frenchify()}
+$$`;
+        },
+        randValues: () => {
+            return [random([32, 52]), randint(5, 11)];
+        },
+        answerValue: (values) => values[0] * values[1],
+    },
+    //article et musique: article au hasard, musique au hasard
+    {
+        instruction: (values) => {
+            return `Wassim rentre chez lui après le travail.
+Dans le métro, il demande à son téléphone de lui afficher un article de presse au hasard.
+Ce soir là, il y a $${values[0]}$ articles disponibles.
+Il lui demande aussi un morceau de musique au hasard parmi ses $${values[1]}$ morceaux favoris.
+Combien cette expérience aléatoire comporte-t-elle d'issues ?`;
+        },
+        correction: (values) => {
+            return `Les issues de cette expérience sont les couples (article;morceau). 
+Pour un article donné, il y a $${values[1]}$ morceaux possibles pour en accompagner la lecture.
+Or il y a $${values[0]}$ articles. 
+Le nombre d'issues de cette expérience aléatoire est donc : 
+
+$$
+${values[0]} \\times ${values[1]} = ${(values[0] * values[1]).frenchify()}
+$$`;
+        },
+        randValues: () => {
+            return [random([15, 50]), randint(50, 250)];
+        },
+        answerValue: (values) => values[0] * values[1],
+    },
+    //représentants au hasard: fille et garçon
+    {
+        instruction: (values) => {
+            return `Pour représenter la classe à un concours d'orthographe, on choisit au hasard une fille et garçon.
+Il y a $${values[0]}$ filles et $${values[1]}$ garçons dans la classe.
+Combien cette expérience aléatoire comporte-t-elle d'issues ?`;
+        },
+        correction: (values) => {
+            return `Les issues de cette expérience sont les binômes (fille;garçon) envoyés au concours. 
+Pour une fille donnée, il y a $${values[1]}$ garçons possibles pour l'accompagner.
+Or il y a $${values[0]}$ filles. 
+Le nombre d'issues de cette expérience aléatoire est donc : 
+
+$$
+${values[0]} \\times ${values[1]} = ${(values[0] * values[1]).frenchify()}
+$$`;
+        },
+        randValues: () => {
+            return [randint(10, 18), randint(10, 18)];
+        },
+        answerValue: (values) => values[0] * values[1],
+    },
+    //sortie restaurant: ville au hasard, restaurant au hasard
+    {
+        instruction: (values) => {
+            return `Un week-end, un couple décide de laisser le hasard décider du restaurant dans lequel ils iront manger.
+L'un des deux tire le nom d'une ville aléatoire dans une liste de $${values[0]}$ noms de villes.
+Et l'autre tire le nom d'un restaurant parmi les $${values[1]}$ meilleurs de la ville tirée précédemment.
+Combien cette expérience aléatoire comporte-t-elle d'issues ?`;
+        },
+        correction: (values) => {
+            return `Les issues de cette expérience sont les couples (ville;restaurant). 
+Pour une ville donnée, il y a $${values[1]}$ restaurants possibles.
+Or il y a $${values[0]}$ villes. 
+Le nombre d'issues de cette expérience aléatoire est donc : 
+
+$$
+${values[0]} \\times ${values[1]} = ${(values[0] * values[1]).frenchify()}
+$$`;
+        },
+        randValues: () => {
+            return [randint(5, 21), randint(3, 6)];
+        },
+        answerValue: (values) => values[0] * values[1],
+    },
+    //dnd: déX et déY
+    {
+        instruction: (values) => {
+            return `Frédéric joue à un jeu de rôle. Pour déterminer respectivement la force et la défense de son personnage, 
+il doit lancer un dé à $${values[0]}$ faces et un dé à $${values[1]}$ faces.
+Combien cette expérience aléatoire comporte-t-elle d'issues ?`;
+        },
+        correction: (values) => {
+            return `Les issues de cette expérience sont les couples (valeur du premier dé; valeur du deuxième dé). 
+Pour un résultat donné du premier dé, il y a $${values[1]}$ résultats différents possibles suite au tirage du second dé.
+Il y a $${values[0]}$ résultats possibles suite au tirage du premier dé.
+Le nombre d'issues de cette expérience aléatoire est donc : 
+
+$$
+${values[0]} \\times ${values[1]} = ${(values[0] * values[1]).frenchify()}
+$$`;
+        },
+        randValues: () => {
+            const a = random([4, 6, 10, 12, 20]);
+            const b = random([4, 6, 10, 12, 20], [a]);
+            return [a, b];
+        },
+        answerValue: (values) => values[0] * values[1],
+    },
+    //}
+];
+const getInstruction = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.instruction(values);
+};
+const getAnswerNode = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.answerValue(values).toTree();
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = () => {
+    return `Si on choisit une lettre au hasard, puis un chiffre au hasard, cela fait $26\\times 10 = 260$ issues, car il y a $26$ lettres dans l'alphabet, et pour chaque lettre on peut choisir un chiffre entre $0$ et $9$ (ce qui fait $10$ chiffres).
+  
+Tu peux appliquer ce raisonnement à la situation de l'énoncé.`;
+};
+const getCorrection = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.correction(values);
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { values } = identifiers;
+    const answerNode = getAnswerNode(identifiers);
+    const propositions = [];
+    addValidProp(propositions, answerNode.toTex());
+    //a+b
+    tryToAddWrongProp(propositions, add(values[0], values[1]).simplify().toTex());
+    //a^b
+    tryToAddWrongProp(propositions, power(values[0], values[1]).simplify().toTex());
+    //b^a
+    tryToAddWrongProp(propositions, power(values[1], values[0]).simplify().toTex());
+    //a
+    tryToAddWrongProp(propositions, values[0].frenchify());
+    //frac{1}{nbIssues} (student has not read the question)
+    {
+        const nbIssues = random([
+            answerNode,
+            add(values[0], values[1]),
+            power(values[0], values[1]),
+            power(values[1], values[0]),
+        ]);
+        const wrongNode = frac(1, nbIssues);
+        tryToAddWrongProp(propositions, wrongNode.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = getAnswerNode(identifiers);
+        return substract(nodeAns, nodeAnswer).simplify().evaluate() === 0;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCountIssuesTwoStepExperimentQuestion = () => {
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const values = situation.randValues();
+    const identifiers = { situationIndex, values };
+    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 countIssuesTwoStepExperiment = {
+    id: "countIssuesTwoStepExperiment",
+    label: "Compter le nombre d'issues d'une expérience à deux épreuves",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getCountIssuesTwoStepExperimentQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

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

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

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

@@ -0,0 +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"}

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

@@ -0,0 +1,2 @@
+export * from "./countIssuesTwoStepExperiment.js";
+export * from "./twoStepExperimentProbas.js";

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

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

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

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