math-exercises 3.0.100 → 3.0.102

package/lib/exercises/math/python/pythonSimpleFunctionInstructionCompletion.js

@@ -0,0 +1,89 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { add } from "../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, answer.replace("*", ""), "raw");
+    tryToAddWrongProp(propositions, answer.replace("*", "x"), "raw");
+    tryToAddWrongProp(propositions, answer.replace("*", "+"), "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { m, p } = identifiers;
+    const mString = m < 0 ? m.toString() : `+${m}`;
+    return `\`${p}${mString}*a\``;
+};
+const getInstruction = (identifiers) => {
+    const { m, p } = identifiers;
+    return `La fonction en Python suivante doit permettre, pour un paramètre \`a\` saisi en entrée, de calculer $${add(p, multiply(m, "a").simplify({ forbidFactorize: true })).toTex()}$.
+
+Par quoi faut-il remplacer les trois points ?
+  
+\`\`\`
+def calcul(a):
+  return ...
+\`\`\`
+`;
+};
+const getHint = (identifiers) => {
+    return `En Python, la multiplication se note \`*\`.`;
+};
+const getCorrection = (identifiers) => {
+    const { p, m } = identifiers;
+    return `En Python, la multiplication se note \`*\`.
+  
+L'opération $${add(p, multiply(m, "a").simplify({ forbidFactorize: true })).toTex()}$ se note donc : 
+  
+${getAnswer(identifiers)}`;
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPythonSimpleFunctionInstructionCompletionQuestion = (ops) => {
+    const identifiers = {
+        m: randint(-10, 11, [-1, 0, 1]),
+        p: randint(-10, 11, [0]),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const pythonSimpleFunctionInstructionCompletion = {
+    id: "pythonSimpleFunctionInstructionCompletion",
+    label: "Compléter une fonction en Python (calcul simple)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPythonSimpleFunctionInstructionCompletionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    threshold: number;
+};
+export declare const pythonWhileStatementCompletion: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pythonWhileStatementCompletion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pythonWhileStatementCompletion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonWhileStatementCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAgFF,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,CAsBhE,CAAC"}

package/lib/exercises/math/python/pythonWhileStatementCompletion.js

@@ -0,0 +1,87 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, threshold }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, `\`${threshold}\``, "raw");
+    tryToAddWrongProp(propositions, `\`x>${threshold}\``, "raw");
+    tryToAddWrongProp(propositions, `\`x*3\``, "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return `\`x<${identifiers.threshold}\``;
+};
+const getInstruction = (identifiers) => {
+    return `On considère la fonction en Python ci-dessous. Cette fonction doit permettre, pour un paramètre \`x\` saisi en entrée, de déterminer combien de fois on doit tripler ce nombre pour qu'il dépasse $${identifiers.threshold}$.
+  
+Par quoi faut-il remplacer les trois points ?
+
+\`\`\`
+def boucle(x):
+  compt=0
+  while ...:
+    x=x*3
+    compt=compt+1
+  return compt
+\`\`\`
+`;
+};
+const getHint = (identifiers) => {
+    return `La boucle \`while\` doit s'exécuter tant que \`x\` n'a pas dépassé $${identifiers.threshold}$.`;
+};
+const getCorrection = (identifiers) => {
+    return `On veut que la boucle \`while\` s'exécute tant que \`x\` est  inférieur à $${identifiers.threshold}$. En python, cela se traduit par : 
+  
+\`\`\`
+while x<${identifiers.threshold}:
+\`\`\`
+`;
+};
+const getKeys = (identifiers) => {
+    return ["x", "sup", "inf", "equal"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPythonWhileStatementCompletionQuestion = (ops) => {
+    const identifiers = {
+        threshold: 50 * randint(2, 20),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const pythonWhileStatementCompletion = {
+    id: "pythonWhileStatementCompletion",
+    label: "Compléter la condition d'une boucle `while` en Python",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPythonWhileStatementCompletionQuestion(opts), nb, 15),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+    maxAllowedQuestions: 15,
+};

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

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    operation: string;
+    coeff: number;
+};
+export declare const pythonWhileStatementOperationCompletion: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pythonWhileStatementOperationCompletion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pythonWhileStatementOperationCompletion.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/python/pythonWhileStatementOperationCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IAEjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAwGF,eAAO,MAAM,uCAAuC,EAAE,QAAQ,CAAC,WAAW,CAsBzE,CAAC"}

package/lib/exercises/math/python/pythonWhileStatementOperationCompletion.js

@@ -0,0 +1,120 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { random } from "../../../utils/alea/random.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, operation, coeff }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, `\`${operation}${coeff}\``, "raw");
+    tryToAddWrongProp(propositions, `\`x>1500\``, "raw");
+    tryToAddWrongProp(propositions, `\`${coeff}\``, "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return `\`x${identifiers.operation}${identifiers.coeff}\``;
+};
+const getInstruction = (identifiers) => {
+    const { coeff, operation } = identifiers;
+    let word = "";
+    if (operation === "*") {
+        if (coeff === 2)
+            word = "doubler ce nombre";
+        else if (coeff === 3)
+            word = "tripler ce nombre";
+        else
+            word = `multiplier ce nombre par $${coeff}$`;
+    }
+    else {
+        word = `additionner $${coeff}$ à ce nombre`;
+    }
+    return `On considère la fonction en Python ci-dessous. Cette fonction doit permettre, pour un paramètre \`x\` saisi en entrée, de déterminer combien de fois on doit ${word} pour qu'il dépasse $1500$.
+  
+Par quoi faut-il remplacer les trois points ?
+
+\`\`\`
+def boucle(x):
+  compt=0
+  while x<1500:
+    x=...
+    compt=compt+1
+  return compt
+\`\`\`
+`;
+};
+const getHint = (identifiers) => {
+    const { coeff, operation } = identifiers;
+    return `Sers-toi de cet exemple : en Python, si l'on veut diviser une variable \`a\` par $2$, on écrit : 
+  
+\`\`\`
+a = a/2
+\`\`\``;
+};
+const getCorrection = (identifiers) => {
+    const { coeff, operation } = identifiers;
+    let word = "";
+    if (operation === "*") {
+        if (coeff === 2)
+            word = "doubler `x` ";
+        else if (coeff === 3)
+            word = "tripler `x`";
+        else
+            word = `multiplier \`x\` par $${coeff}$`;
+    }
+    else {
+        word = `additionner $${coeff}$ à \`x\``;
+    }
+    return `On veut  ${word} à chaque exécution de la boucle \`while\`. En python, cela se traduit par : 
+  
+\`\`\`
+x=x${operation}${coeff}
+\`\`\`
+`;
+};
+const getKeys = (identifiers) => {
+    return ["x", "sup", "inf", "equal"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return ans === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPythonWhileStatementCompletionQuestion = (ops) => {
+    const identifiers = {
+        operation: random(["+", "*"]),
+        coeff: randint(2, 11),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const pythonWhileStatementOperationCompletion = {
+    id: "pythonWhileStatementOperationCompletion",
+    label: "Compléter une instruction dans une boucle `while` en Python",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPythonWhileStatementCompletionQuestion(opts), nb, 15),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+    maxAllowedQuestions: 15,
+};

package/lib/exercises/math/sampling/samplingFrequency.js

@@ -22,7 +22,7 @@ const getAnswer = (identifiers) => {
 };
 const getInstruction = (identifiers) => {
     const length = identifiers.samples.length;
-    return `Ce graphique donne les fréquences $${length}$ échantillons d'une expérience aléatoire. Estimer la probabilité de l'évènement $A$.`;
+    return `Ce graphique donne les fréquences de $${length}$ échantillons d'une expérience aléatoire. Estimer la probabilité de l'évènement $A$.`;
 };
 const getHint = (identifiers) => {
     return `Chaque échantillon donne une valeur approximative proche de la probabilité réelle. 

package/lib/index.d.ts

@@ -1381,6 +1381,10 @@ declare const mathExercises: (Exercise<{
     shape: "square" | "rectangle";
     side: number;
     side2?: number;
+}, {}> | Exercise<{
+    isEqui: boolean;
+    side: number;
+    base?: number;
 }, {}> | Exercise<{
     ratio: number;
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
@@ -1751,6 +1755,15 @@ declare const mathExercises: (Exercise<{
 }, {}> | Exercise<{
     triangleIdentifiers: import("./math/geometry/triangles/triangle.js").TriangleIdentifiers;
     angleAsked: number;
+}, {}> | Exercise<{
+    perimeter: number;
+    askingX: boolean;
+}, {}> | Exercise<{
+    shape: number;
+    side: number;
+}, {}> | Exercise<{
+    shape: number;
+    side: number;
 }, {}> | Exercise<{
     coeffs: number[];
     to: "+\\infty" | "-\\infty";
@@ -2511,6 +2524,25 @@ declare const mathExercises: (Exercise<{
     a: number;
     b: number;
     opName: string;
+}, {}> | Exercise<{
+    coeff: number;
+    iterations: number;
+    operation: string;
+}, {}> | Exercise<{
+    ineq: string;
+    coeff: number;
+}, {}> | Exercise<{
+    threshold: number;
+}, {}> | Exercise<{
+    operation: string;
+    coeff: number;
+}, {}> | Exercise<{
+    coeff: number;
+    iterations: number;
+    operation: string;
+}, {}> | Exercise<{
+    m: number;
+    p: number;
 }, {}> | Exercise<{
     p: number;
     n: 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;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,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;AAE/D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA+B,CAAC;AACnD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAA6B,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.100",
+  "version": "3.0.102",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [