math-exercises 3.0.132 → 3.0.133

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLine.js

@@ -1,56 +1,32 @@
-import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
 import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
-import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
 import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
 import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
 import { Point } from "../../../../math/geometry/point.js";
 import { NumberType } from "../../../../math/numbers/nombre.js";
-import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { round } from "../../../../math/utils/round.js";
-import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
-import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
-import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { FractionNode } from "../../../../tree/nodes/operators/fractionNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { random } from "../../../../utils/alea/random.js";
-const getInstruction = ({ abscissType, absciss2, }) => {
-    const absciss2Node = NodeConstructor.fromIdentifiers(absciss2);
-    return `Placer le point d'abscisse $${abscissType === NumberType.Decimal
-        ? round(absciss2Node.evaluate(), 1).frenchify()
-        : absciss2Node.toTex()}$ sur la demi-droite graduée ci-dessous :`;
+const getInstruction = ({ abscissTex }) => {
+    return `Placer le point d'abscisse $${abscissTex}$ sur la demi-droite graduée ci-dessous :`;
 };
 // const getHint: GetHint<Identifiers> = (identifiers) => {};
 // const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
-const getGGBAnswer = ({ absciss2 }) => {
-    const nodeAbciss2 = NodeConstructor.fromIdentifiers(absciss2);
-    return [`(${nodeAbciss2.evaluate()},0)`];
+const getGGBAnswer = ({ coeff }) => {
+    return [`(${coeff},0)`];
 };
-const getStudentGGBOptions = ({ abscissType, absciss1, axisUnit, absciss2, }) => {
-    const [axisUnitNode, absciss1Node, absciss2Node] = [
-        axisUnit,
-        absciss1,
-        absciss2,
-    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
-    const [valueAxisUnit, valueAbsciss1, valueAbsciss2] = [
-        axisUnitNode,
-        absciss1Node,
-        absciss2Node,
-    ].map((node) => node.evaluate());
-    const xMin = Math.min(Math.min(0, valueAbsciss1), valueAbsciss2);
-    const xMax = Math.max(Math.max(0, valueAbsciss1), valueAbsciss2);
-    const yxRatio = 0.5;
-    const yMax = yxRatio * (xMax - xMin);
-    const yMin = -yMax;
+const getStudentGGBOptions = ({ oneUnitTex, abscissType, }) => {
     const O = new Point("O", (0).toTree(), (0).toTree());
-    const I = new Point("I", absciss1Node, (0).toTree());
+    const I = new Point("I", (1).toTree(), (0).toTree());
     const commands = [
         ...O.toGGBCommand(),
-        `Text("\\footnotesize 0", (0, ${yMin / 4}), false, true, 0, 0)`,
+        `Text("\\footnotesize 0", (0, -0.5), false, true, 0, 0)`,
         ...I.toGGBCommand(),
-        `Text("\\footnotesize ${abscissType === NumberType.Decimal
-            ? round(absciss1Node.evaluate(), 1).frenchify()
-            : absciss1Node.toTex()}", (${valueAbsciss1}, ${abscissType === NumberType.Rational ? yMin / 2 : yMin / 4}), false, true, 0, 0)`,
+        `Text("\\footnotesize ${oneUnitTex}", (1, ${abscissType === NumberType.Rational ? -1 : -0.5}), false, true, 0, 0)`,
     ];
     const ggb = new GeogebraConstructor({
         commands,
@@ -60,7 +36,7 @@ const getStudentGGBOptions = ({ abscissType, absciss1, axisUnit, absciss2, }) =>
         hideGrid: true,
         xAxis: {
             hideNumbers: true,
-            steps: valueAxisUnit,
+            steps: 1,
             showPositive: true,
         },
         yAxis: {
@@ -70,102 +46,73 @@ const getStudentGGBOptions = ({ abscissType, absciss1, axisUnit, absciss2, }) =>
         forbidShiftDragZoom: true,
     });
     return ggb.getOptions({
-        coords: ggb.getAdaptedCoords({
-            xMin,
-            xMax,
-            yMin,
-            yMax,
-        }),
-        // coords: [xMin, xMax, yMin, yMax],
+        coords: [-1, 10, -2, 2],
     });
 };
-const isGGBAnswerValid = (ans, { absciss2, axisUnit }) => {
-    const [absciss2Node, axisUnitNode] = [absciss2, axisUnit].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
-    const commands = ans;
-    const dictObj = new GeogebraParser(commands).objectDict();
-    console.log("dictObj:", dictObj);
-    const strPointA = dictObj["A"];
-    if (!strPointA) {
-        return false;
-    }
-    const coordsA = ggbPointToCoords(strPointA);
+const isGGBAnswerValid = (ans, { coeff }) => {
     const points = parseGGBPoints(ans).map((p) => ggbPointToCoords(p));
-    return (points.length === 3 && //O,I,A
-        Math.abs(coordsA.y) < 0.5 * axisUnitNode.evaluate() &&
-        Math.abs(coordsA.x - absciss2Node.evaluate()) <
-            0.1 * axisUnitNode.evaluate());
+    return (points.length === 1 &&
+        Math.abs(points[0].y) < 0.5 &&
+        Math.abs(points[0].x - coeff) < 0.1);
 };
-const getPlaceAbscissOnSemiLineQuestion = (optsIn) => {
-    const arrayedOptions = optsIn ?? optsDefault;
-    const opts = {
-        questionType: random(arrayedOptions.questionType),
-        numberType: random(arrayedOptions.numberType),
-    };
-    const abscissType = (() => {
-        switch (opts.numberType) {
-            case "Entiers":
-                return NumberType.Integer;
-            case "Rationnels":
-                return NumberType.Rational;
-            case "Décimaux":
-                return NumberType.Decimal;
-        }
-    })();
-    //[ [1/2, 2/2, 3/2], [1/3,2/3,3/3,4/3,5/3], ...]
-    function fracFamilyList() {
-        const maxDen = 5;
-        return [...Array(maxDen - 2).keys()]
-            .map((index) => index + 2)
-            .map((den) => [...Array(den === 2 ? 3 * den - 1 : 2 * den - 1).keys()]
-            .map((index) => index + 1)
-            .filter((num) => opts.questionType === "éviter le comptage"
-            ? num !== 1 && num !== den
-            : true)
-            .map((num) => frac(num, den)));
-    }
-    const fracList = random(fracFamilyList());
-    const den = fracList[0].rightChild;
-    const factor1 = random(fracList);
-    const factor2 = random(fracList, [factor1]);
-    let referenceNum;
-    let absciss1Node;
-    let absciss2Node;
+const getPlaceAbscissOnSemiLineQuestion = () => {
+    const abscissType = random([
+        NumberType.Integer,
+        NumberType.Rational,
+        NumberType.Decimal,
+    ]);
+    let absciss, axisUnit, oneUnitTex, abscissTex, coeff;
     switch (abscissType) {
         case NumberType.Integer:
-            {
-                referenceNum = multiply(randint(1, 13), den);
-                absciss1Node = multiply(referenceNum, factor1).simplify();
-                absciss2Node = multiply(referenceNum, factor2).simplify();
-            }
+            axisUnit = randint(1, 10);
+            coeff = randint(2, 10);
+            absciss = axisUnit * coeff;
+            oneUnitTex = axisUnit.frenchify();
+            abscissTex = absciss.frenchify();
             break;
         case NumberType.Rational:
             {
-                referenceNum = random([...Array(19).keys()]
-                    .map((index) => index + 1)
-                    .filter((num) => !dividersOf(num).includes(den.evaluate()))).toTree();
-                absciss1Node = frac(multiply(referenceNum, factor1.leftChild).simplify(), factor1.rightChild);
-                absciss2Node = frac(multiply(referenceNum, factor2.leftChild).simplify(), factor2.rightChild);
+                const randomFrac = random([
+                    [1, 2],
+                    [1, 3],
+                    [2, 3],
+                    [1, 4],
+                    [3, 4],
+                    [1, 5],
+                    [2, 5],
+                    [3, 5],
+                    [4, 5],
+                ]);
+                axisUnit = randomFrac[0] / randomFrac[1];
+                const oneUnit = new FractionNode(randomFrac[0].toTree(), randomFrac[1].toTree());
+                oneUnitTex = oneUnit.toTex();
+                coeff = randint(2, 10);
+                absciss = axisUnit * coeff;
+                abscissTex = new MultiplyNode(oneUnit, coeff.toTree())
+                    .simplify()
+                    .toTex();
             }
             break;
         case NumberType.Decimal:
         default:
-            {
-                referenceNum = frac(multiply(randint(1, 13 * 10), den), 10);
-                absciss1Node = multiply(referenceNum, factor1).simplify();
-                absciss2Node = multiply(referenceNum, factor2).simplify();
-            }
+            axisUnit = randfloat(0, 5, 1);
+            coeff = randint(2, 10);
+            absciss = round(axisUnit * coeff, 2);
+            oneUnitTex = axisUnit.frenchify();
+            abscissTex = absciss.frenchify();
             break;
     }
-    const axisUnitNode = frac(referenceNum, den).simplify();
     const identifiers = {
+        absciss,
+        abscissTex,
         abscissType,
-        axisUnit: axisUnitNode.toIdentifiers(),
-        absciss1: absciss1Node.toIdentifiers(),
-        absciss2: absciss2Node.toIdentifiers(),
+        axisUnit,
+        coeff,
+        oneUnitTex,
     };
     return getQuestionFromIdentifiers(identifiers);
 };
-const getQuestionFromIdentifiers = (identifiers, opts) => {
+const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         ggbAnswer: getGGBAnswer(identifiers),
         instruction: getInstruction(identifiers),
@@ -173,38 +120,14 @@ const getQuestionFromIdentifiers = (identifiers, opts) => {
         identifiers,
         // hint: getHint(identifiers),
         // correction: getCorrection(identifiers),
-        options: opts,
     };
     return question;
 };
-const optsDefault = {
-    questionType: ["standard", "éviter le comptage"],
-    numberType: ["Entiers", "Rationnels", "Décimaux"],
-};
-const options = [
-    {
-        id: "questionType",
-        label: "Type de question",
-        target: GeneratorOptionTarget.generation,
-        type: GeneratorOptionType.multiselect,
-        values: ["standard", "éviter le comptage"],
-        defaultValue: optsDefault.questionType,
-    },
-    {
-        id: "numberType",
-        label: "Type de nombres",
-        target: GeneratorOptionTarget.generation,
-        type: GeneratorOptionType.multiselect,
-        values: ["Entiers", "Rationnels", "Décimaux"],
-        defaultValue: optsDefault.numberType,
-    },
-];
 export const placeAbscissOnSemiLine = {
     id: "placeAbscissOnSemiLine",
     label: "Placer un point d'abscisse donnée sur une demi-droite graduée",
     isSingleStep: true,
-    generator: (nb, opts) => getDistinctQuestions(() => getPlaceAbscissOnSemiLineQuestion(opts), nb),
-    options,
+    generator: (nb) => getDistinctQuestions(getPlaceAbscissOnSemiLineQuestion, nb),
     ggbTimer: 60,
     isGGBAnswerValid,
     subject: "Mathématiques",

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.d.ts

@@ -0,0 +1,16 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NumberType } from "../../../../math/numbers/nombre.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    abscissType: NumberType;
+    axisUnit: NodeIdentifiers;
+    absciss1: NodeIdentifiers;
+    absciss2: NodeIdentifiers;
+};
+type Options = {
+    questionType: "standard" | "éviter le comptage";
+    numberType: "Entiers" | "Rationnels" | "Décimaux";
+};
+export declare const placeAbscissOnSemiLineV2: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=placeAbscissOnSemiLineV2.d.ts.map

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placeAbscissOnSemiLineV2.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAQrC,OAAO,EAAE,UAAU,EAAE,MAAM,8BAA8B,CAAC;AAK1D,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IACjB,WAAW,EAAE,UAAU,CAAC;IACxB,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;IAC1B,QAAQ,EAAE,eAAe,CAAC;CAC3B,CAAC;AAkOF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,UAAU,GAAG,oBAAoB,CAAC;IAChD,UAAU,EAAE,SAAS,GAAG,YAAY,GAAG,UAAU,CAAC;CACnD,CAAC;AA6BF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAYnE,CAAC"}

package/lib/exercises/math/geometry/cartesian/placeAbscissOnSemiLineV2.js

@@ -0,0 +1,213 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { GeogebraParser } from "../../../../geogebra/parsers/geogebraParser.js";
+import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
+import { Point } from "../../../../math/geometry/point.js";
+import { NumberType } from "../../../../math/numbers/nombre.js";
+import { dividersOf } from "../../../../math/utils/arithmetic/dividersOf.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const getInstruction = ({ abscissType, absciss2, }) => {
+    const absciss2Node = NodeConstructor.fromIdentifiers(absciss2);
+    return `Placer le point d'abscisse $${abscissType === NumberType.Decimal
+        ? round(absciss2Node.evaluate(), 1).frenchify()
+        : absciss2Node.toTex()}$ sur la demi-droite graduée ci-dessous :`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getGGBAnswer = ({ absciss2 }) => {
+    const nodeAbciss2 = NodeConstructor.fromIdentifiers(absciss2);
+    return [`(${nodeAbciss2.evaluate()},0)`];
+};
+const getStudentGGBOptions = ({ abscissType, absciss1, axisUnit, absciss2, }) => {
+    const [axisUnitNode, absciss1Node, absciss2Node] = [
+        axisUnit,
+        absciss1,
+        absciss2,
+    ].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [valueAxisUnit, valueAbsciss1, valueAbsciss2] = [
+        axisUnitNode,
+        absciss1Node,
+        absciss2Node,
+    ].map((node) => node.evaluate());
+    const xMin = Math.min(Math.min(0, valueAbsciss1), valueAbsciss2);
+    const xMax = Math.max(Math.max(0, valueAbsciss1), valueAbsciss2);
+    const yxRatio = 0.5;
+    const yMax = yxRatio * (xMax - xMin);
+    const yMin = -yMax;
+    const O = new Point("O", (0).toTree(), (0).toTree());
+    const I = new Point("I", absciss1Node, (0).toTree());
+    const commands = [
+        ...O.toGGBCommand(),
+        `Text("\\footnotesize 0", (0, ${yMin / 4}), false, true, 0, 0)`,
+        ...I.toGGBCommand(),
+        `Text("\\footnotesize ${abscissType === NumberType.Decimal
+            ? round(absciss1Node.evaluate(), 1).frenchify()
+            : absciss1Node.toTex()}", (${valueAbsciss1}, ${abscissType === NumberType.Rational ? yMin / 2 : yMin / 4}), false, true, 0, 0)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+        hideGrid: true,
+        xAxis: {
+            hideNumbers: true,
+            steps: valueAxisUnit,
+            showPositive: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        maxHeight: 220,
+        forbidShiftDragZoom: true,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin,
+            xMax,
+            yMin,
+            yMax,
+        }),
+        // coords: [xMin, xMax, yMin, yMax],
+    });
+};
+const isGGBAnswerValid = (ans, { absciss2, axisUnit }) => {
+    const [absciss2Node, axisUnitNode] = [absciss2, axisUnit].map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const commands = ans;
+    const dictObj = new GeogebraParser(commands).objectDict();
+    console.log("dictObj:", dictObj);
+    const strPointA = dictObj["A"];
+    if (!strPointA) {
+        return false;
+    }
+    const coordsA = ggbPointToCoords(strPointA);
+    const points = parseGGBPoints(ans).map((p) => ggbPointToCoords(p));
+    return (points.length === 3 && //O,I,A
+        Math.abs(coordsA.y) < 0.5 * axisUnitNode.evaluate() &&
+        Math.abs(coordsA.x - absciss2Node.evaluate()) <
+            0.1 * axisUnitNode.evaluate());
+};
+const getPlaceAbscissOnSemiLineV2Question = (optsIn) => {
+    const arrayedOptions = optsIn ?? optsDefault;
+    const opts = {
+        questionType: random(arrayedOptions.questionType),
+        numberType: random(arrayedOptions.numberType),
+    };
+    const abscissType = (() => {
+        switch (opts.numberType) {
+            case "Entiers":
+                return NumberType.Integer;
+            case "Rationnels":
+                return NumberType.Rational;
+            case "Décimaux":
+                return NumberType.Decimal;
+        }
+    })();
+    //[ [1/2, 2/2, 3/2], [1/3,2/3,3/3,4/3,5/3], ...]
+    function fracFamilyList() {
+        const maxDen = 5;
+        return [...Array(maxDen - 2).keys()]
+            .map((index) => index + 2)
+            .map((den) => [...Array(den === 2 ? 3 * den - 1 : 2 * den - 1).keys()]
+            .map((index) => index + 1)
+            .filter((num) => opts.questionType === "éviter le comptage"
+            ? num !== 1 && num !== den
+            : true)
+            .map((num) => frac(num, den)));
+    }
+    const fracList = random(fracFamilyList());
+    const den = fracList[0].rightChild;
+    const factor1 = random(fracList);
+    const factor2 = random(fracList, [factor1]);
+    let referenceNum;
+    let absciss1Node;
+    let absciss2Node;
+    switch (abscissType) {
+        case NumberType.Integer:
+            {
+                referenceNum = multiply(randint(1, 13), den);
+                absciss1Node = multiply(referenceNum, factor1).simplify();
+                absciss2Node = multiply(referenceNum, factor2).simplify();
+            }
+            break;
+        case NumberType.Rational:
+            {
+                referenceNum = random([...Array(19).keys()]
+                    .map((index) => index + 1)
+                    .filter((num) => !dividersOf(num).includes(den.evaluate()))).toTree();
+                absciss1Node = frac(multiply(referenceNum, factor1.leftChild).simplify(), factor1.rightChild);
+                absciss2Node = frac(multiply(referenceNum, factor2.leftChild).simplify(), factor2.rightChild);
+            }
+            break;
+        case NumberType.Decimal:
+        default:
+            {
+                referenceNum = frac(multiply(randint(1, 13 * 10), den), 10);
+                absciss1Node = multiply(referenceNum, factor1).simplify();
+                absciss2Node = multiply(referenceNum, factor2).simplify();
+            }
+            break;
+    }
+    const axisUnitNode = frac(referenceNum, den).simplify();
+    const identifiers = {
+        abscissType,
+        axisUnit: axisUnitNode.toIdentifiers(),
+        absciss1: absciss1Node.toIdentifiers(),
+        absciss2: absciss2Node.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    questionType: ["standard", "éviter le comptage"],
+    numberType: ["Entiers", "Rationnels", "Décimaux"],
+};
+const options = [
+    {
+        id: "questionType",
+        label: "Type de question",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["standard", "éviter le comptage"],
+        defaultValue: optsDefault.questionType,
+    },
+    {
+        id: "numberType",
+        label: "Type de nombres",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+        values: ["Entiers", "Rationnels", "Décimaux"],
+        defaultValue: optsDefault.numberType,
+    },
+];
+export const placeAbscissOnSemiLineV2 = {
+    id: "placeAbscissOnSemiLineV2",
+    label: "Placer un point d'abscisse donnée sur une demi-droite graduée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlaceAbscissOnSemiLineV2Question(opts), nb),
+    options,
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "GGB",
+};

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

@@ -103,7 +103,7 @@ const createRandomNode = (numberType, isPossibleProba) => {
             case "Fraction": {
                 if (probaFlip(0.7)) {
                     const num = randint(0, 10_000);
-                    const den = randint(num, 20_000);
+                    const den = randint(num, 20_000, [0]);
                     return frac(num, den);
                 }
                 else {
@@ -145,7 +145,7 @@ const createRandomNode = (numberType, isPossibleProba) => {
                     const num = coinFlip()
                         ? randint(10_000, 20_000)
                         : randint(-20_000, -10_000);
-                    const den = randint(0, abs(num).evaluate());
+                    const den = randint(1, abs(num).evaluate());
                     return frac(num, den);
                 }
                 else {

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

@@ -57,12 +57,12 @@ const situations = [
     {
         context: "Dans une émission TV, le présentateur demande son prénom à quelqu'un dans le public.",
         strA: "Le prénom est Jean-Michel.",
-        strB: 'Le prénom commence par la lettre "A".',
+        strB: "La personne est un adulte.",
         "(A)": "que le prénom soit Jean-Michel",
-        "(B)": 'que le prénom commence par la lettre "J"',
-        "(A \\cap B)": 'que le prénom soit Jean-Michel et qu\'il commence par un "A"',
-        "_A(B)": 'que le prénom commence par un "A", sachant que c\'est Jean-Michel',
-        "_B(A)": 'que le prénom soit Jean-Michel, sachant qu\'il commence par un "A"',
+        "(B)": "que la personne soit un adulte",
+        "(A \\cap B)": "que le prénom soit Jean-Michel et que la personne soit un adulte",
+        "_A(B)": "que la personne soit un adulte, sachant que son prénom est Jean-Michel",
+        "_B(A)": "que le prénom soit Jean-Michel, sachant que la personne est un adulte",
     },
     {
         context: "Il est $14$h$37$. Yohann et Sarah sont assis en classe. C'est un cours sur les probabilités.",
@@ -119,7 +119,7 @@ Soit $B$ l'évenement :
 
 Écris en langage mathématique : 
 
-La probabilité ${situation[pType]}.`;
+> La probabilité ${situation[pType]}.`;
     return instruction;
 };
 const getAnswer = (identifiers) => {

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

@@ -22,7 +22,6 @@ type EventIdentifiers = {
 type Options = {
     nbElem: string[];
     unionLength: string[];
-    isProbasAreNumbers: boolean;
 };
 export declare const probaAsSumOfProbas: Exercise<Identifiers, Options>;
 export {};

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

@@ -1 +1 @@
-{"version":3,"file":"probaAsSumOfProbas.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaAsSumOfProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAkBT,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,gBAAgB,GACjB;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,eAAe,CAAC;CACpB,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,eAAe,CAAC;IACnB,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AA4eN,KAAK,OAAO,GAAG;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,kBAAkB,EAAE,OAAO,CAAC;CAC7B,CAAC;AAqRF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe7D,CAAC"}
+{"version":3,"file":"probaAsSumOfProbas.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/probaStat/probaAsSumOfProbas.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EAkBT,MAAM,mBAAmB,CAAC;AAK3B,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAa7C,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,QAAQ,EAAE,gBAAgB,CAAC;IAC3B,QAAQ,EAAE,eAAe,EAAE,CAAC;CAC7B,CAAC;AAEF,KAAK,gBAAgB,GACjB;IACE,IAAI,EAAE,YAAY,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,eAAe,CAAC;CACpB,GACD;IACE,IAAI,EAAE,OAAO,CAAC;IACd,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,eAAe,CAAC;IACnB,WAAW,EAAE,gBAAgB,EAAE,CAAC;IAChC,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AA0eN,KAAK,OAAO,GAAG;IACb,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB,CAAC;AAsQF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAe7D,CAAC"}