math-exercises 3.0.150 → 3.0.152

package/lib/exercises/math/probaStat/twoStepExperiments/numberPoolTwiceProbas.js

@@ -0,0 +1,189 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../exercise.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { getCartesiansProducts } from "../../../../utils/arrays/cartesianProducts.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+import { joinanded } from "../../../../utils/strings/joinanded.js";
+import { random } from "../../../../utils/alea/random.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+function highlighted(str) {
+    return `{ \\color{green} ${str} }`;
+}
+const numberPool = [1, 2, 3, 4];
+const events = [
+    //elem
+    ...getCartesiansProducts([numberPool, numberPool]).flatMap(([i1, i2]) => {
+        return {
+            str: `On obtient $${i1}$ puis $${i2}$`,
+            isRealizingEvent: (v1, v2) => v1 === i1 && v2 === i2,
+        };
+    }),
+    //at least one
+    ...numberPool.map((i) => {
+        return {
+            str: `On obtient au moins un $${i}$`,
+            isRealizingEvent: (v1, v2) => v1 === i || v2 === i,
+        };
+    }),
+    //none
+    ...numberPool.map((i) => {
+        return {
+            str: `On obtient aucun $${i}$`,
+            isRealizingEvent: (v1, v2) => v1 !== i && v2 !== i,
+        };
+    }),
+    //exactly one
+    ...numberPool.map((i) => {
+        return {
+            str: `On obtient exactement un $${i}$`,
+            isRealizingEvent: (v1, v2) => (v1 === i && v2 !== i) || (v1 !== i && v2 === i),
+        };
+    }),
+    //same twice
+    {
+        str: `On obtient deux fois le même numéro`,
+        isRealizingEvent: (v1, v2) => v1 === v2,
+    },
+    //or
+    {
+        str: `On obtient au moins un numéro pair`,
+        isRealizingEvent: (v1, v2) => v1 % 2 === 0 || v2 % 2 === 0,
+    },
+    {
+        str: `On obtient au moins un numéro impair`,
+        isRealizingEvent: (v1, v2) => v1 % 2 === 1 || v2 % 2 === 1,
+    },
+    //and
+    {
+        str: `On obtient un numéro impair puis un numéro pair`,
+        isRealizingEvent: (v1, v2) => v1 % 2 === 1 && v2 % 2 === 0,
+    },
+    {
+        str: `On obtient un numéro impair puis un numéro impair`,
+        isRealizingEvent: (v1, v2) => v1 % 2 === 0 && v2 % 2 === 1,
+    },
+    //sum=5
+    {
+        str: `On obtient deux numéros dont la somme vaut $5$`,
+        isRealizingEvent: (v1, v2) => v1 + v2 === 5,
+    },
+];
+const getInstruction = (identifiers) => {
+    const { indexEvent } = identifiers;
+    const event = events[indexEvent];
+    return `À deux reprises, on tire un numéro parmi ${joinanded(numberPool.map((i) => `$${i}$`), ", ", " et ")}.
+Quelle est la probabilité de l'évènement "${event.str}" ?`;
+};
+const getAnswerNode = (identifiers) => {
+    const { indexEvent } = identifiers;
+    const event = events[indexEvent];
+    const arrOutcome = getCartesiansProducts([numberPool, numberPool]);
+    const arrRealized = arrOutcome.filter(([v1, v2]) => event.isRealizingEvent(v1, v2));
+    return frac(arrRealized.length, arrOutcome.length);
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).simplify().toTex();
+};
+const getHint = () => {
+    return `Tu peux dresser un tableau à deux entrées avec les différentes issues et compter combien réalisent l'évènement demandé.`;
+};
+const getCorrection = (identifiers) => {
+    const { indexEvent } = identifiers;
+    const event = events[indexEvent];
+    const fractionNode = getAnswerNode(identifiers);
+    const nbRealized = fractionNode.leftChild.evaluate();
+    const nbOutcomes = fractionNode.rightChild.evaluate();
+    const arrOutcome = getCartesiansProducts([numberPool, numberPool]);
+    const arrArrStr = arrOutcome.reduce((acc, [v1, v2]) => {
+        if (!acc[v1]) {
+            acc[v1] = {};
+        }
+        const strEventSmall = `\\left(${v1},${v2}\\right)`;
+        acc[v1][v2] = event.isRealizingEvent(v1, v2)
+            ? highlighted(strEventSmall)
+            : strEventSmall;
+        return acc;
+    }, {});
+    return `Dans le tableau ci-dessous, on a indiqué en vert les issues qui réalisent l'évènement "${event.str}" : 
+  
+${mdTable([
+        ["\\text{}", ...numberPool.map((i) => `n_2 : ${i}`)],
+        ...Object.entries(arrArrStr).map(([s, arrStr]) => [
+            `n_1 : ${+s}`,
+            ...Object.values(arrStr),
+        ]),
+    ], true)}
+
+Sur les $${nbOutcomes.frenchify()}$ issues possibles, ${nbRealized === 1 ? "une seule réalise" : `$${nbRealized}$ réalisent`} l'évènement "${event.str}".
+
+La probabilité de l'évènement "${event.str}" est donc $${fractionNode.toTex()}$.
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    [...Array(events.length).keys()].map((indexEvent) => {
+        const identifiersWrong = Object.assign({}, identifiers, { indexEvent });
+        const tex = getAnswer(identifiersWrong);
+        tryToAddWrongProp(propositions, tex);
+    });
+    //P=0 and P=1
+    [0, 1]
+        .map((i) => i.toTree())
+        .map((nodeProba) => {
+        tryToAddWrongProp(propositions, nodeProba.toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = getAnswerNode(identifiers);
+        return (substract(nodeAns.simplify(), nodeAnswer.simplify())
+            .simplify()
+            .evaluate() === 0);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getNumberPoolTwiceProbasQuestion = () => {
+    const nbEventElem = numberPool.length * numberPool.length;
+    const arrIndexEvent = events.map((_, i) => i);
+    const arrIndexEventElem = arrIndexEvent.slice(0, nbEventElem);
+    const arrIndexEventAdvanced = arrIndexEvent.slice(nbEventElem);
+    //avoid asking easy questions too much
+    const arrIndexEventUsed = probaFlip(0.38)
+        ? arrIndexEventElem
+        : arrIndexEventAdvanced;
+    const indexEvent = random(arrIndexEventUsed);
+    const identifiers = { indexEvent };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+export const numberPoolTwiceProbas = {
+    id: "numberPoolTwiceProbas",
+    label: "Calculer la probabilité d'un évènement dans une expérience à deux épreuves (numéros)",
+    isSingleStep: true,
+    generator: (nb) => [...Array(nb).keys()].map(() => getNumberPoolTwiceProbasQuestion()),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/spaceGeometry/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./vectors/index.js";
 export * from "./basis/index.js";
+export * from "./sections/index.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/spaceGeometry/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/spaceGeometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/spaceGeometry/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,kBAAkB,CAAC;AAEjC,cAAc,qBAAqB,CAAC"}

package/lib/exercises/math/spaceGeometry/index.js

@@ -1,3 +1,4 @@
 export * from "./vectors/index.js";
 export * from "./basis/index.js";
 // export * from "./planes/index.js";
+export * from "./sections/index.js";

package/lib/exercises/math/spaceGeometry/sections/areaOfConeSection.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    isDiameterGiven: boolean;
+    radius: number;
+    height: number;
+    offset: number;
+    planeType: string;
+};
+type Options = {
+    planeTypes: string[];
+};
+export declare const areaOfConeSection: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=areaOfConeSection.d.ts.map

package/lib/exercises/math/spaceGeometry/sections/areaOfConeSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"areaOfConeSection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sections/areaOfConeSection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AA8GrC,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkXF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAuBF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAwB5D,CAAC"}

package/lib/exercises/math/spaceGeometry/sections/areaOfConeSection.js

@@ -0,0 +1,439 @@
+import { shuffleProps, addValidProp, tryToAddWrongProp, GeneratorOptionType, GeneratorOptionTarget, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { blueLight, red } from "../../../../geogebra/colors.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { sqrt } from "../../../../tree/nodes/functions/sqrtNode.js";
+import { PiNode } from "../../../../tree/nodes/numbers/piNode.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const cylinderSectionGGBCommands = (radius, height, offset, isShowSectionPlane, planeType) => {
+    return [
+        //hide xOyPlane
+        `SetFilling(xOyPlane, 0)`,
+        //cone
+        `Con = Cone((0,0,0), (0,0,${height}), ${radius})`,
+        `SetColor(Con, "#d3dde6ff")`,
+        `SetFilling(Con, 0.36)`,
+        `SetLineThickness(Con, 1)`,
+        //plane
+        ...(isShowSectionPlane
+            ? (() => {
+                switch (planeType) {
+                    case "contenant l'axe de révolution":
+                        {
+                            return [
+                                `Pl = Plane((0,0,0), (0,1,0), (0,1,1))`,
+                                `SetColor(Pl, "${blueLight}")`,
+                                `SetFilling(Pl, 0.23)`,
+                            ];
+                        }
+                        break;
+                    case "perpendiculaire à l'axe de révolution":
+                        {
+                            return [
+                                `Pl = Plane((${1}, 0, ${offset}), (0, ${1}, ${offset}), (${-1}, 0, ${offset}))`,
+                                `SetColor(Pl, "${blueLight}")`,
+                                `SetFilling(Pl, 0.23)`,
+                            ];
+                        }
+                        break;
+                    default:
+                        throw new Error("unsupported planeType: " + planeType);
+                }
+            })()
+            : []),
+        //section
+        ...(() => {
+            switch (planeType) {
+                case "contenant l'axe de révolution":
+                    {
+                        return [
+                            `s = Polygon((0, ${-radius}, 0), (0, ${radius}, 0), (0, 0, ${height}))`,
+                            `SetColor(s, "${red}")`,
+                            // `SetFilling(s, 0.36)`,
+                            `SetLineThickness(s, 3)`,
+                        ];
+                    }
+                    break;
+                case "perpendiculaire à l'axe de révolution":
+                    {
+                        const nodeHalfWidth = multiply(radius, substract(1, frac(offset, height)));
+                        const width = nodeHalfWidth.evaluate();
+                        return [
+                            `s = Circle((${width}, 0, ${offset}), (0, ${width}, ${offset}), (${-width}, 0, ${offset}))`,
+                            `SetColor(s, "${red}")`,
+                            // `SetFilling(s, 0.36)`,
+                            `SetLineThickness(s, 3)`,
+                        ];
+                    }
+                    break;
+                default:
+                    throw new Error("unsupported planeType: " + planeType);
+            }
+        })(),
+        //points
+        `O = Point({0,0,0})`,
+        `ShowLabel(O,true)`,
+        `I = Point({0,0,${offset}})`,
+        `ShowLabel(I,true)`,
+        `H = Point({0,0,${height}})`,
+        `ShowLabel(H,true)`,
+        //center view
+        `CenterView(Point({0,0,0}))`,
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { radius, height, isDiameterGiven, offset, planeType } = identifiers;
+    return `Soit $\\mathcal{K}$ un cône ayant pour base le cercle $\\mathcal{C}$ de centre $O$ et de ${isDiameterGiven ? "diamètre" : "rayon"} $${isDiameterGiven ? 2 * radius : radius} \\ \\textrm{cm}$ et pour hauteur $${height.frenchify()} \\ \\textrm{cm}$.
+
+${(() => {
+        switch (planeType) {
+            case "contenant l'axe de révolution":
+                {
+                    return `Un plan contenant l'axe de révolution coupe $\\mathcal{K}$ en une section telle que $OI = ${offset.frenchify()}\\ \\textrm{cm}$.`;
+                }
+                break;
+            case "perpendiculaire à l'axe de révolution":
+                {
+                    return `Un plan perpendiculaire à l'axe de révolution coupe $\\mathcal{K}$ en une section telle que $OI = ${offset.frenchify()}\\ \\textrm{cm}$.`;
+                }
+                break;
+            default:
+                throw new Error("unsupported planeType: " + planeType);
+        }
+    })()}
+
+Quelle est l'aire de la section plane en $\\textrm{cm}^2$ ?
+On donnera le résultat sous forme arrondie à deux décimales.`;
+};
+const getAnswerNode = (identifiers) => {
+    const { radius, height, offset, planeType } = identifiers;
+    const nodeArea = (() => {
+        switch (planeType) {
+            case "contenant l'axe de révolution":
+                {
+                    return frac(multiply(radius, height), 2);
+                }
+                break;
+            case "perpendiculaire à l'axe de révolution":
+                {
+                    const nodeHalfWidth = multiply(radius, substract(1, frac(offset, height)));
+                    return multiply(PiNode, power(nodeHalfWidth, 2));
+                }
+                break;
+            default:
+                throw new Error("unsupported planeType: " + planeType);
+        }
+    })();
+    const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+    return nodeAreaRounded;
+};
+const getAnswer = (identifiers) => {
+    return getAnswerNode(identifiers).toTex();
+};
+const getHint = (identifiers) => {
+    const { planeType } = identifiers;
+    switch (planeType) {
+        case "contenant l'axe de révolution":
+            {
+                return `Utilise la formule qui donne l'aire d'un triangle.`;
+            }
+            break;
+        case "perpendiculaire à l'axe de révolution":
+            {
+                return `Trouve un moyen de calculer le rayon du cercle section puis utilise la formule qui donne l'aire d'un cercle.`;
+            }
+            break;
+        default:
+            throw new Error("unsupported planeType: " + planeType);
+    }
+};
+const getCorrection = (identifiers) => {
+    const { radius, height, planeType, offset } = identifiers;
+    switch (planeType) {
+        case "contenant l'axe de révolution":
+            {
+                return `La section est un triangle de hauteur $${height} \\ \\textrm{cm}$ et de base $${2 * radius} \\ \\textrm{cm}$.
+Son aire vaut :
+
+$$
+\\mathcal{A}_{\\text{triangle}} = \\frac{${height} \\times ${2 * radius}}{2} = ${getAnswer(identifiers)} \\ \\textrm{cm}^2
+$$
+
+`;
+            }
+            break;
+        case "perpendiculaire à l'axe de révolution":
+            {
+                return `La section est un cercle dont on peut calculer le rayon.
+        
+En effet, on peut exhiber une configuration de Thalès en plaçant le point $P$, sur la section, 
+et le point $B$ sur la base du cône $\\mathcal{K}$ de manière à ce que $H$, $P$ et $B$ soient alignés.
+D'après le théorème de Thalès, on a :
+
+$$
+\\frac{PI}{BO} = \\frac{HI}{HO}
+$$
+
+$$
+\\frac{PI}{BO} = \\frac{HO - OI}{HO}
+$$
+
+$$
+PI = BO \\times \\frac{HO - OI}{HO}
+$$
+
+$$
+PI = ${radius} \\times \\frac{${height} - ${offset}}{${height}}
+$$
+
+L'aire du cercle section vaut donc :
+
+$$
+\\mathcal{A}_{\\text{cercle}} = \\pi \\times {PI}^2 \\approx ${getAnswer(identifiers)} \\ \\textrm{cm}^2
+$$
+
+`;
+            }
+            break;
+        default:
+            throw new Error("unsupported planeType: " + planeType);
+    }
+};
+const getCorrectionGGBOptions = (identifiers) => {
+    const { radius, height, offset, planeType } = identifiers;
+    const commands = [
+        ...cylinderSectionGGBCommands(radius, height, offset, false, planeType),
+        `SetFilling(s, 0.36)`,
+        ...(() => {
+            switch (planeType) {
+                case "contenant l'axe de révolution":
+                    {
+                        return [];
+                    }
+                    break;
+                case "perpendiculaire à l'axe de révolution":
+                    {
+                        const nodeHalfWidth = multiply(radius, substract(1, frac(offset, height)));
+                        const width = nodeHalfWidth.evaluate();
+                        return [
+                            `P = Point({0,${-width},${offset}})`,
+                            `ShowLabel(P, true)`,
+                            `B = Point({0,${-radius},0})`,
+                            `ShowLabel(B, true)`,
+                        ];
+                    }
+                    break;
+                default:
+                    throw new Error("unsupported planeType: " + planeType);
+            }
+        })(),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        xAxis: {
+            hidden: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        zAxis: {
+            hidden: false,
+        },
+    });
+    const xMax = radius;
+    const xMin = -xMax;
+    const yMax = radius;
+    const yMin = -yMax;
+    const zMax = radius;
+    const zMin = -zMax;
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax, zMin, zMax],
+    });
+};
+const getGGBOptions = (identifiers) => {
+    const { radius, height, offset, planeType } = identifiers;
+    const commands = [
+        ...cylinderSectionGGBCommands(radius, height, offset, true, planeType),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        is3D: true,
+        xAxis: {
+            hidden: true,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        zAxis: {
+            hidden: false,
+        },
+    });
+    const xMax = radius;
+    const xMin = -xMax;
+    const yMax = radius;
+    const yMin = -yMax;
+    const zMax = radius;
+    const zMin = -zMax;
+    return ggb.getOptions({
+        coords: [xMin, xMax, yMin, yMax, zMin, zMax],
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const nodeAns = parseAlgebraic(ans);
+        const nodeAnswer = parseAlgebraic(answer);
+        return substract(nodeAns, nodeAnswer).evaluate() === 0;
+    }
+    catch (e) {
+        return handleVEAError(e);
+    }
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { radius, height, offset, planeType } = identifiers;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    switch (planeType) {
+        case "contenant l'axe de révolution":
+            {
+                //wrong formula: height * base instead of (height * base)/2
+                {
+                    const nodeArea = multiply(height, 2 * radius);
+                    const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeAreaRounded.toTex());
+                }
+                //wrong formula: perimeter
+                {
+                    const nodeLength = sqrt(add(power(height, 2), power(radius, 2)));
+                    const nodePerimeter = add(2 * radius, multiply(2, nodeLength));
+                    const nodePerimeterRounded = round(nodePerimeter.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodePerimeterRounded.toTex());
+                }
+            }
+            break;
+        case "perpendiculaire à l'axe de révolution":
+            {
+                const nodeHalfWidth = multiply(radius, substract(1, frac(offset, height)));
+                //wrong formula: circumference
+                {
+                    const nodeCircumference = multiply(multiply(2, PiNode), nodeHalfWidth);
+                    const nodeCircumferenceRounded = round(nodeCircumference.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeCircumferenceRounded.toTex());
+                }
+                //wrong formula: 2*radius instead of radius
+                {
+                    const nodeArea = multiply(PiNode, power(multiply(2, nodeHalfWidth), 2));
+                    const nodeAreaRounded = round(nodeArea.evaluate(), 2).toTree();
+                    tryToAddWrongProp(propositions, nodeAreaRounded.toTex());
+                }
+            }
+            break;
+        default:
+            throw new Error("unsupported planeType: " + planeType);
+    }
+    propWhile(propositions, n, () => {
+        const identifiersWrong = (() => {
+            const isDiameterGiven = probaFlip(0.23);
+            const radius = randint(5, 21);
+            const height = randint(5, 21);
+            const offset = randint(2, Math.min(radius, height / 2.0));
+            const identifiers = {
+                radius,
+                height,
+                isDiameterGiven,
+                offset,
+                planeType,
+            };
+            return {
+                planeType: identifiers.planeType,
+                isDiameterGiven,
+                radius,
+                height,
+                offset,
+            };
+        })();
+        tryToAddWrongProp(propositions, getAnswer(identifiersWrong));
+    });
+    return shuffleProps(propositions, n);
+};
+const getAreaOfConeSectionQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const planeType = random(opts.planeTypes);
+    const isDiameterGiven = probaFlip(0.23);
+    const radius = randint(5, 21);
+    const height = randint(5, 21);
+    const offset = randint(2, Math.min(radius, height / 2.0));
+    const identifiers = { radius, height, isDiameterGiven, offset, planeType };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        answer: getAnswer(identifiers),
+        hint: getHint(identifiers),
+        keys: getKeys(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+        correctionGgbOptions: getCorrectionGGBOptions(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        options: opts,
+    };
+    return question;
+};
+const optsDefault = {
+    planeTypes: [
+        "contenant l'axe de révolution",
+        "perpendiculaire à l'axe de révolution",
+    ],
+};
+const options = [
+    {
+        id: "planeTypes",
+        label: "Type de plan pour la section",
+        type: GeneratorOptionType.multiselect,
+        target: GeneratorOptionTarget.generation,
+        values: [
+            "contenant l'axe de révolution",
+            "perpendiculaire à l'axe de révolution",
+        ],
+        defaultValue: optsDefault.planeTypes,
+    },
+];
+export const areaOfConeSection = {
+    id: "areaOfConeSection",
+    connector: "=",
+    label: "Calculer l'aire d'une section plane de cône",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getAreaOfConeSectionQuestion(opts), nb),
+    options,
+    validateOptions: (opts) => {
+        return {
+            valid: opts?.planeTypes.length > 0,
+            message: "Veuillez choisir un type de section.",
+        };
+    },
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+    hasGeogebra: true,
+};

package/lib/exercises/math/spaceGeometry/sections/areaOfCylinderSection.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    isDiameterGiven: boolean;
+    radius: number;
+    height: number;
+    offset: number;
+    planeType: string;
+};
+type Options = {
+    planeTypes: string[];
+};
+export declare const areaOfCylinderSection: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=areaOfCylinderSection.d.ts.map

package/lib/exercises/math/spaceGeometry/sections/areaOfCylinderSection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"areaOfCylinderSection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sections/areaOfCylinderSection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAoBT,MAAM,6BAA6B,CAAC;AA4JrC,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,OAAO,CAAC;IACzB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqcF,KAAK,OAAO,GAAG;IACb,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AAwBF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBhE,CAAC"}