math-exercises 3.0.163 → 3.0.164

package/lib/exercises/math/functions/trinoms/roots/index.d.ts

@@ -5,4 +5,5 @@ export * from "./rootsFromFactorizedForm.js";
 export * from "./rootsProduct.js";
 export * from "./rootsReading.js";
 export * from "./rootsSum.js";
+export * from "./trinomAlgebraicFormFromRootsAndPoint.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/trinoms/roots/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,uBAAuB,CAAC;AACtC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,mBAAmB,CAAC;AAClC,cAAc,mBAAmB,CAAC;AAClC,cAAc,eAAe,CAAC;AAC9B,cAAc,2CAA2C,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/index.js

@@ -5,3 +5,4 @@ export * from "./rootsFromFactorizedForm.js";
 export * from "./rootsProduct.js";
 export * from "./rootsReading.js";
 export * from "./rootsSum.js";
+export * from "./trinomAlgebraicFormFromRootsAndPoint.js";

package/lib/exercises/math/functions/trinoms/roots/rootsFromFactorizedForm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rootsFromFactorizedForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromFactorizedForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkHF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAazD,CAAC"}
+{"version":3,"file":"rootsFromFactorizedForm.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/rootsFromFactorizedForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiJF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/rootsFromFactorizedForm.js

@@ -4,18 +4,48 @@ import { Trinom, TrinomConstructor } from "../../../../../math/polynomials/trino
 import { randint } from "../../../../../math/utils/random/randint.js";
 import { OppositeNode } from "../../../../../tree/nodes/functions/oppositeNode.js";
 import { NumberNode } from "../../../../../tree/nodes/numbers/numberNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
 import { discreteSetParser } from "../../../../../tree/parsers/discreteSetParser.js";
 import { shuffle } from "../../../../../utils/alea/shuffle.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
-// const getHint: GetHint<Identifiers> = (identifiers) => {
-//   return `Un produit est nul si et seulement si un de ses facteurs est nul.
-// Il faut donc trouver les valeurs de $x$ qui rendent un des facteurs nuls.`;
-// };
-// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {
-//   const { a, b, c } = identifiers;
-//   const trinom = new Trinom(a, b, c);
-//   return ``;
-// };
+const getHint = () => {
+    return `Un produit est nul si et seulement si un de ses facteurs est nul.
+
+Il faut donc trouver les valeurs de $x$ qui rendent un des facteurs nuls.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, c } = identifiers;
+    const trinom = new Trinom(a, b, c);
+    const roots = trinom.getRootsNode();
+    const factors = roots.map((r) => substract("x", r).simplify());
+    return `Un produit est nul si et seulement si un de ses facteurs est nul.
+
+${roots.length === 2
+        ? `Or,
+
+$$
+${factors[0].toTex()} = 0 \\iff x = ${roots[0].toTex()} 
+$$
+
+et
+
+$$
+${factors[1].toTex()} = 0 \\iff x = ${roots[1].toTex()} 
+$$
+`
+        : `Or, 
+  
+$$
+${square(factors[0]).toTex()} = 0 \\iff x = ${roots[0].toTex()} 
+$$`}
+
+L'ensemble des solutions de $f(x) = 0$ est donc : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
 const getInstruction = (identifiers) => {
     const { a, b, c } = identifiers;
     const trinom = new Trinom(a, b, c);
@@ -45,6 +75,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
         keys: ["S", "equal", "lbrace", "semicolon", "rbrace", "varnothing"],
         answerFormat: "tex",
         identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -94,4 +126,5 @@ export const rootsFromFactorizedForm = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/trinoms/roots/trinomAlgebraicFormFromRootsAndPoint.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../../math/geometry/point.js";
+import { NodeIdentifiers } from "../../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    rootsIds: NodeIdentifiers[];
+    pointIds: PointIdentifiers;
+};
+type Options = {
+    expectedForm: string;
+};
+export declare const trinomAlgebraicFormFromRootsAndPoint: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=trinomAlgebraicFormFromRootsAndPoint.d.ts.map

package/lib/exercises/math/functions/trinoms/roots/trinomAlgebraicFormFromRootsAndPoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trinomAlgebraicFormFromRootsAndPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/roots/trinomAlgebraicFormFromRootsAndPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,EAAE,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AA4RF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAWF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,WAAW,EACX,OAAO,CAwBR,CAAC"}

package/lib/exercises/math/functions/trinoms/roots/trinomAlgebraicFormFromRootsAndPoint.js

@@ -0,0 +1,252 @@
+import { addValidProp, shuffleProps, GeneratorOptionTarget, GeneratorOptionType, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../../math/utils/random/randTupleInt.js";
+import { reifyAlgebraic, } from "../../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { square } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const getPropositions = (n, { answer }, opts) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, getAnswer(generateIdentifiers(), opts));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswerNode = (identifiers, options) => {
+    const { pointIds, rootsIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const roots = rootsIds.map((rootId) => reifyAlgebraic(rootId));
+    const partialTrinom = roots.length === 1
+        ? square(substract("x", roots[0]).simplify())
+        : multiply(substract("x", roots[0]).simplify(), substract("x", roots[1]).simplify());
+    const partialImage = partialTrinom
+        .toDetailedEvaluation({ x: point.x })
+        .simplify();
+    const a = frac(point.y, partialImage).simplify();
+    const facto = multiply(a, partialTrinom).simplify({ forbidFactorize: true });
+    if (options?.expectedForm === "Forme développée")
+        return facto.simplify({ towardsDistribute: true, forbidFactorize: true });
+    return facto;
+};
+const getAnswer = (identifiers, opts) => {
+    return getAnswerNode(identifiers, opts).toTex();
+};
+const getInstruction = (identifiers, opts) => {
+    const { pointIds, rootsIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const roots = rootsIds.map((rootId) => reifyAlgebraic(rootId));
+    return `Soit $f$ une fonction polynôme du second degré, dont la parabole passe par le point $${point.toTexWithCoords()}$, et qui a ${roots.length === 1
+        ? `pour seule racine : $${roots[0].toTex()}$`
+        : `deux racines : $${roots[0].toTex()}$ et $${roots[1].toTex()}$`}
+  
+Déterminer la forme ${opts?.expectedForm === "Forme développée" ? "développée" : "factorisée"} de $f(x)$.
+`;
+};
+const getHint = () => {
+    return `Si $f$ est une fonction polynôme du second degré ayant deux racines $x_1$ et $x_2$, alors sa forme factorisée est : 
+  
+$$
+f(x) = a(x-x_1)(x-x_2)
+$$
+
+Si elle n'admet qu'une racine $x_0$, alors sa forme factorisée est :
+
+$$
+f(x) = a(x-x_0)^2 
+$$
+
+Sers-toi ensuite du fait que $A$ appartient à la courbe de $f$ pour déterminer $a$.
+`;
+};
+const getCorrection = (identifiers, opts) => {
+    const { pointIds, rootsIds } = identifiers;
+    const point = PointConstructor.fromIdentifiers(pointIds);
+    const roots = rootsIds.map((rootId) => reifyAlgebraic(rootId));
+    const partialTrinom = roots.length === 1
+        ? square(substract("x", roots[0]).simplify())
+        : multiply(substract("x", roots[0]).simplify(), substract("x", roots[1]).simplify());
+    const partialImage = partialTrinom
+        .toDetailedEvaluation({ x: point.x })
+        .simplify();
+    const a = frac(point.y, partialImage).simplify();
+    if (roots.length === 1) {
+        return `Puisque $f$ a une seule racine $${roots[0].toTex()}$, sa forme factorisée est :
+    
+$$
+f(x) = ${multiply("a", square(substract("x", roots[0]).simplify())).toTex()}
+$$
+
+Pour déterminer $a$, on utilise le fait que $${point.toTexWithCoords()}$ appartient à la parabole représentative de $f$. Cela implique que $f(${point.x.toTex()})=${point.y.toTex()}$. Donc : 
+
+$$
+${multiply("a", square(substract(point.x, roots[0]))).toTex()}=${point.y.toTex()}
+$$
+
+d'où $a =${a.toTex()}$.
+
+La forme factorisée de $f$ est donc : 
+
+$$
+f(x) = ${multiply(a, partialTrinom).toTex()}
+$$
+
+${opts?.expectedForm === "Forme développée"
+            ? `
+Il suffit alors de développer et réduire pour obtenir la forme développée : 
+
+${alignTex([
+                ["f(x)", "=", multiply(a, partialTrinom).toTex()],
+                [
+                    "",
+                    "=",
+                    multiply(a, partialTrinom.simplify({
+                        towardsDistribute: true,
+                        forbidFactorize: true,
+                    })).toTex(),
+                ],
+                [
+                    "",
+                    "=",
+                    multiply(a, partialTrinom)
+                        .simplify({ towardsDistribute: true, forbidFactorize: true })
+                        .toTex(),
+                ],
+            ])}
+`
+            : ""}
+`;
+    }
+    return `Puisque $f$ a deux racines $${roots[0].toTex()}$ et $${roots[1].toTex()}$, sa forme factorisée est :
+    
+$$
+f(x) = ${multiply("a", multiply(substract("x", roots[0]).simplify(), substract("x", roots[1]).simplify())).toTex()}
+$$
+
+Pour déterminer $a$, on utilise le fait que $${point.toTexWithCoords()}$ appartient à la parabole représentative de $f$. Cela implique que $f(${point.x.toTex()})=${point.y.toTex()}$. Donc : 
+
+$$
+${multiply("a", multiply(substract(point.x, roots[0]).simplify(), substract(point.x, roots[1]).simplify())).toTex()}=${point.y.toTex()}
+$$
+
+d'où $a =${a.toTex()}$.
+
+La forme factorisée de $f$ est donc : 
+
+$$
+f(x) = ${multiply(a, partialTrinom).toTex()}
+$$
+
+${opts?.expectedForm === "Forme développée"
+        ? `
+Il suffit alors de développer et réduire pour obtenir la forme développée : 
+
+${alignTex([
+            ["f(x)", "=", multiply(a, partialTrinom).toTex()],
+            [
+                "",
+                "=",
+                multiply(a, partialTrinom.simplify({
+                    towardsDistribute: true,
+                    forbidFactorize: true,
+                })).toTex(),
+            ],
+            [
+                "",
+                "=",
+                multiply(a, partialTrinom)
+                    .simplify({ towardsDistribute: true, forbidFactorize: true })
+                    .toTex(),
+            ],
+        ])}
+`
+        : ""}`;
+};
+const getKeys = () => {
+    return ["xsquare", "x"];
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        const ansNode = getAnswerNode(identifiers, opts);
+        return (parsed
+            .simplify({ towardsDistribute: true, forbidFactorize: true })
+            .toTex() ===
+            ansNode
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const generateIdentifiers = (_options) => {
+    const uniqueRoot = coinFlip();
+    const roots = uniqueRoot
+        ? [randint(-9, 10, [0])]
+        : randTupleInt(2, {
+            from: -9,
+            to: 10,
+            allDifferent: true,
+        }).sort((a, b) => a - b);
+    const a = randint(-9, 10, [0]);
+    const pointX = randint(-9, 10, roots);
+    const pointY = multiply(a, uniqueRoot
+        ? square(substract(pointX, roots[0]))
+        : multiply(substract(pointX, roots[0]), substract(pointX, roots[1]))).simplify();
+    const point = new Point("A", pointX, pointY);
+    return {
+        pointIds: point.toIdentifiers(),
+        rootsIds: roots.map((r) => r.toTree().toIdentifiers()),
+    };
+};
+const getTrinomAlgebraicFormFromRootsAndPointQuestion = (opts) => {
+    return getQuestionFromIdentifiers(generateIdentifiers(opts), opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    return {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+    };
+};
+const options = [
+    {
+        id: "expectedForm",
+        label: "Forme attendue",
+        target: GeneratorOptionTarget.answer,
+        type: GeneratorOptionType.select,
+        values: ["Forme développée", "Forme factorisée"],
+        defaultValue: "Forme factorisée",
+    },
+];
+export const trinomAlgebraicFormFromRootsAndPoint = {
+    id: "trinomAlgebraicFormFromRootsAndPoint",
+    connector: "=",
+    label: "Déterminer l'expression algébrique d'un trinôme en connaissant ses racines et un point de la parabole",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTrinomAlgebraicFormFromRootsAndPointQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    options,
+};

package/lib/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.d.ts

@@ -4,6 +4,9 @@ type Identifiers = {
     summitIds: PointIdentifiers;
     pointIds: PointIdentifiers;
 };
-export declare const devFormFromSummitAndPoint: Exercise<Identifiers>;
+type Options = {
+    expectedForm: string;
+};
+export declare const devFormFromSummitAndPoint: Exercise<Identifiers, Options>;
 export {};
 //# sourceMappingURL=devFormFromSummitAndPoint.d.ts.map

package/lib/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"devFormFromSummitAndPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAyLF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAmB3D,CAAC"}
+{"version":3,"file":"devFormFromSummitAndPoint.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAWtC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,gBAAgB,CAAC;IAC5B,QAAQ,EAAE,gBAAgB,CAAC;CAC5B,CAAC;AAyNF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAaF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBpE,CAAC"}

package/lib/exercises/math/functions/trinoms/summitAndCanonical/devFormFromSummitAndPoint.js

@@ -1,4 +1,4 @@
-import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, GeneratorOptionTarget, GeneratorOptionType, } from "../../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
 import { Point, PointConstructor, } from "../../../../../math/geometry/point.js";
 import { randint } from "../../../../../math/utils/random/randint.js";
@@ -10,7 +10,7 @@ import { substract } from "../../../../../tree/nodes/operators/substractNode.js"
 import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
 import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
 import { alignTex } from "../../../../../utils/latex/alignTex.js";
-const getPropositions = (n, { answer }) => {
+const getPropositions = (n, { answer }, opts) => {
     const propositions = [];
     addValidProp(propositions, answer);
     propWhile(propositions, n, () => {
@@ -23,27 +23,30 @@ const getPropositions = (n, { answer }) => {
             pointIds: point.toIdentifiers(),
             summitIds: summit.toIdentifiers(),
         };
-        tryToAddWrongProp(propositions, getAnswer(fakeIds));
+        tryToAddWrongProp(propositions, getAnswer(fakeIds, opts));
     });
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
+const getAnswerNode = (identifiers, opts) => {
     const { pointIds, summitIds } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIds);
     const summit = PointConstructor.fromIdentifiers(summitIds);
     const a = frac(substract(point.y, summit.y), square(substract(point.x, summit.x))).simplify();
-    const cano = add(multiply(a, square(substract("x", summit.x))), summit.y);
-    return cano
-        .simplify({ towardsDistribute: true, forbidFactorize: true })
-        .toTex();
+    const cano = add(multiply(a, square(substract("x", summit.x).simplify())), summit.y);
+    if (opts?.expectedForm === "Forme canonique")
+        return cano;
+    return cano.simplify({ towardsDistribute: true, forbidFactorize: true });
 };
-const getInstruction = (identifiers) => {
+const getAnswer = (identifiers, opts) => {
+    return getAnswerNode(identifiers, opts).toTex();
+};
+const getInstruction = (identifiers, opts) => {
     const { pointIds, summitIds } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIds);
     const summit = PointConstructor.fromIdentifiers(summitIds);
     return `On considère une fonction polynôme du second degré $f$. Sa parabole passe par le point $${point.toTexWithCoords()}$, et son sommet est $${summit.toTexWithCoords()}$. 
   
-Déterminer la forme développée de $f$.`;
+Déterminer la forme ${opts?.expectedForm === "Forme canonique" ? "canonique" : "développée"} de $f$.`;
 };
 const getHint = (identifiers) => {
     return `La forme canonique d'une fonction polynôme du second degré $f$ est : 
@@ -56,7 +59,7 @@ où $\\alpha$ est l'abscisse du sommet de la parabole, et $\\beta$ son ordonnée
 
 Utilise cette formule ici, puis le fait que le point $${PointConstructor.fromIdentifiers(identifiers.pointIds).toTexWithCoords()}$ est un point de la parabole pour déterminer $a$.`;
 };
-const getCorrection = (identifiers) => {
+const getCorrection = (identifiers, opts) => {
     const { pointIds, summitIds } = identifiers;
     const point = PointConstructor.fromIdentifiers(pointIds);
     const summit = PointConstructor.fromIdentifiers(summitIds);
@@ -88,49 +91,59 @@ ${alignTex([
         ["a", "=", a.simplify().toTex()],
     ])}
 
-Il ne reste plus qu'à développer la forme canonique de $f$ :
+${opts?.expectedForm === "Forme canonique"
+        ? `La forme canonique de $f$ est donc : 
+    
+$$
+f(x) = ${getAnswer(identifiers, opts)}
+$$`
+        : `Il ne reste plus qu'à développer la forme canonique de $f$ :
 
 ${alignTex([
-        [
-            "f(x)",
-            "=",
-            add(multiply(a, square(substract("x", alpha))), beta)
-                .simplify()
-                .toTex(),
-        ],
-        [
-            "",
-            "=",
-            add(multiply(a, square(substract("x", alpha)).simplify({
-                towardsDistribute: true,
-                forbidFactorize: true,
-            })), beta).toTex(),
-        ],
-        [
-            "",
-            "=",
-            add(multiply(a, square(substract("x", alpha))), beta)
-                .simplify({ towardsDistribute: true, forbidFactorize: true })
-                .toTex(),
-        ],
-    ])}
-`;
+            [
+                "f(x)",
+                "=",
+                add(multiply(a, square(substract("x", alpha))), beta)
+                    .simplify()
+                    .toTex(),
+            ],
+            [
+                "",
+                "=",
+                add(multiply(a, square(substract("x", alpha)).simplify({
+                    towardsDistribute: true,
+                    forbidFactorize: true,
+                })), beta).toTex(),
+            ],
+            [
+                "",
+                "=",
+                add(multiply(a, square(substract("x", alpha))), beta)
+                    .simplify({ towardsDistribute: true, forbidFactorize: true })
+                    .toTex(),
+            ],
+        ])}
+`}`;
 };
 const getKeys = () => {
     return ["xsquare", "x"];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }, opts) => {
     try {
         const parsed = parseAlgebraic(ans);
+        const ansNode = getAnswerNode(identifiers, opts);
         return (parsed
             .simplify({ towardsDistribute: true, forbidFactorize: true })
-            .toTex() === answer);
+            .toTex() ===
+            ansNode
+                .simplify({ towardsDistribute: true, forbidFactorize: true })
+                .toTex());
     }
     catch (err) {
         return handleVEAError(err);
     }
 };
-const getDevFormFromSummitAndPointQuestion = () => {
+const getDevFormFromSummitAndPointQuestion = (opts) => {
     const summit = PointConstructor.random("S");
     const a = randint(-10, 10, [0]);
     const pointX = randint(-10, 10, [summit.x.evaluate()]);
@@ -140,23 +153,33 @@ const getDevFormFromSummitAndPointQuestion = () => {
         pointIds: point.toIdentifiers(),
         summitIds: summit.toIdentifiers(),
     };
-    return getQuestionFromIdentifiers(identifiers);
+    return getQuestionFromIdentifiers(identifiers, opts);
 };
-const getQuestionFromIdentifiers = (identifiers) => {
+const getQuestionFromIdentifiers = (identifiers, opts) => {
     return {
-        answer: getAnswer(identifiers),
-        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
         keys: getKeys(identifiers),
         answerFormat: "tex",
         identifiers,
-        hint: getHint(identifiers),
-        correction: getCorrection(identifiers),
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
     };
 };
+const options = [
+    {
+        id: "expectedForm",
+        label: "Forme attendue",
+        target: GeneratorOptionTarget.answer,
+        type: GeneratorOptionType.select,
+        values: ["Forme développée", "Forme canonique"],
+        defaultValue: "Forme développée",
+    },
+];
 export const devFormFromSummitAndPoint = {
     id: "devFormFromSummitAndPoint",
     connector: "=",
-    label: "Déterminer la forme développée d'un trinôme en connaissant un point et le sommet de la parabole",
+    label: "Déterminer l'expression algébrique d'un trinôme en connaissant un point et le sommet de la parabole",
     isSingleStep: true,
     generator: (nb, opts) => getDistinctQuestions(() => getDevFormFromSummitAndPointQuestion(opts), nb),
     qcmTimer: 60,
@@ -169,5 +192,6 @@ export const devFormFromSummitAndPoint = {
     getCorrection,
     getAnswer,
     getQuestionFromIdentifiers,
+    options,
     hasHintAndCorrection: true,
 };

package/lib/index.d.ts

@@ -1397,6 +1397,11 @@ declare const mathExercises: (Exercise<{
 }> | Exercise<{
     trinomIdentifiers: import("./tree/nodes/polynomials/trinomNode.js").TrinomNodeIdentifiers;
 }, Record<string, string | boolean | string[]>> | Exercise<{
+    rootsIds: import("./tree/nodes/nodeConstructor.js").NodeIdentifiers[];
+    pointIds: import("./math/geometry/point.js").PointIdentifiers;
+}, {
+    expectedForm: string;
+}> | Exercise<{
     trinomCoeffs: number[];
     isAskingPositive: boolean;
 }, Record<string, string | boolean | string[]>> | Exercise<{
@@ -1442,7 +1447,9 @@ declare const mathExercises: (Exercise<{
 }, Record<string, string | boolean | string[]>> | Exercise<{
     summitIds: import("./math/geometry/point.js").PointIdentifiers;
     pointIds: import("./math/geometry/point.js").PointIdentifiers;
-}, Record<string, string | boolean | string[]>> | Exercise<{
+}, {
+    expectedForm: string;
+}> | Exercise<{
     type: number;
     points: number[][];
 }, Record<string, string | boolean | string[]>> | Exercise<{

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.163",
+  "version": "3.0.164",
   "description": "Math exercises generator for middle school and high school",
   "main": "lib/index.js",
   "files": [