math-exercises 3.0.190 → 3.0.192

package/lib/exercises/math/dataRepresentations/tables/fillDoubleTable.js

@@ -0,0 +1,187 @@
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { valueTableVEA } from "../../../../exercises/vea/valueTableVEA.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getAnswerTable = (identifiers) => {
+    const { coeffs } = identifiers;
+    let done = false;
+    let counter = 1;
+    const rightCoeffs = coeffs.map((e) => [...e]);
+    while (!done && counter < 1000) {
+        counter++;
+        if (counter > 1000)
+            throw new Error("Too many iterations in fillDoubleTable");
+        // console.log(rightCoeffs);
+        for (let i = 0; i < 9; i++) {
+            const cellLine = Math.floor(i / 3);
+            const cellColumn = i % 3;
+            const cell = rightCoeffs[cellLine][cellColumn];
+            if (cell)
+                continue;
+            const isLineCalculable = rightCoeffs[cellLine].filter((e) => !!e).length === 2;
+            if (isLineCalculable) {
+                //si total ligne
+                if ((cellColumn + 1) % 3 === 0)
+                    rightCoeffs[cellLine][cellColumn] = rightCoeffs[cellLine]
+                        .filter((e) => !!e)
+                        .reduce((acc, e) => acc + e, 0);
+                else
+                    rightCoeffs[cellLine][cellColumn] =
+                        rightCoeffs[cellLine][2] -
+                            (rightCoeffs[cellLine][0] ?? rightCoeffs[cellLine][1]);
+            }
+            const isColCalculable = rightCoeffs[(cellLine + 1) % 3][cellColumn] &&
+                rightCoeffs[(cellLine + 2) % 3][cellColumn];
+            if (isColCalculable) {
+                const prev = rightCoeffs[(cellLine + 1) % 3][cellColumn];
+                const next = rightCoeffs[(cellLine + 2) % 3][cellColumn];
+                //si total colomne
+                if (cellLine === 2)
+                    rightCoeffs[cellLine][cellColumn] = prev + next;
+                else
+                    rightCoeffs[cellLine][cellColumn] =
+                        rightCoeffs[2][cellColumn] -
+                            rightCoeffs[1 - cellLine][cellColumn];
+            }
+        }
+        done = rightCoeffs.every((line) => line.every((a) => a !== undefined));
+    }
+    return [
+        [" ", "A", "A'", "Total"],
+        ["B", ...rightCoeffs[0].map((e) => e.frenchify())],
+        ["B'", ...rightCoeffs[1].map((e) => e.frenchify())],
+        ["Total", ...rightCoeffs[2].map((e) => e.frenchify())],
+    ];
+};
+const getInstruction = (identifiers) => {
+    const { coeffs } = identifiers;
+    return `Compléter entièrement le tableau croisé d'effectifs suivant :
+  
+${mdTable([
+        [" ", "$A$", "$A'$", "Total"],
+        ["$B$", ...coeffs[0].map((e) => (e ? dollarize(e.frenchify()) : ""))],
+        ["$B'$", ...coeffs[1].map((e) => (e ? dollarize(e.frenchify()) : ""))],
+        ["Total", ...coeffs[2].map((e) => (e ? dollarize(e.frenchify()) : ""))],
+    ])}`;
+};
+const getHint = () => {
+    return `Pour chaque ligne, le total doit être égal à la somme des deux cases précédentes.
+  
+De même, sur chaque colonne, le total doit être égal à la somme des deux cases précédentes.`;
+};
+const getCorrection = (identifiers) => {
+    const ansTable = getAnswerTable(identifiers);
+    const dollarized = ansTable.map((e, i) => i === 0 ? e : [e[0], ...e.slice(1).map((e) => dollarize(e))]);
+    return `On s'assure que sur chaque ligne, le total est bien égal à la somme des deux cases précédentes, et que sur chaque colonne, le total est bien égal à la somme des deux cases précédentes.
+
+On obtient le tableau suivant :
+  
+${mdTable(dollarized)}
+  `;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerTableValid = (ans, { answerTable }) => {
+    try {
+        return valueTableVEA(ans, answerTable);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+function rank(vectors) {
+    const basis = [];
+    for (let v of vectors) {
+        for (const b of basis) {
+            v = Math.min(v, v ^ b); // réduction
+        }
+        if (v !== 0)
+            basis.push(v);
+    }
+    return basis.length;
+}
+const getFillDoubleTableQuestion = () => {
+    const [a, b, c, d] = randTupleInt(4, {
+        from: 1,
+        to: 100,
+    });
+    //on calcule le rang de 4 vecteurs ci-dessous pris au hasard, si linéairement indépendants alors le tableau est remplissable
+    const vecs = [
+        [1, 0, 0, 0], //A1
+        [0, 1, 0, 0], //A2
+        [1, 1, 0, 0], //TA
+        [0, 0, 1, 0], //B1
+        [0, 0, 0, 1], //B2
+        [0, 0, 1, 1], //TB
+        [1, 0, 1, 0], //T1
+        [0, 1, 0, 1], //T2
+        [1, 1, 1, 1], //T
+    ];
+    const coeffs = [
+        [a, b, a + b],
+        [c, d, c + d],
+        [a + c, b + d, a + b + c + d],
+    ];
+    let choices = [];
+    do {
+        choices = randTupleInt(4, {
+            from: 0,
+            to: vecs.length,
+            allDifferent: true,
+        });
+    } while (rank(choices.map((i) => parseInt(vecs[i].join(""), 2))) !== 4);
+    for (let i = 0; i < 9; i++) {
+        if (choices.includes(i))
+            continue;
+        coeffs[Math.floor(i / 3)][i % 3] = undefined;
+    }
+    const identifiers = {
+        coeffs,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const { coeffs } = identifiers;
+    return {
+        answerTable: getAnswerTable(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        initTable: [
+            [" ", "A", "A'", "Total"],
+            ["B", ...coeffs[0].map((e) => (e ? e.frenchify() : ""))],
+            ["B'", ...coeffs[1].map((e) => (e ? e.frenchify() : ""))],
+            ["Total", ...coeffs[2].map((e) => (e ? e.frenchify() : ""))],
+        ],
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: true,
+            },
+        },
+    };
+};
+export const fillDoubleTable = {
+    id: "fillDoubleTable",
+    label: "Compléter un tableau croisé d'effectifs",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFillDoubleTableQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerTableValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswerTable,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    answerType: "valueTable",
+};

package/lib/exercises/math/dataRepresentations/tables/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./tableReading.js";
+export * from "./fillDoubleTable.js";
+export * from "./buildDoubleTableFromContext.js";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/dataRepresentations/tables/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/tables/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,sBAAsB,CAAC;AACrC,cAAc,kCAAkC,CAAC"}

package/lib/exercises/math/dataRepresentations/tables/index.js

@@ -0,0 +1,3 @@
+export * from "./tableReading.js";
+export * from "./fillDoubleTable.js";
+export * from "./buildDoubleTableFromContext.js";

package/lib/exercises/math/dataRepresentations/tables/tableReading.d.ts

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

package/lib/exercises/math/dataRepresentations/tables/tableReading.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tableReading.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/dataRepresentations/tables/tableReading.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IAIjB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAsGF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAa9C,CAAC"}

package/lib/exercises/math/dataRepresentations/tables/tableReading.js

@@ -0,0 +1,109 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } 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 { random } from "../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer, values }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, random(values.flat()).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { values, caseAsked } = identifiers;
+    const flatValues = values.flat();
+    return flatValues[caseAsked].frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { values, caseAsked } = identifiers;
+    const population = caseAsked % 3 === 0
+        ? "de la $6^e$ A"
+        : caseAsked % 3 === 1
+            ? "de la $6^e$ B"
+            : "";
+    const caractere = caseAsked < 3
+        ? "préfèrent le jeu Minecraft"
+        : caseAsked < 6
+            ? "préfèrent le jeu The Legend of Zelda"
+            : "ont répondu au sondage";
+    return `Un sondage a été réalisé auprès des élèves de deux classes de $6^e$ pour connaître leur jeu vidéo préféré. Voici leurs réponses : 
+  
+${mdTable([
+        ["", "$6^e$ A", "$6^e$ B", "Total"],
+        ["Minecraft", ...values[0].map(dollarize)],
+        ["The Legend of Zelda", ...values[1].map(dollarize)],
+        ["Total", ...values[2].map(dollarize)],
+    ])}
+
+Combien d'élèves ${population} ${caractere} ?
+`;
+};
+// const getHint: GetHint<Identifiers> = (identifiers) => {};
+// const getCorrection: GetCorrection<Identifiers> = (identifiers) => {};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getTableReadingQuestion = () => {
+    const caseAsked = randint(0, 9);
+    const totalA = randint(20, 30);
+    const totalB = randint(20, 30, [totalA]);
+    const case0 = randint(3, totalA - 5);
+    const case1 = randint(3, totalB - 5, [case0]);
+    const case3 = totalA - case0;
+    const case4 = totalB - case1;
+    const values = [
+        [case0, case1, case0 + case1],
+        [case3, case4, case3 + case4],
+        [totalA, totalB, totalA + totalB],
+    ];
+    const identifiers = {
+        caseAsked,
+        values,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        // hint: getHint(identifiers),
+        // correction: getCorrection(identifiers),
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: true,
+            },
+        },
+    };
+    return question;
+};
+export const tableReading = {
+    id: "tableReading",
+    connector: "=",
+    label: "Lire un tableau à double entrée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getTableReadingQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+};

package/lib/exercises/math/derivation/applications/findYearForDecreasingPopulation.d.ts

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

package/lib/exercises/math/derivation/applications/findYearForDecreasingPopulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findYearForDecreasingPopulation.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/applications/findYearForDecreasingPopulation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAarC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,OAAO,CAAC;CACpB,CAAC;AA4IF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,CAqBjE,CAAC"}

package/lib/exercises/math/derivation/applications/findYearForDecreasingPopulation.js

@@ -0,0 +1,145 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.js";
+import { Affine } from "../../../../math/polynomials/affine.js";
+import { TrinomConstructor } from "../../../../math/polynomials/trinom.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { firstDegreeInequationResolutionTex } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer, coeffs, isAskingX }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    propWhile(propositions, n, () => {
+        if (isAskingX)
+            tryToAddWrongProp(propositions, (2013 + randint(1, 20)).frenchify());
+        else
+            tryToAddWrongProp(propositions, trinom
+                .toTree()
+                .toDetailedEvaluation({
+                x: randint(1, 20).toTree(),
+            })
+                .simplify()
+                .toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { coeffs, isAskingX } = identifiers;
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    const a = round(2 * coeffs[2], 4);
+    const b = coeffs[1];
+    const root = frac(-b, a).simplify();
+    if (isAskingX) {
+        return round(2013 + root.evaluate(), 4).frenchify();
+    }
+    return trinom
+        .toTree()
+        .toDetailedEvaluation({
+        x: root,
+    })
+        .simplify()
+        .toTex();
+};
+const getInstruction = (identifiers) => {
+    const { coeffs, isAskingX } = identifiers;
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    return `On estime que la population d'une ville, exprimée en milliers d'habitants, peut être modélisée par la fonction $f$ définie sur $[0; +\\infty[$ par :
+  
+$$
+f(x) = ${trinom.toTree().toTex()}
+$$
+
+où $x$ est la durée, en année, écoulée depuis $2013$.
+
+${isAskingX
+        ? `En quelle année la population de la ville est-elle maximale ?`
+        : `Quelle est la population maximale de la ville ?`}`;
+};
+const getHint = () => {
+    return `Calcule la dérivée $f'$ de $f$, puis étudie son signe. Le maximum de $f$ est atteint pour la valeur de $x$ telle que $f'(x) = 0$ et telle que $f'$ change de signe en $x$.`;
+};
+const getCorrection = (identifiers) => {
+    const { coeffs } = identifiers;
+    const trinom = TrinomConstructor.fromCoeffs(coeffs);
+    const a = round(2 * coeffs[2], 4);
+    const b = coeffs[1];
+    const affine = new Affine(a, b);
+    const root = frac(-b, a).simplify();
+    const froot = trinom.toTree().toDetailedEvaluation({ x: root }).simplify();
+    return `On calcule $f'(x)$ : 
+  
+$$
+f'(x) = ${trinom.derivate().toTree().toTex()}
+$$
+
+On étudie ensuite le signe de $f'(x)$ :
+
+$$
+${firstDegreeInequationResolutionTex(affine, "\\ge", (0).toTree())}
+$$
+
+On en déduit donc que $f$ atteint son maximum pour $x = ${root.toTex()}$, et on a alors : 
+
+$$
+f(${root.toTex()}) = ${froot.toTex()}
+$$
+
+La population de la ville est donc maximale à l'année $${round(2013 + root.evaluate(), 4)}$, et elle est alors de $${froot.toTex()}$ milliers d'habitants.`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindYearForDecreasingPopulationQuestion = () => {
+    const alpha = randint(1, 20);
+    const beta = randfloat(10, 100, 2);
+    const a = randfloat(-0.9, -0.1, 2);
+    const b = round(-2 * a * alpha, 4);
+    const c = round((beta + a * alpha) ^ 2, 4);
+    const identifiers = {
+        isAskingX: coinFlip(),
+        coeffs: [c, b, a],
+    };
+    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 findYearForDecreasingPopulation = {
+    id: "findYearForDecreasingPopulation",
+    connector: "=",
+    label: "Déterminer le maximum d'une population (dérivation)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindYearForDecreasingPopulationQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/derivation/applications/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./maxBenefice.js";
 export * from "./minimalCost.js";
+export * from "./findYearForDecreasingPopulation.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/derivation/applications/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/applications/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/applications/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AACjC,cAAc,sCAAsC,CAAC"}

package/lib/exercises/math/derivation/applications/index.js

@@ -1,2 +1,3 @@
 export * from "./maxBenefice.js";
 export * from "./minimalCost.js";
+export * from "./findYearForDecreasingPopulation.js";

package/lib/exercises/math/derivation/tangent/tangentEquationFromFunctionExpression.js

@@ -254,7 +254,7 @@ const getPropositions = (n, { answer, ...identifiers }) => {
     ]);
 };
 const getKeys = () => {
-    return [];
+    return ["x", "y", "equal"];
 };
 const isAnswerValid = (ans, { answer }) => {
     try {

package/lib/exercises/math/derivation/variations/signVarTableFromFunctionExpression.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"signVarTableFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/signVarTableFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgM7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAkXF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyCF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CACvD,WAAW,EACX,OAAO,CAuBR,CAAC"}
+{"version":3,"file":"signVarTableFromFunctionExpression.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/derivation/variations/signVarTableFromFunctionExpression.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AAarC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAgM7C,KAAK,WAAW,GAAG;IACjB,QAAQ,EAAE,eAAe,CAAC;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqXF,KAAK,OAAO,GAAG;IACb,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyCF,eAAO,MAAM,kCAAkC,EAAE,QAAQ,CACvD,WAAW,EACX,OAAO,CAuBR,CAAC"}

package/lib/exercises/math/derivation/variations/signVarTableFromFunctionExpression.js

@@ -266,7 +266,10 @@ const getAnswerTable = (identifiers) => {
         [
             "$f'(x)$",
             "\\ ",
-            ...arrSignOutsideRoots.flatMap((sign) => [sign > 0 ? "+" : "-", "\\ "]),
+            ...arrSignOutsideRoots.flatMap((sign, i, arr) => [
+                sign > 0 ? "+" : "-",
+                i === arr.length - 1 ? "\\ " : "0",
+            ]),
         ],
         [
             "$\\ $",

package/lib/exercises/math/functions/affines/affineCompareTwoImagesFromVariations.d.ts

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    nodeIdsAbscissa: NodeIdentifiers[];
+    nodeIdsSlope: NodeIdentifiers;
+    typeAbscissa: string;
+};
+type Options = {
+    typeAbscissa: string;
+};
+export declare const affineCompareTwoImagesFromVariations: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=affineCompareTwoImagesFromVariations.d.ts.map

package/lib/exercises/math/functions/affines/affineCompareTwoImagesFromVariations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"affineCompareTwoImagesFromVariations.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/affines/affineCompareTwoImagesFromVariations.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAKrC,OAAO,EAEL,eAAe,EAChB,MAAM,qCAAqC,CAAC;AAiB7C,KAAK,WAAW,GAAG;IACjB,eAAe,EAAE,eAAe,EAAE,CAAC;IACnC,YAAY,EAAE,eAAe,CAAC;IAC9B,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAwNF,KAAK,OAAO,GAAG;IACb,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AAiBF,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,WAAW,EACX,OAAO,CAoBR,CAAC"}