math-exercises 3.0.209 → 3.0.211

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"}

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

@@ -0,0 +1,265 @@
+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 { nodeInterval, nodeDistanceMax } = getHydrated(identifiers);
+    const [strIntervalBoundA, strIntervalBoundB] = [
+        nodeInterval.a,
+        nodeInterval.b,
+    ].map(createStrPythonForNode);
+    const strDistanceMax = createStrPythonForNode(nodeDistanceMax);
+    return `def encadrement(f,a,b, precision):
+    xL,xR = a,b                                  #
+    while True:
+        xL,xR = dichotomie(f,xL,xR)              #
+        if(xR-xL < precision):                   #                                
+            return xL,xR                                                            
+
+def dichotomie(f, a, b):
+    m = (a+b) / 2                                #
+    if f(a) * f(m) <= 0:                         #
+        return a, m                              #
+    else:
+        return m,b                               #
+
+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, strEncadrementDichotomie, strEncadrementCondition, strDichotomieM, strDichotomieCondition, strDichotomieBlockValid, strDichotomieBlockInvalid, 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:
+        ${strEncadrementDichotomie}
+        ${strEncadrementCondition}                                
+            return xL,xR                                                            
+
+def dichotomie(f, a, b):
+    ${strDichotomieM}
+    ${strDichotomieCondition}
+      ${strDichotomieBlockValid}
+    else:
+      ${strDichotomieBlockInvalid}
+
+${strCallEncadrement}
+print(xL, "<=", "alpha", "<=", xR)`;
+};
+const getDictStrCompletion = (identifiers) => {
+    const { nodeInterval, nodeDistanceMax } = getHydrated(identifiers);
+    const [strIntervalBoundA, strIntervalBoundB] = [
+        nodeInterval.a,
+        nodeInterval.b,
+    ].map(createStrPythonForNode);
+    const strDistanceMax = createStrPythonForNode(nodeDistanceMax);
+    return {
+        strEncadrementInitialization: `xL,xR = a,b`,
+        strEncadrementDichotomie: `xL,xR = dichotomie(f,xL,xR)`,
+        strEncadrementCondition: `if(xR-xL < precision):`,
+        strDichotomieM: `m = (a+b)/2`,
+        strDichotomieCondition: `if f(a) * f(m) <= 0:`,
+        strDichotomieBlockValid: `return a,m`,
+        strDichotomieBlockInvalid: `return m,b`,
+        strCallEncadrement: `xL,xR = encadrement(f,${strIntervalBoundA}, ${strIntervalBoundB},${strDistanceMax})`,
+    };
+};
+const getInstruction = (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 dichotomie.
+
+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 "strEncadrementDichotomie":
+            return `On veut trouver les nouvelles abscisses "à gauche" et "à droite" obtenue après dichotomie.`;
+        case "strEncadrementCondition":
+            return `Écris en Python "Si la différence de l'abscisse "à droite" avec l'abscisse "à gauche" est inférieure à $precision$ alors"`;
+        case "strDichotomieM":
+            return `Dans un algorithme par dichotomie, on coupe l'intervalle considéré en $2$ et on détermine si l'on garde le côté gauche ou le côté droit.`;
+        case "strDichotomieCondition":
+            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 "strDichotomieBlockValid":
+            return `On a coupé en deux et dans ce cas, on veut garder le côté gauche.`;
+        case "strDichotomieBlockInvalid":
+            return `On a coupé en deux et dans ce cas, on veut garder le côté droit.`;
+        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;
+    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 "strEncadrementDichotomie":
+            {
+                [
+                    "xR,xL = dichotomie(f,a,b)",
+                    "a,b = dichotomie(f,xL,xR)",
+                    `dichotomie(f,xL,xR)`,
+                ].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 "strDichotomieM":
+            {
+                ["m = (b-a)/2", "m = a+b", "m = b-a"].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strDichotomieCondition":
+            {
+                [
+                    "if f(a) - f(m) <= 0:",
+                    "if f(a) < 0 and f(m) > 0:",
+                    "if f(a) > 0 and f(m) < 0:",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strDichotomieBlockValid":
+            {
+                [
+                    "return a, (a+m)/2",
+                    "return (a+m)/2, m",
+                    "return (a+m)/2, (b+m)/2",
+                ].forEach((str) => tryToAddWrongProp(propositions, codifyChunk(str), "raw"));
+            }
+            break;
+        case "strDichotomieBlockInvalid":
+            {
+                [
+                    "return m, (m+b)/2",
+                    "return (m+b)/2, b",
+                    "return (a+m)/2, (b+m)/2",
+                ].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",
+        "strEncadrementDichotomie",
+        "strEncadrementCondition",
+        "strDichotomieM",
+        "strDichotomieCondition",
+        "strDichotomieBlockValid",
+        "strDichotomieBlockInvalid",
+        // "strCallEncadrement",
+    ]);
+    const nodeInterval = (() => {
+        const a = randint(-5, 5);
+        const b = a + randint(1, 5);
+        return new IntervalNode(a.toTree(), b.toTree(), ClosureType.FF);
+    })();
+    const identifiers = {
+        nodeIdsInterval: nodeInterval.toIdentifiers(),
+        nodeIdsDistanceMax: nodeDistanceMax.toIdentifiers(),
+        keyIncomplete,
+    };
+    return identifiers;
+};
+const getPyContinuityDichotomyInstructionCompletionQuestion = () => {
+    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 pyContinuityDichotomyInstructionCompletion = {
+    id: "pyContinuityDichotomyInstructionCompletion",
+    label: "Compléter le script d'un algorithme d'encadrement par dichotomie de $\\alpha$ tel que $f(\\alpha)=0$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPyContinuityDichotomyInstructionCompletionQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

package/lib/exercises/math/integration/algorithms/index.d.ts

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

package/lib/exercises/math/integration/algorithms/index.d.ts.map

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

package/lib/exercises/math/integration/algorithms/index.js

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

package/lib/exercises/math/integration/algorithms/pyIntegrationInstructionCompletion.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 pyIntegrationInstructionCompletion: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=pyIntegrationInstructionCompletion.d.ts.map

package/lib/exercises/math/integration/algorithms/pyIntegrationInstructionCompletion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pyIntegrationInstructionCompletion.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/integration/algorithms/pyIntegrationInstructionCompletion.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;AAsUF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CAAC,WAAW,CAgBpE,CAAC"}