math-exercises 3.0.129 → 3.0.131

package/lib/exercises/math/calcul/ordering/compareA10N.d.ts

@@ -3,9 +3,14 @@ type A10N = {
     a: number;
     n: number;
 };
+type Item = {
+    tex: string;
+    isValid: boolean;
+};
 type Identifiers = {
     signType: string;
-    items: A10N[];
+    a10Ns: A10N[];
+    items: Item[];
 };
 type Options = {
     signTypes: string[];

package/lib/exercises/math/calcul/ordering/compareA10N.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareA10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareA10N.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,IAAI,GAAG;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAwTF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AA0CF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAetD,CAAC"}
+{"version":3,"file":"compareA10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareA10N.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAkBrC,KAAK,IAAI,GAAG;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAEF,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AA2TF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,EAAE,CAAC;IACpB,YAAY,EAAE,MAAM,EAAE,CAAC;CACxB,CAAC;AAyCF,eAAO,MAAM,WAAW,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgBtD,CAAC"}

package/lib/exercises/math/calcul/ordering/compareA10N.js

@@ -6,12 +6,11 @@ import { round } from "../../../../math/utils/round.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply, } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
-import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
 import { random, randomMany } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
-import { permute } from "../../../../utils/arrays/permutations.js";
+import { getAllPicks } from "../../../../utils/arrays/getAllPicks.js";
 const getTexForA10N = (a10N) => {
     const { a, n } = a10N;
     return `${a.frenchify()} \\times 10^{${n}}`;
@@ -55,12 +54,14 @@ const compareFuncForA10N = (a10N1, a10N2) => {
     }
 };
 const getInstruction = (identifiers) => {
-    const { items } = identifiers;
-    return `Ranger par ordre croissant les nombres suivants :
+    const { a10Ns } = identifiers;
+    return `Voici une liste de nombres :
 
-$$
-${items.map((item) => getTexForA10N(item)).join(" ; ")}
-$$`;
+${a10Ns.map((a10N) => `- $${getTexForA10N(a10N)}$`).join(`
+  
+`)}
+
+Parmi les propositions suivantes, lesquelles sont vraies ?`;
 };
 const getHint = (identifiers) => {
     const { signType } = identifiers;
@@ -87,15 +88,15 @@ On range les puissances de $10$ en ordre croissant, puis pour chaque puissance d
 `;
 };
 const getCorrection = (identifiers) => {
-    const { signType, items } = identifiers;
+    const { signType, a10Ns } = identifiers;
     return `Même si on a l'impression que les nombres sont écris en écriture scientifique, ce n'est pas le cas. 
 Il faut les convertir en écriture scientifique et utiliser cette écriture pour les ranger dans l'ordre croissant.
 
-${items
-        .map((item) => `
+${a10Ns
+        .map((a10N) => `
   
 $$
-${getTexForA10N(item)} = ${getSciMultNodeForA10N(item).toTex()}
+${getTexForA10N(a10N)} = ${getSciMultNodeForA10N(a10N).toTex()}
 $$
 
 `)
@@ -104,45 +105,45 @@ $$
 ${(() => {
         switch (signType) {
             case "positifs": {
-                const positive = items.toSorted(compareFuncForA10N);
+                const positive = a10Ns.toSorted(compareFuncForA10N);
                 return `Ici, tous les nombres sont positifs, donc
 on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
 C'est un double tri.
 
 $$
-${positive.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${positive.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Conclusion :
 
 $$
-${positive.map((item) => getTexForA10N(item)).join("<")}
+${positive.map((a10N) => getTexForA10N(a10N)).join("<")}
 $$
 
 `;
             }
             case "négatifs": {
-                const negative = items.toSorted(compareFuncForA10N);
+                const negative = a10Ns.toSorted(compareFuncForA10N);
                 return `Ici, tous les nombres sont négatifs, donc
 on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
 C'est un double tri.
 
 $$
-${negative.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${negative.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Conclusion :
 
 $$
-${negative.map((item) => getTexForA10N(item)).join("<")}
+${negative.map((a10N) => getTexForA10N(a10N)).join("<")}
 $$
 `;
             }
             case "mélange": {
-                const positive = items
+                const positive = a10Ns
                     .filter(({ a }) => a >= 0)
                     .toSorted(compareFuncForA10N);
-                const negative = items
+                const negative = a10Ns
                     .filter(({ a }) => a < 0)
                     .toSorted(compareFuncForA10N);
                 return `Ici, il y a des nombres négatifs et des nombres positifs.
@@ -150,20 +151,20 @@ On commence par les négatifs :
 on range les puissances de $10$ en ordre décroissant, puis pour chaque puissance de $10$, les facteurs en ordre décroissant.
 
 $$
-${negative.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${negative.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Puis on range les positifs :
 on range les puissances de $10$ en ordre croissant, puis pour chaque puissance de $10$, les facteurs en ordre croissant.
 
 $$
-${positive.map((item) => getSciMultNodeForA10N(item).toTex()).join("<")}
+${positive.map((a10N) => getSciMultNodeForA10N(a10N).toTex()).join("<")}
 $$
 
 Conclusion :
 
 $$
-${[...negative, ...positive].map((item) => getTexForA10N(item)).join("<")}
+${[...negative, ...positive].map((a10N) => getTexForA10N(a10N)).join("<")}
 $$
 `;
             }
@@ -174,37 +175,23 @@ $$
 const getPropositions = (n, { answer, ...identifiers }) => {
     const { items } = identifiers;
     const propositions = [];
-    addValidProp(propositions, answer);
-    permute(items)
-        .slice(0, 5)
-        .forEach((permutedItems) => {
-        const arrayOfTex = permutedItems.map((item) => getTexForA10N(item));
-        tryToAddWrongProp(propositions, arrayOfTex.join("<"));
-        tryToAddWrongProp(propositions, arrayOfTex.join(">"));
+    items.forEach((item) => {
+        if (item.isValid) {
+            addValidProp(propositions, item.tex);
+        }
+        else {
+            tryToAddWrongProp(propositions, item.tex);
+        }
     });
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
-    const { items } = identifiers;
-    const answer = items
-        .toSorted(compareFuncForA10N)
-        .map((item) => getTexForA10N(item))
-        .join("<");
-    return answer;
-};
-const isAnswerValid = (ans, { answer, items }) => {
-    const nbItems = items.length;
-    const [ansNodes, answerNodes] = [ans, answer].map((str) => str.split("<").map((tex) => parseAlgebraic(tex)));
-    return (ansNodes.length === nbItems &&
-        [...Array(nbItems).keys()].every((i) => ansNodes[i].equals(answerNodes[i])));
-};
 const getKeys = (identifiers) => {
-    const { items } = identifiers;
+    const { a10Ns } = identifiers;
     return [
         "sup",
         "inf",
-        ...items.map((item) => {
-            const tex = getTexForA10N(item);
+        ...a10Ns.map((a10N) => {
+            const tex = getTexForA10N(a10N);
             return {
                 id: "custom",
                 label: tex,
@@ -263,14 +250,34 @@ const getCompareA10NQuestion = (optsIn) => {
         arrayOfN.push(random(subPoolOfN) + random([-2, -1, 0, 1, 2]));
     }
     arrayOfN = shuffle(arrayOfN);
-    const items = [...Array(nbItems).keys()].map((i) => {
+    const a10Ns = [...Array(nbItems).keys()].map((i) => {
         return {
             a: arrayOfA[i],
             n: arrayOfN[i],
         };
     });
+    const nbTotal = 4;
+    const nbValid = randint(1, 4);
+    const ascOrderedA10Ns = a10Ns.toSorted(compareFuncForA10N);
+    const items = shuffle(shuffle(getAllPicks(ascOrderedA10Ns).filter((arr) => arr.length === 2))
+        .slice(0, nbTotal)
+        .map(([a10N1, a10N2], i) => {
+        if (i < nbValid) {
+            return {
+                tex: `${getTexForA10N(a10N1)}<${getTexForA10N(a10N2)}`,
+                isValid: true,
+            };
+        }
+        else {
+            return {
+                tex: `${getTexForA10N(a10N2)}<${getTexForA10N(a10N1)}`,
+                isValid: false,
+            };
+        }
+    }));
     return getQuestionFromIdentifiers({
         signType,
+        a10Ns,
         items,
     });
 };
@@ -298,7 +305,6 @@ const options = [
 ];
 const getQuestionFromIdentifiers = (identifiers, opts) => {
     const question = {
-        answer: getAnswer(identifiers),
         instruction: getInstruction(identifiers),
         keys: getKeys(identifiers),
         answerFormat: "tex",
@@ -318,9 +324,10 @@ export const compareA10N = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
 };

package/lib/exercises/math/calcul/ordering/compareABUsingQuotient.js

@@ -10,7 +10,7 @@ const getInstruction = (identifiers) => {
     const [A, B] = orderedNodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds).toTex());
     return `Sachant que $\\frac{${B}}{${A}} > 1$,
   
-comparer $${B}$ et $${A}$.;`;
+comparer $${B}$ et $${A}$.`;
 };
 const getHint = (identifiers) => {
     const { orderedNodeIds } = identifiers;

package/lib/exercises/math/calcul/ordering/compareFracAndDec.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareFracAndDec.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracAndDec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAiBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAW7C,KAAK,OAAO,GAAG;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AA0SF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,OAAO,CAAC;CACpC,CAAC;AAuBF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB5D,CAAC"}
+{"version":3,"file":"compareFracAndDec.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareFracAndDec.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAU7C,KAAK,OAAO,GAAG;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,MAAM,CAAC;IACZ,OAAO,EAAE,eAAe,CAAC;IACzB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,aAAa,EAAE,CAAC;IAChC,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AA6RF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,OAAO,CAAC;CACpC,CAAC;AAuBF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB5D,CAAC"}

package/lib/exercises/math/calcul/ordering/compareFracAndDec.js

@@ -5,7 +5,6 @@ import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
 import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
 import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
-import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
 import { random } from "../../../../utils/alea/random.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
@@ -108,11 +107,6 @@ const getAnswer = (identifiers) => {
     const answer = items.find((item) => item.isValidAnswer).tex;
     return answer;
 };
-const isAnswerValid = (ans, { answer }) => {
-    const [ansNodes, answerNodes] = [ans, answer].map((str) => str.split(">").map((tex) => parseAlgebraic(tex)));
-    return (ansNodes.length === 3 &&
-        [0, 1, 2].every((i) => substract(ansNodes[i], answerNodes[i]).evaluate() === 0));
-};
 const getKeys = (identifiers, optsIn) => {
     const { questionParams } = identifiers;
     const opts = Object.assign(optsDefault, optsIn);
@@ -249,9 +243,9 @@ export const compareFracAndDec = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calcul/ordering/compareWithSquareRoots.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareWithSquareRoots.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareWithSquareRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AA+KF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}
+{"version":3,"file":"compareWithSquareRoots.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/compareWithSquareRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAsIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAexD,CAAC"}

package/lib/exercises/math/calcul/ordering/compareWithSquareRoots.js

@@ -1,12 +1,7 @@
 import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
-import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
-import { add } from "../../../../tree/nodes/operators/addNode.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";
 const getInstruction = (identifiers) => {
     const { a, b, isAdd } = identifiers;
     return `Sachant que  $\\sqrt{${a}} < \\sqrt{${a + 1}}$,
@@ -48,44 +43,10 @@ $$
 
 `;
 };
-const getAnswerNodes = (identifiers) => {
-    const { a, b, isAdd } = identifiers;
-    const addSub = isAdd ? add : substract;
-    const nodeWithA = addSub(b, sqrt(a));
-    const nodeWithAPlus1 = addSub(b, sqrt(add(a, 1)));
-    return isAdd ? [nodeWithA, nodeWithAPlus1] : [nodeWithAPlus1, nodeWithA];
-};
 const getAnswer = (identifiers) => {
     const { a, b, isAdd } = identifiers;
     return `${b}${isAdd ? "+" : "-"}\\sqrt{${a}}${isAdd ? "<" : ">"}${b}${isAdd ? "+" : "-"}\\sqrt{${a + 1}}`;
 };
-const isAnswerValid = (ans, { answer, ...identifiers }) => {
-    function getOrderedNodesFromTex(tex, compSymbol) {
-        return tex
-            .split(compSymbol)
-            .map((str) => parseAlgebraic(str))
-            .toSorted(() => (compSymbol === "<" ? +1 : -1));
-    }
-    try {
-        const compSymbol = ans.includes("<")
-            ? "<"
-            : ans.includes(">")
-                ? ">"
-                : undefined;
-        if (compSymbol) {
-            const [ansNode1, ansNode2] = getOrderedNodesFromTex(ans, compSymbol);
-            const [answerNode1, answerNode2] = getAnswerNodes(identifiers);
-            return (substract(ansNode1, answerNode1).simplify().evaluate() === 0 &&
-                substract(ansNode2, answerNode2).simplify().evaluate() === 0);
-        }
-        else {
-            return false;
-        }
-    }
-    catch (err) {
-        return handleVEAError(err);
-    }
-};
 const getPropositions = (nbProps, { answer, ...identifiers }) => {
     const { a, b, isAdd } = identifiers;
     const propositions = [];
@@ -140,10 +101,10 @@ export const compareWithSquareRoots = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     getAnswer,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calcul/rounding/estimateAroundPow10NTimesAroundPow10N.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"estimateAroundPow10NTimesAroundPow10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/estimateAroundPow10NTimesAroundPow10N.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAerC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+EF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAmBvE,CAAC"}
+{"version":3,"file":"estimateAroundPow10NTimesAroundPow10N.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/estimateAroundPow10NTimesAroundPow10N.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAmEF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAmBvE,CAAC"}

package/lib/exercises/math/calcul/rounding/estimateAroundPow10NTimesAroundPow10N.js

@@ -3,9 +3,7 @@ import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQue
 import { randint } from "../../../../math/utils/random/randint.js";
 import { add } from "../../../../tree/nodes/operators/addNode.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
-import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { coinFlip } from "../../../../utils/alea/coinFlip.js";
-import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 import { toSeperatedThousands } from "../../../../utils/numberPrototype/toSeparatedThousands.js";
 const toPrettyString = (node) => {
     return toSeperatedThousands("" + node.evaluate().toFixed(0));
@@ -28,18 +26,6 @@ const getAnswer = (identifiers) => {
     const { n } = identifiers;
     return `10^{${2 * n}}`;
 };
-const isAnswerValid = (ans, { answer }) => {
-    try {
-        const ansNode = parseAlgebraic(ans);
-        const answerNode = parseAlgebraic(answer);
-        return ansNode
-            .simplify({ calculatePowers: true })
-            .equals(answerNode.simplify({ calculatePowers: true }));
-    }
-    catch (err) {
-        return handleVEAError(err);
-    }
-};
 const getPropositions = (nbProps, { answer, ...identifiers }) => {
     const { n } = identifiers;
     const propositions = [];
@@ -74,10 +60,10 @@ export const estimateAroundPow10NTimesAroundPow10N = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     getAnswer,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calcul/rounding/estimatePow10NPlusPow10MinusN.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"estimatePow10NPlusPow10MinusN.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/estimatePow10NPlusPow10MinusN.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAwFF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAmB/D,CAAC"}
+{"version":3,"file":"estimatePow10NPlusPow10MinusN.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/rounding/estimatePow10NPlusPow10MinusN.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA8EF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAmB/D,CAAC"}

package/lib/exercises/math/calcul/rounding/estimatePow10NPlusPow10MinusN.js

@@ -2,9 +2,7 @@ import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exer
 import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
 import { randint } from "../../../../math/utils/random/randint.js";
 import { power } from "../../../../tree/nodes/operators/powerNode.js";
-import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
 import { random } from "../../../../utils/alea/random.js";
-import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
 const getInstruction = (identifiers) => {
     const { n, varName } = identifiers;
     const A = varName;
@@ -34,16 +32,6 @@ const getAnswer = (identifiers) => {
     const { n } = identifiers;
     return `10^{${n}}`;
 };
-const isAnswerValid = (ans, { answer }) => {
-    try {
-        const ansNode = parseAlgebraic(ans);
-        const answerNode = parseAlgebraic(answer);
-        return ansNode.simplify().equals(answerNode.simplify());
-    }
-    catch (err) {
-        return handleVEAError(err);
-    }
-};
 const getPropositions = (nbProps, { answer, ...identifiers }) => {
     const { n } = identifiers;
     const propositions = [];
@@ -80,10 +68,10 @@ export const estimatePow10NPlusPow10MinusN = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    isAnswerValid,
     getAnswer,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calculLitteral/equation/equationFromProblem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationFromProblem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromProblem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAetE,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA6qBF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}
+{"version":3,"file":"equationFromProblem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationFromProblem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAC;AAKlE,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AActE,KAAK,WAAW,GAAG;IACjB,oBAAoB,EAAE,MAAM,CAAC;IAC7B,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC,CAAC;IACzE,cAAc,EAAE,MAAM,CAAC;IACvB,aAAa,EAAE,MAAM,EAAE,EAAE,CAAC;IAC1B,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AAmrBF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAcrD,CAAC"}

package/lib/exercises/math/calculLitteral/equation/equationFromProblem.js

@@ -10,7 +10,6 @@ import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { substract } from "../../../../tree/nodes/operators/substractNode.js";
 import { random, randomMany } from "../../../../utils/alea/random.js";
 import { isOperatorNode, OperatorIds, } from "../../../../tree/nodes/operators/operatorNode.js";
-import { mdTable } from "../../../../utils/markdown/mdTable.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
 class ProblemConstructor {
     static byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays) {
@@ -291,7 +290,13 @@ const getInstruction = (identifiers) => {
     const { problemSkeletonIndex, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays, } = identifiers;
     const skeleton = skeletons[problemSkeletonIndex];
     const problem = ProblemConstructor.byHydratingSkeleton(skeleton, groupNameToVarNameToValue, mysteryVarPath, shuffleArrays);
-    return `${mdTable([[""], [problem.frenchStr]])}
+    return `Voici une situation :
+
+$\\ $ 
+
+${problem.frenchStr}
+
+$\\ $
   
 Parmi les équations suivantes, laquelle modélise cette situation ?`;
 };

package/lib/exercises/math/calculLitteral/equation/equationWithDistributivity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"equationWithDistributivity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationWithDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA+HF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAgEF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}
+{"version":3,"file":"equationWithDistributivity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/equationWithDistributivity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAmBT,MAAM,6BAA6B,CAAC;AAmBrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyIF,KAAK,OAAO,GAAG;IACb,gBAAgB,EAAE,OAAO,CAAC;CAC3B,CAAC;AAgEF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAerE,CAAC"}

package/lib/exercises/math/calculLitteral/equation/equationWithDistributivity.js

@@ -24,16 +24,15 @@ const getPropositions = (n, { answer }, opts) => {
     });
     return shuffleProps(propositions, n);
 };
-const getAnswer = (identifiers) => {
+const getAnswerNode = (identifiers) => {
     const { type, a, b, c, d, e, f } = identifiers;
-    const sol = type
-        ? frac(substract(multiply(d, f), multiply(a, c)), substract(multiply(a, b), multiply(d, e)))
-            .simplify()
-            .toTex()
-        : frac(substract(e, multiply(a, c)), substract(multiply(a, b), d))
-            .simplify()
-            .toTex();
-    return `x=${sol}`;
+    return type
+        ? frac(substract(multiply(d, f), multiply(a, c)), substract(multiply(a, b), multiply(d, e))).simplify()
+        : frac(substract(e, multiply(a, c)), substract(multiply(a, b), d)).simplify();
+};
+const getAnswer = (identifiers) => {
+    const answerNode = getAnswerNode(identifiers);
+    return `x=${answerNode.toTex()}`;
 };
 const getInstruction = (identifiers) => {
     const { type, a, b, c, d, e, f } = identifiers;
@@ -100,11 +99,16 @@ $$
 const getKeys = () => {
     return ["x", "equal"];
 };
-const isAnswerValid = (ans, { answer }) => {
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
     const parsed = equationSolutionParser(ans);
     if (!parsed)
         return false;
-    return `x=${parsed.toTex()}` === answer;
+    return (`x=${parsed.toTex()}` === answer ||
+        (() => {
+            const ansNode = parsed;
+            const answerNode = getAnswerNode(identifiers);
+            return substract(ansNode, answerNode).simplify().evaluate() === 0;
+        })());
 };
 const getEquationWithDistributivityQuestion = (opts) => {
     const type = random([0, 1]);

package/lib/exercises/math/calculLitteral/equation/multiplicationEquation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}
+{"version":3,"file":"multiplicationEquation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/equation/multiplicationEquation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAkIF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/math/calculLitteral/equation/multiplicationEquation.js

@@ -8,6 +8,8 @@ import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
 import { DiscreteSetNode } from "../../../../tree/nodes/sets/discreteSetNode.js";
 import { alignTex } from "../../../../utils/latex/alignTex.js";
 import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { SetVEA } from "../../../../exercises/vea/setVEA.js";
+import { discreteSetParser } from "../../../../tree/parsers/discreteSetParser.js";
 const getStatementNode = (identifiers) => {
     const { a, b, c, d } = identifiers;
     const polynome1 = new Polynomial([b, a]);
@@ -110,14 +112,13 @@ const getPropositions = (n, { answer }) => {
     return shuffle(propositions);
 };
 const isAnswerValid = (ans, { a, b, c, d }) => {
+    const parsed = discreteSetParser(ans);
+    if (!parsed)
+        return false;
     const sol1 = new Rational(-b, a).simplify().toTree();
     const sol2 = new Rational(-d, c).simplify().toTree();
     const sortedSols = -b / a < -d / c ? [sol1, sol2] : [sol2, sol1];
-    const answer = new EquationSolutionNode(new DiscreteSetNode(sortedSols), {
-        opts: { allowFractionToDecimal: true },
-    });
-    const texs = answer.toAllValidTexs();
-    return texs.includes(ans);
+    return SetVEA.isArrayOfNodesValid(parsed.elements, sortedSols);
 };
 export const multiplicationEquation = {
     id: "multiplicationEquation",

package/lib/exercises/math/calculLitteral/factorisation/index.d.ts

@@ -6,5 +6,4 @@ export * from "./factorizeCanonicalForm.js";
 export * from "./factorizeCanonicalFormWithSqrt.js";
 export * from "./factoType2.js";
 export * from "./factoByX.js";
-export * from "./factorizeAX2PlusBX.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calculLitteral/factorisation/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC;AAC9B,cAAc,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/factorisation/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,aAAa,CAAC;AAC5B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,qCAAqC,CAAC;AACpD,cAAc,iBAAiB,CAAC;AAChC,cAAc,eAAe,CAAC"}

package/lib/exercises/math/calculLitteral/factorisation/index.js

@@ -6,4 +6,4 @@ export * from "./factorizeCanonicalForm.js";
 export * from "./factorizeCanonicalFormWithSqrt.js";
 export * from "./factoType2.js";
 export * from "./factoByX.js";
-export * from "./factorizeAX2PlusBX.js";
+// export * from "./factorizeAX2PlusBX.js"; //! existe déjà

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareAMinusB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareAMinusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAyMF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}
+{"version":3,"file":"compareAMinusB.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/ordering/compareAMinusB.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,cAAc,EAAE,MAAM,EAAE,CAAC;IACzB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAqMF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAchD,CAAC"}

package/lib/exercises/math/calculLitteral/ordering/compareAMinusB.js

@@ -66,9 +66,6 @@ const getAnswer = (identifiers) => {
     const { texsAnswer } = identifiers;
     return texsAnswer[0];
 };
-const isAnswerValid = (ans, { texsAnswer }) => {
-    return texsAnswer.includes(ans);
-};
 const getCompareAMinusBQuestion = () => {
     const namesPool = ["a", "b", "c", "d", "r", "s", "t", "u", "v"];
     const names = randomMany(namesPool, 2);
@@ -175,10 +172,10 @@ export const compareAMinusB = {
     generator: (nb, opts) => getDistinctQuestions(() => getCompareAMinusBQuestion(opts), nb, 30),
     qcmTimer: 60,
     freeTimer: 60,
-    isAnswerValid,
     getPropositions,
     subject: "Mathématiques",
     maxAllowedQuestions: 30,
     getQuestionFromIdentifiers,
     hasHintAndCorrection: true,
+    answerType: "QCU",
 };

package/lib/exercises/math/calculLitteral/simplifying/compareATimes0.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compareATimes0.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/compareATimes0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAwHF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}
+{"version":3,"file":"compareATimes0.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calculLitteral/simplifying/compareATimes0.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,IAAI,GAAG;IACV,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAqGF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAehD,CAAC"}