math-exercises 3.0.150 → 3.0.152

package/lib/exercises/math/dataRepresentations/histogram/etendueHistogram.js

@@ -0,0 +1,175 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.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 { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { data, bounds } = identifiers;
+    addValidProp(propositions, answer);
+    //maxHeight - minHeight
+    const nodeWidths = [...Array(bounds.length - 1).keys()].map((i) => substract(bounds[i + 1], bounds[i]));
+    const nodeHeights = nodeWidths.map((nodeWidth, i) => frac(data[i], nodeWidth).simplify());
+    const nodeHeightsSortedAsc = nodeHeights.toSorted((node1, node2) => node1.evaluate() - node2.evaluate());
+    const [nodeMaxHeight, nodeMinHeight] = [
+        nodeHeightsSortedAsc[nodeHeightsSortedAsc.length - 1],
+        nodeHeightsSortedAsc[0],
+    ];
+    tryToAddWrongProp(propositions, substract(nodeMaxHeight, nodeMinHeight).simplify().toTex());
+    //filler
+    const arrFiller = shuffle([
+        //max bound
+        (() => {
+            const maxBound = bounds[bounds.length - 1];
+            return maxBound.frenchify();
+        })(),
+        //maxHeight
+        nodeMaxHeight.toTex(),
+        //(maxBound + minBound) / 2
+        (() => {
+            const maxBound = bounds[bounds.length - 1];
+            const minBound = bounds[0];
+            return ((maxBound + minBound) / 2).frenchify();
+        })(),
+    ]);
+    const genFiller = (function* () {
+        yield* arrFiller;
+        return "done";
+    })();
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, genFiller.next().value);
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { bounds } = identifiers;
+    const maxBound = bounds[bounds.length - 1];
+    const minBound = bounds[0];
+    const span = maxBound - minBound;
+    return `${span.frenchify()}`;
+};
+const getInstruction = () => {
+    return `Quelle est l'étendue dans cet histogramme ?`;
+};
+const getHint = () => {
+    return `L'étendue concerne le critère qui nous sert à classer les éléments.`;
+};
+const getCorrection = (identifiers) => {
+    const { bounds } = identifiers;
+    const maxBound = bounds[bounds.length - 1];
+    const minBound = bounds[0];
+    const span = maxBound - minBound;
+    return `Ici le critère pour classer est le diamètre.
+On s'intéresse aux bornes de ce critère.
+L'étendue est la différence entre la borne la plus élévée et la plus petite.
+
+$$
+${maxBound.frenchify()} - ${minBound.frenchify()} = ${span.frenchify()}
+$$
+
+L'étendue est de $${span.frenchify()} \\ \\textrm{cm}$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { bounds, data } = identifiers;
+    const heights = [];
+    for (let i = 0; i < data.length; i++) {
+        const width = bounds[i + 1] - bounds[i];
+        const height = data[i] / width;
+        heights.push(height);
+    }
+    const offsetX = -bounds[0] + 1;
+    const offsettedBounds = bounds.map((bound) => bound + offsetX);
+    // const xMin = offsettedBounds[0];
+    const xMax = offsettedBounds[offsettedBounds.length - 1];
+    // const heightMin = 0;
+    const heightMax = Math.max(...heights);
+    const commands = [
+        `B = Histogram({${offsettedBounds}}, {${heights.join(",")}})`,
+        ...bounds.map((bound, i) => `XBound_{${i}} = Text("\\footnotesize ${bound.frenchify()}", (${offsettedBounds[i]}, 0), true, true, 0, -1)`),
+        `ShowLabel(B,false)`,
+        ...heights.map((height, i) => `YBound_{${i}} = Text("\\footnotesize ${round(height, 0).frenchify()}", (0, ${height}), true, true, 0, 0)`),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideGrid: true,
+        fontSize: 16,
+        lockedAxesRatio: false,
+        xAxis: {
+            hideNumbers: true,
+            showPositive: true,
+            label: "$\\footnotesize Diamètre (cm)$",
+        },
+        yAxis: {
+            showPositive: true,
+            label: "$\\footnotesize Pommes/cm$",
+            hideNumbers: true,
+        },
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: -xMax * 0.1,
+            xMax: xMax * 1.5,
+            yMin: -heightMax * 0.25,
+            yMax: heightMax * 1.5,
+        }),
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getEtendueHistogramQuestion = () => {
+    const boundsRaw = [11.5, 12, 13.5, 15, 15.5, 16, 16.2];
+    const nbBounds = randint(3, 5);
+    const bounds = random([...Array(boundsRaw.length - nbBounds).keys()].map((i) => boundsRaw.slice(i, i + nbBounds)));
+    const heightPool = shuffle([...Array(10).keys()].map((i) => i * 100 + 300));
+    const data = [...Array(bounds.length - 1).keys()].map((i) => {
+        const nodeWidth = substract(bounds[i + 1], bounds[i]);
+        const nodeHeight = heightPool[i].toTree();
+        return multiply(nodeWidth, nodeHeight).simplify().evaluate();
+    });
+    const identifiers = {
+        bounds,
+        data,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const etendueHistogram = {
+    id: "etendueHistogram",
+    label: "Calcul de l'étendue d'un histogramme",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getEtendueHistogramQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/dataRepresentations/histogram/histogramCommenting.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    isMax: boolean;
+    bounds: number[];
+    data: number[];
+};
+export declare const histogramCommenting: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=histogramCommenting.d.ts.map

package/lib/exercises/math/dataRepresentations/histogram/histogramCommenting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"histogramCommenting.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/histogram/histogramCommenting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AA6BrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;CAChB,CAAC;AAiRF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAmBrD,CAAC"}

package/lib/exercises/math/dataRepresentations/histogram/histogramCommenting.js

@@ -0,0 +1,250 @@
+import { addValidProp, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { frenchify } from "../../../../math/utils/latex/frenchify.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getStrStatClassForIndexCateg = (indexCateg, data, bounds) => {
+    const labels = bounds.map(frenchify);
+    const isLastCateg = indexCateg == data.length;
+    return `[${labels[indexCateg]};${labels[indexCateg + 1]}${isLastCateg ? "]" : "["}`;
+};
+const getPropositions = (_, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { data } = identifiers;
+    const arrStr = [...data.map((_, i) => i), -1].map((i) => getStrForAnswerIndex(i, identifiers));
+    arrStr.forEach((str) => {
+        if (str === answer) {
+            addValidProp(propositions, str, "raw");
+        }
+        else {
+            tryToAddWrongProp(propositions, str, "raw");
+        }
+    });
+    return propositions;
+};
+const getAnswerIndex = (identifiers) => {
+    const { data, isMax } = identifiers;
+    return data.slice(1).reduce((acc, x, i) => {
+        if (acc.value === x) {
+            return {
+                index: -1,
+                value: acc.value,
+            };
+        }
+        else {
+            const isLess = acc.value < x;
+            if (isMax ? isLess : !isLess) {
+                return {
+                    index: i + 1,
+                    value: x,
+                };
+            }
+            else {
+                return acc;
+            }
+        }
+    }, {
+        index: 0,
+        value: data[0],
+    }).index;
+};
+const getStrForAnswerIndex = (indexAnswer, identifiers) => {
+    switch (indexAnswer) {
+        case -1: {
+            return "Les classes ont le même effectif.";
+        }
+        default: {
+            const { data, bounds } = identifiers;
+            return getStrStatClassForIndexCateg(indexAnswer, data, bounds);
+        }
+    }
+};
+const getAnswer = (identifiers) => {
+    return getStrForAnswerIndex(getAnswerIndex(identifiers), identifiers);
+};
+const getInstruction = (identifiers) => {
+    const { isMax } = identifiers;
+    return `Un producteur trie sa récolte de pommes selon leur diamètre. L'histogramme ci-dessous représente ses résultats.
+
+Quelle est la classe statistique avec l'effectif ${isMax ? "le plus grand" : "le plus petit"} ?
+`;
+};
+const getHint = () => {
+    return `Dans un histogramme, l'effectif d'une classe est donné par l'aire du rectangle
+compris entre les deux bornes de la classe.`;
+};
+const getCorrection = (identifiers) => {
+    const { bounds, data, isMax } = identifiers;
+    const arrDict = data.map((_, i) => {
+        const upperBound = bounds[i + 1];
+        const lowerBound = bounds[i];
+        const nodeWidth = substract(upperBound, lowerBound).simplify();
+        const nodeHeight = frac(data[i], nodeWidth).simplify();
+        return {
+            width: nodeWidth.evaluate(),
+            height: nodeHeight.evaluate(),
+            area: data[i],
+        };
+    });
+    return `Voici un tableau représentant les données de l'histogramme : 
+  
+${mdTable([
+        [
+            "\\text{}",
+            ...data.map((_, i) => getStrStatClassForIndexCateg(i, data, bounds)),
+        ],
+        ["\\text{largeur}", ...arrDict.map((dict) => dict["width"].frenchify())],
+        ["\\text{hauteur}", ...arrDict.map((dict) => dict["height"].frenchify())],
+        ["\\text{effectif}", ...arrDict.map((dict) => dict["area"].frenchify())],
+    ], true)}
+
+On peut conclure que ${(() => {
+        const indexAnswer = getAnswerIndex(identifiers);
+        switch (indexAnswer) {
+            case -1:
+                return "les classes ont le même effectif";
+            default:
+                return `la classe statistique avec l'effectif ${isMax ? "le plus grand" : "le plus petit"} est $${getStrForAnswerIndex(indexAnswer, identifiers)}$`;
+        }
+    })()}.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { bounds, data } = identifiers;
+    const heights = [];
+    for (let i = 0; i < data.length; i++) {
+        const width = bounds[i + 1] - bounds[i];
+        const height = data[i] / width;
+        heights.push(height);
+    }
+    const offsetX = -bounds[0] + 1;
+    const offsettedBounds = bounds.map((bound) => bound + offsetX);
+    // const xMin = offsettedBounds[0];
+    const xMax = offsettedBounds[offsettedBounds.length - 1];
+    // const heightMin = 0;
+    const heightMax = Math.max(...heights);
+    const commands = [
+        `B = Histogram({${offsettedBounds}}, {${heights.join(",")}})`,
+        ...bounds.map((bound, i) => `XBound_{${i}} = Text("\\footnotesize ${bound.frenchify()}", (${offsettedBounds[i]}, 0), true, true, 0, -1)`),
+        `ShowLabel(B,false)`,
+        ...heights.map((height, i) => `YBound_{${i}} = Text("\\footnotesize ${round(height, 0).frenchify()}", (0, ${height}), true, true, 0, 0)`),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideGrid: true,
+        fontSize: 16,
+        lockedAxesRatio: false,
+        xAxis: {
+            hideNumbers: true,
+            showPositive: true,
+            label: "$\\footnotesize Diamètre (cm)$",
+        },
+        yAxis: {
+            showPositive: true,
+            label: "$\\footnotesize Pommes/cm$",
+            hideNumbers: true,
+        },
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: -xMax * 0.1,
+            xMax: xMax * 1.5,
+            yMin: -heightMax * 0.25,
+            yMax: heightMax * 1.5,
+        }),
+    });
+};
+const getHistogramCommentingQuestion = () => {
+    // const boundsRaw: number[] = [11.5, 12, 13.5, 15, 15.5, 16, 16.2];
+    // const nbBounds = 3;
+    const bounds = random([
+        [11.5, 12, 13.5],
+        [12, 13.5, 15],
+        [13.5, 15, 15.5],
+        [15.5, 16, 16.2],
+    ]);
+    const offsetY = randint(2, 6) * 100;
+    const heightPool = shuffle([...Array(20).keys()].map((i) => i * 100 + offsetY));
+    let data;
+    if (probaFlip(0.36) && bounds[1] !== 13.5) {
+        //same height
+        const nodeHeightSame = heightPool[0];
+        data = [...Array(bounds.length - 1).keys()].map((i) => {
+            const nodeWidth = substract(bounds[i + 1], bounds[i]);
+            const nodeHeight = nodeHeightSame;
+            return multiply(nodeWidth, nodeHeight).simplify().evaluate();
+        });
+    }
+    else {
+        //different heights
+        if (probaFlip(0.48) && bounds[1] !== 13.5) {
+            //same data
+            const dictDataSame = heightPool.reduce((acc, _, i) => {
+                const nodeHeight = heightPool[i].toTree();
+                [...Array(bounds.length - 1).keys()].forEach((i) => {
+                    const nodeWidth = substract(bounds[i + 1], bounds[i]);
+                    const data = multiply(nodeWidth, nodeHeight).simplify().evaluate();
+                    if (!acc[data]) {
+                        acc[data] = {};
+                    }
+                    acc[data][nodeWidth.evaluate()] = true;
+                });
+                return acc;
+            }, {});
+            const [dataSame, _] = random(Object.entries(dictDataSame).filter(([_, dictWidth]) => Object.keys(dictWidth).length >= 2));
+            data = [...Array(bounds.length - 1).keys()].map(() => +dataSame);
+        }
+        else {
+            data = [...Array(bounds.length - 1).keys()].map((i) => {
+                const nodeWidth = substract(bounds[i + 1], bounds[i]);
+                const nodeHeight = heightPool[i].toTree();
+                return multiply(nodeWidth, nodeHeight).simplify().evaluate();
+            });
+        }
+    }
+    const identifiers = {
+        isMax: coinFlip(),
+        bounds,
+        data,
+    };
+    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 histogramCommenting = {
+    id: "histogramCommenting",
+    label: "Commenter un histogramme",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getHistogramCommentingQuestion(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/histogram/histogramFillDataTableFromHistogramData.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    bounds: number[];
+    data: number[];
+    initTable: string[][];
+};
+export declare const histogramFillDataTableFromHistogramData: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=histogramFillDataTableFromHistogramData.d.ts.map

package/lib/exercises/math/dataRepresentations/histogram/histogramFillDataTableFromHistogramData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"histogramFillDataTableFromHistogramData.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/histogram/histogramFillDataTableFromHistogramData.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,6BAA6B,CAAC;AAwDrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;CACvB,CAAC;AAyJF,eAAO,MAAM,uCAAuC,EAAE,QAAQ,CAAC,WAAW,CAsBzE,CAAC"}

package/lib/exercises/math/dataRepresentations/histogram/histogramFillDataTableFromHistogramData.js

@@ -0,0 +1,173 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { frenchify } from "../../../../math/utils/latex/frenchify.js";
+import { round } from "../../../../math/utils/round.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 { numberParser } from "../../../../tree/parsers/numberParser.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getStrStatClassForIndexCateg = (indexCateg, data, bounds) => {
+    const labels = bounds.map(frenchify);
+    const isLastCateg = indexCateg == data.length;
+    return `[${labels[indexCateg]};${labels[indexCateg + 1]}${isLastCateg ? "]" : "["}`;
+};
+const getTableForHistogramData = (data, bounds) => {
+    const arrDict = data.map((_, i) => {
+        const upperBound = bounds[i + 1];
+        const lowerBound = bounds[i];
+        const nodeWidth = substract(upperBound, lowerBound).simplify();
+        const nodeHeight = frac(data[i], nodeWidth).simplify();
+        return {
+            width: nodeWidth.evaluate(),
+            height: nodeHeight.evaluate(),
+            area: data[i],
+        };
+    });
+    return [
+        [
+            "\\text{Diamètre(cm)}",
+            ...data.map((_, i) => getStrStatClassForIndexCateg(i, data, bounds)),
+        ],
+        ["\\text{largeur}", ...arrDict.map((dict) => dict["width"].frenchify())],
+        ["\\text{hauteur}", ...arrDict.map((dict) => dict["height"].frenchify())],
+        ["\\text{effectif}", ...arrDict.map((dict) => dict["area"].frenchify())],
+    ];
+};
+const getAnswerTable = (identifiers) => {
+    const { data, bounds } = identifiers;
+    return getTableForHistogramData(data, bounds);
+};
+const getInstruction = () => {
+    return `Remplir le tableau avec les données issues de l'histogramme ci-dessous.`;
+};
+const getHint = () => {
+    return `Dans un histogramme, l'effectif d'une classe est donné par l'aire du rectangle
+compris entre les deux bornes de la classe.`;
+};
+const getCorrection = (identifiers) => {
+    const { data, bounds } = identifiers;
+    return `On peut représenter l'histogramme par le tableau suivant : 
+  
+${mdTable(getTableForHistogramData(data, bounds), true)}
+
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { data, bounds } = identifiers;
+    const heights = [];
+    for (let i = 0; i < data.length; i++) {
+        const width = bounds[i + 1] - bounds[i];
+        const height = data[i] / width;
+        heights.push(height);
+    }
+    const offsetX = -bounds[0] + 1;
+    const offsettedBounds = bounds.map((bound) => bound + offsetX);
+    // const xMin = offsettedBounds[0];
+    const xMax = offsettedBounds[offsettedBounds.length - 1];
+    // const heightMin = 0;
+    const heightMax = Math.max(...heights);
+    const commands = [
+        `B = Histogram({${offsettedBounds}}, {${heights.join(",")}})`,
+        ...bounds.map((bound, i) => `XBound_{${i}} = Text("\\footnotesize ${bound.frenchify()}", (${offsettedBounds[i]}, 0), true, true, 0, -1)`),
+        `ShowLabel(B,false)`,
+        ...heights.map((height, i) => `YBound_{${i}} = Text("\\footnotesize ${round(height, 0).frenchify()}", (0, ${height}), true, true, 0, 0)`),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        hideGrid: true,
+        fontSize: 16,
+        lockedAxesRatio: false,
+        xAxis: {
+            hideNumbers: true,
+            showPositive: true,
+            label: "$\\footnotesize Diamètre (cm)$",
+        },
+        yAxis: {
+            showPositive: true,
+            label: "$\\footnotesize Pommes/cm$",
+            hideNumbers: true,
+        },
+    });
+    return ggb.getOptions({
+        coords: ggb.getAdaptedCoords({
+            xMin: -xMax * 0.1,
+            xMax: xMax * 1.5,
+            yMin: -heightMax * 0.25,
+            yMax: heightMax * 1.5,
+        }),
+    });
+};
+const getKeys = () => {
+    return ["lbracket", "rbracket", "semicolon"];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        for (let i = 0; i < 2; i++) {
+            for (let j = 1; j < ans[i].length; j++) {
+                const ansParsed = numberParser(ans[i][j]);
+                const answerParsed = numberParser(answerTable[i][j]);
+                const valid = ansParsed === answerParsed;
+                if (!valid)
+                    return false;
+            }
+        }
+        return true;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getHistogramFillDataTableFromHistogramDataQuestion = () => {
+    const boundsRaw = [11.5, 12, 13.5, 15, 15.5, 16, 16.2];
+    const nbBounds = 3;
+    const bounds = random([...Array(boundsRaw.length - nbBounds).keys()].map((i) => boundsRaw.slice(i, i + nbBounds)));
+    const heightPool = shuffle([...Array(10).keys()].map((i) => i * 100 + 300));
+    const data = [...Array(bounds.length - 1).keys()].map((i) => {
+        const nodeWidth = substract(bounds[i + 1], bounds[i]);
+        const nodeHeight = heightPool[i].toTree();
+        return multiply(nodeWidth, nodeHeight).simplify().evaluate();
+    });
+    const initTable = getTableForHistogramData(data, bounds).map((arr) => arr.map((str, i) => (i !== 0 ? "" : str)));
+    const identifiers = {
+        bounds,
+        data,
+        initTable,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        answerFormat: "tex",
+        initTable: identifiers.initTable,
+        keys: getKeys(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const histogramFillDataTableFromHistogramData = {
+    id: "histogramFillDataTableFromHistogramData",
+    label: "Remplir un tableau avec les données issues d'un histogramme",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getHistogramFillDataTableFromHistogramDataQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    subject: "Mathématiques",
+    isAnswerTableValid,
+    getAnswerTable,
+    getInstruction,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    answerType: "valueTable",
+};

package/lib/exercises/math/dataRepresentations/histogram/histogramIsSameData.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    histogram: {
+        bounds: number[];
+        data: number[];
+    };
+    table: {
+        bounds: number[];
+        data: number[];
+    } | undefined;
+};
+export declare const histogramIsSameData: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=histogramIsSameData.d.ts.map

package/lib/exercises/math/dataRepresentations/histogram/histogramIsSameData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"histogramIsSameData.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/histogram/histogramIsSameData.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAyErC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE;QACT,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,IAAI,EAAE,MAAM,EAAE,CAAC;KAChB,CAAC;IACF,KAAK,EACD;QACE,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,IAAI,EAAE,MAAM,EAAE,CAAC;KAChB,GACD,SAAS,CAAC;CACf,CAAC;AAmNF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAmBrD,CAAC"}