math-exercises 3.0.75 → 3.0.77

package/lib/exercises/math/probaStat/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/getComplementaryProbability.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"getComplementaryProbability.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/getComplementaryProbability.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;CACZ,CAAC;AAiFF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAoB7D,CAAC"}

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

@@ -0,0 +1,90 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { round } from "../../../math/utils/round.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const wrongVal = randfloat(0.1, 0.95, 2);
+        tryToAddWrongProp(propositions, wrongVal.frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = ({ pA }) => {
+    return round(1 - pA, 2).frenchify();
+};
+const getInstruction = ({ pA }) => {
+    return `Soit $A$ un événement tel que $P(A) = ${pA.frenchify()}$. 
+  
+Que vaut la probabilité $P(\\overline A)$ ?`;
+};
+const getHint = () => {
+    return `La probabilité de l'évènement complémentaire $\\overline{A}$ s'obtient par la formule :
+  
+$$
+P(\\overline A) = 1 - P(A)
+$$`;
+};
+const getCorrection = ({ pA }) => {
+    const answer = getAnswer({ pA });
+    return `La probabilité de l'évènement complémentaire $\\overline{A}$ s'obtient par la formule :
+  
+$$
+P(\\overline A) = 1 - P(A)
+$$
+
+Ici, on a donc : 
+
+$$
+P(\\overline A) = 1 - ${pA.frenchify()} = ${answer}
+$$`;
+};
+const getKeys = () => {
+    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 getGetComplementaryProbabilityQuestion = () => {
+    const pA = randfloat(0.1, 0.99, 2);
+    const identifiers = { pA };
+    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 getComplementaryProbability = {
+    id: "getComplementaryProbability",
+    label: "Calculer la probabilité d'un évènement complémentaire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGetComplementaryProbabilityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"getMissingProbabilityValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/getMissingProbabilityValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAiHF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAiB5D,CAAC"}

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

@@ -0,0 +1,109 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { round } from "../../../math/utils/round.js";
+import { dollarize } from "../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../utils/markdown/mdTable.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+const getPropositions = (n, { answer }) => {
+    const props = [];
+    addValidProp(props, answer);
+    while (props.length < n) {
+        const numeric = answer.unfrenchify();
+        const offset = randfloat(-0.2, 0.2, 2);
+        const candidate = round(numeric + offset, 2).frenchify();
+        tryToAddWrongProp(props, candidate);
+    }
+    return shuffleProps(props, n);
+};
+const getAnswer = ({ pValues, missingIndex }) => {
+    return pValues[missingIndex].frenchify();
+};
+const getInstruction = ({ labels, pValues, missingIndex, }) => {
+    return `Quelle est la valeur manquante dans la loi de probabilité suivante ?
+
+${mdTable([
+        ["Issue", ...labels.map((l) => dollarize(l))],
+        [
+            "Probabilité",
+            ...pValues.map((p, i) => i === missingIndex ? "..." : dollarize(p.frenchify())),
+        ],
+    ])}`;
+};
+const getHint = () => {
+    return `La somme des probabilités d'une loi de probabilité est égale à $1$.`;
+};
+const getCorrection = ({ labels, pValues, missingIndex, }) => {
+    const knownTerms = labels
+        .map((l, i) => (i === missingIndex ? null : pValues[i].frenchify()))
+        .filter(Boolean)
+        .join("+");
+    const sumKnown = round(pValues.filter((_, i) => i !== missingIndex).reduce((s, v) => s + v, 0), 2);
+    const missing = round(1 - sumKnown, 2);
+    return `
+On additionne les probabilités connues :
+
+$$
+${knownTerms} = ${sumKnown.frenchify()}
+$$
+
+Puisque la somme des probabilités d'une loi de probabilité vaut $1$, on peut en déduire la probabilité manquante : 
+
+
+$$
+P(${labels[missingIndex]}) = 1 - ${sumKnown.frenchify()} = ${missing.frenchify()}.
+$$
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const a = parseAlgebraic(ans);
+        const b = parseAlgebraic(answer);
+        return a.simplify().equals(b.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGetMissingProbabilityValueQuestion = () => {
+    const labels = ["A", "B", "C", "D", "E"];
+    const raw = labels.map(() => Math.random());
+    const total = raw.reduce((s, v) => s + v, 0);
+    let pValues = raw.map((v) => round(v / total, 2));
+    // ajustement pour que la somme fasse exactement 1
+    const sumRounded = pValues.reduce((s, v) => s + v, 0);
+    const diff = round(1 - sumRounded, 2);
+    pValues[pValues.length - 1] = round(pValues[pValues.length - 1] + diff, 2);
+    const missingIndex = Math.floor(Math.random() * labels.length);
+    return getQuestionFromIdentifiers({ labels, pValues, missingIndex });
+};
+const getQuestionFromIdentifiers = (identifiers) => ({
+    answer: getAnswer(identifiers),
+    instruction: getInstruction(identifiers),
+    keys: getKeys(identifiers),
+    answerFormat: "tex",
+    identifiers,
+    hint: getHint(identifiers),
+    correction: getCorrection(identifiers),
+});
+export const getMissingProbabilityValue = {
+    id: "getMissingProbabilityValue",
+    label: "Calculer une valeur manquante dans une loi de probabilité",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGetMissingProbabilityValueQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -12,4 +12,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";
 //# 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,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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/index.ts"],"names":[],"mappings":"AAAA,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"}

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

@@ -12,3 +12,7 @@ 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";

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

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

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

@@ -149,7 +149,7 @@ const getCorrection = (identifiers) => {
                     : event === "P(\\overline A)"
                         ? "\\overline{A}"
                         : "\\overline{B}";
-            return `On lit le total de la ligne $${singleEvnmt}$ : c'est $${probaFrac[0]}$. La probabilité $${event}$ vaut donc : 
+            return `On lit le total de la ${singleEvnmt.includes("A") ? "ligne" : "colonne"} $${singleEvnmt}$ : c'est $${probaFrac[0]}$. La probabilité $${event}$ vaut donc : 
           
 $$
 ${event} = ${frac(probaFrac[0], probaFrac[1]).toSimplificationTex()}

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

@@ -2,6 +2,7 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercis
 import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
 import { Rational } from "../../../math/numbers/rationals/rational.js";
 import { randint } from "../../../math/utils/random/randint.js";
+import { frac } from "../../../tree/nodes/operators/fractionNode.js";
 import { rationalParser } from "../../../tree/parsers/rationalParser.js";
 import { random } from "../../../utils/alea/random.js";
 import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
@@ -145,133 +146,92 @@ const isAnswerValid = (ans, { answer, probaFrac }, options) => {
         return handleVEAError(err);
     }
 };
-// const getHint: GetHint<Identifiers> = (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.`;
-//     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.`;
-//     case "intersection":
-//     default:
-//       return `Lit la case qui correspond aux issues appartenant à la fois aux deux événements demandés.`;
-//   }
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   const {
-//     aBarreCapB,
-//     aBarreCapBBarre,
-//     aCapB,
-//     aCapBBarre,
-//     probaFrac,
-//     type,
-//     event,
-//   } = identifiers;
-//   const aTotal = aCapB + aCapBBarre;
-//   const bTotal = aCapB + aBarreCapB;
-//   const aBarreTotal = aBarreCapB + aBarreCapBBarre;
-//   const bBarreTotal = aBarreCapBBarre + aCapBBarre;
-//   switch (type) {
-//     case "singleEvent":
-//       const singleEvnmt =
-//         event === "P(A)"
-//           ? "A"
-//           : event === "P(B)"
-//           ? "B"
-//           : event === "P(\\overline A)"
-//           ? "\\overline{A}"
-//           : "\\overline{B}";
-//       return `On lit le total de la ligne $${singleEvnmt}$ : c'est $${
-//         probaFrac[0]
-//       }$. La probabilité $${event}$ vaut donc :
-// $$
-// ${event} = ${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]}
-//       $.
-// La probabilité $${event}$ vaut donc :
-// $$
-// ${event} = ${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 :
-// $$
-// ${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()}
-// $$`;
-//   }
-// };
+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.`;
+        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.`;
+        case "intersection":
+        default:
+            return `Lit la case qui correspond aux issues appartenant à la fois aux deux événements demandés.`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre, probaFrac, type, event, } = identifiers;
+    const aTotal = aCapB + aCapBBarre;
+    const bTotal = aCapB + aBarreCapB;
+    const aBarreTotal = aBarreCapB + aBarreCapBBarre;
+    const bBarreTotal = aBarreCapBBarre + aCapBBarre;
+    switch (type) {
+        case "singleEvent":
+            const singleEvnmt = event === "une fille"
+                ? "A"
+                : event === "un garçon"
+                    ? "\\overline{A}"
+                    : 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 :
+
+$$
+${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]}
+      $.
+
+La probabilité $${event}$ vaut donc :
+
+$$
+${event} = ${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 :
+
+$$
+${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()}
+$$`;
+    }
+};
 export const probaFromTableWithContext = {
     id: "probaFromTableWithContext",
     connector: "=",

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    pA: number;
+    pB: number;
+    pUnion: number;
+    pIntersection: number;
+    target: "pA" | "pB" | "pUnion" | "pIntersection";
+};
+export declare const unionIntersectionProba: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=unionIntersectionProba.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unionIntersectionProba.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/unionIntersectionProba.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,IAAI,GAAG,IAAI,GAAG,QAAQ,GAAG,eAAe,CAAC;CAClD,CAAC;AAsKF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAkBxD,CAAC"}