math-exercises 3.0.125 → 3.0.126

package/lib/exercises/math/conversion/kmPerMinToKmPerHourConversion.js

@@ -0,0 +1,98 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { dividersOf } from "../../../math/utils/arithmetic/dividersOf.js";
+import { randint } from "../../../math/utils/random/randint.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 { random } from "../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { distance, minutes } = identifiers;
+    return `Si on parcourt $${distance.frenchify()}$ km en $${minutes.frenchify()}$ min, 
+quelle est la vitesse moyenne en km/h ( $km.h^{-1}$ ) ?`;
+};
+const getAnswer = (identifiers) => {
+    const { distance, minutes } = identifiers;
+    const nodeAnswer = multiply(distance, frac(60, minutes));
+    return `${nodeAnswer.simplify().toTex()}km.h^{-1}`;
+};
+const isAnswerValid = (ans, { distance, minutes }) => {
+    const nodeAnswer = multiply(distance, frac(60, minutes));
+    const nodeAns = parseAlgebraic(ans.replace("$km.h^{-1}$", "").replace("km/h", ""));
+    return substract(nodeAns, nodeAnswer).evaluate() === 0;
+};
+const getHint = () => {
+    return `Combien de minutes constituent une heure ?`;
+};
+const getCorrection = (identifiers) => {
+    const { distance, minutes } = identifiers;
+    return `En $60$ minutes, on parcourt $${multiply(distance, frac(60, minutes)).toTex()}$ km 
+donc la vitesse est de $${multiply(distance, frac(60, minutes).simplify()).toTex()} = ${multiply(distance, frac(60, minutes))
+        .simplify()
+        .toTex()}$ $km.h^{-1}$`;
+};
+const getPropositions = (n, { answer, distance, minutes }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, `${multiply(60, minutes).simplify().toTex()}km.h^{-1}`);
+    tryToAddWrongProp(propositions, `${frac(distance, minutes).simplify().toTex()}km.h^{-1}`);
+    tryToAddWrongProp(propositions, `${multiply(3.6, frac(distance, minutes)).simplify().toTex()}km.h^{-1}`);
+    return shuffleProps(propositions, n);
+};
+const getKmPerMinToKmPerHourConversionQuestion = () => {
+    const distance = randint(1, 101);
+    const minutes = random(dividersOf(60));
+    const identifiers = {
+        distance,
+        minutes,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [
+            {
+                id: "custom",
+                label: "{km}.{h}^{-1}",
+                labelType: "tex",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: "{km}.{h}^{-1}",
+                },
+            },
+            {
+                id: "custom",
+                label: "km/h",
+                labelType: "raw",
+                mathfieldInstructions: {
+                    method: "write",
+                    content: "km/h",
+                },
+            },
+        ],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const kmPerMinToKmPerHourConversion = {
+    id: "kmPerMinToKmPerHourConversion",
+    connector: "=",
+    label: "Effectuer des conversions de vitesse ( $x$ km en $y$ min donne une vitesse $V$ en km/h)",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getKmPerMinToKmPerHourConversionQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/conversion/minutesToHours.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    isMinutesToHours: boolean;
+    nodeIdsMinutes: NodeIdentifiers;
+    nodeIdsHours: NodeIdentifiers;
+};
+export declare const minutesToHours: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=minutesToHours.d.ts.map

package/lib/exercises/math/conversion/minutesToHours.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"minutesToHours.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/minutesToHours.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,eAAe,CAAC;IAChC,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA2LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAgBhD,CAAC"}

package/lib/exercises/math/conversion/minutesToHours.js

@@ -0,0 +1,150 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { dividersOf } from "../../../math/utils/arithmetic/dividersOf.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+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";
+const getInstruction = (identifiers) => {
+    const { isMinutesToHours, nodeIdsMinutes, nodeIdsHours } = identifiers;
+    const minutes = NodeConstructor.fromIdentifiers(nodeIdsMinutes);
+    const hours = NodeConstructor.fromIdentifiers(nodeIdsHours);
+    return `Convertir ${isMinutesToHours ? `$${minutes.toTex()}$ min` : `$${hours.toTex()}$ h`} en ${isMinutesToHours ? "heures" : "minutes"}. 
+
+Donner la valeur exacte (et pas la valeur arrondie).`;
+};
+const getAnswer = (identifiers) => {
+    const { isMinutesToHours, nodeIdsMinutes, nodeIdsHours } = identifiers;
+    const minutes = NodeConstructor.fromIdentifiers(nodeIdsMinutes);
+    const hours = NodeConstructor.fromIdentifiers(nodeIdsHours);
+    const answer = isMinutesToHours
+        ? `${hours.toTex()}\\text{h}`
+        : `${minutes.toTex()}\\text{min}`;
+    return answer;
+};
+const isAnswerValid = (ans, { isMinutesToHours, nodeIdsMinutes, nodeIdsHours }) => {
+    if (isMinutesToHours) {
+        if (ans.includes("\\text{min}"))
+            return false;
+        const nodeAns = parseAlgebraic(ans.replace("\\text{h}", ""));
+        const nodeAnswer = NodeConstructor.fromIdentifiers(nodeIdsHours);
+        return substract(nodeAns, nodeAnswer).evaluate() === 0;
+    }
+    else {
+        if (ans.includes("\\text{h}"))
+            return false;
+        const nodeAns = parseAlgebraic(ans.replace("\\text{min}", ""));
+        const nodeAnswer = NodeConstructor.fromIdentifiers(nodeIdsMinutes);
+        return substract(nodeAns, nodeAnswer).evaluate() === 0;
+    }
+};
+const getHint = (identifiers) => {
+    const { isMinutesToHours } = identifiers;
+    if (isMinutesToHours) {
+        return `Combien y-a-t-il d'heures dans $120$ minutes ?`;
+    }
+    else {
+        return `Combien y-a-t-il de minutes dans une heure ?`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { isMinutesToHours, nodeIdsMinutes, nodeIdsHours } = identifiers;
+    const minutes = NodeConstructor.fromIdentifiers(nodeIdsMinutes);
+    const hours = NodeConstructor.fromIdentifiers(nodeIdsHours);
+    return `
+${(() => {
+        if (isMinutesToHours) {
+            return `Comme il y a $60$ minutes dans une heure alors $${minutes.toTex()}$ minutes correspondent à $${frac(minutes, 60).toTex()} = ${hours.toTex()} $ ${hours.evaluate() >= 2 ? `heures` : `heure`}.`;
+        }
+        else {
+            return `Comme il y a $60$ minutes dans une heure alors $${hours.toTex()}$ ${hours.evaluate() >= 2 ? `heures` : `heure`} correspondent à $${hours.toTex()} \\times {60} = ${minutes.toTex()} $ minutes.`;
+        }
+    })()}
+
+Attention, il fallait donner la valeur exacte et pas la valeur approchée.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { isMinutesToHours, nodeIdsMinutes, nodeIdsHours } = identifiers;
+    const minutes = NodeConstructor.fromIdentifiers(nodeIdsMinutes);
+    const hours = NodeConstructor.fromIdentifiers(nodeIdsHours);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    if (isMinutesToHours) {
+        const roundedValue = round(hours.evaluate(), 2);
+        const texDecimal = roundedValue.frenchify().split(",")[1];
+        tryToAddWrongProp(propositions, `${roundedValue.frenchify()}\\text{h}`);
+        tryToAddWrongProp(propositions, `${multiply(minutes.evaluate(), 60).simplify().toTex()}\\text{h}`);
+        tryToAddWrongProp(propositions, `${frac(60, minutes).toTex()}\\text{h}`);
+        propWhile(propositions, n, () => {
+            tryToAddWrongProp(propositions, `${0},${texDecimal}\\text{h}`);
+            tryToAddWrongProp(propositions, `${1},${texDecimal}\\text{h}`);
+        });
+    }
+    else {
+        tryToAddWrongProp(propositions, `${round(multiply(hours.evaluate(), 60).evaluate(), 0).frenchify()}\\text{min}`);
+        tryToAddWrongProp(propositions, `${round(multiply(round(hours.evaluate(), 0), 60).evaluate(), 0).frenchify()}\\text{min}`);
+        tryToAddWrongProp(propositions, `${frac(60, hours).simplify().toTex()}\\text{min}`);
+        tryToAddWrongProp(propositions, `${multiply(hours, frac(1, 60)).simplify().toTex()}\\text{min}`);
+        tryToAddWrongProp(propositions, `${multiply(hours, frac(1, 60)).toTex()}\\text{min}`);
+        tryToAddWrongProp(propositions, `${round(multiply(hours, round(frac(1, 60).evaluate(), 4)).evaluate(), 0).frenchify()}\\text{min}`);
+    }
+    return shuffleProps(propositions, n);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["hours", "minutes"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getMinutesToHoursQuestion = () => {
+    const isMinutesToHours = coinFlip();
+    let minutes;
+    let hours;
+    const dividersOf60 = dividersOf(60);
+    if (isMinutesToHours) {
+        minutes = coinFlip()
+            ? randint(1, 18000).toTree()
+            : multiply(randint(1, 101), random(dividersOf60)).evaluate().toTree();
+        hours = frac(minutes, 60).simplify();
+    }
+    else {
+        const numerator = coinFlip()
+            ? randint(1, 1800).toTree()
+            : multiply(randint(1, 21), random(dividersOf60));
+        hours = frac(numerator, random(dividersOf60)).simplify();
+        minutes = multiply(hours, 60).simplify();
+    }
+    const identifiers = {
+        isMinutesToHours,
+        nodeIdsMinutes: minutes.toIdentifiers(),
+        nodeIdsHours: hours.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+export const minutesToHours = {
+    id: "minutesToHours",
+    connector: "=",
+    label: "Convertir une durée en minutes en une durée en heures et inversement",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getMinutesToHoursQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/conversion/prefixToNumber.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../exercise.js";
+type Identifiers = {
+    prefixIndexesPool: number[];
+    prefixIndex: number;
+    isToPow10: boolean;
+    isFromSymbol: boolean;
+};
+type Options = {
+    prefixPool: string[];
+    isToPow10: boolean;
+    isFromSymbol: boolean;
+};
+export declare const prefixToNumber: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=prefixToNumber.d.ts.map

package/lib/exercises/math/conversion/prefixToNumber.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prefixToNumber.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/prefixToNumber.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,QAAQ,EAiBT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,iBAAiB,EAAE,MAAM,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAsLF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,OAAO,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA+EF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAiBzD,CAAC"}

package/lib/exercises/math/conversion/prefixToNumber.js

@@ -0,0 +1,233 @@
+import { power } from "../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../tree/parsers/latexParser.js";
+import { random } from "../../../utils/alea/random.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+import { mdTable } from "../../../utils/markdown/mdTable.js";
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, tryToAddWrongProp, } from "../../exercise.js";
+import { getDistinctQuestions } from "../../utils/getDistinctQuestions.js";
+const prefixes = [
+    {
+        name: "Déca",
+        symbol: "da",
+        meaning: "dix",
+        superscript: 1,
+        texPow10: power(10, 1).toTex(),
+        texValue: "10",
+    },
+    {
+        name: "Hecto",
+        symbol: "h",
+        meaning: "cent",
+        superscript: 2,
+        texPow10: power(10, 2).toTex(),
+        texValue: "100",
+    },
+    {
+        name: "Kilo",
+        symbol: "k",
+        meaning: "mille",
+        superscript: 3,
+        texPow10: power(10, 3).toTex(),
+        texValue: "1 000",
+    },
+    {
+        name: "Méga",
+        symbol: "M",
+        meaning: "million",
+        superscript: 6,
+        texPow10: power(10, 6).toTex(),
+        texValue: "1 000 000",
+    },
+    {
+        name: "Giga",
+        symbol: "G",
+        meaning: "milliard",
+        superscript: 9,
+        texPow10: power(10, 9).toTex(),
+        texValue: "1 000 000 000",
+    },
+    {
+        name: "Déci",
+        symbol: "d",
+        meaning: "dixième de",
+        superscript: -1,
+        texPow10: power(10, -1).toTex(),
+        texValue: "0,1",
+    },
+    {
+        name: "Centi",
+        symbol: "c",
+        meaning: "centième de",
+        superscript: -2,
+        texPow10: power(10, -2).toTex(),
+        texValue: "0,01",
+    },
+    {
+        name: "Milli",
+        symbol: "m",
+        meaning: "millième de",
+        superscript: -3,
+        texPow10: power(10, -3).toTex(),
+        texValue: "0,001",
+    },
+    {
+        name: "Micro",
+        symbol: "\\mu",
+        meaning: "millionième de",
+        superscript: -6,
+        texPow10: power(10, -6).toTex(),
+        texValue: "0,000 001",
+    },
+    {
+        name: "Nano",
+        symbol: "n",
+        meaning: "milliardième de",
+        superscript: -9,
+        texPow10: power(10, -9).toTex(),
+        texValue: "0,000 000 001",
+    },
+].toSorted((prefix1, prefix2) => prefix1.superscript - prefix2.superscript);
+const getMdTable = (prefixes, indexBold = -1) => {
+    function boldify(str) {
+        return `**${str}**`;
+    }
+    return mdTable([
+        ["Préfixe", "Symbole", "Signification", "Puissance"],
+        ...prefixes.map((prefix, i) => [
+            prefix.name,
+            `$${prefix.symbol}$`,
+            prefix.meaning,
+            `$${prefix.texPow10}$`,
+        ].map((str) => (i === indexBold ? boldify(str) : str))),
+    ]);
+};
+const getInstruction = (identifiers) => {
+    const { prefixIndex, isFromSymbol, isToPow10 } = identifiers;
+    const prefix = prefixes[prefixIndex];
+    return `Quelle est la valeur du préfixe ${isFromSymbol ? `$${prefix.symbol}$` : prefix.name} ?
+  
+Ecris la réponse sous la forme ${isToPow10 ? `d'une puissance de $10$` : `d'un nombre décimal`}.`;
+};
+const getHint = (identifiers) => {
+    const { prefixIndexesPool } = identifiers;
+    const prefixPool = prefixIndexesPool.map((i) => prefixes[i]);
+    return getMdTable(prefixPool);
+};
+const getCorrection = (identifiers) => {
+    const { prefixIndexesPool, prefixIndex } = identifiers;
+    const prefixPool = prefixIndexesPool.map((i) => prefixes[i]);
+    const indexBold = (() => {
+        for (let i = 0; i < prefixIndexesPool.length; i++) {
+            if (prefixIndexesPool[i] === prefixIndex)
+                return i;
+        }
+    })();
+    return getMdTable(prefixPool, indexBold);
+};
+const getAnswer = (identifiers) => {
+    const { prefixIndex, isToPow10 } = identifiers;
+    const prefix = prefixes[prefixIndex];
+    return isToPow10 ? prefix.texPow10 : prefix.texValue;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { prefixIndexesPool, prefixIndex, isToPow10 } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const wrongIndexesPool = prefixIndexesPool.filter((i) => i !== prefixIndex);
+    let availableWrongPrefixIndexes = wrongIndexesPool.length >= n - 1
+        ? wrongIndexesPool
+        : prefixes.map((_, i) => i).filter((i) => i !== prefixIndex);
+    propWhile(propositions, n, () => {
+        const wrongPrefixIndex = random(availableWrongPrefixIndexes);
+        const wrongPrefix = prefixes[wrongPrefixIndex];
+        const wrongTex = isToPow10 ? wrongPrefix.texPow10 : wrongPrefix.texValue;
+        tryToAddWrongProp(propositions, wrongTex);
+        availableWrongPrefixIndexes = availableWrongPrefixIndexes.filter((i) => i !== wrongPrefixIndex);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    const nodeAns = parseAlgebraic(ans);
+    const nodeAnswer = parseAlgebraic(answer);
+    return substract(nodeAns, nodeAnswer).evaluate() === 0;
+};
+const optionsDefault = {
+    prefixPool: prefixes.map((prefix) => prefix.name),
+    isToPow10: [true, false],
+    isFromSymbol: [true, false],
+};
+const options = [
+    {
+        id: "prefixPool",
+        label: "N'utiliser que les préfixes suivants :",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: prefixes.map((prefix) => prefix.name),
+    },
+    {
+        id: "isToPow10",
+        label: "Réponse sous forme de puissance de 10 ?",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        values: optionsDefault.isToPow10,
+    },
+    {
+        id: "units",
+        label: "Utiliser le symbole pour la question ?",
+        type: GeneratorOptionType.checkbox,
+        target: GeneratorOptionTarget.generation,
+        values: optionsDefault.isFromSymbol,
+    },
+];
+const getPrefixToNumberQuestion = (optsIn) => {
+    const opts = optsIn ? Object.assign(optionsDefault, optsIn) : optionsDefault;
+    const prefixIndexesPool = opts.prefixPool.map((prefixName) => {
+        const prefixIndex = (() => {
+            for (let i = 0; i < prefixes.length; i++) {
+                if (prefixes[i].name === prefixName)
+                    return i;
+            }
+        })();
+        return prefixIndex;
+    }) ?? optionsDefault.prefixPool;
+    const prefixIndex = random(prefixIndexesPool);
+    const isFromSymbol = optsIn?.isFromSymbol ?? random(optionsDefault.isFromSymbol);
+    const isToPow10 = optsIn?.isToPow10 ?? random(optionsDefault.isToPow10);
+    const identifiers = {
+        prefixIndexesPool,
+        prefixIndex,
+        isFromSymbol,
+        isToPow10,
+    };
+    return getQuestionFromIdentifiers(identifiers, optsIn);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers, opts),
+        answer: getAnswer(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const prefixToNumber = {
+    id: "prefixToNumber",
+    connector: "=",
+    label: "Convertir un préfixe en nombre",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPrefixToNumberQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getAnswer,
+    getInstruction,
+    options,
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/conversion/secondsToHours.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    isSecondsToHours: boolean;
+    nodeIdsSeconds: NodeIdentifiers;
+    nodeIdsHours: NodeIdentifiers;
+};
+export declare const secondsToHours: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=secondsToHours.d.ts.map

package/lib/exercises/math/conversion/secondsToHours.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secondsToHours.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/conversion/secondsToHours.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAQ7C,KAAK,WAAW,GAAG;IACjB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,eAAe,CAAC;IAChC,YAAY,EAAE,eAAe,CAAC;CAC/B,CAAC;AA2LF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAiBhD,CAAC"}

package/lib/exercises/math/conversion/secondsToHours.js

@@ -0,0 +1,150 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { dividersOf } from "../../../math/utils/arithmetic/dividersOf.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { round } from "../../../math/utils/round.js";
+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";
+const getInstruction = (identifiers) => {
+    const { isSecondsToHours, nodeIdsSeconds, nodeIdsHours } = identifiers;
+    const seconds = NodeConstructor.fromIdentifiers(nodeIdsSeconds);
+    const hours = NodeConstructor.fromIdentifiers(nodeIdsHours);
+    return `Convertir ${isSecondsToHours ? `$${seconds.toTex()}$ s` : `$${hours.toTex()}$ h`} en ${isSecondsToHours ? "heures" : "secondes"}. 
+
+Donner la valeur exacte (et pas la valeur arrondie).`;
+};
+const getAnswer = (identifiers) => {
+    const { isSecondsToHours, nodeIdsSeconds, nodeIdsHours } = identifiers;
+    const seconds = NodeConstructor.fromIdentifiers(nodeIdsSeconds);
+    const hours = NodeConstructor.fromIdentifiers(nodeIdsHours);
+    const answer = isSecondsToHours
+        ? `${hours.toTex()}\\text{h}`
+        : `${seconds.toTex()}\\text{s}`;
+    return answer;
+};
+const isAnswerValid = (ans, { isSecondsToHours, nodeIdsSeconds, nodeIdsHours }) => {
+    if (isSecondsToHours) {
+        if (ans.includes("\\text{s}"))
+            return false;
+        const nodeAns = parseAlgebraic(ans.replace("\\text{h}", ""));
+        const nodeAnswer = NodeConstructor.fromIdentifiers(nodeIdsHours);
+        return substract(nodeAns, nodeAnswer).evaluate() === 0;
+    }
+    else {
+        if (ans.includes("\\text{h}"))
+            return false;
+        const nodeAns = parseAlgebraic(ans.replace("\\text{s}", ""));
+        const nodeAnswer = NodeConstructor.fromIdentifiers(nodeIdsSeconds);
+        return substract(nodeAns, nodeAnswer).evaluate() === 0;
+    }
+};
+const getHint = (identifiers) => {
+    const { isSecondsToHours } = identifiers;
+    if (isSecondsToHours) {
+        return `Combien y-a-t-il d'heures dans $7200$ secondes ?`;
+    }
+    else {
+        return `Combien y-a-t-il de secondes dans une heure ?`;
+    }
+};
+const getCorrection = (identifiers) => {
+    const { isSecondsToHours, nodeIdsSeconds, nodeIdsHours } = identifiers;
+    const seconds = NodeConstructor.fromIdentifiers(nodeIdsSeconds);
+    const hours = NodeConstructor.fromIdentifiers(nodeIdsHours);
+    return `
+${(() => {
+        if (isSecondsToHours) {
+            return `Comme il y a $3600$ secondes dans une heure alors $${seconds.toTex()}$ minutes correspondent à $${frac(seconds, 3600).toTex()} = ${hours.toTex()} $ ${hours.evaluate() >= 2 ? `heures` : `heure`}.`;
+        }
+        else {
+            return `Comme il y a $3600$ secondes dans une heure alors $${hours.toTex()}$ ${hours.evaluate() >= 2 ? `heures` : `heure`} correspondent à $${hours.toTex()} \\times {3600} = ${seconds.toTex()} $ secondes.`;
+        }
+    })()}
+
+Attention, il fallait donner la valeur exacte et pas la valeur approchée.`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { isSecondsToHours, nodeIdsSeconds, nodeIdsHours } = identifiers;
+    const seconds = NodeConstructor.fromIdentifiers(nodeIdsSeconds);
+    const hours = NodeConstructor.fromIdentifiers(nodeIdsHours);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    if (isSecondsToHours) {
+        const roundedValue = round(hours.evaluate(), 2);
+        const texDecimal = roundedValue.frenchify().split(",")[1];
+        tryToAddWrongProp(propositions, `${roundedValue.frenchify()}\\text{h}`);
+        tryToAddWrongProp(propositions, `${multiply(seconds.evaluate(), 3600).simplify().toTex()}\\text{h}`);
+        tryToAddWrongProp(propositions, `${frac(3600, seconds).toTex()}\\text{h}`);
+        propWhile(propositions, n, () => {
+            tryToAddWrongProp(propositions, `${0},${texDecimal}\\text{h}`);
+            tryToAddWrongProp(propositions, `${1},${texDecimal}\\text{h}`);
+        });
+    }
+    else {
+        tryToAddWrongProp(propositions, `${round(multiply(hours.evaluate(), 3600).evaluate(), 0).frenchify()}\\text{s}`);
+        tryToAddWrongProp(propositions, `${round(multiply(round(hours.evaluate(), 0), 3600).evaluate(), 0).frenchify()}\\text{s}`);
+        tryToAddWrongProp(propositions, `${frac(3600, hours).simplify().toTex()}\\text{s}`);
+        tryToAddWrongProp(propositions, `${multiply(hours, frac(1, 3600)).simplify().toTex()}\\text{s}`);
+        tryToAddWrongProp(propositions, `${multiply(hours, frac(1, 3600)).toTex()}\\text{s}`);
+        tryToAddWrongProp(propositions, `${round(multiply(hours, round(frac(1, 3600).evaluate(), 4)).evaluate(), 0).frenchify()}\\text{s}`);
+    }
+    return shuffleProps(propositions, n);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: ["hours", "minutes"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getMinutesToHoursQuestion = () => {
+    const isSecondsToHours = coinFlip();
+    let seconds;
+    let hours;
+    const dividersOf3600 = dividersOf(3600);
+    if (isSecondsToHours) {
+        seconds = coinFlip()
+            ? randint(1, 18000).toTree()
+            : multiply(randint(1, 101), random(dividersOf3600)).evaluate().toTree();
+        hours = frac(seconds, 3600).simplify();
+    }
+    else {
+        const numerator = coinFlip()
+            ? randint(1, 1800).toTree()
+            : multiply(randint(1, 21), random(dividersOf3600));
+        hours = frac(numerator, random(dividersOf3600)).simplify();
+        seconds = multiply(hours, 3600).simplify();
+    }
+    const identifiers = {
+        isSecondsToHours,
+        nodeIdsSeconds: seconds.toIdentifiers(),
+        nodeIdsHours: hours.toIdentifiers(),
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+export const secondsToHours = {
+    id: "secondsToHours",
+    connector: "=",
+    label: "Convertir une durée en secondes en une durée en heures et inversement",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getMinutesToHoursQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    shouldHaveCalculator: true,
+    answerType: "QCU",
+};