math-exercises 3.0.76 → 3.0.78

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,10 @@ 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";
 //# 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;AAClD,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC"}

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

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

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+export type Identifiers = {
+    numericValues: NodeIdentifiers[];
+    isMax: boolean;
+};
+export declare const mostLeastProbable: Exercise<Identifiers>;
+//# sourceMappingURL=mostLeastProbable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mostLeastProbable.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/mostLeastProbable.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAM7C,MAAM,MAAM,WAAW,GAAG;IACxB,aAAa,EAAE,eAAe,EAAE,CAAC;IACjC,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA2HF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAkBnD,CAAC"}

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

@@ -0,0 +1,114 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { RationalConstructor } from "../../../math/numbers/rationals/rational.js";
+import { randfloat } from "../../../math/utils/random/randfloat.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { reifyAlgebraic, } from "../../../tree/nodes/nodeConstructor.js";
+import { round } from "../../../math/utils/round.js";
+import { approxOrEqual } from "../../../utils/latex/approxOrEqual.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+const getPropositions = (n, { answer }) => {
+    const allLabels = ["J", "R", "V"];
+    const props = [];
+    addValidProp(props, answer);
+    for (const label of allLabels) {
+        tryToAddWrongProp(props, label);
+    }
+    return shuffleProps(props, n);
+};
+const getAnswer = ({ numericValues, isMax }) => {
+    const numericValuesParsed = numericValues.map((v) => reifyAlgebraic(v).evaluate());
+    const targetValue = isMax
+        ? Math.max(...numericValuesParsed)
+        : Math.min(...numericValuesParsed);
+    const index = numericValuesParsed.indexOf(targetValue);
+    return ["J", "R", "V"][index];
+};
+const getInstruction = ({ numericValues, isMax, }) => {
+    const labels = ["$J$", "$R$", "$V$"];
+    const displayValues = numericValues.map((v, i) => {
+        if (labels[i] === "$R$") {
+            const pct = round(reifyAlgebraic(v).evaluate() * 100, 6);
+            return `${pct.frenchify()}\\%`;
+        }
+        else {
+            return reifyAlgebraic(v).toTex();
+        }
+    });
+    const header = `Une expérience aléatoire a trois issues : ${labels.join(", ")}.
+  
+Leurs probabilités sont respectivement $${displayValues[0]}$ , $${displayValues[1]}$ et $${displayValues[2]}$.\n\n`;
+    return header + `Quelle issue est la ${isMax ? "plus" : "moins"} probable ?`;
+};
+const getHint = () => {
+    return "Convertis les probabilités dans le même format pour les comparer.";
+};
+const getCorrection = ({ numericValues, isMax, }) => {
+    const fraction = reifyAlgebraic(numericValues[0]);
+    const percent = reifyAlgebraic(numericValues[1]);
+    const evaluatedValues = numericValues.map((v) => round(reifyAlgebraic(v).evaluate(), 2));
+    const sortedAsc = [...evaluatedValues].sort((a, b) => a - b);
+    const target = isMax ? "plus" : "moins";
+    const result = getAnswer({ numericValues, isMax });
+    return `On convertit le pourcentage et la fraction en nombres décimaux (éventuellement avec une valeur approchée) pour pouvoir les comparer : 
+  
+- $${fraction.toTex()} ${approxOrEqual(fraction.evaluate(), 2).join("")}$
+
+- $${multiply(percent, 100).simplify().toTex()}\\% = ${percent.toTex()}$
+
+Puisque $${sortedAsc
+        .map((e) => e.frenchify())
+        .join("\\leq")}$, l'issue la ${target} probable est donc $${result}$.`;
+};
+const getKeys = () => [];
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans.trim() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getMostLeastProbableQuestion = (opts) => {
+    let numericValues = [];
+    do {
+        numericValues = [
+            RationalConstructor.randomIrreductibleProba().toTree(),
+            randfloat(0.1, 0.9, 2).toTree(),
+            randfloat(0.1, 0.9, 2).toTree(),
+        ];
+    } while (numericValues.some((e, i) => numericValues.some((e2, i2) => i2 !== i && round(e2.evaluate(), 2) === round(e.evaluate(), 2))));
+    const isMax = coinFlip();
+    return getQuestionFromIdentifiers({
+        numericValues: numericValues.map((e) => e.toIdentifiers()),
+        isMax,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => ({
+    answer: getAnswer(identifiers),
+    instruction: getInstruction(identifiers),
+    keys: getKeys(identifiers),
+    answerFormat: "tex",
+    identifiers,
+    hint: getHint(identifiers),
+    correction: getCorrection(identifiers),
+});
+export const mostLeastProbable = {
+    id: "mostLeastProbable",
+    label: "Identifier l'issue la plus ou la moins probable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMostLeastProbableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

@@ -0,0 +1,164 @@
+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";
+import { random } from "../../../utils/alea/random.js";
+import { alignTex } from "../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    while (propositions.length < n) {
+        const offset = randfloat(-0.2, 0.2, 2);
+        const wrongVal = answer.unfrenchify() + offset;
+        tryToAddWrongProp(propositions, round(wrongVal, 2).frenchify());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = ({ pA, pB, pUnion, pIntersection, target, }) => {
+    let result;
+    switch (target) {
+        case "pA":
+            result = pUnion + pIntersection - pB;
+            break;
+        case "pB":
+            result = pUnion + pIntersection - pA;
+            break;
+        case "pUnion":
+            result = pA + pB - pIntersection;
+            break;
+        case "pIntersection":
+            result = pA + pB - pUnion;
+            break;
+    }
+    return round(result, 2).frenchify();
+};
+const getInstruction = ({ pA, pB, pUnion, pIntersection, target, }) => {
+    const vals = {
+        pA: pA.frenchify(),
+        pB: pB.frenchify(),
+        pUnion: pUnion.frenchify(),
+        pIntersection: pIntersection.frenchify(),
+    };
+    let instruction = `Soit $A$ et $B$ deux événements tels que :\n\n`;
+    const texts = {
+        pA: `$P(B)=${vals.pB}$, $P(A\\cup B)=${vals.pUnion}$ et $P(A\\cap B)=${vals.pIntersection}$.\n\n Calculer $P(A)$.`,
+        pB: `$P(A)=${vals.pA}$, $P(A\\cup B)=${vals.pUnion}$ et $P(A\\cap B)=${vals.pIntersection}$.\n\n Calculer $P(B)$.`,
+        pUnion: `$P(A)=${vals.pA}$, $P(B)=${vals.pB}$ et $P(A\\cap B)=${vals.pIntersection}$.\n\n Calculer $P(A\\cup B)$.`,
+        pIntersection: `$P(A)=${vals.pA}$, $P(B)=${vals.pB}$ et $P(A\\cup B)=${vals.pUnion}$.\n\n Calculer $P(A\\cap B)$.`,
+    };
+    return instruction + texts[target];
+};
+const getHint = ({ target }) => {
+    return `Utilise la formule : 
+  
+$$
+P(A \\cup B) = P(A) + P(B) - P(A \\cap B)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { pA, pB, pUnion, pIntersection, target } = identifiers;
+    const fmt = {
+        pA: pA.frenchify(),
+        pB: pB.frenchify(),
+        pUnion: pUnion.frenchify(),
+        pIntersection: pIntersection.frenchify(),
+    };
+    let explanation = `On utilise la formule : 
+  
+$$
+P(A \\cup B) = P(A) + P(B) - P(A \\cap B)
+$$
+
+Ici on a donc : \n `;
+    switch (target) {
+        case "pA":
+            explanation += `
+${alignTex([
+                ["P(A)", "=", "P(A\\cup B) + P(A\\cap B) - P(B)"],
+                ["", "=", `${fmt.pUnion} + ${fmt.pIntersection} - ${fmt.pB}`],
+                ["", "=", getAnswer(identifiers)],
+            ])}`;
+            break;
+        case "pB":
+            explanation += `
+${alignTex([
+                ["P(B)", "=", "P(A\\cup B) + P(A\\cap B) - P(A)"],
+                ["", "=", `${fmt.pUnion} + ${fmt.pIntersection} - ${fmt.pA}`],
+                ["", "=", getAnswer(identifiers)],
+            ])}`;
+            break;
+        case "pUnion":
+            explanation += `
+${alignTex([
+                ["P(A\\cup B)", "=", "P(A) + P(B) - P(A\\cap B)"],
+                ["", "=", `${fmt.pA} + ${fmt.pB} - ${fmt.pIntersection}`],
+                ["", "=", getAnswer(identifiers)],
+            ])}`;
+            break;
+        case "pIntersection":
+            explanation += `
+${alignTex([
+                ["P(A\\cap B)", "=", "P(A) + P(B) - P(A\\cup B)"],
+                ["", "=", `${fmt.pA} + ${fmt.pB} - ${fmt.pUnion}`],
+                ["", "=", getAnswer(identifiers)],
+            ])}`;
+            break;
+    }
+    return explanation;
+};
+const getKeys = () => [];
+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 getUnionIntersectionProbaQuestion = (ops) => {
+    const pA = randfloat(0.1, 0.8, 2);
+    const pB = randfloat(0.1, 0.8, 2);
+    const maxIntersection = Math.min(pA, pB);
+    const minIntersection = Math.max(0, round(pA + pB - 1, 2));
+    const pIntersection = randfloat(minIntersection, maxIntersection, 2);
+    const pUnion = round(pA + pB - pIntersection, 2);
+    const targets = [
+        "pA",
+        "pB",
+        "pUnion",
+        "pIntersection",
+    ];
+    const target = random(targets);
+    const identifiers = { pA, pB, pUnion, pIntersection, target };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => ({
+    answer: getAnswer(identifiers),
+    instruction: getInstruction(identifiers),
+    keys: getKeys(identifiers),
+    answerFormat: "tex",
+    identifiers,
+    hint: getHint(identifiers),
+    correction: getCorrection(identifiers),
+});
+export const unionIntersectionProba = {
+    id: "unionIntersectionProba",
+    label: "Calculer une probabilité via les formules de l’union et de l’intersection",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getUnionIntersectionProbaQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/python/conditionIfElifElse.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    opName: string;
+};
+export declare const conditionIfElifElse: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=conditionIfElifElse.d.ts.map

package/lib/exercises/math/python/conditionIfElifElse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditionIfElifElse.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/conditionIfElifElse.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AA+HF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}