math-exercises 3.0.125 → 3.0.127

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 d'heures font $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",
+};

package/lib/exercises/math/dataRepresentations/barChartInterpreting.d.ts

@@ -0,0 +1,53 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    barChart: BarChart;
+    itemAsked: AskedItem;
+    questionStr: string;
+    answerStr: string;
+    displayType: string;
+};
+type AskedItem = {
+    type: "xForCategory" | "categoryForX";
+    isLess: boolean;
+    ordinal: number;
+    index: number;
+};
+type ColorStyle = {
+    type: "color";
+    color: string;
+    frStr: string;
+};
+type FillStyle = {
+    type: "fill";
+    fill: number;
+    frStr: string;
+};
+type CategoryProps = {
+    name: string;
+    frStr: string;
+};
+type CategoryStyle = ColorStyle | FillStyle;
+type Category = {
+    props: CategoryProps;
+    style: CategoryStyle;
+};
+type BarProps = {
+    label: string;
+    frStr: string;
+};
+type Bar = {
+    props: BarProps;
+    data: number[];
+};
+type BarChart = {
+    description: string;
+    axisLabels: string[];
+    bars: Bar[];
+    categories: Category[];
+};
+type Options = {
+    displayType: string;
+};
+export declare const barChartInterpreting: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=barChartInterpreting.d.ts.map

package/lib/exercises/math/dataRepresentations/barChartInterpreting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"barChartInterpreting.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/barChartInterpreting.ts"],"names":[],"mappings":"AAAA,OAAO,EAaL,QAAQ,EAKT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,QAAQ,CAAC;IACnB,SAAS,EAAE,SAAS,CAAC;IACrB,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,cAAc,GAAG,cAAc,CAAC;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,UAAU,GAAG;IAChB,IAAI,EAAE,OAAO,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,SAAS,GAAG;IACf,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,aAAa,GAAG,UAAU,GAAG,SAAS,CAAC;AAE5C,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,aAAa,CAAC;IACrB,KAAK,EAAE,aAAa,CAAC;CACtB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,KAAK,GAAG,GAAG;IACT,KAAK,EAAE,QAAQ,CAAC;IAChB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAEF,KAAK,QAAQ,GAAG;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,IAAI,EAAE,GAAG,EAAE,CAAC;IACZ,UAAU,EAAE,QAAQ,EAAE,CAAC;CACxB,CAAC;AAotBF,KAAK,OAAO,GAAG;IACb,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsBF,eAAO,MAAM,oBAAoB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAgB/D,CAAC"}