math-exercises 3.0.139 → 3.0.141

package/lib/exercises/math/calcul/proportionality/fourthProportionalFromProblem.js

@@ -0,0 +1,392 @@
+import { addValidProp, tryToAddWrongProp, shuffleProps, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.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 { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getStrRoundTo = (roundTo) => {
+    switch (roundTo) {
+        case 1:
+            return `arrondie à $1$ décimale`;
+        default:
+            return `arrondie à $${roundTo}$ décimales`;
+    }
+};
+const situations = [
+    //standard1: [a |--> b,c |--> ?],[a |--> ?,c |--> d]
+    {
+        roundTo: 1,
+        instruction: (values, roundTo) => `Un tuyau oxydé fuit. Il sort de la fuite $${values[1][0].frenchify()}$ $\\textrm{mL}$ d'eau toutes les $${values[0][0].frenchify()}$ $\\textrm{min}$.
+Quelle quantité d'eau va-t-il fuire pendant $${values[0][1].frenchify()}$ $\\textrm{min}$ (en $\\textrm{mL}$ ${getStrRoundTo(roundTo)}) ?`,
+        answer: (values, roundTo) => round(values[1][1], roundTo).frenchify(),
+        propositions: (values, roundTo) => {
+            const propositions = [];
+            const valueAnswer = values[1][1];
+            addValidProp(propositions, valueAnswer.frenchify());
+            //moreOrLessMult
+            const arrMoreOrLessMult = [0.7, 0.8, 0.9, 1.1, 1.2, 1.3];
+            arrMoreOrLessMult.forEach((coeffDistortion) => {
+                const valueMoreOrLess = round(multiply(valueAnswer, coeffDistortion).evaluate(), roundTo);
+                tryToAddWrongProp(propositions, valueMoreOrLess.frenchify());
+            });
+            //moreOrLessAdd
+            const arrMoreOrLessAdd = [5, 10, 15, 20, 25, 30].flatMap((v) => [v, -v]);
+            arrMoreOrLessAdd.forEach((offset) => {
+                const valueMoreOrLess = round(add(valueAnswer, offset).evaluate(), roundTo);
+                const isCloseEnoughToAnswer = Math.abs((valueMoreOrLess - valueAnswer) / valueAnswer) <= 0.3;
+                if (isCloseEnoughToAnswer) {
+                    tryToAddWrongProp(propositions, valueMoreOrLess.frenchify());
+                }
+            });
+            //terror (== moreOrLessAdd(roundTo))
+            {
+                let valueTerrorSrc;
+                if (probaFlip(0.3)) {
+                    valueTerrorSrc = valueAnswer;
+                }
+                else {
+                    const valuesSoFar = propositions.map((proposition) => parseAlgebraic(proposition.statement).evaluate());
+                    valueTerrorSrc = random(valuesSoFar);
+                }
+                [power(10, -roundTo)]
+                    .flatMap((microOffset) => [microOffset, -microOffset])
+                    .forEach((microOffset) => {
+                    const valueTerrorDst = round(add(valueTerrorSrc, microOffset).evaluate(), roundTo);
+                    tryToAddWrongProp(propositions, valueTerrorDst.frenchify());
+                });
+            }
+            return propositions.filter((proposition) => proposition.statement !== "NaN");
+        },
+        hint: (_) => {
+            return `Tu peux commencer par nommer $x$ la quantité d'eau que tu recherches, et dresser un tableau correspondant à la situation.
+Il est sous-entendu que la situation est une situation de proportionnalité ; Il y a donc une égalité que tu peux écrire.`;
+        },
+        correction: (values, _) => {
+            return `On va noter $x$ le volume d'eau recherché.      
+On peut dresser le tableau suivant: 
+${mdTable([
+                ["Robinet", ...values[0].map(() => "")],
+                [
+                    "durée ($\\textrm{min}$)",
+                    ...values[0].map((value) => `$${value.frenchify()}$`),
+                ],
+                [
+                    "volume d'eau ($\\textrm{mL}$)",
+                    ...values[1].map((value, i) => i === 1 ? "$x$" : `$${value.frenchify()}$`),
+                ],
+            ])}
+
+Il est sous-entendu que l'on a affaire à une situation de proportionnalité.
+On peut donc écrire l'égalité des produits en croix :
+
+$$
+${values[0][0].frenchify()} \\times x = ${values[1][0].frenchify()} \\times ${values[0][1].frenchify()}
+$$
+
+On résout l'équation :
+
+${alignTex([
+                [
+                    `x`,
+                    "=",
+                    `\\frac{${values[1][0].frenchify()} \\times ${values[0][1].frenchify()}}{${values[0][0].frenchify()}}`,
+                ],
+                [`x`, "\\approx", `${values[1][1].frenchify()}`],
+            ])}
+
+La quantité d'eau recherchée est $${values[1][1].frenchify()}$ $\\textrm{mL}$.`;
+        },
+        randValues: (roundTo) => {
+            const nbValues = 2;
+            const stepA = 5;
+            const valuesA = [...Array(nbValues).keys()]
+                .reduce((acc) => [
+                ...acc,
+                randint(1, 19, acc.map((v) => v / stepA)) * stepA,
+            ], [])
+                .toSorted((a, b) => a - b);
+            const coeff = randfloat(0.4, 0.7, 2);
+            const valuesB = valuesA.map((valueA) => round(valueA * coeff, roundTo));
+            return [valuesA, valuesB];
+        },
+    },
+    //standard2: [a |--> b,? |--> d],[? |--> b,c |--> d]
+    {
+        roundTo: 2,
+        instruction: (values, roundTo) => `Pour une fête de village, Imane prépare des spaghetti à la sauce tomate.
+Sur son téléphone, la recette prévoit $${values[1][0].frenchify()}$ $\\textrm{kg}$ de sauce pour $${values[0][0].frenchify()}$ $\\textrm{kg}$ de pâtes.
+Sachant qu'elle a déjà préparé $${values[1][1].frenchify()}$ $\\textrm{kg}$ de sauce, quelle quantité de pâtes (en $\\textrm{kg}$ ${getStrRoundTo(roundTo)}) faut-il qu'elle fasse cuire ?`,
+        answer: (values, roundTo) => round(values[0][1], roundTo).frenchify(),
+        propositions: (values, roundTo) => {
+            const propositions = [];
+            const valueAnswer = values[0][1];
+            addValidProp(propositions, valueAnswer.frenchify());
+            //moreOrLessMult
+            const arrMoreOrLessMult = [0.7, 0.8, 0.9, 1.1, 1.2, 1.3];
+            arrMoreOrLessMult.forEach((coeffDistortion) => {
+                const valueMoreOrLess = round(multiply(valueAnswer, coeffDistortion).evaluate(), roundTo);
+                tryToAddWrongProp(propositions, valueMoreOrLess.frenchify());
+            });
+            //moreOrLessAdd
+            const arrMoreOrLessAdd = [5, 10, 15, 20, 25, 30].flatMap((v) => [v, -v]);
+            arrMoreOrLessAdd.forEach((offset) => {
+                const valueMoreOrLess = round(add(valueAnswer, offset).evaluate(), roundTo);
+                const isCloseEnoughToAnswer = Math.abs((valueMoreOrLess - valueAnswer) / valueAnswer) <= 0.3;
+                if (isCloseEnoughToAnswer) {
+                    tryToAddWrongProp(propositions, valueMoreOrLess.frenchify());
+                }
+            });
+            //terror (== moreOrLessAdd(roundTo))
+            {
+                let valueTerrorSrc;
+                if (probaFlip(0.3)) {
+                    valueTerrorSrc = valueAnswer;
+                }
+                else {
+                    const valuesSoFar = propositions.map((proposition) => parseAlgebraic(proposition.statement).evaluate());
+                    valueTerrorSrc = random(valuesSoFar);
+                }
+                [power(10, -roundTo)]
+                    .flatMap((microOffset) => [microOffset, -microOffset])
+                    .forEach((microOffset) => {
+                    const valueTerrorDst = round(add(valueTerrorSrc, microOffset).evaluate(), roundTo);
+                    tryToAddWrongProp(propositions, valueTerrorDst.frenchify());
+                });
+            }
+            return propositions.filter((proposition) => proposition.statement !== "NaN");
+        },
+        hint: (_) => {
+            return `Tu peux commencer par nommer $x$ la quantité de pâtes que tu recherches, et dresser un tableau correspondant à la situation.
+Imane utilise une recette. C'est une situation de proportionnalité et il y a donc une égalité que tu peux écrire.`;
+        },
+        correction: (values, _) => {
+            return `On va noter $x$ la quantité de pâtes recherchée.      
+On peut dresser le tableau suivant: 
+${mdTable([
+                ["Recette", ...values[0].map(() => "")],
+                [
+                    "pâtes ($\\textrm{kg}$)",
+                    ...values[0].map((value, i) => i === 1 ? "$x$" : `$${value.frenchify()}$`),
+                ],
+                [
+                    "sauce tomate ($\\textrm{kg}$)",
+                    ...values[1].map((value) => `$${value.frenchify()}$`),
+                ],
+            ])}
+
+Il est sous-entendu que l'on a affaire à une situation de proportionnalité.
+On peut donc écrire l'égalité des produits en croix :
+
+$$
+${values[0][0].frenchify()} \\times ${values[1][1].frenchify()}  = ${values[1][0].frenchify()} \\times x
+$$
+
+On résout l'équation :
+
+${alignTex([
+                [
+                    `\\frac{${values[0][0].frenchify()} \\times ${values[1][1].frenchify()}}{${values[1][0].frenchify()}}`,
+                    "=",
+                    `x`,
+                ],
+                [`${values[0][1].frenchify()}`, "\\approx", `x`],
+            ])}
+
+La quantité de pâtes recherchée est $${values[0][1].frenchify()}$ $\\textrm{kg}$.`;
+        },
+        randValues: (roundTo) => {
+            const nbValues = 2;
+            const valuesA = [...Array(nbValues).keys()].reduce((acc, i) => {
+                if (i === 0) {
+                    return [randint(5, 15)];
+                }
+                else {
+                    return [...acc, randfloat(5, 15, roundTo, acc)];
+                }
+            }, []);
+            const coeff = randfloat(1.1, 3.7, 2);
+            const valuesB = valuesA.map((valueA) => round(valueA * coeff, roundTo));
+            return [valuesA, valuesB];
+        },
+    },
+    //crypto: [a |--> b, crypto(n*a) |--> ?]  //todo? (par exemple, "toute une journée")
+    //with compound unit
+    {
+        roundTo: 2,
+        instruction: (values, roundTo) => `Tatiana contemple une statue en bronze dans un musée.
+Sur le cartouche qui accompagne l'oeuvre, il est indiqué que la masse volumique du bronze utilisé est de $${values[1][0].frenchify()}$ $\\textrm{kg}/\\textrm{m}^3$
+et que la masse de la statue est $${values[1][1].frenchify()}$ $\\textrm{kg}$.
+Quel est le volume de bronze de la statue (en $\\textrm{m}^3$ ${getStrRoundTo(roundTo)}) ?`,
+        answer: (values, roundTo) => round(values[0][1], roundTo).frenchify(),
+        propositions: (values, roundTo) => {
+            const propositions = [];
+            const valueAnswer = values[0][1];
+            addValidProp(propositions, valueAnswer.frenchify());
+            //moreOrLessMult
+            const arrMoreOrLessMult = [0.7, 0.8, 0.9, 1.1, 1.2, 1.3];
+            arrMoreOrLessMult.forEach((coeffDistortion) => {
+                const valueMoreOrLess = round(multiply(valueAnswer, coeffDistortion).evaluate(), roundTo);
+                tryToAddWrongProp(propositions, valueMoreOrLess.frenchify());
+            });
+            //moreOrLessAdd
+            const arrMoreOrLessAdd = [5, 10, 15, 20, 25, 30].flatMap((v) => [v, -v]);
+            arrMoreOrLessAdd.forEach((offset) => {
+                const valueMoreOrLess = round(add(valueAnswer, offset).evaluate(), roundTo);
+                const isCloseEnoughToAnswer = Math.abs((valueMoreOrLess - valueAnswer) / valueAnswer) <= 0.3;
+                if (isCloseEnoughToAnswer) {
+                    tryToAddWrongProp(propositions, valueMoreOrLess.frenchify());
+                }
+            });
+            //terror (== moreOrLessAdd(roundTo))
+            {
+                let valueTerrorSrc;
+                if (probaFlip(0.3)) {
+                    valueTerrorSrc = valueAnswer;
+                }
+                else {
+                    const valuesSoFar = propositions.map((proposition) => parseAlgebraic(proposition.statement).evaluate());
+                    valueTerrorSrc = random(valuesSoFar);
+                }
+                [power(10, -roundTo)]
+                    .flatMap((microOffset) => [microOffset, -microOffset])
+                    .forEach((microOffset) => {
+                    const valueTerrorDst = round(add(valueTerrorSrc, microOffset).evaluate(), roundTo);
+                    tryToAddWrongProp(propositions, valueTerrorDst.frenchify());
+                });
+            }
+            return propositions.filter((proposition) => proposition.statement !== "NaN");
+        },
+        hint: (values) => {
+            return `Tu peux commencer par nommer $x$ le volume que tu recherches.
+Si la masse volumique est de $${values[1][0].frenchify()}$ $\\textrm{kg}/\\textrm{m}^3$ alors $1$ $\\textrm{m}^3$ de bronze aura une masse de $${values[1][0].frenchify()}$ $kg$.
+Tu peux donc dresser un tableau avec ces données.
+L'unité $\\textrm{kg}/\\textrm{m}^3$ est un quotient. Il y a proportionnalité entre la masse et le volume et il y a donc une égalité que tu peux écrire.`;
+        },
+        correction: (values, _) => {
+            return `On va noter $x$ le volume recherché.      
+On peut dresser le tableau suivant: 
+${mdTable([
+                ["Statue", ...values[0].map(() => "")],
+                [
+                    "volume ($\\textrm{m}^3$)",
+                    ...values[0].map((value, i) => i === 1 ? "$x$" : `$${value.frenchify()}$`),
+                ],
+                [
+                    "masse ($\\textrm{kg}$)",
+                    ...values[1].map((value) => `$${value.frenchify()}$`),
+                ],
+            ])}
+
+Il est manifeste que l'on a affaire à une situation de proportionnalité.
+On peut donc écrire l'égalité des produits en croix :
+
+$$
+${values[0][0].frenchify()} \\times ${values[1][1].frenchify()}  = ${values[1][0].frenchify()} \\times x
+$$
+
+On résout l'équation :
+
+${alignTex([
+                [
+                    `\\frac{${values[0][0].frenchify()} \\times ${values[1][1].frenchify()}}{${values[1][0].frenchify()}}`,
+                    "=",
+                    `x`,
+                ],
+                [`${values[0][1].frenchify()}`, "\\approx", `x`],
+            ])}
+
+Le volume de bronze de la statue est $${values[0][1].frenchify()}$ $\\textrm{m}^3$.`;
+        },
+        randValues: (roundTo) => {
+            const nbValues = 2;
+            const valuesA = [...Array(nbValues).keys()].reduce((acc, i) => {
+                if (i === 0) {
+                    return [1];
+                }
+                else {
+                    return [...acc, randfloat(0.2, 4, roundTo, acc)];
+                }
+            }, []);
+            const coeff = randfloat(8400, 8900, 2);
+            const valuesB = valuesA.map((valueA) => round(valueA * coeff, roundTo));
+            return [valuesA, valuesB];
+        },
+    },
+];
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return shuffleProps(situation.propositions(values, situation.roundTo), n);
+};
+const getAnswer = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.answer(values, situation.roundTo);
+};
+const getInstruction = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.instruction(values, situation.roundTo);
+};
+const getHint = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.hint(values);
+};
+const getCorrection = (identifiers) => {
+    const { situationIndex, values } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.correction(values, situation.roundTo);
+};
+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 getFourthProportionalFromProblemQuestion = () => {
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const values = situation.randValues(situation.roundTo);
+    const identifiers = { situationIndex, values };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const fourthProportionalFromProblem = {
+    id: "fourthProportionalFromProblem",
+    label: "Calculer une quatrième proportionnelle à partir d'un énoncé",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFourthProportionalFromProblemQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    isAnswerValid,
+};

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

@@ -6,4 +6,6 @@ export * from "./isTableProportionalNonInteger.js";
 export * from "./findCoeffInProportionalTableNonIntegers.js";
 export * from "./isTableProportional.js";
 export * from "./rectangleSideAfterReduction.js";
+export * from "./isProportionalFromProblem.js";
+export * from "./fourthProportionalFromProblem.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oCAAoC,CAAC;AACnD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sCAAsC,CAAC;AACrD,cAAc,uBAAuB,CAAC;AACtC,cAAc,iBAAiB,CAAC;AAChC,cAAc,oCAAoC,CAAC;AACnD,cAAc,8CAA8C,CAAC;AAC7D,cAAc,0BAA0B,CAAC;AACzC,cAAc,kCAAkC,CAAC;AACjD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC"}

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

@@ -6,3 +6,5 @@ export * from "./isTableProportionalNonInteger.js";
 export * from "./findCoeffInProportionalTableNonIntegers.js";
 export * from "./isTableProportional.js";
 export * from "./rectangleSideAfterReduction.js";
+export * from "./isProportionalFromProblem.js";
+export * from "./fourthProportionalFromProblem.js";

package/lib/exercises/math/calcul/proportionality/isProportionalFromProblem.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    situationIndex: number;
+    values: number[][];
+};
+export declare const isProportionalFromProblem: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=isProportionalFromProblem.d.ts.map

package/lib/exercises/math/calcul/proportionality/isProportionalFromProblem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"isProportionalFromProblem.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/proportionality/isProportionalFromProblem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAWT,MAAM,6BAA6B,CAAC;AAiBrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB,CAAC;AA0aF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAiB3D,CAAC"}