math-exercises 3.0.203 → 3.0.205

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

@@ -0,0 +1,193 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { Polynomial } from "../../../../math/polynomials/polynomial.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { abs } from "../../../../tree/nodes/functions/absNode.js";
+import { exp } from "../../../../tree/nodes/functions/expNode.js";
+import { LogNode } from "../../../../tree/nodes/functions/logNode.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 { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    return identifiers.type < 5 ? "Oui" : "Non";
+};
+const getInstruction = () => {
+    return `On considère la fonction $f$ représentée ci-dessous. 
+    
+$f$ semble-t-elle continue sur son ensemble de définition ?`;
+};
+const getHint = () => {
+    return `On reconnaît graphiquement une fonction continue au fait qu'on peut la tracer "sans lever le crayon". Est-ce le cas ici ?`;
+};
+const getCorrection = (identifiers) => {
+    const isContinuous = getAnswer(identifiers) === "Oui";
+    if (isContinuous)
+        return `On voit graphiquement que la courbe représentative de $f$ semble pouvoir être tracée sans avoir besoin de "lever le crayon". La fonction $f$ semble donc continue sur son ensemble de définition.`;
+    return `On voit graphiquement que la courbe représentative de $f$ ne semble pas pouvoir être tracée sans avoir besoin de "lever le crayon". La fonction $f$ ne semble donc pas continue sur son ensemble de définition.`;
+};
+const getGGBOptions = (identifiers) => {
+    const ggb = new GeogebraConstructor({
+        commands: [identifiers.functionCmd],
+        lockedAxesRatio: false,
+        gridDistance: false,
+    });
+    return ggb.getOptions({
+        coords: identifiers.coords,
+    });
+};
+const getKeys = () => {
+    return [];
+};
+const getIsFunctionContinuousFromGraphQuestion = () => {
+    const isContinuous = coinFlip();
+    const type = isContinuous ? randint(1, 5) : randint(5, 8);
+    let functionCmd = "";
+    let coords = [];
+    switch (type) {
+        case 1:
+            {
+                const k = randint(-10, 10, [0]);
+                const f = multiply(k, abs("x"));
+                const xs = new Array(22).fill(0).map((_, i) => i - 10);
+                const ys = xs.map((x) => f.evaluate({ x }));
+                const yMin = Math.min(...ys);
+                const yMax = Math.max(...ys);
+                functionCmd = `f(x) = ${k}*abs(x)`;
+                coords = [-10, 10, yMin, yMax];
+            }
+            break;
+        case 2:
+            {
+                const a = randint(-10, 10);
+                const b = randint(-10, 10);
+                const c = randint(-10, 10);
+                const d = randint(-10, 10, [0]);
+                const f = new Polynomial([a, b, c, d]).toTree();
+                functionCmd = `f(x) = ${f.toMathString()}`;
+                const xs = new Array(22).fill(0).map((_, i) => i - 10);
+                const ys = xs.map((x) => f.evaluate({ x }));
+                const yMin = Math.min(...ys);
+                const yMax = Math.max(...ys);
+                coords = [-10, 10, yMin, yMax];
+            }
+            break;
+        case 3:
+            {
+                const k = randint(-10, 10, [0]);
+                const m = randint(-10, 10, [0]);
+                const f = multiply(k, exp(multiply(m, "x")));
+                functionCmd = `f(x) = ${f.toMathString()}`;
+                const xs = new Array(22).fill(0).map((_, i) => i - 10);
+                const ys = xs
+                    .map((x) => f.evaluate({ x }))
+                    .filter((y) => !isNaN(y) && y > -10000 && y < 10000);
+                const yMin = Math.min(...ys, -2);
+                const yMax = Math.max(...ys, 2);
+                coords = [-10, 10, yMin, yMax];
+            }
+            break;
+        case 4:
+            {
+                const k = randint(-10, 10, [0]);
+                const m = randint(-10, 10, [0]);
+                const f = multiply(k, new LogNode(multiply(m, "x")));
+                functionCmd = `f(x) = ${f.toMathString()}`;
+                const xs = new Array(22).fill(0).map((_, i) => i - 10);
+                const ys = xs
+                    .map((x) => f.evaluate({ x }))
+                    .filter((y) => !isNaN(y) && y > -10000 && y < 10000);
+                const yMin = Math.min(...ys, -2);
+                const yMax = Math.max(...ys, 2);
+                coords = [m > 0 ? -1 : -10, m > 0 ? 10 : 1, yMin, yMax];
+            }
+            break;
+        case 5:
+            {
+                const k = randint(-10, 10, [0]);
+                const f = (x) => k * Math.floor(x);
+                functionCmd = `f(x) = ${k}*floor(x)`;
+                const xs = new Array(22).fill(0).map((_, i) => i - 10);
+                const ys = xs.map((x) => f(x));
+                const yMin = Math.min(...ys, -2);
+                const yMax = Math.max(...ys, 2);
+                coords = [-10, 10, yMin, yMax];
+            }
+            break;
+        case 6:
+            {
+                const a = randint(-10, 10, [0]);
+                const b = randint(-10, 10, [0]);
+                const c = randint(-10, 10, [0]);
+                const d = doWhile(() => randint(-10, 10, [0]), (x) => a / c === b / x);
+                const root = -d / c;
+                const f = frac(add(multiply(a, "x"), b), add(multiply(c, "x"), d));
+                functionCmd = `f(x) = ${f.toMathString()}`;
+                coords = [root - 10, root + 10, -100, 100];
+            }
+            break;
+        case 7:
+            {
+                const a = randint(-10, 10);
+                const aff = AffineConstructor.random().toTree();
+                const fa = aff.evaluate({ x: a });
+                const trinom = doWhile(() => TrinomConstructor.random().toTree(), (t) => Math.abs(t.evaluate({ x: a }) - fa) < 5);
+                const f = (x) => x < a ? aff.evaluate({ x }) : trinom.evaluate({ x });
+                functionCmd = `f(x) = If(x<${a}, ${aff.toMathString()}, ${trinom.toMathString()})`;
+                const xs = new Array(11).fill(0).map((_, i) => i - 5 + a);
+                const ys = xs.map((x) => f(x));
+                const yMin = Math.min(...ys, -2);
+                const yMax = Math.max(...ys, 2);
+                coords = [a - 5, a + 5, yMin, yMax];
+            }
+            break;
+    }
+    const identifiers = {
+        type,
+        functionCmd,
+        coords,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const isFunctionContinuousFromGraph = {
+    id: "isFunctionContinuousFromGraph",
+    label: "Déterminer si une fonction semble continue à partir de sa représentation graphique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getIsFunctionContinuousFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"piecewiseFunctionContinuity.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/continuity/piecewiseFunctionContinuity.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAK7C,KAAK,WAAW,GAAG;IAGjB,IAAI,EAAE,eAAe,CAAC;IACtB,KAAK,EAAE,eAAe,CAAC;IACvB,KAAK,EAAE,eAAe,CAAC;CACxB,CAAC;AAwJF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,CAqB7D,CAAC"}

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

@@ -0,0 +1,150 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { Trinom } from "../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { LimitNode } from "../../../../tree/nodes/operators/limitNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer, "raw");
+    tryToAddWrongProp(propositions, "Oui", "raw");
+    tryToAddWrongProp(propositions, "Non", "raw");
+    tryToAddWrongProp(propositions, "On ne peut pas savoir", "raw");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { aIds, f1Ids, f2Ids } = identifiers;
+    const a = reifyAlgebraic(aIds).evaluate();
+    const f1 = reifyAlgebraic(f1Ids);
+    const f2 = reifyAlgebraic(f2Ids);
+    return Math.abs(f1.evaluate({ x: a }) - f2.evaluate({ x: a })) < 0.01
+        ? "Oui"
+        : "Non";
+};
+const getInstruction = (identifiers) => {
+    const { aIds, f1Ids, f2Ids } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const f1 = reifyAlgebraic(f1Ids);
+    const f2 = reifyAlgebraic(f2Ids);
+    return `Soit $f$ la fonction définie sur $\\mathbb{R}$ par : 
+  
+$$
+f(x) = \\begin{cases} ${f1.toTex()} & \\text{si } x \\leq ${a.toTex()} \\\\ ${f2.toTex()} & \\text{si } x > ${a.toTex()} \\end{cases}
+$$ 
+  
+  
+La fonction $f$ est-elle continue sur $\\mathbb{R}$ ?`;
+};
+const getHint = (identifiers) => {
+    const { aIds } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    return `La fonction $f$ est une fonction définie par morceaux. Pour savoir si elle est continue sur $\\mathbb{R}$, il faut :
+  
+- s'assurer que chaque "morceau" définissant $f$ soit continue;
+- puis s'assurer que $f$ soit continue en $${a.toTex()}$. Pour cela, il faut vérifier si on a bien  : 
+
+$$
+${new LimitNode(a, new VariableNode("f(x)"), "-").toTex()} = ${new LimitNode(a, new VariableNode("f(x)"), "+").toTex()} = f(${a.toTex()})
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { aIds, f1Ids, f2Ids } = identifiers;
+    const a = reifyAlgebraic(aIds);
+    const f1 = reifyAlgebraic(f1Ids);
+    const f2 = reifyAlgebraic(f2Ids);
+    const fa = f1.evaluate({ x: a.evaluate() });
+    const f2a = f2.toDetailedEvaluation({ x: a });
+    const isContinuous = getAnswer(identifiers) === "Oui";
+    return `
+  
+La fonction $x \\mapsto ${f1.toTex()}$ est une fonction affine, donc elle est continue sur $]-\\infty; ${a.toTex()}]$.
+
+
+La fonction $x \\mapsto ${f1.toTex()}$  est un polynôme du second degré, donc elle est continue sur $]${a.toTex()}; +\\infty[$.
+
+Il reste à analyser la continuité de $f$ en $${a.toTex()}$. On a :
+
+- $f(${a.toTex()}) = ${f1.toDetailedEvaluation({ x: a }).toTex()} = ${fa}$
+
+- $${new LimitNode(a, new VariableNode("f(x)"), "-").toTex()} = f(${a.toTex()}) =${fa}$
+
+- $${new LimitNode(a, new VariableNode("f(x)"), "+").toTex()} = ${new LimitNode(a, f2, "+").toTex()} = ${f2a.simplify().toTex()}$
+
+${isContinuous
+        ? `On a donc : 
+
+$$
+${new LimitNode(a, new VariableNode("f(x)")).toTex()} = f(${a.toTex()})
+$$
+
+On en déduit que $f$ est continue en $${a.toTex()}$, et donc continue sur $\\mathbb{R}$.
+  
+`
+        : `On a donc : 
+
+$$
+${new LimitNode(a, new VariableNode("f(x)")).toTex()} \\neq f(${a.toTex()})
+$$
+
+On en déduit que $f$ n'est pas continue en $${a.toTex()}$, et donc n'est pas continue sur $\\mathbb{R}$.
+  `}  `;
+};
+const getKeys = () => {
+    return [];
+};
+const getPiecewiseFunctionContinuityQuestion = () => {
+    const isContinuous = coinFlip();
+    const a = randint(-5, 6);
+    const f1Aff = AffineConstructor.random();
+    let f2Ids;
+    const fa = f1Aff.calculate(a);
+    if (isContinuous) {
+        const m = randint(-9, 10, [0]);
+        const n = randint(-9, 10);
+        const p = fa - m * a ** 2 - n * a;
+        f2Ids = new Trinom(m, n, p).toTree().toIdentifiers();
+    }
+    else {
+        const m = randint(-9, 10, [0]);
+        const n = randint(-9, 10);
+        const p = fa - m * a ** 2 - n * a + randint(-9, 10, [0]);
+        f2Ids = new Trinom(m, n, p).toTree().toIdentifiers();
+    }
+    const identifiers = {
+        aIds: a.toTree().toIdentifiers(),
+        f1Ids: f1Aff.toTree().toIdentifiers(),
+        f2Ids,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "raw",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const piecewiseFunctionContinuity = {
+    id: "piecewiseFunctionContinuity",
+    label: "Déterminer si une fonction définie par morceaux est continue sur $\\mathbb{R}$.",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPiecewiseFunctionContinuityQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "QCU",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"signTableFromVarTableWithZeroes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/continuity/signTableFromVarTableWithZeroes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAyJF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAqBjE,CAAC"}

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

@@ -0,0 +1,162 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { signTableVEA } from "../../../../exercises/vea/signTableVEA.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getAnswerTable = (identifiers) => {
+    const { xValues, yValues, xZeroes } = identifiers;
+    const signs = yValues[0] > 0 ? ["+", "-", "+"] : ["-", "+", "-"];
+    return [
+        [
+            "$x$",
+            xValues[0].frenchify(),
+            "\\ ",
+            xZeroes[0].frenchify(),
+            "\\ ",
+            xZeroes[1].frenchify(),
+            "\\ ",
+            xValues[3].frenchify(),
+        ],
+        ["$f(x)$", "\\ ", signs[0], "0", signs[1], "0", signs[2], "\\ "],
+    ];
+};
+const getTable = (identifiers) => {
+    const { xValues, yValues, xZeroes } = identifiers;
+    const isFirstAscending = yValues[0] < yValues[1];
+    const arrows = isFirstAscending
+        ? ["\\nearrow", "\\searrow", "\\nearrow"]
+        : ["\\searrow", "\\nearrow", "\\searrow"];
+    const xs = [];
+    for (let i = 0; i < xValues.length; i++) {
+        xs.push(xValues[i].frenchify());
+        const x = xZeroes.find((e) => e > xValues[i] && e < xValues[i + 1]);
+        xs.push(x !== undefined ? x.frenchify() : "\\ ");
+        if (x !== undefined)
+            arrows[i] = "0" + arrows[i];
+    }
+    return [
+        ["£x£", ...xs],
+        [
+            " ",
+            isFirstAscending ? "\\ " : yValues[0].frenchify(),
+            "\\ ",
+            isFirstAscending ? yValues[1].frenchify() : "\\ ",
+            "\\ ",
+            isFirstAscending ? "\\ " : yValues[2].frenchify(),
+            "\\ ",
+            isFirstAscending ? yValues[3].frenchify() : "\\ ",
+        ],
+        ["£f(x)£", "\\ ", arrows[0], "\\ ", arrows[1], "\\ ", arrows[2], "\\ "],
+        [
+            " ",
+            !isFirstAscending ? "\\ " : yValues[0].frenchify(),
+            "\\ ",
+            !isFirstAscending ? yValues[1].frenchify() : "\\ ",
+            "\\ ",
+            !isFirstAscending ? "\\ " : yValues[2].frenchify(),
+            "\\ ",
+            !isFirstAscending ? yValues[3].frenchify() : "\\ ",
+        ],
+    ];
+};
+const getInstruction = (identifiers) => {
+    const table = getTable(identifiers);
+    return `On donne ci-dessous le tableau de variations d'une fonction $f$, avec les antécédents de $0$ apparents.
+  
+<svg id="varTable">${JSON.stringify(table)}</svg>
+
+Dresser le tableau de signes de $f$.
+`;
+};
+const getHint = () => {
+    return `Dans le tableau de variations, les antécédents de $0$ sont apparents. Sers-toi de ces informations pour dresser le tableau de signes de $f$.`;
+};
+const getCorrection = (identifiers) => {
+    const answer = getAnswerTable(identifiers);
+    const signs = [answer[1][2], answer[1][4], answer[1][6]];
+    const words = signs.map((s) => (s === "+" ? "positive" : "négative"));
+    const intervals = [answer[0][1], answer[0][3], answer[0][5], answer[0][7]];
+    return `Puisque $f$ est une fonction continue, d'après son tableau de variations, elle est ${words[0]} sur $[${intervals[0]}; ${intervals[1]}]$, puis ${words[1]} sur $[${intervals[1]}; ${intervals[2]}]$, puis ${words[2]} sur $[${intervals[2]}; ${intervals[3]}]$.`;
+};
+const getKeys = () => {
+    return ["infty"];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return signTableVEA(ans, answerTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getSignTableFromVarTableWithZeroesQuestion = () => {
+    const xValues = [
+        randint(-12, -3),
+        randint(-4, 2),
+        randint(3, 7),
+        randint(8, 10),
+    ];
+    const yValues = [randint(-9, 10, [-1, 0, 1])];
+    // x = [a,b,c,d]
+    // deux zéros
+    const nonZeroInterval = randint(0, 3);
+    for (let i = 0; i < 3; i++) {
+        const prevY = yValues[i];
+        if (nonZeroInterval === i) {
+            if (prevY < 0) {
+                //on doit descendre car on remontera post 0 après
+                yValues.push(randint(-15, prevY));
+            }
+            else {
+                //on doit monter car on descendra post 0 après
+                yValues.push(randint(prevY, 15));
+            }
+        }
+        else {
+            yValues.push(prevY < 0 ? randint(1, 10) : randint(-10, 0));
+        }
+    }
+    const xZeroes = [];
+    for (let i = 0; i < 3; i++) {
+        if (nonZeroInterval === i)
+            continue;
+        xZeroes.push(randint(xValues[i] + 1, xValues[i + 1]));
+    }
+    const identifiers = {
+        xValues,
+        yValues,
+        xZeroes,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: [
+            ["$x$", "", "\\ ", "", "\\ ", "", "\\ ", ""],
+            ["$f(x)$", "\\ ", "", "", "", "", "", "\\ "],
+        ],
+    };
+};
+export const signTableFromVarTableWithZeroes = {
+    id: "signTableFromVarTableWithZeroes",
+    label: "Dresser le tableau de signes d'une fonction à partir de son tableau de variations",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getSignTableFromVarTableWithZeroesQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "signTable",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"thirdDegreeZeroesFramingWithCalculator.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/continuity/thirdDegreeZeroesFramingWithCalculator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAUrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,OAAO,EAAE,MAAM,EAAE,CAAC;CACnB,CAAC;AAkMF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAsBxE,CAAC"}