math-exercises 3.0.180 → 3.0.182

package/lib/exercises/math/probaStat/independancy/independancyFromEffectifTable.js

@@ -0,0 +1,154 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } 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 { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    ["Oui", "Non", "On ne peut pas savoir"].forEach((prop) => tryToAddWrongProp(propositions, prop, "raw"));
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre } = identifiers;
+    return aCapB * aBarreCapBBarre === aCapBBarre * aBarreCapB ? "Oui" : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre } = identifiers;
+    const total = aBarreCapB + aBarreCapBBarre + aCapB + aCapBBarre;
+    const aTotal = aCapB + aCapBBarre;
+    const bTotal = aCapB + aBarreCapB;
+    const aBarreTotal = aBarreCapB + aBarreCapBBarre;
+    const bBarreTotal = aBarreCapBBarre + aCapBBarre;
+    return `On considère deux événements $A$ et $B$. 
+  
+Le tableau suivant donne le nombre d'issues pour chacun des événements $A\\cap B$, $\\overline A\\cap B$, $A\\cap \\overline B$ et $\\overline A \\cap \\overline B$. 
+      
+${mdTable([
+        [" ", "$B$", "$\\overline{B}$", "Total"],
+        ["$A$", dollarize(aCapB), `$${aCapBBarre}$`, `$${aTotal}$`],
+        [
+            "$\\overline{A}$",
+            dollarize(aBarreCapB),
+            dollarize(aBarreCapBBarre),
+            dollarize(aBarreTotal),
+        ],
+        ["Total", dollarize(bTotal), dollarize(bBarreTotal), dollarize(total)],
+    ])}
+
+Les événements $A$ et $B$ sont-ils indépendants ?
+  `;
+};
+const getHint = () => {
+    return `Deux évènements $A$ et $B$ sont indépendants lorsque :
+  
+  
+$$
+P(A\\cap B) = P(A)\\times P(B)
+$$
+
+Une autre façon de vérifier si deux évènements sont indépendants utilise les probabilités conditionnelles : $A$ et $B$ sont indépendants si et seulement si :
+
+$$
+P_B(A) = P(A)
+$$
+
+Choisis une de ces deux méthodes, puis vérifie si l'égalité est vraie.`;
+};
+const getCorrection = (identifiers) => {
+    const { aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre } = identifiers;
+    const total = aBarreCapB + aBarreCapBBarre + aCapB + aCapBBarre;
+    const aTotal = aCapB + aCapBBarre;
+    const bTotal = aCapB + aBarreCapB;
+    const pA = frac(aTotal, total);
+    const pB = frac(bTotal, total);
+    const pANB = frac(aCapB, total);
+    const isInde = getAnswer(identifiers) === "Oui";
+    return `On vérifie si $P(A\\cap B) = P(A)\\times P(B)$.
+  
+On a : 
+
+$$
+P(A\\cap B) = ${pANB.toSimplificationTex()}
+$$
+
+$$
+P(A) = ${pA.toSimplificationTex()}
+$$
+
+$$
+P(B) = ${pB.toSimplificationTex()}
+$$
+
+donc :
+
+$$
+P(A) \\times P(B) = ${multiply(pA.simplify(), pB.simplify()).toSimplificationTex()}
+$$
+
+Puisque $P(A\\cap B) ${isInde ? "=" : "\\neq"} P(A)\\times P(B)$, les évènements $A$ et $B$ ${isInde ? "sont" : "ne sont pas"} indépendants.`;
+};
+const getIndependancyFromEffectifTableQuestion = () => {
+    const isInde = coinFlip();
+    let aCapB;
+    let aCapBBarre;
+    let aBarreCapB;
+    let aBarreCapBBarre;
+    if (isInde) {
+        const r = randint(1, 7);
+        const u = randint(1, 7, [r]);
+        const s = randint(1, 7);
+        const t = randint(1, 7, [s]);
+        console.log(r, u, s, t);
+        aCapB = r * s;
+        aCapBBarre = r * t;
+        aBarreCapB = u * s;
+        aBarreCapBBarre = u * t;
+    }
+    else {
+        do {
+            aCapB = randint(1, 20);
+            aCapBBarre = randint(1, 20, [aCapB]);
+            aBarreCapB = randint(1, 20, [aCapB, aCapBBarre]);
+            aBarreCapBBarre = randint(1, 20, [aCapB, aCapBBarre, aBarreCapB]);
+        } while (aCapB * aBarreCapBBarre === aCapBBarre * aBarreCapB);
+    }
+    const identifiers = {
+        aBarreCapB,
+        aBarreCapBBarre,
+        aCapB,
+        aCapBBarre,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const independancyFromEffectifTable = {
+    id: "independancyFromEffectifTable",
+    label: "Déterminer si deux évènements sont indépendants à partir d'un tableau d'effectifs",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIndependancyFromEffectifTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/independancy/independancyFromProbaTree.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    pAIds: NodeIdentifiers;
+    p_ABIds: NodeIdentifiers;
+    p_ABarreBIds: NodeIdentifiers;
+};
+export declare const independancyFromProbaTree: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=independancyFromProbaTree.d.ts.map

package/lib/exercises/math/probaStat/independancy/independancyFromProbaTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"independancyFromProbaTree.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/independancyFromProbaTree.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,eAAe,CAAC;IACvB,OAAO,EAAE,eAAe,CAAC;IACzB,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AAoJF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAiB3D,CAAC"}

package/lib/exercises/math/probaStat/independancy/independancyFromProbaTree.js

@@ -0,0 +1,152 @@
+/* eslint-disable @typescript-eslint/naming-convention */
+import { addValidProp, shuffleProps, tryToAddWrongProp, } 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 { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    ["Oui", "Non", "On ne peut pas savoir"].forEach((prop) => tryToAddWrongProp(propositions, prop, "raw"));
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { p_ABIds, p_ABarreBIds } = identifiers;
+    const p_AB = reifyAlgebraic(p_ABIds);
+    const p_ABarreB = reifyAlgebraic(p_ABarreBIds);
+    return p_AB.simplify().toTex() === p_ABarreB.simplify().toTex()
+        ? "Oui"
+        : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { pAIds, p_ABIds, p_ABarreBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const pABarre = substract(1, pA).simplify();
+    const p_AB = reifyAlgebraic(p_ABIds);
+    const p_ABBarre = substract(1, p_AB).simplify();
+    const p_ABarreB = reifyAlgebraic(p_ABarreBIds);
+    const p_ABarreBBarre = substract(1, p_ABarreB).simplify();
+    const tree = [
+        [
+            [
+                [`£${pA.toTex()}£`, "£A£"],
+                [`£${pABarre.toTex()}£`, "£\\overline{A}£"],
+            ],
+        ],
+        [
+            [
+                [`£${p_AB.toTex()}£`, "£B£"],
+                [`£${p_ABBarre.toTex()}£`, "£\\overline{B}£"],
+            ],
+            [
+                [`£${p_ABarreB.toTex()}£`, "£B£"],
+                [`£${p_ABarreBBarre.toTex()}£`, "£\\overline{B}£"],
+            ],
+        ],
+    ];
+    return `On considère l'arbre de probabilités ci-dessous :
+  
+<svg id="treeDiagram">${JSON.stringify(tree)}</svg>
+
+Les événements $A$ et $B$ sont-ils indépendants ?`;
+};
+const getHint = () => {
+    return `Deux évènements $A$ et $B$ sont indépendants lorsque :
+  
+  
+$$
+P(A\\cap B) = P(A)\\times P(B)
+$$
+
+Une autre façon de vérifier si deux évènements sont indépendants utilise les probabilités conditionnelles : $A$ et $B$ sont indépendants si et seulement si :
+
+$$
+P_A(B) = P(B)
+$$
+
+Choisis une de ces deux méthodes, puis vérifie si l'égalité est vraie.`;
+};
+const getCorrection = (identifiers) => {
+    const { pAIds, p_ABIds, p_ABarreBIds } = identifiers;
+    const pA = reifyAlgebraic(pAIds);
+    const p_AB = reifyAlgebraic(p_ABIds);
+    const p_ABarreB = reifyAlgebraic(p_ABarreBIds);
+    const pB = add(multiply(pA, p_AB), multiply(substract(1, pA), p_ABarreB));
+    const isInde = p_AB.simplify().toTex() === pB.simplify().toTex();
+    return `Deux évènements $A$ et $B$ sont indépendants si et seulement si :
+  
+$$
+P_A(B) = P(B)
+$$
+
+Ici, $P_A(B)$ se lit dans l'arbre : 
+
+$$
+P_A(B) = ${p_AB.simplify().toTex()}
+$$
+
+Il reste donc à calculer $P(B)$, en utilisant la formule des probabilités totales : 
+
+${alignTex([
+        ["P(B)", "=", "P(A\\cap B)+P(\\overline{A}\\cap B)"],
+        ["", "=", pB.toTex()],
+        ["", "=", pB.simplify().toTex()],
+    ])}
+
+Puisque $P_A(B) ${isInde ? "=" : "\\neq"} P(B)$, les évènements $A$ et $B$ ${isInde ? "sont" : "ne sont pas"} indépendants.
+
+
+**Remarque** : en fait, on peut voir directement si $A$ et $B$ sont indépendants ou non, en comparant $P_A(B)$ et $P_{\\overline{A}}(B)$. En effet, ces deux probabilités sont égales si et seulement si $A$ et $B$ sont indépendants. L'idée est que si $A$ et $B$ sont indépendants, le fait que $A$ soit réalisé ou non ne change pas la probabilité de $B$. 
+`;
+};
+const getIndependancyFromProbaTreeQuestion = () => {
+    const getProba = (isFrac = false) => {
+        return isFrac
+            ? RationalConstructor.randomIrreductibleProba().toTree()
+            : randfloat(0.1, 0.91, 1).toTree();
+    };
+    const isInde = coinFlip();
+    const isFrac = coinFlip();
+    const pAIds = getProba(isFrac);
+    const p_ABIds = getProba(isFrac);
+    const p_ABarreBIds = isInde ? p_ABIds : getProba(isFrac);
+    const identifiers = {
+        p_ABarreBIds: p_ABarreBIds.toIdentifiers(),
+        p_ABIds: p_ABIds.toIdentifiers(),
+        pAIds: pAIds.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const independancyFromProbaTree = {
+    id: "independancyFromProbaTree",
+    label: "Déterminer si deux évènements sont indépendants à partir d'un arbre",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIndependancyFromProbaTreeQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -2,4 +2,6 @@ export * from "./independancy.js";
 export * from "./isIndependantFromDefinition.js";
 export * from "./independancyFindCap.js";
 export * from "./independancyFindCup.js";
+export * from "./independancyFromEffectifTable.js";
+export * from "./independancyFromProbaTree.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/independancy/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kCAAkC,CAAC;AACjD,cAAc,0BAA0B,CAAC;AACzC,cAAc,0BAA0B,CAAC;AACzC,cAAc,oCAAoC,CAAC;AACnD,cAAc,gCAAgC,CAAC"}

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

@@ -2,3 +2,5 @@ export * from "./independancy.js";
 export * from "./isIndependantFromDefinition.js";
 export * from "./independancyFindCap.js";
 export * from "./independancyFindCup.js";
+export * from "./independancyFromEffectifTable.js";
+export * from "./independancyFromProbaTree.js";

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

@@ -1,2 +1,5 @@
-export { probabilityTree, } from "./probabilityTree.js";
+export { probabilityTree, probabilityTreeIntersection, probabilityTreeTotalProbability, probabilityTreeReadProbability, probabilityTreeInversionProbability, } from "./probabilityTreeV2.js";
+export * from "./fillProbaTreeWithComplementaryProbabilities.js";
+export * from "./buildTreeFromSituation.js";
+export * from "./probaTreeSituationTotalProbaFormula.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,GAKhB,MAAM,sBAAsB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/index.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,eAAe,EACf,2BAA2B,EAC3B,+BAA+B,EAC/B,8BAA8B,EAC9B,mCAAmC,GACpC,MAAM,wBAAwB,CAAC;AAChC,cAAc,kDAAkD,CAAC;AACjE,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0CAA0C,CAAC"}

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

@@ -1,10 +1,6 @@
 // export * from "./treeInInstruction.js";
 // export * from "./treeInAnswer.js";
-export { probabilityTree,
-// probabilityTreeIntersection,
-// probabilityTreeTotalProbability,
-// probabilityTreeReadProbability,
-// probabilityTreeInversionProbability,
- } from "./probabilityTree.js";
-// export * from "./fillProbaTreeWithComplementaryProbabilities.js";
-// export * from "./buildTreeFromSituation.js";
+export { probabilityTree, probabilityTreeIntersection, probabilityTreeTotalProbability, probabilityTreeReadProbability, probabilityTreeInversionProbability, } from "./probabilityTreeV2.js";
+export * from "./fillProbaTreeWithComplementaryProbabilities.js";
+export * from "./buildTreeFromSituation.js";
+export * from "./probaTreeSituationTotalProbaFormula.js";

package/lib/exercises/math/probaStat/trees/probaTreeSituationTotalProbaFormula.d.ts

@@ -1,2 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { ProbaTreeSituationParams } from "./probaTreeSituations.js";
+type Identifiers = {
+    params: ProbaTreeSituationParams;
+};
+export declare const probaTreeSituationTotalProbaFormula: Exercise<Identifiers>;
 export {};
 //# sourceMappingURL=probaTreeSituationTotalProbaFormula.d.ts.map

package/lib/exercises/math/probaStat/trees/probaTreeSituationTotalProbaFormula.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"probaTreeSituationTotalProbaFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/probaTreeSituationTotalProbaFormula.ts"],"names":[],"mappings":""}
+{"version":3,"file":"probaTreeSituationTotalProbaFormula.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/trees/probaTreeSituationTotalProbaFormula.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,OAAO,EAGL,wBAAwB,EACzB,MAAM,0BAA0B,CAAC;AAElC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,wBAAwB,CAAC;CAClC,CAAC;AA2HF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAqBrE,CAAC"}

package/lib/exercises/math/probaStat/trees/probaTreeSituationTotalProbaFormula.js

@@ -1,80 +1,125 @@
-// import {
-//   Exercise,
-//   Proposition,
-//   QCMGenerator,
-//   Question,
-//   QuestionGenerator,
-//   VEA,
-//   addValidProp,
-//   shuffleProps,
-//   GetAnswer,
-//   GetHint,
-//   GetCorrection,
-//   GetInstruction,
-//   GetKeys,
-//   GetQuestionFromIdentifiers,
-// } from '../../../../exercises/exercise.js';
-// import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions.js';
-// import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
-export {};
-// type Identifiers = {
-// };
-// const getPropositions: QCMGenerator<Identifiers> = (n, { answer }) => {
-//   const propositions: Proposition[] = [];
-//   addValidProp(propositions, answer);
-//   propWhile(propositions, n, () => {
-//     throw Error("QCM not implemented")
-//   })
-//   return shuffleProps(propositions, n);
-// };
-// const getAnswer : GetAnswer<Identifiers> = (identifiers)=>{
-// }
-// const getInstruction : GetInstruction<Identifiers> = (identifiers)=>{
-// }
-// const getHint : GetHint<Identifiers> = (identifiers)=>{
-// }
-// const getCorrection : GetCorrection<Identifiers> = (identifiers)=>{
-// }
-// const getKeys : GetKeys<Identifiers> = (identifiers)=>{
-//   return []
-// }
-// const isAnswerValid: VEA<Identifiers> = (ans, {answer})=>{
-//   try {
-//     throw Error("VEA not implemented")
-//   } catch(err){
-//     return handleVEAError(err)
-//   }
-// }
-// const getProbaTreeSituationTotalProbaFormulaQuestion: QuestionGenerator<Identifiers>  = (ops)=>{
-//   const identifiers: Identifiers = {}
-//   return getQuestionFromIdentifiers(identifiers);
-// }
-// const getQuestionFromIdentifiers: GetQuestionFromIdentifiers<Identifiers> = (identifiers)=>{
-//   return {
-//     answer: getAnswer(identifiers),
-//     instruction: getInstruction(identifiers),
-//     keys: getKeys(identifiers),
-//     answerFormat: 'tex',
-//     identifiers,
-//     hint: getHint(identifiers),
-//     correction: getCorrection(identifiers)
-//   }
-// }
-// export const probaTreeSituationTotalProbaFormula: Exercise<Identifiers> = {
-//   id: 'probaTreeSituationTotalProbaFormula',
-//   connector: "",
-//   label: undefined,
-//   isSingleStep: true,
-//   generator: (nb, opts) => getDistinctQuestions(()=>getProbaTreeSituationTotalProbaFormulaQuestion(opts), nb),
-//   qcmTimer: 60,
-//   freeTimer: 60,
-//   getPropositions,
-//   isAnswerValid,
-//   subject: "Mathématiques",
-//   getInstruction,
-//   getHint,
-//   getCorrection,
-//   getAnswer,
-//   getQuestionFromIdentifiers,
-//   hasHintAndCorrection: true
-// };
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { buildProbaTreeSituation, getProbaTreeSituation, } from "./probaTreeSituations.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, round(randfloat(0, 1, 4), 4).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { params } = identifiers;
+    const situation = getProbaTreeSituation(params);
+    const { firstCondProba, mainEventProba, secondCondProba } = situation;
+    const firstCondProbaDec = frac(firstCondProba, 100).evaluate();
+    const mainEventProbaDec = frac(mainEventProba, 100).evaluate();
+    const secondCondProbaDec = frac(secondCondProba, 100).evaluate();
+    const aNb = multiply(mainEventProbaDec, firstCondProbaDec).evaluate();
+    const abarreNb = multiply(substract(1, mainEventProbaDec), secondCondProbaDec).evaluate();
+    const pb = round(add(aNb, abarreNb).evaluate(), 6);
+    return pb.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { params } = identifiers;
+    const situation = getProbaTreeSituation(params);
+    return (situation.context +
+        `
+  
+Calculer $P(${situation.secondEvent})$.`);
+};
+const getHint = () => {
+    return `Modélise la situation par un arbre pondéré. 
+    
+Puis, utilise la formule des probabilités totales : pour deux évènements $A$ et $B$, on a :
+
+$$
+P(B) = P(A\\cap B)+P(\\overline{A}\\cap B)
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { params } = identifiers;
+    const situation = getProbaTreeSituation(params);
+    const { mainEvent, mainEventProba, firstCondProba, secondCondProba, secondEvent, tree, } = situation;
+    const firstCondProbaDec = frac(firstCondProba, 100).evaluate();
+    const mainEventProbaDec = frac(mainEventProba, 100).evaluate();
+    const secondCondProbaDec = frac(secondCondProba, 100).evaluate();
+    return `On commence par modéliser la situation par un arbre : 
+  
+<svg id="treeDiagram">${JSON.stringify(tree)}</svg>
+
+On utilise ensuite la formule des probabilités totales :
+
+$$
+P(${secondEvent}) = P(${mainEvent}\\cap ${secondEvent})+P(\\overline{${mainEvent}}\\cap ${secondEvent})
+$$
+
+On a donc : 
+
+${alignTex([
+        [
+            `P(${secondEvent})`,
+            "=",
+            add(multiply(mainEventProbaDec, firstCondProbaDec), multiply(substract(1, mainEventProbaDec).simplify(), secondCondProbaDec)).toTex(),
+        ],
+        ["", "=", getAnswer(identifiers)],
+    ])}
+`;
+};
+const getKeys = () => {
+    return ["percent"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getProbaTreeSituationTotalProbaFormulaQuestion = () => {
+    const params = buildProbaTreeSituation();
+    const identifiers = {
+        params,
+    };
+    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 probaTreeSituationTotalProbaFormula = {
+    id: "probaTreeSituationTotalProbaFormula",
+    connector: "=",
+    label: "Utiliser la formule des probabilités totales dans un contexte",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getProbaTreeSituationTotalProbaFormulaQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRecurrenceFormulaFromSituation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arithmeticFindRecurrenceFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRecurrenceFormulaFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAGhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAgB1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;CACtD,CAAC;AAiRF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CACjE,WAAW,EACX,OAAO,CAoBR,CAAC"}
+{"version":3,"file":"arithmeticFindRecurrenceFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRecurrenceFormulaFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAGhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAW1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;CACtD,CAAC;AAiRF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CACjE,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRecurrenceFormulaFromSituation.js

@@ -10,10 +10,6 @@ import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
-const _getNodeFactor = (firstRank, varName = "n") => {
-    const nodeN = varName.toTree();
-    return firstRank === 0 ? nodeN : substract(nodeN, 1);
-};
 const situations = situationsArithmetic;
 const getInstruction = (identifiers, optsIn) => {
     const opts = optsIn ?? optsDefault;

package/lib/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoConsecutiveTerms.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindExplicitFormulaFromTwoConsecutiveTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoConsecutiveTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAoB3D,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAyVF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,mDAAmD,EAAE,QAAQ,CACxE,WAAW,EACX,OAAO,CAqBR,CAAC"}
+{"version":3,"file":"geometricFindExplicitFormulaFromTwoConsecutiveTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindExplicitFormulaFromTwoConsecutiveTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAiB3D,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,gBAAgB,EAAE,MAAM,CAAC;IACzB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAwVF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,mDAAmD,EAAE,QAAQ,CACxE,WAAW,EACX,OAAO,CAqBR,CAAC"}