math-exercises 3.0.124 → 3.0.126

package/lib/exercises/math/dataRepresentations/boxPlotInterpreting.js

@@ -0,0 +1,223 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { multiply } from "../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { randomMany } from "../../../utils/alea/random.js";
+import { getAllPicks } from "../../../utils/arrays/getAllPicks.js";
+const getAvailableQuestionObjs = (quartiles) => {
+    const [q0, q1, _, q3, q4] = quartiles;
+    const arrQuartileIndexAvailable = [
+        0,
+        ...(q0 !== q1 ? [1] : []),
+        2,
+        ...(q3 !== q4 ? [3] : []),
+        4,
+    ];
+    return getAllPicks(arrQuartileIndexAvailable)
+        .filter((quartileIndexesPicked) => quartileIndexesPicked.length === 2)
+        .flatMap((quartileIndexesPicked) => {
+        return [
+            ...(quartileIndexesPicked[0] === 0 ? ["below"] : []),
+            "between",
+            ...(quartileIndexesPicked[1] === 4 ? ["above"] : []),
+        ].map((typeQ) => {
+            return {
+                typeQ: typeQ,
+                quartileIndexes: quartileIndexesPicked,
+            };
+        });
+    });
+};
+const getPercentageNode = (quartileIndexes) => {
+    return multiply(substract(quartileIndexes[1], quartileIndexes[0]), 25).simplify();
+};
+const getFrenchStringForPercentage = (n) => {
+    switch (n) {
+        case 25:
+            return `Un quart des`;
+        case 50:
+            return `La moitié des`;
+        case 75:
+            return `Trois quarts des`;
+        case 100:
+            return `Tous les`;
+        default:
+            return "";
+    }
+};
+const getTexPercentage = (n) => {
+    return coinFlip()
+        ? `$${n.frenchify()}\\%$ des`
+        : getFrenchStringForPercentage(n);
+};
+const getValidProp = (quartiles, questionObj) => {
+    const { typeQ, quartileIndexes } = questionObj;
+    const percentageNode = getPercentageNode(quartileIndexes);
+    const texPercentage = getTexPercentage(percentageNode.evaluate());
+    switch (typeQ) {
+        case "below":
+            return `${texPercentage} élèves ont eu $${quartiles[quartileIndexes[1]]}$ ou moins.`;
+        case "between":
+            return `${texPercentage} élèves ont eu entre $${quartiles[quartileIndexes[0]]}$ et $${quartiles[quartileIndexes[1]]}$.`;
+        case "above":
+            return `${texPercentage} élèves ont eu $${quartiles[quartileIndexes[0]]}$ ou plus.`;
+    }
+};
+const getInvalidProps = (quartiles, questionObj) => {
+    const { typeQ, quartileIndexes } = questionObj;
+    const validPercentageNode = getPercentageNode(quartileIndexes);
+    const validPercentage = validPercentageNode.evaluate();
+    const invalidPercentages = [0, 25, 50, 75, 100].filter((n) => n > validPercentage);
+    switch (typeQ) {
+        case "below":
+            return invalidPercentages.map((n) => `${getTexPercentage(n)} élèves ont eu $${quartiles[quartileIndexes[1]]}$ ou moins.`);
+        case "between":
+            return invalidPercentages.map((n) => `${getTexPercentage(n)} élèves ont eu entre $${quartiles[quartileIndexes[0]]}$ et $${quartiles[quartileIndexes[1]]}$.`);
+        case "above":
+            return invalidPercentages.map((n) => `${getTexPercentage(n)} élèves ont eu $${quartiles[quartileIndexes[0]]}$ ou plus.`);
+    }
+};
+const getInstruction = (identifiers) => {
+    const { quartiles } = identifiers;
+    return `Voici la boîtes à moustaches correspondant aux notes du bac en mathématiques.
+
+On observe que $Q1 = ${quartiles[1].frenchify()}$, que la médiane vaut $${quartiles[2].frenchify()}$ 
+et que $Q3 = ${quartiles[3].frenchify()}$. 
+
+On peut alors en déduire que :
+`;
+};
+const getHint = () => {
+    return `Il y a autant d'élèves qui ont eu la médiane ou plus que d'élèves qui ont eu la médiane ou moins.
+
+Au moins $25\\%$  des élèves ont eu $Q1$ ou moins que $Q1$.
+
+Au moins $75\\%$  des élèves ont eu $Q3$ ou moins que $Q3$.`;
+};
+const getCorrection = (identifiers) => {
+    const { quartiles } = identifiers;
+    const [q0, q1, _, q3, q4] = quartiles;
+    const questionObjs = [
+        { typeQ: "below", quartileIndexes: [0, 1] },
+        ...(q0 !== q1
+            ? [{ typeQ: "between", quartileIndexes: [1, 2] }]
+            : [{ typeQ: "between", quartileIndexes: [0, 2] }]),
+        ...(q3 !== q4
+            ? [{ typeQ: "between", quartileIndexes: [2, 3] }]
+            : [{ typeQ: "between", quartileIndexes: [2, 4] }]),
+        { typeQ: "above", quartileIndexes: [3, 4] },
+    ];
+    const validProps = questionObjs.map((questionObj) => getValidProp(quartiles, questionObj));
+    return `Voici quelques commentaires sur la répartition des notes des élèves : 
+  
+${validProps.join(`
+
+`)}`;
+};
+const getPropositions = (n, { quartiles }) => {
+    const propositions = [];
+    const questionObjs = getAvailableQuestionObjs(quartiles);
+    const nbValid = randint(1, 4);
+    const allValidProps = [
+        ...questionObjs.map((questionObj) => getValidProp(quartiles, questionObj)),
+        `Aucun élève n'a eu en dessous de $${quartiles[0]}$`,
+        `Aucun élève n'a eu au dessus de $${quartiles[4]}$`,
+    ];
+    const validProps = randomMany(allValidProps, nbValid);
+    validProps.forEach((validProp) => {
+        addValidProp(propositions, validProp, "raw");
+    });
+    const nbInvalid = n - nbValid;
+    const allInvalidProps = [
+        ...questionObjs.flatMap((questionObj) => getInvalidProps(quartiles, questionObj)),
+        `Aucun élève n'a eu en dessous de $${quartiles[2]}$`,
+        `Aucun élève n'a eu au dessus de $${quartiles[2]}$`,
+    ];
+    const invalidProps = randomMany(allInvalidProps, nbInvalid);
+    invalidProps.forEach((invalidProp) => {
+        tryToAddWrongProp(propositions, invalidProp, "raw");
+    });
+    return shuffleProps(propositions, n);
+};
+const getGGBOptions = (identifiers) => {
+    const { quartiles } = identifiers;
+    const [q0, q1, q2, q3, q4] = quartiles;
+    const yOffset = 2;
+    const yScale = 0.8;
+    const commands = [
+        `BM = BoxPlot(${yOffset}, ${yScale}, ${q0}, ${q1}, ${q2}, ${q3}, ${q4})`,
+        `ShowLabel(BM, false)`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        forbidShiftDragZoom: false,
+        lockedAxesRatio: false,
+        // gridDistance: [0.5, 1],
+        xAxis: {
+            hideNumbers: false,
+            steps: 1,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        maxHeight: 100,
+        fontSize: 20,
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: q0,
+            xMax: q4,
+            yMin: -2,
+            yMax: 5,
+        }),
+    });
+};
+const getBoxInterpretingQuestion = () => {
+    const arrBounds = [
+        { min: 0, max: 8 },
+        { min: 12, max: 20 },
+    ];
+    const [q0, q1] = [0, 1]
+        .map((_) => randint(arrBounds[0].min, arrBounds[0].max))
+        .toSorted((i1, i2) => i1 - i2);
+    const [q3, q4] = [0, 1]
+        .map((_) => randint(arrBounds[1].min, arrBounds[1].max))
+        .toSorted((i1, i2) => i1 - i2);
+    const q2 = randint(q1, q3, [q1]); //we prevent q2 from being equal to q1 or q3
+    const quartiles = [q0, q1, q2, q3, q4];
+    const identifiers = { quartiles };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const boxPlotInterpreting = {
+    id: "boxPlotInterpreting",
+    label: "Interpréter une boite à moustaches",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBoxInterpretingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCM",
+    isQCM: true,
+};

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

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise.js";
+type Identifiers = {
+    xValues: number[];
+    yValues: number[];
+    answerIndex: number;
+    isLess: boolean;
+};
+export declare const cartesianGraphExtremaReading: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=cartesianGraphExtremaReading.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cartesianGraphExtremaReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/cartesianGraphExtremaReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,OAAO,CAAC;CACjB,CAAC;AAuJF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAsB9D,CAAC"}

package/lib/exercises/math/dataRepresentations/cartesianGraphExtremaReading.js

@@ -0,0 +1,139 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random } from "../../../utils/alea/random.js";
+import { shuffle } from "../../../utils/alea/shuffle.js";
+const getPropositions = (n, { xValues, answerIndex }) => {
+    const propositions = [];
+    const xAnswer = xValues[answerIndex];
+    [
+        xAnswer,
+        ...shuffle(xValues.filter((xValue) => xValue !== xAnswer)).slice(0, n - 1),
+    ]
+        .toSorted((x1, x2) => x1 - x2)
+        .forEach((xValue) => {
+        const tex = `en $${xValue.frenchify()}$`;
+        if (xValue === xAnswer) {
+            addValidProp(propositions, tex, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, tex, "raw");
+        }
+    });
+    return propositions;
+};
+const getAnswer = (identifiers) => {
+    const { answerIndex, xValues } = identifiers;
+    return xValues[answerIndex].frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { isLess } = identifiers;
+    return `Ce diagramme cartésien représente le nombre de naissance (en milliers) entre $2003$ et $2011$.
+Durant cette période, en quelle année y a-t-il eu le ${isLess ? `moins` : `plus`} de naissances ?`;
+};
+const getHint = (identifiers) => {
+    const { isLess } = identifiers;
+    return `Observe quand la courbe est la plus ${isLess ? `basse` : `haute`}.`;
+};
+const getCorrection = (identifiers) => {
+    const { isLess } = identifiers;
+    const answer = getAnswer(identifiers);
+    return `La courbe est la plus ${isLess ? `basse` : `haute`} en $${answer}$.
+Donc c'est en $${answer}$ qu'il y a eu le ${isLess ? `moins` : `plus`} de naissances en France.
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { xValues, yValues } = identifiers;
+    const commands = [
+        `LG = LineGraph({${xValues.join(",")}}, {${yValues.join(",")}})`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        // forbidShiftDragZoom: false,
+        lockedAxesRatio: (xValues.length / (840 - 760)) * 0.5,
+        gridDistance: [1, 1],
+        xAxis: {
+            hideNumbers: false,
+            steps: 1,
+            label: "Année",
+        },
+        yAxis: {
+            hideNumbers: false,
+            steps: 10,
+            label: "Nombre de naissances (en milliers)",
+        },
+        maxHeight: 200,
+        fontSize: 15,
+    });
+    return ggb.getOptions({
+        // coords: ggb.getAdaptedCoords({
+        //   xMin: xValues[0] - 1,
+        //   xMax: xValues[xValues.length - 1] + 1,
+        //   yMin: 760,
+        //   yMax: 840,
+        // }),
+        coords: [xValues[0] - 1, xValues[xValues.length - 1] + 1, 760, 840],
+    });
+};
+const getCartesianGraphExtremaReadingQuestion = () => {
+    const isLess = coinFlip();
+    const nbYears = 9;
+    const yMin = 770;
+    const yMax = 830;
+    const xValues = [...Array(nbYears).keys()].map((i) => i + 2003);
+    const indexExtremum = random([...Array(nbYears).keys()]);
+    const yExtremum = isLess
+        ? randint(yMin, 0.4 * yMin + 0.6 * yMax)
+        : randint(0.4 * yMin + 0.6 * yMax, yMax + 1);
+    const yReadabilityOffset = 10;
+    const yMinForPick = isLess ? yExtremum + yReadabilityOffset : yMin;
+    const yMaxForPick = isLess ? yMax : yExtremum - yReadabilityOffset;
+    const yValues = [...Array(nbYears).keys()].map((i) => {
+        if (i === indexExtremum) {
+            return yExtremum;
+        }
+        else {
+            return randint(yMinForPick, yMaxForPick + 1);
+        }
+    });
+    const answerIndex = yValues
+        .map((yValue, i) => {
+        return { value: yValue, index: i };
+    })
+        .toSorted(({ value: y1 }, { value: y2 }) => isLess ? y1 - y2 : y2 - y1)[0].index;
+    const identifiers = { xValues, yValues, isLess, answerIndex };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const cartesianGraphExtremaReading = {
+    id: "cartesianGraphExtremaReading",
+    label: "Commenter un diagramme cartésien",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCartesianGraphExtremaReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataToGraphGraphToData.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/dataToGraphGraphToData.ts"],"names":[],"mappings":"AAAA,OAAO,EAYL,QAAQ,EACT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA4JF,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,WAAW,CAcxD,CAAC"}

package/lib/exercises/math/dataRepresentations/dataToGraphGraphToData.js

@@ -0,0 +1,133 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { random } from "../../../utils/alea/random.js";
+const situations = [
+    {
+        description: (n) => `Sur $${n * 3}$ personnes : 
+$${n}$ ont moins de $18$ ans; 
+$${n}$ ont entre $18$ et $65$ ans 
+et les autres ont plus de $65$ ans.`,
+        answer: "a",
+        hint: (n) => `$${n}$ est le tiers de $${n * 3}$.`,
+        correction: (n) => `Comme $${n}$ est le tiers de $${n * 3}$ 
+alors seul le graphiques $a$ convient, car c'est le seul à contenir un tiers de disque.`,
+    },
+    {
+        description: (n) => `Sur $${n * 5}$ personnes : 
+$${n * 2.5}$ ont moins de $18$ ans, 
+$${n}$ ont entre $18$ et $65$ ans 
+et les autres ont plus de $65$ ans.`,
+        answer: "b",
+        hint: (n) => `$${n * 2.5}$ est la moitié de $${n * 5}$.`,
+        correction: (n) => `Comme $${n * 2.5}$ est la moitié de $${n * 5}$ 
+alors seuls les graphiques $b$ et $d$ conviennent. 
+De plus comme le quart de $${n * 5}$ vaut $${(n * 5) / 4}$ 
+et que $${n}<${(n * 5) / 4}$ alors seul le graphique $b$ convient.`,
+    },
+    {
+        description: (n) => `Sur $${n * 10}$ personnes : 
+$${n * 3}$ ont moins de $18$ ans, 
+$${n}$ ont entre $18$ et $65$ ans 
+et les autres ont plus de $65$ ans.`,
+        answer: "c",
+        hint: (n) => `$${n}$ est le dixième de $${n * 10}$.`,
+        correction: (n) => `Comme $${n}$ est le dixième de $${n * 10}$ 
+alors seuls le graphique $c$ convient.`,
+    },
+    {
+        description: (n) => `Sur $${n * 5}$ personnes : 
+$${n * 2.5}$ ont moins de $18$ ans, 
+$${(n * 5) / 4}$ ont entre $18$ et $65$ ans 
+et les autres ont plus de $65$ ans.`,
+        answer: "d",
+        hint: (n) => `$${n * 2.5}$ est la moitié de $${n * 5}$.`,
+        correction: (n) => `Comme $${n * 2.5}$ est la moitié de $${n * 5}$ 
+alors seuls les graphiques $b$ et $d$ conviennent. 
+De plus comme le quart de $${n * 5}$ vaut $${(n * 5) / 4}$ 
+et que $${n}<${(n * 5) / 4}$ alors seul le graphique $d$ convient.`,
+    },
+];
+const getInstruction = (identifiers) => {
+    const { indexSituation, bigNumber } = identifiers;
+    const situation = situations[indexSituation];
+    return `${situation.description(bigNumber)}
+  
+Parmi les représentations suivantes, laquelle décrit cette situation ?
+ ![](https://heureuxhasarddocsbucket.s3-eu-west-3.amazonaws.com/mathlive/tps/teacherImgUpload/c2b24209-5075-4c0f-953a-55dabcedc61f.jpeg)`;
+};
+const getAnswer = (identifiers) => {
+    const { indexSituation } = identifiers;
+    const situation = situations[indexSituation];
+    return situation.answer;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { indexSituation } = identifiers;
+    const situation = situations[indexSituation];
+    const propObjs = [
+        { tex: situation.answer, isValid: true },
+        ...["a", "b", "c", "d"]
+            .filter((letter) => letter !== situation.answer)
+            .map((letter) => {
+            return { tex: letter, isValid: false };
+        }),
+    ];
+    const propositions = [];
+    propObjs
+        .toSorted(({ tex: l1 }, { tex: l2 }) => l1.localeCompare(l2))
+        .forEach(({ tex, isValid }) => {
+        if (isValid) {
+            addValidProp(propositions, tex, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, tex, "raw");
+        }
+    });
+    return propositions;
+};
+const getHint = (identifiers) => {
+    const { indexSituation, bigNumber } = identifiers;
+    const situation = situations[indexSituation];
+    return situation.hint(bigNumber);
+};
+const getCorrection = (identifiers) => {
+    const { indexSituation, bigNumber } = identifiers;
+    const situation = situations[indexSituation];
+    return situation.correction(bigNumber);
+};
+const getDataToGraphGraphToDataQuestion = () => {
+    const indexSituation = randint(0, situations.length);
+    const bigNumber = random([
+        100, 200, 300, 400, 500, 1_000, 2_000, 3_000, 4_000, 5_000, 10_000, 20_000,
+    ]);
+    return getQuestionFromIdentifiers({
+        indexSituation,
+        bigNumber,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const dataToGraphGraphToData = {
+    id: "dataToGraphGraphToData",
+    label: "Passer du graphique aux données et vice-versa",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getDataToGraphGraphToDataQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    hasHintAndCorrection: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"graphReading.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/dataRepresentations/graphReading.ts"],"names":[],"mappings":"AAAA,OAAO,EAWL,QAAQ,EACT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoKF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAc9C,CAAC"}

package/lib/exercises/math/dataRepresentations/graphReading.js

@@ -0,0 +1,136 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { coinFlip } from "../../../utils/alea/coinFlip.js";
+import { random } from "../../../utils/alea/random.js";
+const propositionFuncs = [
+    (interval) => `Le nombre de naissances n'a pas cessé de croitre entre $${interval.min}$ et $${interval.max}$.`,
+    (interval) => `Le nombre de naissances n'a pas eu une variation monotone entre $${interval.min}$ et $${interval.max}$.`,
+    (interval) => `Le nombre de naissances a augmenté puis diminué entre $${interval.min}$ et $${interval.max}$.`,
+    (interval, maxOrScam) => `Le nombre de naissances a toujours été inférieur ou égal à $${maxOrScam}$ entre $${interval.min}$ et $${interval.max}$.`,
+];
+const situations = [
+    {
+        interval: { min: 2003, max: 2006 },
+        maxValue: 830_000,
+        answerIndexes: [0],
+        hint: `Observe les variations du graphiques entre $2003$ et $2006$. Monotone signifie "que croissant" ou "que décroissant".`,
+        correction: `Comme la courbe monte entre $2003$ et $2006$ alors le nombre de naissances n'a pas cessé de croitre entre $2003$ et $2006$.`,
+    },
+    {
+        interval: { min: 2003, max: 2007 },
+        maxValue: 830_000,
+        answerIndexes: [1, 2],
+        hint: `Observe les variations du graphiques entre $2003$ et $2007$. Monotone signifie "que croissant" ou "que décroissant".`,
+        correction: `Comme la courbe monte entre $2003$ et $2006$, puis descend entre $2006$ et $2007$ alors le nombre de naissances a augmenté puis diminué entre $2003$ et $2007$.`,
+    },
+    {
+        interval: { min: 2007, max: 2008 },
+        maxValue: 828_000,
+        answerIndexes: [0],
+        hint: `Observe les variations du graphiques entre $2007$ et $2008$. Monotone signifie "que croissant" ou "que décroissant".`,
+        correction: `Comme la courbe monte entre $2007$ et $2008$ alors le nombre de naissances n'a pas cessé de croitre entre $2007$ et $2008$.`,
+    },
+    {
+        interval: { min: 2006, max: 2008 },
+        maxValue: 830_000,
+        answerIndexes: [1],
+        hint: `Observe les variations du graphiques entre $2006$ et $2008$. Monotone signifie "que croissant" ou "que décroissant".`,
+        correction: `Comme la courbe descend entre $2006$ et $2007$ puis monte entre $2007$ et $2008$ alors le nombre de naissances a augmenté puis diminué entre $2006$ et $2008$.`,
+    },
+    {
+        interval: { min: 2008, max: 2009 },
+        maxValue: 828_000,
+        answerIndexes: [],
+        hint: `Observe les variations du graphiques entre $2008$ et $2009$. Monotone signifie "que croissant" ou "que décroissant".`,
+        correction: `Comme la courbe monte descend entre $2008$ et $2009$ alors le nombre de naissances a diminué entre $2008$ et $2009$.`,
+    },
+    {
+        interval: { min: 2009, max: 2011 },
+        maxValue: 833_000,
+        answerIndexes: [1, 2],
+        hint: `Observe les variations du graphiques entre $2009$ et $2011$. Monotone signifie "que croissant" ou "que décroissant".`,
+        correction: `Comme la courbe monte entre $2009$ et $2010$, puis descend entre $2010$ et $2011$ alors le nombre de naissances a augmenté puis diminué entre $2009$ et $2011$.`,
+    },
+];
+const getInstruction = (identifiers) => {
+    const { indexSituation } = identifiers;
+    const situation = situations[indexSituation];
+    return `Sur le graphique ci dessous :
+
+ ![](https://heureuxhasarddocsbucket.s3-eu-west-3.amazonaws.com/mathlive/tps/teacherImgUpload/354be741-9335-4496-a9c4-84f0e17a85c0.jpeg)
+ 
+Que peut-on dire du nombre de naissances entre $${situation.interval.min}$ et $${situation.interval.max}$ ?`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const { indexSituation, maxOrScam } = identifiers;
+    const situation = situations[indexSituation];
+    const propositions = [];
+    propositionFuncs.map((propositionFunc, i) => {
+        let isValid = situation.answerIndexes.includes(i);
+        if (i === 3 && situation.maxValue <= maxOrScam) {
+            isValid = true;
+        }
+        const tex = propositionFunc(situation.interval, maxOrScam);
+        if (isValid) {
+            addValidProp(propositions, tex, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, tex, "raw");
+        }
+    });
+    return propositions;
+};
+const getHint = (identifiers) => {
+    const { indexSituation } = identifiers;
+    const situation = situations[indexSituation];
+    return situation.hint;
+};
+const getCorrection = (identifiers) => {
+    const { indexSituation, maxOrScam } = identifiers;
+    const situation = situations[indexSituation];
+    const isScam = maxOrScam < 1000;
+    return `${situation.correction}
+  
+${isScam
+        ? `Attention, $${maxOrScam}$ n'est pas du tout égal à $${maxOrScam * 1000}$.
+Il faut aussi bien regarder les unités sur un graphique.`
+        : ``}`;
+};
+const getGraphReadingQuestion = () => {
+    const indexSituation = randint(0, situations.length);
+    const situation = situations[indexSituation];
+    const isScam = coinFlip();
+    const maxOrScam = situation.answerIndexes.length === 0 //guarantee one valid proposition
+        ? 840_000
+        : random([820, 830, 840]) * (isScam ? 1 : 1000);
+    return getQuestionFromIdentifiers({
+        indexSituation,
+        maxOrScam,
+    });
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const graphReading = {
+    id: "graphReading",
+    label: "Lire un graphique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGraphReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    hasHintAndCorrection: true,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+};