math-exercises 2.0.34 → 2.0.35

package/lib/exercises/geometry/vectors/equalCaracteristicFromGraph.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equalCaracteristicFromGraph = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const random_1 = require("../../../utils/random");
+/**
+ *
+ * Soient deux cercles C1 et C2 de rayon 3 et de centres (-4,0) et (4,0)
+ * on construit u dans C1 et v dans C2
+ */
+const getEqualCaracteristicFromGraphQuestion = () => {
+    let points = [];
+    // const caracAsked = random(["sens", "direction", "norme"]);
+    let instruction = "";
+    const caracAsked = (0, random_1.random)(["opposes"]);
+    // ["sens", "norme", "direction", "egaux", "opposes"]
+    const isTrue = (0, coinFlip_1.coinFlip)();
+    let uPoints = [];
+    let vPoints = [];
+    //On construit u dans C1
+    const theta = Math.random() * 2 * Math.PI;
+    uPoints.push([3 * Math.cos(theta) - 4, 3 * Math.sin(theta)]);
+    uPoints.push([
+        3 * Math.cos(theta + Math.PI) - 4,
+        3 * Math.sin(theta + Math.PI),
+    ]);
+    let thetaPrime;
+    let sameDirection;
+    let sameNorm;
+    let sameSens;
+    let rho;
+    switch (caracAsked) {
+        case "direction":
+            instruction = "avoir la même direction";
+            thetaPrime = isTrue
+                ? theta
+                : theta + (0, randfloat_1.randfloat)(1 / 4, 1 / 3) * Math.PI * 2;
+            sameNorm = (0, coinFlip_1.coinFlip)();
+            rho = sameNorm ? 3 : (0, randfloat_1.randfloat)(1, 2.5);
+            vPoints.push([
+                rho * Math.cos(thetaPrime) + 4,
+                rho * Math.sin(thetaPrime),
+            ]);
+            vPoints.push([
+                rho * Math.cos(thetaPrime + Math.PI) + 4,
+                rho * Math.sin(thetaPrime + Math.PI),
+            ]);
+            if ((0, coinFlip_1.coinFlip)())
+                uPoints = [uPoints[1], uPoints[0]];
+            if ((0, coinFlip_1.coinFlip)())
+                [uPoints, vPoints] = [vPoints, uPoints];
+            break;
+        case "norme":
+            instruction = "avoir la même norme";
+            sameDirection = (0, coinFlip_1.coinFlip)();
+            thetaPrime = sameDirection ? theta : Math.random() * 2 * Math.PI;
+            if (isTrue) {
+                vPoints.push([3 * Math.cos(thetaPrime) + 4, 3 * Math.sin(thetaPrime)]);
+                vPoints.push([
+                    3 * Math.cos(thetaPrime + Math.PI) + 4,
+                    3 * Math.sin(thetaPrime + Math.PI),
+                ]);
+            }
+            else {
+                vPoints.push([Math.cos(thetaPrime) + 4, Math.sin(thetaPrime)]);
+                vPoints.push([
+                    Math.cos(thetaPrime + Math.PI) + 4,
+                    Math.sin(thetaPrime + Math.PI),
+                ]);
+            }
+            if ((0, coinFlip_1.coinFlip)())
+                uPoints = [uPoints[1], uPoints[0]];
+            if ((0, coinFlip_1.coinFlip)())
+                [uPoints, vPoints] = [vPoints, uPoints];
+            break;
+        case "sens":
+            instruction = "avoir le même sens";
+            sameDirection = (0, coinFlip_1.coinFlip)();
+            sameNorm = (0, coinFlip_1.coinFlip)();
+            thetaPrime =
+                isTrue || sameDirection
+                    ? theta
+                    : theta + (0, randfloat_1.randfloat)(1 / 4, 1 / 3) * Math.PI * 2;
+            rho = sameNorm ? 3 : (0, randfloat_1.randfloat)(1, 2.5);
+            vPoints.push([
+                rho * Math.cos(thetaPrime) + 4,
+                rho * Math.sin(thetaPrime),
+            ]);
+            vPoints.push([
+                rho * Math.cos(thetaPrime + Math.PI) + 4,
+                rho * Math.sin(thetaPrime + Math.PI),
+            ]);
+            if (!isTrue)
+                vPoints = [vPoints[1], vPoints[0]];
+            if ((0, coinFlip_1.coinFlip)())
+                [uPoints, vPoints] = [vPoints, uPoints];
+            break;
+        case "egaux":
+            instruction = "être égaux";
+            sameDirection = isTrue || (0, coinFlip_1.coinFlip)();
+            sameNorm = isTrue || (0, coinFlip_1.coinFlip)();
+            sameSens = isTrue || (sameDirection && sameNorm ? false : (0, coinFlip_1.coinFlip)());
+            thetaPrime = sameDirection
+                ? theta
+                : theta + (0, randfloat_1.randfloat)(1 / 4, 1 / 3) * Math.PI * 2;
+            rho = sameNorm ? 3 : (0, randfloat_1.randfloat)(1, 2);
+            vPoints.push([
+                rho * Math.cos(thetaPrime) + 4,
+                rho * Math.sin(thetaPrime),
+            ]);
+            vPoints.push([
+                rho * Math.cos(thetaPrime + Math.PI) + 4,
+                rho * Math.sin(thetaPrime + Math.PI),
+            ]);
+            if (!sameSens)
+                vPoints = [vPoints[1], vPoints[0]];
+            if ((0, coinFlip_1.coinFlip)())
+                [uPoints, vPoints] = [vPoints, uPoints];
+            break;
+        case "opposes":
+            instruction = "être opposés";
+            sameDirection = isTrue || (0, coinFlip_1.coinFlip)();
+            sameNorm = isTrue || (0, coinFlip_1.coinFlip)();
+            sameSens = !isTrue || (sameDirection && sameNorm ? false : (0, coinFlip_1.coinFlip)());
+            thetaPrime = sameDirection
+                ? theta
+                : theta + (0, randfloat_1.randfloat)(1 / 4, 1 / 3) * Math.PI * 2;
+            rho = sameNorm ? 3 : (0, randfloat_1.randfloat)(1, 2.5);
+            vPoints.push([
+                rho * Math.cos(thetaPrime) + 4,
+                rho * Math.sin(thetaPrime),
+            ]);
+            vPoints.push([
+                rho * Math.cos(thetaPrime + Math.PI) + 4,
+                rho * Math.sin(thetaPrime + Math.PI),
+            ]);
+            if (!sameSens)
+                vPoints = [vPoints[1], vPoints[0]];
+            if ((0, coinFlip_1.coinFlip)())
+                [uPoints, vPoints] = [vPoints, uPoints];
+            break;
+    }
+    const commands = [
+        `u = Vector((${uPoints[0][0]},${uPoints[0][1]}), (${uPoints[1][0]},${uPoints[1][1]}))`,
+        `v = Vector((${vPoints[0][0]},${vPoints[0][1]}), (${vPoints[1][0]},${vPoints[1][1]}))`,
+        'SetCaption(u, "$\\overrightarrow u$")',
+        'SetCaption(v, "$\\overrightarrow v$")',
+        "ShowLabel(u, true)",
+        "ShowLabel(v,true)",
+    ];
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+        hideAxes: true,
+    });
+    const answer = isTrue ? "Oui" : "Non";
+    const question = {
+        answer,
+        instruction: `Les vecteurs $\\overrightarrow{u}$ et $\\overrightarrow{v}$ suivants semblent-ils ${instruction} ?`,
+        keys: [],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: [-8, 8, -4, 4],
+        answerFormat: "tex",
+        identifiers: { caracAsked, uPoints, vPoints },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.equalCaracteristicFromGraph = {
+    id: "equalCaracteristicFromGraph",
+    label: "Direction, sens, norme, égalité, opposés",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Vecteurs"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getEqualCaracteristicFromGraphQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    answerType: "QCM",
+};

package/lib/exercises/geometry/vectors/index.d.ts

@@ -9,4 +9,5 @@ export * from "./alignementViaColinearity";
 export * from "./paralellismViaColinearity";
 export * from "./parallelogramViaEqualVectors";
 export * from "./fourthParallelogramPoint";
+export * from "./equalCaracteristicFromGraph";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/geometry/vectors/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/geometry/vectors/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,sBAAsB,CAAC;AACrC,cAAc,eAAe,CAAC;AAC9B,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,uBAAuB,CAAC;AACtC,cAAc,eAAe,CAAC;AAC9B,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,+BAA+B,CAAC"}

package/lib/exercises/geometry/vectors/index.js

@@ -25,3 +25,4 @@ __exportStar(require("./alignementViaColinearity"), exports);
 __exportStar(require("./paralellismViaColinearity"), exports);
 __exportStar(require("./parallelogramViaEqualVectors"), exports);
 __exportStar(require("./fourthParallelogramPoint"), exports);
+__exportStar(require("./equalCaracteristicFromGraph"), exports);

package/lib/exercises/matrices/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./matrixInversibilityDomain";
+export * from "./productCell";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/matrices/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/matrices/index.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAC;AAC5C,cAAc,eAAe,CAAC"}

package/lib/exercises/matrices/index.js

@@ -15,3 +15,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./matrixInversibilityDomain"), exports);
+__exportStar(require("./productCell"), exports);

package/lib/exercises/matrices/productCell.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    AiCoeff: number;
+    AjCoeff: number;
+    BiCoeff: number;
+    BjCoeff: number;
+};
+export declare const productCell: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=productCell.d.ts.map

package/lib/exercises/matrices/productCell.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"productCell.d.ts","sourceRoot":"","sources":["../../../src/exercises/matrices/productCell.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAqDF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAYjD,CAAC"}

package/lib/exercises/matrices/productCell.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.productCell = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../math/utils/random/randint");
+const sum_1 = require("../../math/utils/sum");
+const addNode_1 = require("../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../tree/nodes/operators/multiplyNode");
+const variableNode_1 = require("../../tree/nodes/variables/variableNode");
+const doWhile_1 = require("../../utils/doWhile");
+//$A=(a_{i,j})$ avec $a_{i,j}=2i-j$ et $B=(b_{i,j})$ avec $b_{i,j}=i+j$ calculer $c_{2,3}$ Réponse: $c_{2,3} = \sum_{k=1}^{3} (2 \cdot 2 - k) \cdot (k + 3)$ $ c_{2,3} = (2 \cdot 2 - 1) \cdot (1 + 3) + (2 \cdot 2 - 2) \cdot (2 + 3) + (2 \cdot 2 - 3) \cdot (3 + 3)$ $c_{2,3}=3\times 4+2\times 5+1\times 6 =28$. Si l'élève détermine l'expression des matrices A et B puis effectue le calcul des bons blocs pour obtenir le coefficient cela est intéressant aussi ! Bonne journée merci
+// Les matrices A et B sont définies par combinaisons linéaires de leurs lignes/colonnes
+// exp a_(i,j) = 2i+j
+const getProductCellQuestion = () => {
+    const i = (0, randint_1.randint)(1, 4);
+    const j = (0, randint_1.randint)(1, 4);
+    const AiCoeff = (0, randint_1.randint)(-3, 4, [0]);
+    const AjCoeff = (0, randint_1.randint)(-3, 4, [0]);
+    const BiCoeff = (0, randint_1.randint)(-3, 4, [0]);
+    const BjCoeff = (0, doWhile_1.doWhile)(() => (0, randint_1.randint)(-3, 4, [0]), (x) => BiCoeff === AiCoeff && x === AjCoeff);
+    const aij = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(AiCoeff.toTree(), new variableNode_1.VariableNode("i")), new multiplyNode_1.MultiplyNode(AjCoeff.toTree(), new variableNode_1.VariableNode("j"))).simplify();
+    const bij = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(BiCoeff.toTree(), new variableNode_1.VariableNode("i")), new multiplyNode_1.MultiplyNode(BjCoeff.toTree(), new variableNode_1.VariableNode("j"))).simplify();
+    const answer = (0, sum_1.sum)(1, 3, (k) => (AiCoeff * i + AjCoeff * k) * (BiCoeff * k + BjCoeff * j)) + "";
+    const question = {
+        answer,
+        instruction: `Soient  $A = \\left(a_{i,j}\\right)$ et $B = \\left(b_{i,j}\\right)$ deux matrices carrées d'ordre $3$, avec $a_{i,j} = ${aij.toTex()}$ et $b_{i,j} = ${bij.toTex()}$. Soit $C = AB$. Calculer $c_{${i},${j}}$.`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { AiCoeff, AjCoeff, BiCoeff, BjCoeff },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-100, 100) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.productCell = {
+    id: "productCell",
+    connector: "=",
+    label: "Calculer un coefficient du produit de deux matrices",
+    levels: ["MathExp"],
+    isSingleStep: true,
+    sections: ["Matrices"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getProductCellQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -6,4 +6,7 @@ export * from "./probabilityTree";
 export * from "./stats1var";
 export * from "./stats2var";
 export * from "./independancy";
+export * from "./issuesCountingForCards";
+export * from "./probaFromTableNoContext";
+export * from "./probaFromTableWithContext";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/probaStat/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC;AAClC,cAAc,0BAA0B,CAAC;AACzC,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC"}

package/lib/exercises/probaStat/index.js

@@ -22,3 +22,6 @@ __exportStar(require("./probabilityTree"), exports);
 __exportStar(require("./stats1var"), exports);
 __exportStar(require("./stats2var"), exports);
 __exportStar(require("./independancy"), exports);
+__exportStar(require("./issuesCountingForCards"), exports);
+__exportStar(require("./probaFromTableNoContext"), exports);
+__exportStar(require("./probaFromTableWithContext"), exports);

package/lib/exercises/probaStat/issuesCountingForCards.d.ts

@@ -0,0 +1,7 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    questionType: string;
+};
+export declare const issuesCountingForCards: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=issuesCountingForCards.d.ts.map

package/lib/exercises/probaStat/issuesCountingForCards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"issuesCountingForCards.d.ts","sourceRoot":"","sources":["../../../src/exercises/probaStat/issuesCountingForCards.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAiEF,eAAO,MAAM,sBAAsB,EAAE,YAAY,CAAC,WAAW,CAa5D,CAAC"}

package/lib/exercises/probaStat/issuesCountingForCards.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.issuesCountingForCards = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../math/utils/random/randint");
+const probaLawFlip_1 = require("../../utils/probaLawFlip");
+const random_1 = require("../../utils/random");
+const randomEnumValue_1 = require("../../utils/randomEnumValue");
+const cardsData_1 = require("../utils/cardsData");
+const getIssuesCountingForCardsQuestion = () => {
+    const questionType = (0, probaLawFlip_1.probaLawFlip)([
+        ["oneCard", 0.25],
+        ["valueCard", 0.25],
+        ["suitCard", 0.25],
+        ["colorCard", 0.25],
+    ]);
+    let answer = "";
+    let target = "";
+    let value;
+    let color;
+    switch (questionType) {
+        case "oneCard":
+            value = (0, randomEnumValue_1.randomEnumValue)(cardsData_1.CardsValues);
+            color = (0, randomEnumValue_1.randomEnumValue)(cardsData_1.CardsColor);
+            target = `${value === "dame" ? "une" : "un"} ${value} de ${color}`;
+            answer = `1`;
+            break;
+        case "valueCard":
+            value = (0, randomEnumValue_1.randomEnumValue)(cardsData_1.CardsValues);
+            target = `${value === "dame" ? "une" : "un"} ${value}`;
+            answer = "4";
+            break;
+        case "colorCard":
+            color = (0, random_1.random)(["rouge", "noire"]);
+            target = `une carte ${color}`;
+            answer = `26`;
+            break;
+        case "suitCard":
+            color = (0, randomEnumValue_1.randomEnumValue)(cardsData_1.CardsColor);
+            target = `un ${color}`;
+            answer = `13`;
+            break;
+    }
+    const question = {
+        answer,
+        instruction: `On tire une carte dans un jeu de 52 cartes. Combien l'événement $A = $ "obtenir ${target}" compte-t-il d'issues ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { questionType },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, "1");
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(0, 52) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.issuesCountingForCards = {
+    id: "issuesCountingForCards",
+    connector: "=",
+    label: "Compter le nombre d'issues d'un événement avec un jeu de cartes",
+    levels: ["3ème", "2nde", "2ndPro", "1rePro"],
+    isSingleStep: true,
+    sections: ["Probabilités"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getIssuesCountingForCardsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

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

@@ -0,0 +1,13 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    aCapB: number;
+    aCapBBarre: number;
+    aBarreCapB: number;
+    aBarreCapBBarre: number;
+    event: string;
+    type: string;
+    probaFrac: number[];
+};
+export declare const probaFromTableNoContext: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=probaFromTableNoContext.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"probaFromTableNoContext.d.ts","sourceRoot":"","sources":["../../../src/exercises/probaStat/probaFromTableNoContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAOlC,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;AAkHF,eAAO,MAAM,uBAAuB,EAAE,YAAY,CAAC,WAAW,CAc7D,CAAC"}

package/lib/exercises/probaStat/probaFromTableNoContext.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probaFromTableNoContext = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../math/numbers/rationals/rational");
+const randint_1 = require("../../math/utils/random/randint");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const random_1 = require("../../utils/random");
+const getProbaFromTableNoContextQuestion = () => {
+    const aCapB = (0, randint_1.randint)(1, 20);
+    const aCapBBarre = (0, randint_1.randint)(1, 20);
+    const aBarreCapB = (0, randint_1.randint)(1, 20);
+    const aBarreCapBBarre = (0, randint_1.randint)(1, 20);
+    const total = aBarreCapB + aBarreCapBBarre + aCapB + aCapBBarre;
+    const aTotal = aCapB + aCapBBarre;
+    const bTotal = aCapB + aBarreCapB;
+    const aBarreTotal = aBarreCapB + aBarreCapBBarre;
+    const bBarreTotal = aBarreCapBBarre + aCapBBarre;
+    let event = "";
+    let proba = [];
+    const type = (0, random_1.random)(["singleEvent", "intersection", "union", "conditionnal"]);
+    switch (type) {
+        case "singleEvent":
+            [event, proba] = (0, random_1.random)([
+                ["P(A)", [aTotal, total]],
+                ["P(B)", [bTotal, total]],
+                ["P(\\overline A)", [aBarreTotal, total]],
+                ["P(\\overline B)", [bBarreTotal, total]],
+            ]);
+            break;
+        case "intersection":
+            [event, proba] = (0, random_1.random)([
+                ["P(A\\cap B)", [aCapB, total]],
+                ["P(\\overline A\\cap B)", [aBarreCapB, total]],
+                ["P(A\\cap \\overline B)", [aCapBBarre, total]],
+                ["P(\\overline A \\cap \\overline B)", [aBarreCapBBarre, total]],
+            ]);
+            break;
+        case "union":
+            [event, proba] = (0, random_1.random)([
+                ["P(A\\cup B)", [total - aBarreCapBBarre, total]],
+                ["P(A\\cup \\overline B)", [total - aBarreCapB, total]],
+                ["P(\\overline A \\cup B)", [total - aCapBBarre, total]],
+                ["P(\\overline A \\cup \\overline B)", [total - aCapB, total]],
+            ]);
+            break;
+        case "conditionnal":
+            [event, proba] = (0, random_1.random)([
+                ["P_A(B)", [aCapB, aTotal]],
+                ["P_A(\\overline B)", [aCapBBarre, aTotal]],
+                ["P_B(A)", [aCapB, bTotal]],
+                ["P_B(\\overline{A})", [aBarreCapB, bTotal]],
+                ["P_{\\overline A}(B)", [aBarreCapB, aBarreTotal]],
+                ["P_{\\overline A}(\\overline B)", [aBarreCapBBarre, aBarreTotal]],
+                ["P_{\\overline B}(A)", [aCapBBarre, bBarreTotal]],
+                ["P_{\\overline B}(\\overline A)", [aBarreCapBBarre, bBarreTotal]],
+            ]);
+    }
+    const answer = new rational_1.Rational(proba[0], proba[1]).simplify().toTree().toTex();
+    const question = {
+        answer,
+        instruction: `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$. Calculer la probabilité $${event}$.
+    
+| | $B$ | $\\overline{B}$|
+|-|-|-|
+|$A$|${aCapB}|${aCapBBarre}|
+|$\\overline{A}$|${aBarreCapB}|${aBarreCapBBarre}|
+    
+    `,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            aBarreCapB,
+            aBarreCapBBarre,
+            aCapB,
+            aCapBBarre,
+            event,
+            type,
+            probaFrac: proba,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational((0, random_1.random)([aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre]), (0, random_1.random)([aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre]) +
+            (0, random_1.random)([aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre]))
+            .simplify()
+            .toTree()
+            .toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, probaFrac }) => {
+    const fracTexs = new fractionNode_1.FractionNode(probaFrac[0].toTree(), probaFrac[1].toTree())
+        .simplify()
+        .toAllValidTexs();
+    return fracTexs.includes(ans);
+};
+exports.probaFromTableNoContext = {
+    id: "probaFromTableNoContext",
+    connector: "=",
+    label: "Utiliser un tableau à double entrée pour calculer une probabilité (sans contexte)",
+    levels: ["1rePro", "1reSpé", "1reTech", "1reESM", "2ndPro"],
+    isSingleStep: true,
+    sections: ["Probabilités"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getProbaFromTableNoContextQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/probaStat/probaFromTableWithContext.d.ts

@@ -0,0 +1,13 @@
+import { MathExercise } from "../../exercises/exercise";
+type Identifiers = {
+    aCapB: number;
+    aCapBBarre: number;
+    aBarreCapB: number;
+    aBarreCapBBarre: number;
+    event: string;
+    type: string;
+    probaFrac: number[];
+};
+export declare const probaFromTableWithContext: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=probaFromTableWithContext.d.ts.map

package/lib/exercises/probaStat/probaFromTableWithContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"probaFromTableWithContext.d.ts","sourceRoot":"","sources":["../../../src/exercises/probaStat/probaFromTableWithContext.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAOlC,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;AAsHF,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,WAAW,CAc/D,CAAC"}