math-exercises 3.0.150 → 3.0.152

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

@@ -0,0 +1,266 @@
+import { addValidProp, shuffleProps, 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 { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { radius, height, isDiameterGiven, isHollow, isBaseCircle } = identifiers;
+    return `Parmi les propositions suivantes, lesquelles peuvent être des sections planes d'un cône de hauteur $${height.frenchify()}\\ \\textrm{cm}$ dont le ${isDiameterGiven ? "diamètre" : "rayon"} de la base mesure $${(isDiameterGiven
+        ? 2 * radius
+        : radius).frenchify()}\\ \\textrm{cm}$ ?
+  On va considérer que le cône est ${isHollow ? "creux" : "plein"}${isHollow
+        ? isBaseCircle
+            ? " avec pour base un cercle"
+            : " avec pour base un disque"
+        : ""}.`;
+};
+const getHint = (identifiers) => {
+    const { isHollow, isBaseCircle } = identifiers;
+    return `Visualise mentalement un cône ${isHollow ? "creux" : "plein"}${isHollow
+        ? isBaseCircle
+            ? " avec pour base un cercle"
+            : " avec pour base un disque"
+        : ""}.`;
+};
+const getCorrection = (identifiers) => {
+    const { radius, isHollow, isBaseCircle } = identifiers;
+    return `Les réponses possibles pour un cône ${isHollow ? "creux" : "plein"}${isHollow
+        ? isBaseCircle
+            ? " avec pour base un cercle"
+            : " avec pour base un disque"
+        : ""} de rayon $${radius} \\ \\textrm{cm}$ sont : 
+
+  - un point si le plan passe seulement par le sommet du cône
+  - un segment si le plan est comme "posé" sur le cône
+${(() => {
+        if (isHollow) {
+            if (isBaseCircle) {
+                return `- un cercle de rayon inférieur ou égal à $${radius} \\ \\textrm{cm}$ si le plan est perpendiculaire à l'axe de révolution du cône 
+- une ligne brisée composée de deux segments si le plan passe par l'axe de révolution du cône`;
+            }
+            else {
+                return `- un cercle de rayon strictement inférieur à $${radius} \\ \\textrm{cm}$ si le plan est perpendiculaire à l'axe de révolution du cône
+- un disque de rayon $${radius} \\ \\textrm{cm}$ si le plan est perpendiculaire à l'axe de révolution du cône et rencontre la base du cône
+- un triangle si le plan passe par l'axe de révolution du cône`;
+            }
+        }
+        else {
+            return `- un disque de rayon inférieur ou égal à $${radius} \\ \\textrm{cm}$ si le plan est perpendiculaire à l'axe de révolution du cône
+- un triangle plein si le plan passe par l'axe de révolution du cône`;
+        }
+    })()}`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { radius, isHollow, isBaseCircle } = identifiers;
+    const propositions = [];
+    if (isHollow) {
+        const validPool = [
+            "un point",
+            "un segment",
+            //circle<radius
+            random([
+                `un cercle de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            ...(isBaseCircle
+                ? [
+                    "une ligne brisée composée de deux segments",
+                    //circle=radius
+                    random([
+                        `un cercle de rayon $${radius} \\ \\textrm{cm}$`,
+                        `un cercle de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : [
+                    "un triangle",
+                    //disk=radius
+                    random([
+                        `un disque de rayon $${radius} \\ \\textrm{cm}$`,
+                        `un disque de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+                    ]),
+                ]),
+        ];
+        const invalidPool = [
+            //circle>radius
+            random([
+                `un cercle de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            ...(isBaseCircle
+                ? [
+                    //disk=radius
+                    random([
+                        `un disque de rayon $${radius} \\ \\textrm{cm}$`,
+                        `un disque de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : [
+                    //circle=radius
+                    random([
+                        `un cercle de rayon $${radius} \\ \\textrm{cm}$`,
+                        `un cercle de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+                    ]),
+                ]),
+            //disk<radius
+            random([
+                `un disque de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //disk>radius
+            random([
+                `un disque de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //rare
+            ...(probaFlip(0.02)
+                ? [
+                    random([
+                        `un disque de rayon $1,5 \\ \\textrm{cm}$`,
+                        `un disque de diamètre $3 \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : []),
+        ];
+        const invalidMiscPool = ["une droite", "un cône", "un cylindre"];
+        if (coinFlip() && validPool.length === 4) {
+            //jackpot
+            validPool.forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+        }
+        else {
+            const nbValid = randint(1, validPool.length + 1);
+            const nbInvalid = n - nbValid;
+            randomMany(validPool, nbValid).forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+            if (probaFlip(0.2)) {
+                randomMany([...invalidPool, random(invalidMiscPool)], nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+            else {
+                randomMany(invalidPool, nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+        }
+    }
+    else {
+        const validPool = [
+            "un point",
+            "un segment",
+            //disk<radius
+            random([
+                `un disque de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            "un triangle plein",
+            //disk=radius
+            random([
+                `un disque de rayon $${radius} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+        ];
+        const invalidPool = [
+            //disk>radius
+            random([
+                `un disque de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //circle=radius
+            random([
+                `un cercle de rayon $${radius} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+            //circle<radius
+            random([
+                `un cercle de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //circle>radius
+            random([
+                `un cercle de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //rare
+            ...(probaFlip(0.02)
+                ? [
+                    random([
+                        `un cercle de rayon $1,5 \\ \\textrm{cm}$`,
+                        `un cercle de diamètre $3 \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : []),
+        ];
+        const invalidMiscPool = ["une droite", "un cône", "un cylindre"];
+        if (coinFlip() && validPool.length === 4) {
+            //jackpot
+            validPool.forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+        }
+        else {
+            const nbValid = randint(1, validPool.length + 1);
+            const nbInvalid = n - nbValid;
+            randomMany(validPool, nbValid).forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+            if (probaFlip(0.2)) {
+                randomMany([...invalidPool, random(invalidMiscPool)], nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+            else {
+                randomMany(invalidPool, nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getRecognizeSectionsOfConeQuestion = () => {
+    const radius = randint(5, 21);
+    const height = randint(5, 21);
+    const isDiameterGiven = coinFlip();
+    const isHollow = coinFlip();
+    const isBaseCircle = isHollow && coinFlip();
+    const identifiers = {
+        radius,
+        height,
+        isDiameterGiven,
+        isHollow,
+        isBaseCircle,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+export const recognizeSectionsOfCone = {
+    id: "recognizeSectionsOfCone",
+    connector: "=",
+    label: "Reconnaître la nature d'une section de cône",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getRecognizeSectionsOfConeQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    radius: number;
+    height: number;
+    isDiameterGiven: boolean;
+    isHollow: boolean;
+    isBaseCircle: boolean;
+};
+export declare const recognizeSectionsOfCylinder: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=recognizeSectionsOfCylinder.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeSectionsOfCylinder.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sections/recognizeSectionsOfCylinder.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;IACzB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AAoRF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAiB7D,CAAC"}

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

@@ -0,0 +1,236 @@
+import { addValidProp, shuffleProps, 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 { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const getInstruction = (identifiers) => {
+    const { radius, height, isDiameterGiven, isHollow, isBaseCircle } = identifiers;
+    return `Parmi les propositions suivantes, lesquelles peuvent être des sections planes d'un cylindre de hauteur $${height.frenchify()}\\ \\textrm{cm}$ et de ${isDiameterGiven ? "diamètre" : "rayon"} $${(isDiameterGiven ? 2 * radius : radius).frenchify()}\\ \\textrm{cm}$ ?
+  On va considérer que le cylindre est ${isHollow ? "creux" : "plein"}${isHollow
+        ? isBaseCircle
+            ? " et ouvert à chaque extrémité"
+            : " et fermé à chaque extrémité"
+        : ""}.`;
+};
+const getHint = (identifiers) => {
+    const { isHollow, isBaseCircle } = identifiers;
+    return `Visualise mentalement un cylindre ${isHollow ? "creux" : "plein"}${isHollow
+        ? isBaseCircle
+            ? " et ouvert à chaque extrémité"
+            : " et fermé à chaque extrémité"
+        : ""}.`;
+};
+const getCorrection = (identifiers) => {
+    const { radius, height, isHollow, isBaseCircle } = identifiers;
+    return `Les réponses possibles pour un cylindre ${isHollow ? "creux" : "plein"}${isHollow
+        ? isBaseCircle
+            ? " et ouvert à chaque extrémité"
+            : " et fermé à chaque extrémité"
+        : ""} de hauteur $${height} \\ \\textrm{cm}$ et de rayon $${radius} \\ \\textrm{cm}$ sont : 
+
+  - un point si le plan passe seulement par un point d'une extrémité
+  - un segment si le plan est comme "posé" sur la paroi du cylindre
+${(() => {
+        if (isHollow) {
+            if (isBaseCircle) {
+                return `- un cercle de rayon égal à $${radius} \\ \\textrm{cm}$ si le plan est perpendiculaire à l'axe de révolution du cylindre 
+- deux segments parallèles si le plan passe par l'axe de révolution du cylindre`;
+            }
+            else {
+                return `- un cercle de rayon égal à $${radius} \\ \\textrm{cm}$ si le plan est perpendiculaire à l'axe de révolution du cylindre
+- un disque de rayon $${radius} \\ \\textrm{cm}$ si le plan est perpendiculaire à l'axe de révolution du cône et rencontre une des extrémités du cylindre
+- un rectangle si le plan passe par l'axe de révolution du cylindre`;
+            }
+        }
+        else {
+            return `- un disque de rayon égal à $${radius} \\ \\textrm{cm}$ si le plan est perpendiculaire à l'axe de révolution du cylindre
+- un rectangle plein si le plan passe par l'axe de révolution du cône`;
+        }
+    })()}`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const { radius, isHollow, isBaseCircle } = identifiers;
+    const propositions = [];
+    if (isHollow) {
+        const validPool = [
+            "un point",
+            "un segment",
+            ...(isBaseCircle
+                ? [
+                    "deux segments parallèles",
+                    //circle=radius
+                    random([
+                        `un cercle de rayon $${radius} \\ \\textrm{cm}$`,
+                        `un cercle de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : [
+                    "un rectangle",
+                    //disk=radius
+                    random([
+                        `un disque de rayon $${radius} \\ \\textrm{cm}$`,
+                        `un disque de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+                    ]),
+                ]),
+        ];
+        const invalidPool = [
+            //circle>radius
+            random([
+                `un cercle de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            ...(isBaseCircle
+                ? [
+                    //disk=radius
+                    random([
+                        `un disque de rayon $${radius} \\ \\textrm{cm}$`,
+                        `un disque de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+                    ]),
+                ]
+                : [
+                    //circle=radius
+                    random([
+                        `un cercle de rayon $${radius} \\ \\textrm{cm}$`,
+                        `un cercle de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+                    ]),
+                ]),
+            //disk<radius
+            random([
+                `un disque de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //disk>radius
+            random([
+                `un disque de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+        ];
+        const invalidMiscPool = ["une droite", "un cône", "un cylindre"];
+        if (coinFlip() && validPool.length === 4) {
+            //jackpot
+            validPool.forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+        }
+        else {
+            const nbValid = randint(1, validPool.length + 1);
+            const nbInvalid = n - nbValid;
+            randomMany(validPool, nbValid).forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+            if (probaFlip(0.2)) {
+                randomMany([...invalidPool, random(invalidMiscPool)], nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+            else {
+                randomMany(invalidPool, nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+        }
+    }
+    else {
+        const validPool = [
+            "un point",
+            "un segment",
+            "un rectangle",
+            //disk=radius
+            random([
+                `un disque de rayon $${radius} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+        ];
+        const invalidPool = [
+            //disk>radius
+            random([
+                `un disque de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un disque de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+            //circle=radius
+            random([
+                `un cercle de rayon $${radius} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * radius} \\ \\textrm{cm}$`,
+            ]),
+            //circle<radius
+            random([
+                `un cercle de rayon $${randint(1, radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(1, radius)} \\ \\textrm{cm}$`,
+            ]),
+            //circle>radius
+            random([
+                `un cercle de rayon $${randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+                `un cercle de diamètre $${2 * randint(radius + 1, 2 * radius)} \\ \\textrm{cm}$`,
+            ]),
+        ];
+        const invalidMiscPool = ["une droite", "un cône", "un cylindre"];
+        if (coinFlip() && validPool.length === 4) {
+            //jackpot
+            validPool.forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+        }
+        else {
+            const nbValid = randint(1, validPool.length + 1);
+            const nbInvalid = n - nbValid;
+            randomMany(validPool, nbValid).forEach((str) => {
+                addValidProp(propositions, str, "raw");
+            });
+            if (probaFlip(0.2)) {
+                randomMany([...invalidPool, random(invalidMiscPool)], nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+            else {
+                randomMany(invalidPool, nbInvalid).forEach((str) => {
+                    tryToAddWrongProp(propositions, str, "raw");
+                });
+            }
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getRecognizeSectionsOfCylinderQuestion = () => {
+    const radius = randint(5, 21);
+    const height = randint(5, 21);
+    const isDiameterGiven = coinFlip();
+    const isHollow = coinFlip();
+    const isBaseCircle = isHollow && coinFlip();
+    const identifiers = {
+        radius,
+        height,
+        isDiameterGiven,
+        isHollow,
+        isBaseCircle,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+export const recognizeSectionsOfCylinder = {
+    id: "recognizeSectionsOfCylinder",
+    connector: "=",
+    label: "Reconnaître la nature d'une section de cylindre",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(getRecognizeSectionsOfCylinderQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeSectionsOfRectangularPrism.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sections/recognizeSectionsOfRectangularPrism.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAKrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAwFF,eAAO,MAAM,mCAAmC,EAAE,QAAQ,CAAC,WAAW,CAoBrE,CAAC"}

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

@@ -0,0 +1,92 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { probaFlip } from "../../../../utils/alea/probaFlip.js";
+import { random, randomMany } from "../../../../utils/alea/random.js";
+const getInstruction = () => {
+    return `Parmi les propositions suivantes, lesquelles peuvent être des sections planes d'un pavé droit ?`;
+};
+const getHint = () => {
+    return `Visualise mentalement un pavé droit et fait passer le plan comme si le pavé droit passait un scanner.
+Tu peux ensuite changer la position du pavé droit et recommencer.`;
+};
+const getCorrection = () => {
+    return `Des réponses possibles pour un pavé droit sont : 
+
+  - un point si le plan passe seulement par un sommet du pavé droit
+  - un segment si le plan est comme "posé" sur une arète du pavé droit
+  - un triangle si le plan est proche d'un sommet du pavé droit
+  - un trapèze
+  - un rectangle`;
+};
+const getPropositions = (n) => {
+    const propositions = [];
+    const validPool = [
+        "un point",
+        "un segment",
+        "un triangle",
+        "un trapèze",
+        "un rectangle",
+    ];
+    const invalidPool = ["un cercle", "un disque", "deux segments parallèles"];
+    const invalidMiscPool = ["une droite", "un cône", "un cylindre"];
+    if (probaFlip(0.07) && validPool.length >= 4) {
+        //jackpot
+        validPool.forEach((str) => {
+            addValidProp(propositions, str, "raw");
+        });
+    }
+    else {
+        const nbValid = randint(1, validPool.length);
+        const nbInvalid = n - nbValid;
+        randomMany(validPool, nbValid).forEach((str) => {
+            addValidProp(propositions, str, "raw");
+        });
+        if (probaFlip(0.2)) {
+            randomMany([...invalidPool, random(invalidMiscPool)], nbInvalid).forEach((str) => {
+                tryToAddWrongProp(propositions, str, "raw");
+            });
+        }
+        else {
+            randomMany(invalidPool, nbInvalid).forEach((str) => {
+                tryToAddWrongProp(propositions, str, "raw");
+            });
+        }
+    }
+    return shuffleProps(propositions, n);
+};
+const getRecognizeSectionsOfRectangularPrismQuestion = () => {
+    const identifiers = {
+        nothing: true,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        instruction: getInstruction(identifiers),
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        keys: [],
+        answerFormat: "raw",
+        identifiers,
+    };
+    return question;
+};
+export const recognizeSectionsOfRectangularPrism = {
+    id: "recognizeSectionsOfRectangularPrism",
+    connector: "=",
+    label: "Reconnaître la nature d'une section de pavé droit",
+    isSingleStep: true,
+    generator: (nb) => 
+    // getDistinctQuestions(getRecognizeSectionsOfRectangularPrismQuestion, nb),
+    [...Array(nb).keys()].map(() => getRecognizeSectionsOfRectangularPrismQuestion()),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    answerType: "QCM",
+    isQCM: true,
+    getHint,
+    getCorrection,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    strOfX: string;
+    radius: number;
+    isDiameterGiven: boolean;
+};
+export declare const recognizeSectionsOfSphereOrBall: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=recognizeSectionsOfSphereOrBall.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeSectionsOfSphereOrBall.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/spaceGeometry/sections/recognizeSectionsOfSphereOrBall.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,EAAE,OAAO,CAAC;CAC1B,CAAC;AAyQF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAiBjE,CAAC"}