math-exercises 3.0.125 → 3.0.127

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

@@ -0,0 +1,368 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.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, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { permute } from "../../../../utils/arrays/permutations.js";
+const getDecimalFormatTex = (questionParam) => {
+    return NodeConstructor.fromIdentifiers(questionParam.nodeIds)
+        .evaluate()
+        .frenchify();
+};
+const getInstruction = (identifiers, optsIn) => {
+    const { dictFakeNameToQuestionParam } = identifiers;
+    const opts = Object.assign(optsDefault, optsIn);
+    return `Voici trois nombres.
+  
+${opts.isUseABC
+        ? Object.entries(dictFakeNameToQuestionParam)
+            .toSorted(([fakeName1], [fakeName2]) => fakeName1.localeCompare(fakeName2))
+            .map(([fakeName, questionParam]) => {
+            return `
+  
+$$
+${fakeName} = ${questionParam.tex}
+$$
+
+`;
+        })
+            .join("")
+        : `
+
+$$
+${Object.values(dictFakeNameToQuestionParam)
+            .map((questionParam) => questionParam.tex)
+            .join(" ; ")}
+$$
+
+`}
+
+Le classement par ordre décroissant de ces trois nombres est :`;
+};
+const getHint = () => {
+    return `Pour comparer des nombres on peut soit les écrire sous forme décimale 
+  
+soit les mettre au même dénominateur.`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const { sign, a, dictFakeNameToQuestionParam } = identifiers;
+    const opts = Object.assign(optsDefault, optsIn);
+    const dictTrueNameToQuestionParam = Object.fromEntries(Object.entries(dictFakeNameToQuestionParam).map(([, questionParam]) => [
+        questionParam.trueName,
+        questionParam,
+    ]));
+    const letters = Object.keys(dictTrueNameToQuestionParam).toSorted((s1, s2) => s1.localeCompare(s2));
+    const [A, B, C] = letters.map((trueName) => {
+        const questionParam = dictTrueNameToQuestionParam[trueName];
+        return opts.isUseABC ? questionParam.fakeName : questionParam.tex;
+    });
+    return `
+
+${(() => {
+        if (opts.nbDecimalFormat > 0) {
+            return `On a :
+
+${letters
+                .toSorted((trueName1, trueName2) => {
+                const [fakeName1, fakeName2] = [trueName1, trueName2].map((trueName) => dictTrueNameToQuestionParam[trueName].fakeName);
+                return fakeName1.localeCompare(fakeName2);
+            })
+                .map((trueName) => {
+                const questionParam = dictTrueNameToQuestionParam[trueName];
+                return questionParam.explainTex;
+            })
+                .join("")}`;
+        }
+        else {
+            return `On a :
+
+$$
+${A} = ${sign === +1 ? `` : `-`}\\frac{${a} \\times 20}{5 \\times 20} = ${sign === +1 ? `` : `-`}\\frac{${20 * a}}{100}
+$$
+
+De plus :
+
+$$
+${A} = ${sign === +1 ? `` : `-`}\\frac{${a} \\times 2}{5 \\times 2} = ${sign === +1 ? `` : `-`}\\frac{${2 * a}}{10}
+$$
+
+Ainsi :
+
+${(() => {
+                if (sign === +1) {
+                    return `
+    
+$$
+${dictTrueNameToQuestionParam["C"].tex} > \\frac{${2 * a}}{10} = \\frac{${20 * a}}{100} > ${dictTrueNameToQuestionParam["B"].tex}
+$$
+
+`;
+                }
+                else {
+                    return `
+    
+$$
+${dictTrueNameToQuestionParam["B"].tex} > -\\frac{${20 * a}}{100} = -\\frac{${2 * a}}{10} > ${dictTrueNameToQuestionParam["C"].tex}
+$$
+
+`;
+                }
+            })()}
+`;
+        }
+    })()}
+
+
+Or :
+
+${(() => {
+        if (sign === +1) {
+            return `
+    
+$$
+${getDecimalFormatTex(dictTrueNameToQuestionParam["C"])} 
+> 
+${getDecimalFormatTex(dictTrueNameToQuestionParam["A"])}
+> 
+${getDecimalFormatTex(dictTrueNameToQuestionParam["B"])}
+$$
+
+Le classement par ordre décroissant est donc :
+
+$$
+${C} > ${A} > ${B}
+$$
+
+`;
+        }
+        else {
+            return `
+    
+$$
+${getDecimalFormatTex(dictTrueNameToQuestionParam["B"])} 
+> 
+${getDecimalFormatTex(dictTrueNameToQuestionParam["A"])}
+> 
+${getDecimalFormatTex(dictTrueNameToQuestionParam["C"])}
+$$
+
+Le classement par ordre décroissant est donc :
+
+$$
+${B} > ${A} > ${C}
+$$
+
+`;
+        }
+    })()}`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { items } = identifiers;
+    const propositions = [];
+    items.forEach((item) => {
+        if (item.isValidAnswer) {
+            addValidProp(propositions, item.tex, "tex");
+        }
+        else {
+            tryToAddWrongProp(propositions, item.tex, "tex");
+        }
+    });
+    return propositions;
+};
+const getAnswer = (identifiers) => {
+    const { items } = 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) => ansNodes[i].equals(answerNodes[i])));
+};
+const getKeys = (identifiers, optsIn) => {
+    const { dictFakeNameToQuestionParam } = identifiers;
+    const opts = Object.assign(optsDefault, optsIn);
+    return [
+        "sup",
+        "inf",
+        ...Object.values(dictFakeNameToQuestionParam).map((questionParam) => {
+            const tex = opts.isUseABC ? questionParam.fakeName : questionParam.tex;
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const getCompareFracAndDecQuestion = (optsIn) => {
+    const opts = Object.assign(optsDefault, optsIn);
+    const sign = opts.isAllowingNegativeNumbers ? (coinFlip() ? +1 : -1) : +1;
+    const a = random([...Array(19).keys()].map((i) => i + 1).filter((i) => i % 5 !== 0));
+    const b = randint(1, a - 1);
+    const c = random([...Array(99).keys()].map((i) => i + 1));
+    const nodes = {
+        A: frac(a, 5),
+        B: frac(substract(multiply(20, a), b).simplify(), 100),
+        C: frac(add(multiply(2, a), c).simplify(), 10)
+            .evaluate()
+            .toTree(),
+    };
+    Object.keys(nodes).forEach((letter) => {
+        nodes[letter] = multiply(sign, nodes[letter]);
+    });
+    const dictIsInDecimalFormat = Object.fromEntries(randomMany(["A", "C"], opts.nbDecimalFormat).map((letter) => [
+        letter,
+        true,
+    ]));
+    const nbTotal = 4;
+    const nbValid = 1;
+    const nbInvalid = nbTotal - nbValid;
+    const letters = Object.keys(nodes).toSorted((s1, s2) => s1.localeCompare(s2));
+    const shuffledLetters = shuffle(letters);
+    const dictFakeNameToQuestionParam = Object.fromEntries(letters.map((trueName, i) => {
+        const node = nodes[trueName];
+        const fakeName = shuffledLetters[i];
+        return [
+            fakeName,
+            {
+                fakeName: fakeName,
+                trueName: trueName,
+                nodeIds: node.toIdentifiers(),
+                tex: dictIsInDecimalFormat[trueName]
+                    ? node.evaluate().frenchify()
+                    : node.toTex(),
+                explainTex: (() => {
+                    if (opts.isUseABC || !dictIsInDecimalFormat[trueName]) {
+                        return `
+              
+$$
+${opts.isUseABC ? `${fakeName} =` : ``}${dictIsInDecimalFormat[trueName]
+                            ? ``
+                            : (() => {
+                                if (trueName === "A") {
+                                    return `${node.toTex()} = 
+${sign === +1 ? `` : `-`}\\frac{${a} \\times 2}{5 \\times 2} = 
+${sign === +1 ? `` : `-`}\\frac{${2 * a}}{10} =`;
+                                }
+                                else {
+                                    return `${node.toTex()} =`;
+                                }
+                            })()} 
+${node.evaluate().frenchify()}
+$$
+
+`;
+                    }
+                    else {
+                        return ``;
+                    }
+                })(),
+            },
+        ];
+    }));
+    const dictTrueNameToQuestionParam = Object.fromEntries(Object.values(dictFakeNameToQuestionParam).map((questionParam) => [
+        questionParam.trueName,
+        questionParam,
+    ]));
+    const [A, B, C] = letters.map((trueName) => {
+        const questionParam = dictTrueNameToQuestionParam[trueName];
+        return opts.isUseABC ? questionParam.fakeName : questionParam.tex;
+    });
+    const validItems = [
+        {
+            tex: sign === +1 ? `{${C}}>{${A}}>{${B}}` : `{${B}}>{${A}}>{${C}}`,
+            isValidAnswer: true,
+        },
+    ];
+    const invalidItems = permute([A, B, C])
+        .filter(([D, E, F]) => `{${D}}>{${E}}>{${F}}` !== validItems[0].tex)
+        .map(([D, E, F]) => {
+        return {
+            tex: `{${D}}>{${E}}>{${F}}`,
+            isValidAnswer: false,
+        };
+    });
+    const items = shuffle([
+        validItems[0],
+        ...shuffle(validItems.slice(1)).slice(0, nbValid - 1),
+        ...shuffle(invalidItems).slice(0, nbInvalid),
+    ]);
+    return getQuestionFromIdentifiers({
+        sign,
+        a,
+        b,
+        c,
+        dictFakeNameToQuestionParam,
+        items,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: getKeys(identifiers, opts),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    isUseABC: false,
+    nbDecimalFormat: 1,
+    isAllowingNegativeNumbers: false,
+};
+const options = [
+    {
+        id: "isUseABC",
+        label: "Utiliser A,B,C",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isUseABC,
+    },
+    {
+        id: "nbDecimalFormat",
+        label: "Nombre d'écritures décimales",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: [1, 2],
+        defaultValue: optsDefault.nbDecimalFormat,
+    },
+    {
+        id: "isAllowingNegativeNumbers",
+        label: "Permettre les nombres négatifs",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isAllowingNegativeNumbers,
+    },
+];
+export const compareFracAndDec = {
+    id: "compareFracAndDec",
+    label: "Comparer une fraction, une fraction décimale et une écriture fractionnaire",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareFracAndDecQuestion(opts), nb, 30),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Item = {
+    name: string;
+    nodeIds: NodeIdentifiers;
+};
+type Identifiers = {
+    items: Item[];
+};
+export declare const comparePowersOfFracs: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=comparePowersOfFracs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"comparePowersOfFracs.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ordering/comparePowersOfFracs.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAO7C,KAAK,IAAI,GAAG;IACV,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,eAAe,CAAC;CAC1B,CAAC;AAEF,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,IAAI,EAAE,CAAC;CACf,CAAC;AAiMF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,CActD,CAAC"}

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

@@ -0,0 +1,164 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { items } = identifiers;
+    return `Voici quatre nombres :  
+
+${items
+        .map((item) => `
+
+$$
+${item.name} = ${NodeConstructor.fromIdentifiers(item.nodeIds).toTex()}
+$$
+
+`)
+        .join("")}
+
+Le plus grand de ces quatre nombres est :`;
+};
+const getHint = () => {
+    return `Ecris chaque nombre sous la forme d'une fraction.`;
+};
+const getCorrection = (identifiers) => {
+    const { items } = identifiers;
+    const nodes = items.map((item) => NodeConstructor.fromIdentifiers(item.nodeIds));
+    const sortedIndexes = [...Array(nodes.length).keys()].toSorted((i1, i2) => substract(nodes[i1], nodes[i2]).simplify().evaluate());
+    const compareSigns = [...Array(sortedIndexes.length).keys()]
+        .slice(0, -1)
+        .map((i) => {
+        const difference = substract(nodes[sortedIndexes[i]], nodes[sortedIndexes[i + 1]])
+            .simplify()
+            .evaluate();
+        const comparison = difference > 0 ? 1 : difference < 0 ? -1 : 0;
+        const compSymbol = comparison == 1 ? ">" : comparison == -1 ? "<" : "=";
+        return compSymbol;
+    });
+    const itemGreatest = sortedIndexes.map((sortedI) => items[sortedI])[items.length - 1];
+    return `On a : 
+
+${items
+        .toSorted((item1, item2) => item1.name.localeCompare(item2.name))
+        .map((item) => {
+        const node = NodeConstructor.fromIdentifiers(item.nodeIds);
+        return `
+
+$$
+${item.name} = ${node.toTex()} = ${node
+            .simplify({ calculatePowers: true, distributePowersOnFrac: true })
+            .toTex()}
+$$
+
+`;
+    })
+        .join("")}
+
+Dans l'ordre croissant :
+
+$$
+${sortedIndexes
+        .map((sortedI, i) => `${nodes[sortedI]
+        .simplify({ calculatePowers: true, distributePowersOnFrac: true })
+        .toTex()} ${i < sortedIndexes.length - 1 ? compareSigns[i] : ""}`)
+        .join("")}
+$$
+
+Le plus grand de ces $${items.length}$ nombres est $${itemGreatest.name}$.
+`;
+};
+const getPropositions = (_, { answer, items }) => {
+    const propositions = [];
+    items
+        .toSorted((item1, item2) => item1.name.localeCompare(item2.name))
+        .forEach((item) => {
+        if (item.name === answer) {
+            addValidProp(propositions, answer);
+        }
+        else {
+            tryToAddWrongProp(propositions, item.name);
+        }
+    });
+    return propositions;
+};
+const getAnswer = (identifiers) => {
+    const { items } = identifiers;
+    const nodes = items.map((item) => NodeConstructor.fromIdentifiers(item.nodeIds));
+    const sortedIndexes = [...Array(items.length).keys()].toSorted((i1, i2) => substract(nodes[i1], nodes[i2]).simplify().evaluate());
+    const itemGreatest = sortedIndexes.map((i) => items[i])[items.length - 1];
+    return itemGreatest.name;
+};
+const getComparePowersOfFracsQuestion = () => {
+    function generateNodes() {
+        const a = coinFlip() ? 2 : 3;
+        const b = randint(a, 6);
+        const c = a + 1;
+        const nodes = [
+            power(frac(1, a), b),
+            power(frac(1, b), a),
+            frac(a, 100),
+            power(frac(1, c), c),
+        ];
+        return nodes;
+    }
+    function checkNodes(nodes) {
+        const sortedIndexes = [...Array(nodes.length).keys()].toSorted((i1, i2) => substract(nodes[i1], nodes[i2]).simplify().evaluate());
+        const compareSigns = [...Array(sortedIndexes.length).keys()]
+            .slice(0, -1)
+            .map((i) => {
+            const difference = substract(nodes[sortedIndexes[i]], nodes[sortedIndexes[i + 1]])
+                .simplify()
+                .evaluate();
+            const comparison = difference > 0 ? 1 : difference < 0 ? -1 : 0;
+            const compSymbol = comparison == 1 ? ">" : comparison == -1 ? "<" : "=";
+            return compSymbol;
+        });
+        return compareSigns[compareSigns.length - 1] !== "=";
+    }
+    let nodes;
+    do {
+        nodes = generateNodes();
+    } while (!checkNodes(nodes));
+    const names = ["A", "B", "C", "D"];
+    const items = shuffle(nodes).map((node, i) => {
+        return {
+            name: names[i],
+            nodeIds: node.toIdentifiers(),
+        };
+    });
+    return getQuestionFromIdentifiers({
+        items,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+export const comparePowersOfFracs = {
+    id: "comparePowersOfFracs",
+    label: "Comparer des puissances de fractions",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getComparePowersOfFracsQuestion(opts), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    a: number;
+    b: number;
+    isAdd: boolean;
+};
+export declare const compareWithSquareRoots: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=compareWithSquareRoots.d.ts.map

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

@@ -0,0 +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;AAQrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,OAAO,CAAC;CAChB,CAAC;AAmKF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAgBxD,CAAC"}

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

@@ -0,0 +1,140 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.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}}$,
+  
+comparer $${b} ${isAdd ? "+" : "-"} \\sqrt{${a}}$ et $${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}$.`;
+};
+const getHint = (identifiers) => {
+    const { a } = identifiers;
+    return `En partant de $\\sqrt{${a}} < \\sqrt{${a + 1}}$,
+  
+essaie de te ramener aux expressions demandées
+
+par des opérations que l'on effectue à droite et à gauche de l'inégalité. 
+
+Attention si tu multiplies à droite et à gauche d'une inégalité par un nombre négatif, l'inégalité se renverse.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, b, isAdd } = identifiers;
+    return `On sait que :
+
+$$
+\\sqrt{${a}} < \\sqrt{${a + 1}}
+$$
+
+${isAdd
+        ? ``
+        : `On multiplie par $-1$ des deux côtés et on renverse l'inégalité :
+    
+$$
+-\\sqrt{${a}} > -\\sqrt{${a + 1}}
+$$
+
+`}
+On ajoute $${b}$ de chaque côté de l'inégalité :
+
+$$
+${b} ${isAdd ? "+" : "-"} \\sqrt{${a}} ${isAdd ? "<" : ">"} ${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}
+$$
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { a, b, isAdd } = identifiers;
+    return `${b} ${isAdd ? "+" : "-"} \\sqrt{${a}} ${isAdd ? "<" : ">"} ${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}`;
+};
+const isAnswerValid = (ans, { answer }) => {
+    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] = getOrderedNodesFromTex(answer, "<");
+            return (ansNode1.simplify().equals(answerNode1.simplify()) &&
+                ansNode2.simplify().equals(answerNode2.simplify()));
+        }
+        else {
+            return false;
+        }
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getPropositions = (nbProps, { answer, ...identifiers }) => {
+    const { a, b, isAdd } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, `${b} ${isAdd ? "+" : "-"} \\sqrt{${a}} ${isAdd ? "<" : ">"} ${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}`, "tex");
+    tryToAddWrongProp(propositions, `${b} ${isAdd ? "+" : "-"} \\sqrt{${a}} ${!isAdd ? "<" : ">"} ${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}`, "tex");
+    return shuffleProps(propositions, nbProps);
+};
+const getKeys = (identifiers) => {
+    const { a, b, isAdd } = identifiers;
+    return [
+        "inf",
+        "sup",
+        ...[
+            `${b} ${isAdd ? "+" : "-"} \\sqrt{${a}}`,
+            `${b} ${isAdd ? "+" : "-"} \\sqrt{${a + 1}}`,
+        ].map((tex) => {
+            return {
+                id: "custom",
+                label: tex,
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: tex,
+                },
+            };
+        }),
+    ];
+};
+const getCompareWithSquareRootsQuestion = () => {
+    const a = randint(2, 150);
+    const b = randint(1, 100);
+    const isAdd = coinFlip();
+    return getQuestionFromIdentifiers({ a, b, isAdd });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const compareWithSquareRoots = {
+    id: "compareWithSquareRoots",
+    label: "Comparer deux nombres directement (avec des racines carrées)",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getCompareWithSquareRootsQuestion(), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    getAnswer,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};