math-exercises 3.0.191 → 3.0.192

package/lib/exercises/math/derivation/applications/findYearForDecreasingPopulation.js

@@ -0,0 +1,145 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { Affine } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.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 { firstDegreeInequationResolutionTex } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, coeffs, isAskingX }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    propWhile(propositions, n, () => {
+        if (isAskingX)
+            tryToAddWrongProp(propositions, (2013 + randint(1, 20)).frenchify());
+        else
+            tryToAddWrongProp(propositions, trinom
+                .toTree()
+                .toDetailedEvaluation({
+                x: randint(1, 20).toTree(),
+            })
+                .simplify()
+                .toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { coeffs, isAskingX } = identifiers;
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    const a = round(2 * coeffs[2], 4);
+    const b = coeffs[1];
+    const root = frac(-b, a).simplify();
+    if (isAskingX) {
+        return round(2013 + root.evaluate(), 4).frenchify();
+    }
+    return trinom
+        .toTree()
+        .toDetailedEvaluation({
+        x: root,
+    })
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { coeffs, isAskingX } = identifiers;
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    return `On estime que la population d'une ville, exprimée en milliers d'habitants, peut être modélisée par la fonction $f$ définie sur $[0; +\\infty[$ par :
+  
+$$
+f(x) = ${trinom.toTree().toTex()}
+$$
+
+où $x$ est la durée, en année, écoulée depuis $2013$.
+
+${isAskingX
+        ? `En quelle année la population de la ville est-elle maximale ?`
+        : `Quelle est la population maximale de la ville ?`}`;
+};
+const getHint = () => {
+    return `Calcule la dérivée $f'$ de $f$, puis étudie son signe. Le maximum de $f$ est atteint pour la valeur de $x$ telle que $f'(x) = 0$ et telle que $f'$ change de signe en $x$.`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs } = identifiers;
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    const a = round(2 * coeffs[2], 4);
+    const b = coeffs[1];
+    const affine = new Affine(a, b);
+    const root = frac(-b, a).simplify();
+    const froot = trinom.toTree().toDetailedEvaluation({ x: root }).simplify();
+    return `On calcule $f'(x)$ : 
+  
+$$
+f'(x) = ${trinom.derivate().toTree().toTex()}
+$$
+
+On étudie ensuite le signe de $f'(x)$ :
+
+$$
+${firstDegreeInequationResolutionTex(affine, "\\ge", (0).toTree())}
+$$
+
+On en déduit donc que $f$ atteint son maximum pour $x = ${root.toTex()}$, et on a alors : 
+
+$$
+f(${root.toTex()}) = ${froot.toTex()}
+$$
+
+La population de la ville est donc maximale à l'année $${round(2013 + root.evaluate(), 4)}$, et elle est alors de $${froot.toTex()}$ milliers d'habitants.`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindYearForDecreasingPopulationQuestion = () => {
+    const alpha = randint(1, 20);
+    const beta = randfloat(10, 100, 2);
+    const a = randfloat(-0.9, -0.1, 2);
+    const b = round(-2 * a * alpha, 4);
+    const c = round((beta + a * alpha) ^ 2, 4);
+    const identifiers = {
+        isAskingX: coinFlip(),
+        coeffs: [c, b, a],
+    };
+    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 findYearForDecreasingPopulation = {
+    id: "findYearForDecreasingPopulation",
+    connector: "=",
+    label: "Déterminer le maximum d'une population (dérivation)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindYearForDecreasingPopulationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/applications/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./maxBenefice.js";
 export * from "./minimalCost.js";
+export * from "./findYearForDecreasingPopulation.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/derivation/applications/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/applications/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/applications/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sCAAsC,CAAC"}

package/lib/exercises/math/derivation/applications/index.js

@@ -1,2 +1,3 @@
 export * from "./maxBenefice.js";
 export * from "./minimalCost.js";
+export * from "./findYearForDecreasingPopulation.js";

package/lib/exercises/math/probaStat/conditional/fillTableConditionalProbabilitySituation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fillTableConditionalProbabilitySituation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/conditional/fillTableConditionalProbabilitySituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAGL,wBAAwB,EACzB,MAAM,iCAAiC,CAAC;AAEzC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,wBAAwB,CAAC;CAClC,CAAC;AAsOF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAqB1E,CAAC"}
+{"version":3,"file":"fillTableConditionalProbabilitySituation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/conditional/fillTableConditionalProbabilitySituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAUrC,OAAO,EAGL,wBAAwB,EACzB,MAAM,iCAAiC,CAAC;AAEzC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,wBAAwB,CAAC;CAClC,CAAC;AA2OF,eAAO,MAAM,wCAAwC,EAAE,QAAQ,CAAC,WAAW,CAqB1E,CAAC"}

package/lib/exercises/math/probaStat/conditional/fillTableConditionalProbabilitySituation.js

@@ -37,7 +37,12 @@ const getAnswerTable = (identifiers) => {
                 .toTex()}`,
             `${substract(1, mainEventProbaDec).simplify().toTex()}`,
         ],
-        ["Total", `${pb.toTex()}`, `${substract(1, pb).simplify().toTex()}`, "1"],
+        [
+            "\\text{Total}",
+            `${pb.toTex()}`,
+            `${substract(1, pb).simplify().toTex()}`,
+            "1",
+        ],
     ];
 };
 const getInstruction = (identifiers) => {
@@ -199,7 +204,7 @@ const getQuestionFromIdentifiers = (identifiers) => {
             ],
             [`$${situation.mainEvent}$`, "", "", ""],
             [`$\\overline{${situation.mainEvent}}$`, "", "", ""],
-            ["Total", "", "", "1"],
+            ["\\text{Total}", "", "", "1"],
         ],
     };
 };

package/lib/exercises/math/probaStat/stats1var/marginalAndConditionalFrequency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"marginalAndConditionalFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/marginalAndConditionalFrequency.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAYT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAmMF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAajE,CAAC"}
+{"version":3,"file":"marginalAndConditionalFrequency.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats1var/marginalAndConditionalFrequency.ts"],"names":[],"mappings":"AAOA,OAAO,EACL,QAAQ,EAcT,MAAM,sBAAsB,CAAC;AAG9B,KAAK,WAAW,GAAG;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AAyPF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAcjE,CAAC"}

package/lib/exercises/math/probaStat/stats1var/marginalAndConditionalFrequency.js

@@ -1,131 +1,194 @@
-import { Rational } from "../../../../math/numbers/rationals/rational.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
 import { randint } from "../../../../math/utils/random/randint.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
 import { dollarize } from "../../../../utils/latex/dollarize.js";
 import { mdTable } from "../../../../utils/markdown/mdTable.js";
 import { addValidProp, propWhile, tryToAddWrongProp, } from "../../../exercise.js";
 import { getDistinctQuestions } from "../../../utils/getDistinctQuestions.js";
-const getFreqStrings = (rand) => {
+const getFreqStrings = (identifiers) => {
+    const { rand, x1, x2, x3, x4 } = identifiers;
+    const total = x1 + x2 + x3 + x4;
     let freqString = "";
     let frequence = "";
+    let mainEvent = "";
+    let subEvent = "";
+    let num = 0;
+    let denum = 0;
     switch (rand) {
         case 0:
             freqString = "marginale de $A$";
             frequence = "f(A)";
+            mainEvent = "A";
+            num = x1 + x3;
+            denum = total;
             break;
         case 1:
             freqString = "marginale de $B$";
             frequence = "f(B)";
+            mainEvent = "B";
+            num = x2 + x4;
+            denum = total;
             break;
         case 2:
             freqString = "marginale de $C$";
             frequence = "f(C)";
+            mainEvent = "C";
+            num = x1 + x2;
+            denum = total;
             break;
         case 3:
             freqString = "marginale de $D$";
             frequence = "f(D)";
+            mainEvent = "D";
+            num = x3 + x4;
+            denum = total;
             break;
         case 4:
             freqString = "conditionnelle de $A$ parmi $C$";
             frequence = "f_C(A)";
+            mainEvent = "A";
+            subEvent = "C";
+            num = x1;
+            denum = x1 + x2;
             break;
         case 5:
             freqString = "conditionnelle de $A$ parmi $D$";
             frequence = "f_D(A)";
+            mainEvent = "A";
+            subEvent = "D";
+            num = x3;
+            denum = x3 + x4;
             break;
         case 6:
             freqString = "conditionnelle de $B$ parmi $C$";
             frequence = "f_C(B)";
+            mainEvent = "B";
+            subEvent = "C";
+            num = x2;
+            denum = x1 + x2;
             break;
         case 7:
             freqString = "conditionnelle de $B$ parmi $D$";
             frequence = "f_D(B)";
+            mainEvent = "B";
+            subEvent = "D";
+            num = x4;
+            denum = x3 + x4;
             break;
         case 8:
             freqString = "conditionnelle de $C$ parmi $A$";
             frequence = "f_A(C)";
+            mainEvent = "C";
+            subEvent = "A";
+            num = x1;
+            denum = x1 + x3;
             break;
         case 9:
             freqString = "conditionnelle de $C$ parmi $B$";
             frequence = "f_B(C)";
+            mainEvent = "C";
+            subEvent = "B";
+            num = x2;
+            denum = x2 + x4;
             break;
         case 10:
             freqString = "conditionnelle de $D$ parmi $A$";
             frequence = "f_A(D)";
+            mainEvent = "D";
+            subEvent = "A";
+            num = x3;
+            denum = x1 + x3;
             break;
         case 11:
             freqString = "conditionnelle de $D$ parmi $B$";
             frequence = "f_B(D)";
+            mainEvent = "D";
+            subEvent = "B";
+            num = x4;
+            denum = x2 + x4;
             break;
         default:
             throw Error("error");
     }
-    return { freqString, frequence };
+    return { freqString, frequence, mainEvent, subEvent, num, denum };
 };
-const getInstruction = ({ x1, x2, x3, x4, rand, }) => {
-    const { freqString } = getFreqStrings(rand);
+const getInstruction = (identifiers) => {
+    const { x1, x2, x3, x4 } = identifiers;
+    const { freqString } = getFreqStrings(identifiers);
     return `On considère le tableau d'effectifs suivant : 
 
 ${mdTable([
-        [" ", "$A$", "$B$"],
-        ["$C$", dollarize(x1), dollarize(x2)],
-        ["$D$", dollarize(x3), dollarize(x4)],
+        [" ", "$A$", "$B$", "Total"],
+        ["$C$", dollarize(x1), dollarize(x2), dollarize(x1 + x2)],
+        ["$D$", dollarize(x3), dollarize(x4), dollarize(x3 + x4)],
+        [
+            "Total",
+            dollarize(x1 + x3),
+            dollarize(x2 + x4),
+            dollarize(x1 + x2 + x3 + x4),
+        ],
     ])}
 
-Calculer la fréquence ${freqString}.`;
+Calculer la fréquence ${freqString} (donner la valeur exacte ou une valeur arrondie au centième).`;
 };
-const getAnswerNode = (rand, x1, x2, x3, x4) => {
-    const x = x1 + x2 + x3 + x4;
-    let answer;
-    switch (rand) {
-        case 0:
-            answer = new Rational(x1 + x3, x).simplify().toTree();
-            break;
-        case 1:
-            answer = new Rational(x2 + x4, x).simplify().toTree();
-            break;
-        case 2:
-            answer = new Rational(x1 + x2, x).simplify().toTree();
-            break;
-        case 3:
-            answer = new Rational(x3 + x4, x).simplify().toTree();
-            break;
-        case 4:
-            answer = new Rational(x1, x1 + x2).simplify().toTree();
-            break;
-        case 5:
-            answer = new Rational(x3, x3 + x4).simplify().toTree();
-            break;
-        case 6:
-            answer = new Rational(x2, x1 + x2).simplify().toTree();
-            break;
-        case 7:
-            answer = new Rational(x4, x3 + x4).simplify().toTree();
-            break;
-        case 8:
-            answer = new Rational(x1, x1 + x3).simplify().toTree();
-            break;
-        case 9:
-            answer = new Rational(x2, x2 + x4).simplify().toTree();
-            break;
-        case 10:
-            answer = new Rational(x3, x1 + x3).simplify().toTree();
-            break;
-        case 11:
-            answer = new Rational(x4, x2 + x4).simplify().toTree();
-            break;
-        default:
-            throw Error("error");
-    }
-    return answer;
+const getAnswerNode = (identifiers) => {
+    const { num, denum } = getFreqStrings(identifiers);
+    return frac(num, denum).simplify();
 };
 const getAnswer = (identifiers) => {
-    const { rand, x1, x2, x3, x4 } = identifiers;
-    const answerNode = getAnswerNode(rand, x1, x2, x3, x4);
+    const answerNode = getAnswerNode(identifiers);
     const answer = answerNode.toTex();
     return answer;
 };
+const getHint = (identifiers) => {
+    const { rand } = identifiers;
+    if (rand < 4) {
+        return `La fréquence marginale de $M$ s'obtient par le calcul : 
+    
+$$
+f(M) = \\frac{\\text{effectif total de } M}{\\text{effectif total}}
+$$`;
+    }
+    return `La fréquence conditionnelle de $M$ parmi $N$ s'obtient par le calcul : 
+    
+$$
+f_N(M) = \\frac{\\text{effectif vérifiant à la fois } M \\text{ et } N}{\\text{effectif marginal de } N}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { rand } = identifiers;
+    const { freqString, frequence, mainEvent, subEvent, num, denum } = getFreqStrings(identifiers);
+    if (rand < 4) {
+        return `La fréquence ${freqString} s'obtient par le calcul : 
+    
+$$
+${frequence} = \\frac{\\text{effectif total de } ${mainEvent}}{\\text{effectif total}}
+$$
+
+Ici, l'effectif total est $${denum.frenchify()}$, et l'effectif total de $${mainEvent}$ est $${num}$.
+    
+On a donc : 
+
+$$
+${frequence} = ${frac(num, denum).toSimplificationTex()}
+$$`;
+    }
+    return `La fréquence ${freqString} s'obtient par le calcul : 
+    
+$$
+${frequence} = \\frac{\\text{effectif vérifiant à la fois } ${mainEvent} \\text{ et } ${subEvent}}{\\text{effectif marginal de } ${subEvent}}
+$$
+
+Ici, l'effectif vérifiant à la fois $${mainEvent}$ et $${subEvent}$ est $${num}$, et l'effectif marginal de $${subEvent}$ est $${denum}$.
+    
+On a donc :
+
+$$
+${frequence} = ${frac(num, denum).toSimplificationTex()}
+$$`;
+};
 const getMarginalAndConditionalFrequency = () => {
     const [x1, x2, x3, x4] = [1, 2, 3, 4].map((_el) => randint(1, 100));
     const rand = randint(0, 12);
@@ -135,7 +198,7 @@ const getMarginalAndConditionalFrequency = () => {
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         instruction: getInstruction(identifiers),
-        startStatement: `${getFreqStrings(identifiers.rand).frequence}`,
+        startStatement: `${getFreqStrings(identifiers).frequence}`,
         answer: getAnswer(identifiers),
         keys: ["f", "cap", "underscore"],
         answerFormat: "tex",
@@ -147,6 +210,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
                 firstRowIsHeader: true,
             },
         },
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -155,15 +220,19 @@ const getPropositions = (n, { answer, x1, x2, x3, x4 }) => {
     addValidProp(propositions, answer);
     propWhile(propositions, n, () => {
         const fakeRand = randint(0, 12);
-        const answerTree = getAnswerNode(fakeRand, x1 + random([0, 1]), x2 + random([0, 1]), x3 + random([0, 1]), x4 + random([0, 1]));
+        const answerTree = getAnswerNode({
+            rand: fakeRand,
+            x1: x1 + random([0, 1]),
+            x2: x2 + random([0, 1]),
+            x3: x3 + random([0, 1]),
+            x4: x4 + random([0, 1]),
+        });
         tryToAddWrongProp(propositions, answerTree.toTex());
     });
     return shuffle(propositions);
 };
-const isAnswerValid = (ans, { rand, x1, x2, x3, x4 }) => {
-    const answerTree = getAnswerNode(rand, x1, x2, x3, x4);
-    const texs = answerTree.toAllValidTexs({ allowFractionToDecimal: true });
-    return texs.includes(ans);
+const isAnswerValid = (ans, { answer }) => {
+    return rationalVEA(ans, answer);
 };
 export const marginalAndConditionalFrequency = {
     id: "marginalAndConditionalFrequency",
@@ -177,4 +246,5 @@ export const marginalAndConditionalFrequency = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/index.d.ts

@@ -1257,6 +1257,9 @@ declare const mathExercises: (Exercise<{
 }, {
     method: string;
 }> | Exercise<{
+    coeffs: number[];
+    isAskingX: boolean;
+}, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     a: number;
@@ -4385,32 +4388,9 @@ declare const mathExercises: (Exercise<{
     values: number[][];
     caseAsked: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    labels: string[];
-    data: number[];
-    itemAsked: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    isAskingX: boolean;
-    xValue?: number;
-    yValue?: number;
-    a: number;
-    b: number;
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    points: number[][];
-    labels: string[];
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    quartiles: number[];
-    arrQuartileIndex: (0 | 1 | 2 | 3 | 4)[];
-    typeQ: "below" | "between" | "above";
-}, Record<string, string | boolean | string[]>> | Exercise<{
-    quartileIndex: 0 | 1 | 2 | 3 | 4;
-    quartiles: number[];
+    coeffs: (number | undefined)[][];
 }, Record<string, string | boolean | string[]>> | Exercise<{
-    indexTopic: number;
-    isLess: boolean;
-    arrDistrib: {
-        name: string;
-        indicators: number[];
-    }[];
+    coeffs: (number | undefined)[][];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     barChart: {
         description: string;
@@ -4450,6 +4430,19 @@ declare const mathExercises: (Exercise<{
 }, {
     displayType: string;
 }> | Exercise<{
+    labels: string[];
+    data: number[];
+    itemAsked: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    isAskingX: boolean;
+    xValue?: number;
+    yValue?: number;
+    a: number;
+    b: number;
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    points: number[][];
+    labels: string[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
     indexSituation: number;
     bigNumber: number;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -4462,6 +4455,20 @@ declare const mathExercises: (Exercise<{
     evolutionType: string;
 }, Record<string, string | boolean | string[]>> | Exercise<{
     quartiles: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    quartileIndex: 0 | 1 | 2 | 3 | 4;
+    quartiles: number[];
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    quartiles: number[];
+    arrQuartileIndex: (0 | 1 | 2 | 3 | 4)[];
+    typeQ: "below" | "between" | "above";
+}, Record<string, string | boolean | string[]>> | Exercise<{
+    indexTopic: number;
+    isLess: boolean;
+    arrDistrib: {
+        name: string;
+        indicators: number[];
+    }[];
 }, Record<string, string | boolean | string[]>> | Exercise<{
     indexSituation: number;
     maxOrScam: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,aAAa,MAAM,2BAA2B,CAAC;AAE3D,OAAO,4BAA4B,CAAC;AACpC,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kDAA6B,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "math-exercises",
   "type": "module",
-  "version": "3.0.191",
+  "version": "3.0.192",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [