math-exercises 3.0.124 → 3.0.126

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

@@ -0,0 +1,135 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { lcm } from "../../../../math/utils/arithmetic/lcm.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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getInstruction = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodes = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    return `Comparer $${nodes[0].toTex()}$ et $${nodes[1].toTex()}$.`;
+};
+const getHint = () => {
+    return `Pour comparer deux fractions on peut les mettre au même dénominateur.`;
+};
+const getCorrection = (identifiers) => {
+    const { nodeIds } = identifiers;
+    const nodes = nodeIds.map((nodeIds) => NodeConstructor.fromIdentifiers(nodeIds));
+    const [den1, den2] = nodes.map((node) => node.rightChild);
+    const sameDen = lcm(den1.evaluate(), den2.evaluate());
+    const nodesSameDenMult = nodes.map((node) => frac(multiply(node.leftChild.simplify(), frac(sameDen, node.rightChild).simplify()), sameDen));
+    const nodesSameDen = nodes.map((node) => frac(multiply(node.leftChild.simplify(), frac(sameDen, node.rightChild)).simplify(), sameDen));
+    const answer = getAnswer(identifiers);
+    return `On a : 
+
+$$
+${nodes[1].toTex()} = ${frac(nodes[1].leftChild.simplify(), nodes[1].rightChild.simplify()).toTex()}
+$$
+
+On veut donc comparer $${nodes[0].toTex()}$ et $${nodes[1].simplify().toTex()}$.
+
+On peut choisir $${sameDen.frenchify()}$ comme dénominateur commun.
+
+${nodes
+        .map((node, i) => node.rightChild.evaluate() !== sameDen
+        ? `
+
+$$
+${(i === 0 ? nodes[i] : nodes[i].simplify()).toTex()} = ${nodesSameDenMult[i].toTex()} = ${nodesSameDen[i].toTex()}
+$$`
+        : ``)
+        .join("")}
+
+Conclusion :
+
+$$
+${answer}
+$$
+
+`;
+};
+/*
+Plus généralement :
+Si  $a<b$ alors  $\\frac{a}{b} < \\frac{a+c}{b+c}$ sinon c'est l'inverse.
+*/
+const getPropositions = (_, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, answer
+        .replace(">", "TMP(>)")
+        .replace("<", "TMP(<)")
+        .replace("TMP(>)", "<")
+        .replace("TMP(<)", ">"));
+    return shuffle(propositions);
+};
+const getAnswer = (identifiers) => {
+    const { texAnswers } = identifiers;
+    return texAnswers[0];
+};
+const isAnswerValid = (ans, { texAnswers }) => {
+    return texAnswers.includes(ans);
+};
+const getCompareFracABWithFracAPlusCBPlusCQuestion = () => {
+    const a = randint(1, 10);
+    const b = randint(1, 10);
+    const c = randint(1, 10);
+    const nodes = [frac(a, b), frac(add(a, c), add(b, c))];
+    const isOrderAsc = coinFlip();
+    const sortedNodes = nodes.toSorted((node1, node2) => (isOrderAsc ? +1 : -1) * (node1.evaluate() - node2.evaluate()));
+    const texAnswers = [
+        `${sortedNodes[0].toTex()}${isOrderAsc ? "<" : ">"}${sortedNodes[1].toTex()}`,
+        `${sortedNodes[1].toTex()}${isOrderAsc ? ">" : "<"}${sortedNodes[0].toTex()}`,
+    ];
+    return getQuestionFromIdentifiers({
+        nodeIds: nodes.map((node) => node.toIdentifiers()),
+        texAnswers,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [
+            "sup",
+            "inf",
+            ...identifiers.nodeIds.map((nodeIds) => {
+                const node = NodeConstructor.fromIdentifiers(nodeIds);
+                const tex = node.toTex();
+                return {
+                    id: "custom",
+                    label: tex,
+                    labelType: "tex",
+                    mathfieldInstructions: {
+                        method: "write",
+                        content: tex,
+                    },
+                };
+            }),
+        ],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        options: opts,
+    };
+    return question;
+};
+export const compareFracABWithFracAPlusCBPlusC = {
+    id: "compareFracABWithFracAPlusCBPlusC",
+    label: "Effectuer des comparaisons entre des fractions simples (de la forme $\\frac{a}{b}$ et $\\frac{a+c}{b+c}$)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareFracABWithFracAPlusCBPlusCQuestion(opts), nb, 30),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    maxAllowedQuestions: 30,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,29 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type QCMItem = {
+    tex: string;
+    isValidAnswer: boolean;
+};
+type QuestionParam = {
+    fakeName: string;
+    trueName: string;
+    tex: string;
+    nodeIds: NodeIdentifiers;
+    explainTex: string;
+};
+type Identifiers = {
+    sign: number;
+    a: number;
+    b: number;
+    c: number;
+    dictFakeNameToQuestionParam: Record<string, QuestionParam>;
+    items: QCMItem[];
+};
+type Options = {
+    isUseABC: boolean;
+    nbDecimalFormat: number;
+    isAllowingNegativeNumbers: boolean;
+};
+export declare const compareFracAndDec: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=compareFracAndDec.d.ts.map

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

@@ -0,0 +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;AAY7C,KAAK,OAAO,GAAG;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,aAAa,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,QAAQ,EAAE,MAAM,CAAC;IACjB,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,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,2BAA2B,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;IAC3D,KAAK,EAAE,OAAO,EAAE,CAAC;CAClB,CAAC;AAiYF,KAAK,OAAO,GAAG;IACb,QAAQ,EAAE,OAAO,CAAC;IAClB,eAAe,EAAE,MAAM,CAAC;IACxB,yBAAyB,EAAE,OAAO,CAAC;CACpC,CAAC;AA+BF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiB5D,CAAC"}

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

@@ -0,0 +1,367 @@
+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 formes décimales 
+  
+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),
+    };
+    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: 0,
+    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: [0, 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"}