math-exercises 3.0.191 → 3.0.193

package/lib/exercises/math/dataRepresentations/barChart/barChartReading.js

@@ -0,0 +1,280 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { valueParser } from "../../../../tree/parsers/valueParser.js";
+import { random } from "../../../../utils/alea/random.js";
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    const { data } = identifiers;
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, random(data).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { data, itemAsked } = identifiers;
+    return data[itemAsked].frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { labels, itemAsked } = identifiers;
+    return `Un producteur trie sa récolte de pommes selon leur diamètre. Le diagramme en bâtons ci-dessous représente ses résultats.
+
+Combien de pommes de $${labels[itemAsked]}\\ \\textrm{cm}$ de diamètre le producteur a-t-il récoltées ?
+`;
+};
+const getHint = (identifiers) => {
+    const { labels, itemAsked } = identifiers;
+    return `Trouve le bâton qui correspond aux pommes de $${labels[itemAsked]}\\ \\textrm{cm}$ et lis la graduation correspondant à sa hauteur.`;
+};
+const getCorrection = (identifiers) => {
+    const { labels, itemAsked, data } = identifiers;
+    return `Le bâton qui correspond aux pommes de $${labels[itemAsked]}\\ \\textrm{cm}$ est le $${itemAsked + 1}^{\\text{${itemAsked > 0 ? "e" : "er"}}}$ en partant de la gauche.
+La graduation correspondante est $${data[itemAsked].frenchify()}$.
+
+Le producteur a récolté $${data[itemAsked].frenchify()}$ pommes de $${labels[itemAsked]}\\ \\textrm{cm}$.
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = valueParser(ans);
+        if (parsed === false)
+            return false;
+        const ansNb = answer.unfrenchify();
+        return Math.abs(parsed - ansNb) < 20;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGGBOptions = (identifiers) => {
+    const { labels, data } = identifiers;
+    const commands = [
+        `B = BarChart({1,2,3,4,5}, {${data.join(",")}}, 0.5)`,
+        ...labels.map((l, i) => `Text("\\footnotesize ${l}", (${i + 1}, 50), true, true, 0, -1)`),
+        `Text("\\footnotesize Diamètre\\ (en \\ cm)", (3, -100), true, true, 0, -1)`,
+        `ShowLabel(B,false)`,
+        `SetColor(B, "#FE0045AB")`,
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        gridDistance: [10000, 50],
+        fontSize: 16,
+        lockedAxesRatio: 1 / 400,
+        xAxis: {
+            // hideNumbers: true,
+            showPositive: true,
+            hidden: true,
+        },
+        yAxis: {
+            showPositive: true,
+            label: "$\\footnotesize Nombre\\ de\\ pommes$",
+            steps: 100,
+        },
+    });
+    return ggb.getOptions({
+        coords: [-0.2, 5.2, -300, 1100],
+    });
+};
+const getBarChartReadingQuestion = () => {
+    const data = [];
+    const labels = ["11", "12", "13", "15", "16"];
+    for (let i = 0; i < labels.length; i++) {
+        data.push(50 *
+            randint(1, i < 3 ? 18 : 20, //pour ne pas que les 2 premieres barres touchent le label de l'axe
+            data.map((d) => d / 50)));
+    }
+    const itemAsked = randint(0, 5);
+    const identifiers = {
+        labels,
+        data,
+        itemAsked,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+    return question;
+};
+export const barChartReading = {
+    id: "barChartReading",
+    label: "Lecture d'un diagramme en bâtons",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBarChartReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasGeogebra: true,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};
+// !signtable
+//  const options = { svg: true };
+//   const d3n = new D3Node(options);
+//   const d3 = d3n.d3;
+//   const width = 600;
+//   const height = 250;
+//   const svg = d3n.createSVG(width, height);
+//   // Define table structure
+//   const rows = 3;
+//   const cols = 5;
+//   const cellWidth = 120;
+//   const cellHeight = 50;
+//   const startX = 50;
+//   const startY = 50;
+//   // Define table values
+//   const headers = ["x", "-\\infty", "-2", "0", "+\\infty"];
+//   const firstRow = ["f'(x)", "+", "0", "-", ""];
+//   const secondRow = ["f(x)", "\\nearrow", "max", "\\searrow", ""];
+//   // Draw table grid
+//   for (let r = 0; r < rows; r++) {
+//     for (let c = 0; c < cols; c++) {
+//       svg
+//         .append("rect")
+//         .attr("x", startX + c * cellWidth)
+//         .attr("y", startY + r * cellHeight)
+//         .attr("width", cellWidth)
+//         .attr("height", cellHeight)
+//         .attr("stroke", "black")
+//         .attr("fill", "black");
+//     }
+//   }
+//   // Function to render LaTeX with KaTeX
+//   const renderLatex = (formula: any) =>
+//     katex.renderToString(formula, { throwOnError: false });
+//   // Add LaTeX text using <foreignObject> for proper positioning
+//   const addLatexText = (x: any, y: any, latex: any) => {
+//     svg
+//       .append("foreignObject")
+//       .attr("x", x - cellWidth / 2)
+//       .attr("y", y - cellHeight / 2)
+//       .attr("width", cellWidth)
+//       .attr("height", cellHeight)
+//       .html(`<div xmlns="http://www.w3.org/1999/xhtml"
+//                       style="display: flex; align-items: center; justify-content: center; width: 100%; height: 100%;">
+//                       ${renderLatex(latex)}
+//                  </div>`);
+//   };
+//   // Insert header row
+//   headers.forEach((text, i) =>
+//     addLatexText(startX + i * cellWidth + cellWidth / 2, startY + 25, text),
+//   );
+//   // Insert first row (derivative sign changes)
+//   firstRow.forEach((text, i) =>
+//     addLatexText(
+//       startX + i * cellWidth + cellWidth / 2,
+//       startY + cellHeight + 25,
+//       text,
+//     ),
+//   );
+//   // Insert second row (function increasing/decreasing)
+//   secondRow.forEach((text, i) =>
+//     addLatexText(
+//       startX + i * cellWidth + cellWidth / 2,
+//       startY + 2 * cellHeight + 25,
+//       text,
+//     ),
+//   );
+/***Final version */
+/**
+ *
+ *   const newspapers = [
+    { name: "Le Figaro", sales: 320000 },
+    { name: "Les Échos", sales: 130000 },
+    { name: "La Croix", sales: 90000 },
+    { name: "L'Équipe", sales: 210000 },
+    { name: "Le Monde", sales: 330000 },
+    { name: "Le Parisien", sales: 270000 },
+    { name: "Libération", sales: 70000 },
+    { name: "L'Humanité", sales: 30000 },
+  ];
+
+  const width = 600,
+    height = 400,
+    margin = { top: 20, right: 30, bottom: 100, left: 60 };
+  const d3n = new D3Node();
+  const d3 = d3n.d3;
+
+  const svg = d3n.createSVG(width, height);
+
+  const xScale = d3
+    .scaleBand()
+    .domain(newspapers.map((d) => d.name))
+    .range([margin.left, width - margin.right])
+    .padding(0.1);
+
+  const yScale = d3
+    .scaleLinear()
+    .domain([0, d3.max(newspapers, (d: any) => d.sales)])
+    .nice()
+    .range([height - margin.bottom, margin.top]);
+
+  svg
+    .append("g")
+    .attr("transform", `translate(0,${height - margin.bottom})`)
+    .call(d3.axisBottom(xScale).tickSize(0))
+    .selectAll("text")
+    .style("text-anchor", "end")
+    .attr("transform", "rotate(-30)");
+
+  svg
+    .append("g")
+    .attr("transform", `translate(${margin.left},0)`)
+    .call(
+      d3
+        .axisLeft(yScale)
+        .ticks(5)
+        .tickFormat((d: any) =>
+          d.toString().replace(/\B(?=(\d{3})+(?!\d))/g, " "),
+        ),
+    );
+
+  svg
+    .append("text")
+    .attr("x", margin.left)
+    .attr("y", margin.top)
+    .attr("text-anchor", "start")
+    .style("font-size", "14px")
+    .style("font-weight", "bold")
+    .text("Nombre d'exemplaires vendus");
+
+  svg
+    .selectAll(".bar")
+    .data(newspapers)
+    .enter()
+    .append("rect")
+    .attr("class", "bar")
+    .attr("x", (d: any) => xScale(d.name))
+    .attr("y", (d: any) => yScale(d.sales))
+    .attr("width", xScale.bandwidth())
+    .attr("height", (d: any) => height - margin.bottom - yScale(d.sales))
+    .attr("fill", "steelblue");
+
+  const svgString = d3n.svgString();
+  return `BBteeeezfst :
+
+  ofzie
+  should read this
+${svgString}
+  should read this
+zef
+`;
+ */

package/lib/exercises/math/dataRepresentations/barChart/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./barChartInterpreting.js";
+export * from "./barChartReading.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/dataRepresentations/barChart/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/barChart/index.ts"],"names":[],"mappings":"AAAA,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC"}

package/lib/exercises/math/dataRepresentations/barChart/index.js

@@ -0,0 +1,2 @@
+export * from "./barChartInterpreting.js";
+export * from "./barChartReading.js";

package/lib/exercises/math/dataRepresentations/boxPlot/boxPlotInterpreting.d.ts

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

package/lib/exercises/math/dataRepresentations/boxPlot/boxPlotInterpreting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boxPlotInterpreting.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/boxPlot/boxPlotInterpreting.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAYrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AAgRF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAmBrD,CAAC"}

package/lib/exercises/math/dataRepresentations/boxPlot/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/boxPlot/boxPlotReading.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type QuartileIndex = 0 | 1 | 2 | 3 | 4;
+type Identifiers = {
+    quartileIndex: QuartileIndex;
+    quartiles: number[];
+};
+export declare const boxPlotReading: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=boxPlotReading.d.ts.map

package/lib/exercises/math/dataRepresentations/boxPlot/boxPlotReading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"boxPlotReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/boxPlot/boxPlotReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,aAAa,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAEvC,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,aAAa,CAAC;IAC7B,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB,CAAC;AA0IF,eAAO,MAAM,cAAc,EAAE,QAAQ,CAAC,WAAW,CAmBhD,CAAC"}

package/lib/exercises/math/dataRepresentations/boxPlot/boxPlotReading.js

@@ -0,0 +1,133 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } 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";
+const getPropositions = (n, { answer, quartiles }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    [0, 1, 2, 3, 4].forEach((qIndex) => {
+        tryToAddWrongProp(propositions, quartiles[qIndex].frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { quartileIndex, quartiles } = identifiers;
+    return quartiles[quartileIndex].frenchify();
+};
+const getFrenchStringForOfQuartile = (quartileIndex) => {
+    switch (quartileIndex) {
+        case 0:
+            return "du minimum";
+        case 1:
+            return "du premier quartile";
+        case 2:
+            return "de la médiane";
+        case 3:
+            return "du troisième quartile";
+        case 4:
+            return "du maximum";
+    }
+};
+const getInstruction = (identifiers) => {
+    const { quartileIndex } = identifiers;
+    return `On a représenté une série statistique à une variable sous forme d'une boîte à moustaches.
+
+Quelle est la valeur ${getFrenchStringForOfQuartile(quartileIndex)} ?
+  `;
+};
+const getHint = () => {
+    return `Une boîte à moustaches permet de lire les indicateurs statistiques d'une série. Chaque trait vertical représente un indicateur. Ces indicateurs sont rangés dans l'ordre : minimum, premier quartile, médiane, troisième quartile, maximum.`;
+};
+const getCorrection = (identifiers) => {
+    const { quartileIndex, quartiles } = identifiers;
+    //https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/boxplot.png
+    return `Une boîte à moustache permet de lire les indicateurs statistiques d'une série : 
+
+![](https://heureuxhasarddocsbucket.s3.eu-west-3.amazonaws.com/mathliveV2/activities/quizzes/generator/boxplot.png)
+  
+La valeur ${getFrenchStringForOfQuartile(quartileIndex)} est donc ici $ ${quartiles[quartileIndex]} $.`;
+};
+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 getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    return numberVEA(ans, answer);
+};
+const getBoxPlotReadingQuestion = () => {
+    const [q0, q1] = [0, 1]
+        .map((_) => randint(0, 8))
+        .toSorted((i1, i2) => i1 - i2);
+    const [q3, q4] = [0, 1]
+        .map((_) => randint(12, 20))
+        .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 quartileIndex = randint(0, 5);
+    const identifiers = { quartileIndex, quartiles };
+    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 boxPlotReading = {
+    id: "boxPlotReading",
+    label: "Lire les indicateurs statistiques sur une boîte à moustaches",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBoxPlotReadingQuestion(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/boxPlot/boxPlotReadingPercentages.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type QuartileIndex = 0 | 1 | 2 | 3 | 4;
+type QuestionType = "below" | "between" | "above";
+type Identifiers = {
+    quartiles: number[];
+    arrQuartileIndex: QuartileIndex[];
+    typeQ: QuestionType;
+};
+export declare const boxPlotReadingPercentages: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=boxPlotReadingPercentages.d.ts.map