math-exercises 3.0.208 → 3.0.211

package/lib/exercises/math/arithmetic/congruenceBasicComputation.d.ts

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

package/lib/exercises/math/arithmetic/congruenceBasicComputation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"congruenceBasicComputation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/congruenceBasicComputation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,GAAG,EAAE,MAAM,CAAC;CACb,CAAC;AAmFF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,WAAW,CAkB5D,CAAC"}

package/lib/exercises/math/arithmetic/congruenceBasicComputation.js

@@ -0,0 +1,93 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, mod }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, mod.frenchify());
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(1, 20).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { a, mod } = identifiers;
+    return Math.floor(a % mod).frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { a, mod } = identifiers;
+    return `Déterminer $x$ tel que $0\\leq x < ${mod}$ et :
+
+$$
+${a} \\equiv x \\ [${mod}]
+$$`;
+};
+const getHint = (identifiers) => {
+    const { a, mod } = identifiers;
+    return `Puisque $0\\leq x < ${mod}$ et $${a} \\equiv x \\ [${mod}]$, alors $x$ est le reste de la division euclidienne de $${a}$ par $${mod}$.`;
+};
+const getCorrection = (identifiers) => {
+    const { a, mod } = identifiers;
+    const left = a % mod;
+    const quot = Math.floor(a / mod);
+    return `$x$ est le reste de la division euclidienne de $${a}$ par $${mod}$.
+  
+Or,
+
+$$
+${a} = ${quot}\\times ${mod} + ${left}
+$$
+
+Ainsi, $x= ${left}$`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCongruenceBasicComputationQuestion = () => {
+    const mod = randint(2, 12);
+    const a = randint(mod, mod * 3);
+    const identifiers = {
+        a,
+        mod,
+    };
+    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),
+    };
+};
+export const congruenceBasicComputation = {
+    id: "congruenceBasicComputation",
+    connector: "=",
+    label: "Déterminer $x$ tel que $x$ est congru à $a$ modulo $n$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCongruenceBasicComputationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./congruenceBasicComputation.js";

package/lib/exercises/math/functions/affines/adjustment/affineAdjustment.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"affineAdjustment.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/affines/adjustment/affineAdjustment.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA8KF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAa1D,CAAC"}
+{"version":3,"file":"affineAdjustment.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/affines/adjustment/affineAdjustment.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAgBrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AA6LF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAc1D,CAAC"}

package/lib/exercises/math/functions/affines/adjustment/affineAdjustment.js

@@ -66,6 +66,18 @@ const getAffineAdjustmentQuestion = () => {
     const identifiers = { xValues, yValues };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = () => {
+    return `Utilise la calculatrice. Va dans le menu "Stats", puis entre les données de la série.`;
+};
+const getCorrection = (identifiers) => {
+    return `On utilise la calculatrice. On se rend dans le menu "Stats", puis on entre les données de la série. La calculatrice nous donne alors les indicateurs statistiques de cette série, et parmi eux, l'équation de la droite d'ajustement obtenue par la méthode des moindres carrés.
+  
+On trouve, arrondie au dixième : 
+
+$$
+${getAnswer(identifiers)}
+$$`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -80,6 +92,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
                 firstRowIsHeader: false,
             },
         },
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -125,5 +139,6 @@ export const affineAdjustmentExercise = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
     getQuestionFromIdentifiers,
 };

package/lib/exercises/math/functions/affines/adjustment/affineAdjustmentRsquared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"affineAdjustmentRsquared.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/affines/adjustment/affineAdjustmentRsquared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAqHF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAalE,CAAC"}
+{"version":3,"file":"affineAdjustmentRsquared.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/functions/affines/adjustment/affineAdjustmentRsquared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAcrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAqIF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAclE,CAAC"}

package/lib/exercises/math/functions/affines/adjustment/affineAdjustmentRsquared.js

@@ -36,6 +36,18 @@ const getAffineAdjustmentRsquaredQuestion = () => {
     const identifiers = { xValues, yValues };
     return getQuestionFromIdentifiers(identifiers);
 };
+const getHint = () => {
+    return `Utilise la calculatrice. Va dans le menu "Stats", puis entre les données de la série.`;
+};
+const getCorrection = (identifiers) => {
+    return `On utilise la calculatrice. On se rend dans le menu "Stats", puis on entre les données de la série. La calculatrice nous donne alors les indicateurs statistiques de cette série, et parmi eux, le coefficient de détermination $R^2$.
+  
+On trouve, arrondie au dixième : 
+
+$$
+R^2 \\approx ${getAnswer(identifiers)}
+$$`;
+};
 const getQuestionFromIdentifiers = (identifiers) => {
     const question = {
         answer: getAnswer(identifiers),
@@ -50,6 +62,8 @@ const getQuestionFromIdentifiers = (identifiers) => {
                 firstRowIsHeader: false,
             },
         },
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
     };
     return question;
 };
@@ -89,4 +103,5 @@ export const affineAdjustmentRsquaredExercise = {
     isAnswerValid,
     subject: "Mathématiques",
     getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/functions/continuity/index.d.ts

@@ -3,4 +3,6 @@ export * from "./piecewiseFunctionContinuity.js";
 export * from "./isFunctionContinuousFromGraph.js";
 export * from "./signTableFromVarTableWithZeroes.js";
 export * from "./thirdDegreeZeroesFramingWithCalculator.js";
+export * from "./pyContinuityBalayageInstructionCompletion.js";
+export * from "./pyContinuityDichotomyInstructionCompletion.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/functions/continuity/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/continuity/index.ts"],"names":[],"mappings":"AAAA,cAAc,4CAA4C,CAAC;AAC3D,cAAc,kCAAkC,CAAC;AACjD,cAAc,oCAAoC,CAAC;AACnD,cAAc,sCAAsC,CAAC;AACrD,cAAc,6CAA6C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/continuity/index.ts"],"names":[],"mappings":"AAAA,cAAc,4CAA4C,CAAC;AAC3D,cAAc,kCAAkC,CAAC;AACjD,cAAc,oCAAoC,CAAC;AACnD,cAAc,sCAAsC,CAAC;AACrD,cAAc,6CAA6C,CAAC;AAC5D,cAAc,gDAAgD,CAAC;AAC/D,cAAc,iDAAiD,CAAC"}

package/lib/exercises/math/functions/continuity/index.js

@@ -3,3 +3,5 @@ export * from "./piecewiseFunctionContinuity.js";
 export * from "./isFunctionContinuousFromGraph.js";
 export * from "./signTableFromVarTableWithZeroes.js";
 export * from "./thirdDegreeZeroesFramingWithCalculator.js";
+export * from "./pyContinuityBalayageInstructionCompletion.js";
+export * from "./pyContinuityDichotomyInstructionCompletion.js";

package/lib/exercises/math/functions/continuity/pyContinuityBalayageInstructionCompletion.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsInterval: NodeIdentifiers;
+    nodeIdsDistanceMax: NodeIdentifiers;
+    nbStepsPerBalayage: number;
+    keyIncomplete: string;
+};
+export declare const pyContinuityBalayageInstructionCompletion: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pyContinuityBalayageInstructionCompletion.d.ts.map

package/lib/exercises/math/functions/continuity/pyContinuityBalayageInstructionCompletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pyContinuityBalayageInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/continuity/pyContinuityBalayageInstructionCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAoB7C,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,eAAe,CAAC;IACjC,kBAAkB,EAAE,eAAe,CAAC;IACpC,kBAAkB,EAAE,MAAM,CAAC;IAC3B,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAmVF,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAAC,WAAW,CAkBzE,CAAC"}

package/lib/exercises/math/functions/continuity/pyContinuityBalayageInstructionCompletion.js

@@ -0,0 +1,276 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { NodeConstructor, } from "../../../../tree/nodes/nodeConstructor.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { ClosureType } from "../../../../tree/nodes/sets/closure.js";
+import { IntervalNode } from "../../../../tree/nodes/sets/intervalNode.js";
+import { random } from "../../../../utils/alea/random.js";
+const codify = (strPython) => {
+    return `\`\`\`python
+${strPython}
+\`\`\``;
+};
+const codifyChunk = (strPython) => {
+    return `\`${strPython}\``;
+};
+const createStrPythonForNode = (node) => {
+    return node.toMathString().replaceAll("^", "**");
+};
+const getHydrated = (identifiers) => {
+    const { nodeIdsInterval, nodeIdsDistanceMax } = identifiers;
+    const nodeInterval = NodeConstructor.fromIdentifiers(nodeIdsInterval);
+    const nodeDistanceMax = NodeConstructor.fromIdentifiers(nodeIdsDistanceMax);
+    return {
+        nodeInterval,
+        nodeDistanceMax,
+    };
+};
+const _getStrPythonProgram = (identifiers) => {
+    const { nbStepsPerBalayage } = identifiers;
+    const { nodeInterval, nodeDistanceMax } = getHydrated(identifiers);
+    const [strIntervalBoundA, strIntervalBoundB] = [
+        nodeInterval.a,
+        nodeInterval.b,
+    ].map(createStrPythonForNode);
+    const strDistanceMax = createStrPythonForNode(nodeDistanceMax);
+    const strNbStepsPerBalayage = createStrPythonForNode(nbStepsPerBalayage.toTree());
+    return `def encadrement(f,a,b, precision):
+    xL,xR = a,b                                  #
+    while True:
+        pas = (xR-xL)/${strNbStepsPerBalayage}   #
+        xL,xR = balayage(f,xL,xR,pas)            #
+        if(xR-xL < precision):                   #                                
+            return xL,xR                                                            
+
+def balayage(f, a, b, pas):
+    x = a                                        #
+    while x <= b:
+        if f(x) * f(x + pas) <= 0:               #
+            return x, x + pas
+        x += pas                                 #
+    return None
+
+xL,xR = encadrement(f, ${strIntervalBoundA} , ${strIntervalBoundB} , ${strDistanceMax})
+print(xL, "<=", "alpha", "<=", xR)`;
+};
+const getStrPythonProgramComplete = (identifiers) => {
+    const identifiersTweaked = {
+        ...identifiers,
+        keyIncomplete: "",
+    };
+    return getStrPythonProgramIncomplete(identifiersTweaked);
+};
+const getStrPythonProgramIncomplete = (identifiers) => {
+    const { keyIncomplete } = identifiers;
+    const { strEncadrementInitialization, strEncadrementPas, strEncadrementBalayage, strEncadrementCondition, strBalayageInitialization, strBalayageCondition, strBalayageNextify, strCallEncadrement, } = Object.fromEntries(Object.entries(getDictStrCompletion(identifiers)).map(([key, str]) => key === keyIncomplete ? [key, "..."] : [key, str]));
+    return `def encadrement(f,a,b, precision):
+    ${strEncadrementInitialization}
+    while True:
+        ${strEncadrementPas}
+        ${strEncadrementBalayage}
+        ${strEncadrementCondition}                                
+            return xL,xR                                                            
+
+def balayage(f, a, b, pas):
+    ${strBalayageInitialization}
+    while x <= b:
+        ${strBalayageCondition}
+            return x, x + pas
+        ${strBalayageNextify}
+    return None
+
+${strCallEncadrement}
+print(xL, "<=", "alpha", "<=", xR)`;
+};
+const getDictStrCompletion = (identifiers) => {
+    const { nbStepsPerBalayage } = identifiers;
+    const { nodeInterval, nodeDistanceMax } = getHydrated(identifiers);
+    const [strIntervalBoundA, strIntervalBoundB] = [
+        nodeInterval.a,
+        nodeInterval.b,
+    ].map(createStrPythonForNode);
+    const strDistanceMax = createStrPythonForNode(nodeDistanceMax);
+    const strNbStepsPerBalayage = createStrPythonForNode(nbStepsPerBalayage.toTree());
+    return {
+        strEncadrementInitialization: `xL,xR = a,b`,
+        strEncadrementPas: `pas = (xR-xL)/${strNbStepsPerBalayage}`,
+        strEncadrementBalayage: `xL,xR = balayage(f,xL,xR,pas)`,
+        strEncadrementCondition: `if(xR-xL < precision):`,
+        strBalayageInitialization: `x = a`,
+        strBalayageCondition: `if f(x) * f(x + pas) <= 0:`,
+        strBalayageNextify: `x += pas`,
+        strCallEncadrement: `xL,xR = encadrement(f,${strIntervalBoundA}, ${strIntervalBoundB},${strDistanceMax})`,
+    };
+};
+const getInstruction = (identifiers) => {
+    const { nbStepsPerBalayage } = identifiers;
+    const { nodeInterval, nodeDistanceMax } = getHydrated(identifiers);
+    return `On considère une fonction $f$ strictement monotone sur $${nodeInterval.toTex()}$ et qui change de signe sur cet intervalle.
+On veut déterminer un encadrement de $\\alpha$ tel que $f(\\alpha)=0$ en utilisant un algorithme de balayage, avec à chaque fois $${nbStepsPerBalayage.frenchify()}$ pas par balayage.
+
+Dans le programme suivant, 
+on suppose que l'on dispose d'une fonction ${codifyChunk("f")} 
+telle que ${codifyChunk("f(x)")} retourne $f(x)$.
+
+Par quoi faut-il remplacer les pointillés dans le programme suivant 
+pour qu'il affiche un encadrement de $\\alpha$ avec un écart strictement inférieur à $${nodeDistanceMax.toTex()}$ ?
+
+${codify(getStrPythonProgramIncomplete(identifiers))}
+
+`;
+};
+const getAnswer = (identifiers) => {
+    const { keyIncomplete } = identifiers;
+    const dictStrCompletion = getDictStrCompletion(identifiers);
+    return codifyChunk(dictStrCompletion[keyIncomplete]);
+};
+const getHint = (identifiers) => {
+    const { keyIncomplete } = identifiers;
+    switch (keyIncomplete) {
+        case "strEncadrementInitialization":
+            return `Au départ, notre première estimation pour l'abscisse "à gauche" est $a$ et notre première estimation pour l'abscisse "à droite" est $b$.`;
+        case "strEncadrementPas": {
+            const { nbStepsPerBalayage } = identifiers;
+            return `Si la largeur de l'intervalle est $b-a$, et qu'on le coupe en $${nbStepsPerBalayage}$ segments, quelle est la longueur d'un segment ?`;
+        }
+        case "strEncadrementBalayage":
+            return `On veut trouver les nouvelles abscisses "à gauche" et "à droite" obtenue après un balayage.`;
+        case "strEncadrementCondition":
+            return `Écris en Python "Si la différence de l'abscisse "à droite" avec l'abscisse "à gauche" est inférieure à $precision$ alors"`;
+        case "strBalayageInitialization":
+            return `On balaye de façon croissante les abscisses. On commence par les abscisses les plus petites.`;
+        case "strBalayageCondition":
+            return `Pour détecter un changement de signe de $f$, on utilise la propriété suivante : Le produit de deux nombres de signes différents est négatif.`;
+        case "strBalayageNextify":
+            return `Si on n'a pas encore détecté de changement de signe, on passe au segment suivant.`;
+        default:
+            throw new Error("Unsupported keyIncomplete: " + keyIncomplete);
+    }
+};
+const getCorrection = (identifiers) => {
+    return `Voici le programme complet :
+
+${codify(getStrPythonProgramComplete(identifiers))}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    const { keyIncomplete } = identifiers;
+    const { nbStepsPerBalayage } = identifiers;
+    const strNbStepsPerBalayage = createStrPythonForNode(nbStepsPerBalayage.toTree());
+    switch (keyIncomplete) {
+        case "strEncadrementInitialization":
+            {
+                ["xL,xR = 0,0", "xR,xL = a,b", "xR,xL = 0,0"].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strEncadrementPas":
+            {
+                [
+                    `pas = ${strNbStepsPerBalayage}`,
+                    `pas = (xR-xL) * ${strNbStepsPerBalayage}`,
+                    `pas = xL + 1/${strNbStepsPerBalayage}`,
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strEncadrementBalayage":
+            {
+                [
+                    "xL,xR = balayage(f,a,b,pas)",
+                    "a,b = balayage(f,xL,xR,pas)",
+                    `xL,xR = balayage(f,xL,xR,${strNbStepsPerBalayage})`,
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strEncadrementCondition":
+            {
+                [
+                    "if(xR-xL < precision):",
+                    "if(xR-xL > precision):",
+                    "if(xL-xR < precision):",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strBalayageInitialization":
+            {
+                ["x = 0", "x = b", "x = pas"].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strBalayageCondition":
+            {
+                [
+                    "if f(x) - f(x + pas) <= 0:",
+                    "if f(x) < 0 and f(x + pas) > 0:",
+                    "if f(x) > 0 and f(x + pas) < 0:",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strBalayageNextify":
+            {
+                ["x = a + pas", "x += x + pas", "x + pas"].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        default:
+            throw new Error("Unsupported keyIncomplete: " + keyIncomplete);
+    }
+    return shuffleProps(propositions, n);
+};
+const createRandomIdentifiers = () => {
+    const nodeDistanceMax = power(10, randint(-3, 0));
+    const keyIncomplete = random([
+        "strEncadrementInitialization",
+        "strEncadrementPas",
+        "strEncadrementBalayage",
+        "strEncadrementCondition",
+        "strBalayageInitialization",
+        "strBalayageCondition",
+        "strBalayageNextify",
+        // "strCallEncadrement",
+    ]);
+    const nodeInterval = (() => {
+        const a = randint(-5, 5);
+        const b = a + randint(1, 5);
+        return new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF);
+    })();
+    const nbStepsPerBalayage = random([10, 20, 50, 100]);
+    const identifiers = {
+        nodeIdsInterval: nodeInterval.toIdentifiers(),
+        nodeIdsDistanceMax: nodeDistanceMax.toIdentifiers(),
+        keyIncomplete,
+        nbStepsPerBalayage,
+    };
+    return identifiers;
+};
+const getPyContinuityBalayageInstructionCompletionQuestion = () => {
+    const identifiers = createRandomIdentifiers();
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+export const pyContinuityBalayageInstructionCompletion = {
+    id: "pyContinuityBalayageInstructionCompletion",
+    label: "Compléter le script d'un algorithme d'encadrement par balayage de $\\alpha$ tel que $f(\\alpha)=0$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyContinuityBalayageInstructionCompletionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/functions/continuity/pyContinuityDichotomyInstructionCompletion.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsInterval: NodeIdentifiers;
+    nodeIdsDistanceMax: NodeIdentifiers;
+    keyIncomplete: string;
+};
+export declare const pyContinuityDichotomyInstructionCompletion: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pyContinuityDichotomyInstructionCompletion.d.ts.map

package/lib/exercises/math/functions/continuity/pyContinuityDichotomyInstructionCompletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pyContinuityDichotomyInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/continuity/pyContinuityDichotomyInstructionCompletion.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAIrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAoB7C,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,eAAe,CAAC;IACjC,kBAAkB,EAAE,eAAe,CAAC;IACpC,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAiUF,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAAC,WAAW,CAkB1E,CAAC"}