math-exercises 3.0.214 → 3.0.216

package/lib/exercises/math/calcul/mentalCaluls/mentalMultiplicationTable.js

@@ -0,0 +1,141 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { defaultArrayedOptsWhereNeeded } from "../../../../exercises/utils/options/arrayedOptions.js";
+import { NumberNode } from "../../../../tree/nodes/numbers/numberNode.js";
+import { MultiplyNode } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    return `Calculer : 
+  
+$$
+${getStartStatement(identifiers)}
+$$`;
+};
+const getStartStatement = (identifiers) => {
+    return getStatementNode(identifiers).toTex();
+};
+const getStatementNode = (identifiers) => {
+    const { numbers } = identifiers;
+    return operatorComposition(MultiplyNode, numbers.map((e) => e.toTree()));
+};
+const getAnswer = (identifiers) => {
+    const statement = getStatementNode(identifiers);
+    return statement.simplify().toTex();
+};
+const getHint = (identifiers) => {
+    const { numbers } = identifiers;
+    const [number1, number2] = numbers;
+    return `Voici le début de la table de $${number2.frenchify()}$ :
+
+${alignTex([...new Array(number1).keys()].map((v) => [
+        `${v} \\times ${number2}`,
+        (v * number2).frenchify(),
+    ]))}
+
+`;
+};
+const getCorrection = (identifiers) => {
+    const { numbers } = identifiers;
+    const [_, number2] = numbers;
+    return `Voici la table de $${number2.frenchify()}$ :
+
+${alignTex([...new Array(12).keys()].map((v) => [
+        `${v} \\times ${number2}`,
+        (v * number2).frenchify(),
+    ]))}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { numbers: [number1, number2], } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const poolWrong1 = [
+        [number1 - 1, number2],
+        [number1, number2 - 1],
+        [number1 + 1, number2],
+        [number1, number2 + 1],
+    ].map(([number1Wrong, number2Wrong]) => number1Wrong * number2Wrong);
+    const poolWrong2 = (() => {
+        const vProduct = number1 * number2;
+        return [
+            ...[...Array(5).keys()].map((i) => -i - 1),
+            ...[...Array(5).keys()].map((i) => +i + 1),
+        ]
+            .map((vOffset) => vProduct + vOffset)
+            .filter((v) => v >= 1);
+    })();
+    shuffle([...poolWrong1, ...poolWrong2]).forEach((v) => {
+        tryToAddWrongProp(propositions, v.frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (studentAns, { answer }) => {
+    const answerTree = new NumberNode(Number(answer.replace(",", ".")));
+    const texs = answerTree.toAllValidTexs();
+    return texs.includes(studentAns);
+};
+const getMentalMultiplicationTableQuestion = (optsIn) => {
+    const arrayedOptions = defaultArrayedOptsWhereNeeded(optsIn, arrayedOptsDefault);
+    const [number1, number2] = [
+        arrayedOptions.number1Pool,
+        arrayedOptions.number2Pool,
+    ].map((numberPool) => random(numberPool.map((str) => parseInt(str))));
+    const identifiers = { numbers: [number1, number2] };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        startStatement: getStartStatement(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const arrayedOptsDefault = {
+    number1Pool: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].map((v) => v.frenchify()),
+    number2Pool: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].map((v) => v.frenchify()),
+};
+const options = [
+    {
+        id: "number1Pool",
+        label: "Valeurs possible pour le premier nombre",
+        defaultValue: arrayedOptsDefault.number1Pool,
+        values: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].map((v) => v.frenchify()),
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+    },
+    {
+        id: "number2Pool",
+        label: "Valeurs possible pour le deuxième nombre",
+        defaultValue: arrayedOptsDefault.number2Pool,
+        values: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12].map((v) => v.frenchify()),
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.multiselect,
+    },
+];
+export const mentalMultiplicationTable = {
+    id: "mentalMultiplicationTable",
+    connector: "=",
+    label: "Tables de multiplication de $2$ à $12$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getMentalMultiplicationTableQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/ratio/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./partUsingRatio.js";
+export * from "./partsUsingRatio.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/ratio/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ratio/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ratio/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AAEpC,cAAc,sBAAsB,CAAC"}

package/lib/exercises/math/calcul/ratio/index.js

@@ -1,2 +1,3 @@
 export * from "./partUsingRatio.js";
 // export * from "./ratioFromParts.js"; //erreur à fix
+export * from "./partsUsingRatio.js";

package/lib/exercises/math/calcul/ratio/partsUsingRatio.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    ratioType: string;
+    situationIndex: number;
+    total: number;
+    ratio: number[];
+};
+type Options = {
+    ratioTypes: string[];
+};
+export declare const partsUsingRatio: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=partsUsingRatio.d.ts.map

package/lib/exercises/math/calcul/ratio/partsUsingRatio.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partsUsingRatio.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/ratio/partsUsingRatio.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAmCrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;CACjB,CAAC;AAiPF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAiBF,eAAO,MAAM,eAAe,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB1D,CAAC"}

package/lib/exercises/math/calcul/ratio/partsUsingRatio.js

@@ -0,0 +1,237 @@
+import { shuffleProps, GeneratorOptionType, GeneratorOptionTarget, tryToAddWrongProp, addValidProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { primes } from "../../../../math/numbers/integer/primes.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.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 { probaLawFlip } from "../../../../utils/alea/probaLawFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getStrRatio = (ratio) => {
+    return `${ratio.join(" : ")}`;
+};
+const getHydrated = (total, ratio) => {
+    const denNode = ratio
+        .map((v) => v.toTree())
+        .reduce((acc, x) => add(acc, x));
+    const arrFractionNode = ratio.map((ratio) => frac(ratio, denNode));
+    const arrShares = arrFractionNode.map((nodeFraction) => multiply(nodeFraction, total).simplify());
+    return {
+        denNode,
+        arrFractionNode,
+        arrShares,
+    };
+};
+const situations = ["€", "cL", "bonbons", "pommes", "frites"].map((strUnit) => {
+    return {
+        instruction: (total, ratio) => `Répartir $${total}$ ${strUnit} suivant le ratio $${getStrRatio(ratio)}$. Séparer chaque part par un point virgule (;).`,
+        correction: (total, ratio) => {
+            const { denNode, arrFractionNode } = getHydrated(total, ratio);
+            return `Le ratio est $${getStrRatio(ratio)}$.
+
+On calcule :
+
+$$
+${ratio.reduce((acc, v, i) => (i === 0 ? `${v}` : `${acc} + ${v}`), "")} = ${denNode.simplify().toTex()}
+$$
+        
+Les fractions correspondantes sont :
+        
+$$
+${arrFractionNode
+                .map((nodeFraction) => nodeFraction.simplify().toTex())
+                .join(";")} 
+$$
+
+Les parts sont donc (en ${strUnit}) :
+
+$$
+${arrFractionNode
+                .map((nodeFraction) => multiply(nodeFraction.simplify(), total).toTex())
+                .join(";")} 
+$$
+
+autrement dit : 
+
+$$
+${arrFractionNode
+                .map((nodeFraction) => `${multiply(nodeFraction.simplify(), total).simplify().toTex()}`)
+                .join(" ; ")} 
+$$
+
+
+`;
+        },
+        randValues: (ratioType) => {
+            switch (ratioType) {
+                case "2": {
+                    const primePool = primes.filter((n) => 1 < n && n < 17);
+                    const indexPrime1 = randint(0, primePool.length - 2);
+                    const [num1, num2] = shuffle([
+                        primePool[indexPrime1],
+                        primePool[indexPrime1 + randint(1, 3)],
+                    ]);
+                    const divisor = num1 + num2;
+                    const total = randint(2, 10) * divisor;
+                    return {
+                        ratio: [num1, num2],
+                        total,
+                    };
+                }
+                case "3": {
+                    const [num1, num2, num3] = randomMany(primes.filter((n) => 1 < n && n < 17), 3);
+                    const divisor = num1 + num2 + num3;
+                    const total = randint(2, 6) * divisor;
+                    return {
+                        ratio: [num1, num2, num3],
+                        total,
+                    };
+                }
+                default:
+                    throw new Error("Unsupported ratioType: " + ratioType);
+            }
+        },
+    };
+});
+const getInstruction = (identifiers) => {
+    const { situationIndex, total, ratio } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.instruction(total, ratio);
+};
+const getAnswer = (identifiers) => {
+    const { ratio, total } = identifiers;
+    const { arrShares } = getHydrated(total, ratio);
+    return `${arrShares.map((node) => node.toTex()).join(";")}`;
+};
+const getHint = () => {
+    return `Cherche à quelle fraction du total correspond chaque part, puis multiplie chaque fraction par le total pour chaque part.`;
+};
+const getCorrection = (identifiers) => {
+    const { situationIndex, total, ratio } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.correction(total, ratio);
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { ratio, total } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { arrShares } = getHydrated(total, ratio);
+    //student: ratio -> percentage
+    {
+        const arrSharesWrong = ratio.map((v) => {
+            const fractionNode = frac(v, 100);
+            const nodeWrong = round(multiply(fractionNode, total).simplify().evaluate(), 0).toTree();
+            return nodeWrong;
+        });
+        tryToAddWrongProp(propositions, arrSharesWrong.map((node) => node.toTex()).join(";"));
+    }
+    //random around
+    propWhile(propositions, n, () => {
+        const arrSharesWrong = arrShares.reduce((acc, node, i, arr) => {
+            const texShare = node.toTex();
+            const nodeShareWrong = (() => {
+                if (!acc.dictReplacement[texShare]) {
+                    if (i !== arr.length - 1) {
+                        const smallV = round(node.evaluate() * 0.2, 0);
+                        const vOffset = randint(-smallV, smallV);
+                        const nodeShareWrong = add(node, vOffset).simplify();
+                        acc.dictReplacement[texShare] = nodeShareWrong;
+                        return nodeShareWrong;
+                    }
+                    else {
+                        const sumPrev = Object.values(acc.dictReplacement).reduce((acc, node) => add(acc, node).simplify());
+                        const nodeShareWrong = probaLawFlip([
+                            [substract(total, sumPrev), 0.78],
+                            [substract(total + randint(-9, 10, [0]), sumPrev), 0.15],
+                            [substract(total + random([-10, 10]), sumPrev), 0.07],
+                        ]);
+                        return nodeShareWrong.simplify();
+                    }
+                }
+                else {
+                    return acc.dictReplacement[texShare];
+                }
+            })();
+            acc.arrSharesWrong.push(nodeShareWrong);
+            return acc;
+        }, {
+            arrSharesWrong: [],
+            dictReplacement: {},
+        }).arrSharesWrong;
+        tryToAddWrongProp(propositions, arrSharesWrong.map((node) => node.toTex()).join(";"));
+    });
+    return shuffleProps(propositions, n);
+};
+const getKeys = () => {
+    return ["semicolon"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const [nodeAns, nodeAnswer] = [ans, answer].map((str) => parseAlgebraic(str));
+        return substract(nodeAns, nodeAnswer).simplify().evaluate() === 0;
+    }
+    catch (_) {
+        return false;
+    }
+};
+const getParstUsingRatioQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const ratioType = random(opts.ratioTypes);
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const { total, ratio } = situation.randValues(ratioType);
+    const identifiers = {
+        ratioType,
+        situationIndex,
+        total,
+        ratio,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, options) => {
+    return {
+        answer: getAnswer(identifiers, options),
+        instruction: getInstruction(identifiers, options),
+        keys: getKeys(identifiers, options),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, options),
+        correction: getCorrection(identifiers, options),
+        options,
+    };
+};
+const options = [
+    {
+        id: "ratioTypes",
+        label: "Longueur du ratio",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: ["2", "3"],
+        defaultValue: ["2", "3"],
+    },
+];
+const optsDefault = {
+    ratioTypes: ["2", "3"],
+};
+export const partsUsingRatio = {
+    id: "partsUsingRatio",
+    label: "Partager une valeur selon un ratio donné",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getParstUsingRatioQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    isAnswerValid,
+};

package/lib/exercises/math/calcul/relatives/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./relativesAddAndSub.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/relatives/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/relatives/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC"}

package/lib/exercises/math/calcul/relatives/index.js

@@ -0,0 +1 @@
+export * from "./relativesAddAndSub.js";

package/lib/exercises/math/calcul/relatives/relativesAddAndSub.d.ts

@@ -0,0 +1,17 @@
+import { Exercise } from "../../../exercise.js";
+/**
+ * (±a)±(±b)
+ */
+type Identifiers = {
+    a: number;
+    b: number;
+    opType: string;
+    explicitWriting: boolean;
+};
+type Options = {
+    explicitWriting: string;
+    opType: string;
+};
+export declare const relativesAddAndSub: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=relativesAddAndSub.d.ts.map

package/lib/exercises/math/calcul/relatives/relativesAddAndSub.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relativesAddAndSub.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/relatives/relativesAddAndSub.ts"],"names":[],"mappings":"AAYA,OAAO,EACL,QAAQ,EAmBT,MAAM,sBAAsB,CAAC;AAE9B;;GAEG;AAEH,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AA4ZF,KAAK,OAAO,GAAG;IACb,eAAe,EAAE,MAAM,CAAC;IACxB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAmCF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkB7D,CAAC"}