math-exercises 3.0.93 → 3.0.95

package/lib/exercises/math/calcul/arithmetics/index.d.ts

@@ -8,15 +8,6 @@ export * from "./divisibiltyCriteria.js";
 export * from "./ppcmCalcul.js";
 export * from "./getParityBetweenTwoNumbers.js";
 export * from "./primeNumberIdentification.js";
-export * from "./imageOfSquareFunction.js";
-export * from "./isNumberDecimal.js";
-export * from "./isPointOnCubicFunction.js";
-export * from "./isPointOnReciprocalFunction.js";
-export * from "./isPointOnFunction.js";
 export * from "./whichMultipleAmI.js";
 export * from "./isMultipleOrDivisor.js";
-export * from "./compareInverseValues.js";
-export * from "./compareSquaredValues.js";
-export * from "./decimalBoundingOnLine.js";
-export * from "./findZeroesProductQuotient.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/arithmetics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sBAAsB,CAAC;AACrC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,kCAAkC,CAAC;AACjD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,2BAA2B,CAAC;AAC1C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/arithmetics/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,mBAAmB,CAAC;AAClC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAClC,cAAc,yBAAyB,CAAC;AACxC,cAAc,0BAA0B,CAAC;AACzC,cAAc,iBAAiB,CAAC;AAChC,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC"}

package/lib/exercises/math/calcul/arithmetics/index.js

@@ -8,14 +8,5 @@ export * from "./divisibiltyCriteria.js";
 export * from "./ppcmCalcul.js";
 export * from "./getParityBetweenTwoNumbers.js";
 export * from "./primeNumberIdentification.js";
-export * from "./imageOfSquareFunction.js";
-export * from "./isNumberDecimal.js";
-export * from "./isPointOnCubicFunction.js";
-export * from "./isPointOnReciprocalFunction.js";
-export * from "./isPointOnFunction.js";
 export * from "./whichMultipleAmI.js";
 export * from "./isMultipleOrDivisor.js";
-export * from "./compareInverseValues.js";
-export * from "./compareSquaredValues.js";
-export * from "./decimalBoundingOnLine.js";
-export * from "./findZeroesProductQuotient.js";

package/lib/exercises/math/calcul/decimals/decimalBoundingOnLine.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { PointIdentifiers } from "../../../../math/geometry/point.js";
+type Identifiers = {
+    point: PointIdentifiers;
+    bounding: number;
+};
+export declare const decimalBoundingOnLine: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=decimalBoundingOnLine.d.ts.map

package/lib/exercises/math/calcul/decimals/decimalBoundingOnLine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decimalBoundingOnLine.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/decimals/decimalBoundingOnLine.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAGL,gBAAgB,EACjB,MAAM,8BAA8B,CAAC;AAUtC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,gBAAgB,CAAC;IACxB,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAkMF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAmBvD,CAAC"}

package/lib/exercises/math/calcul/decimals/decimalBoundingOnLine.js

@@ -0,0 +1,171 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Point, PointConstructor, } from "../../../../math/geometry/point.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../math/utils/round.js";
+import { InequationNode } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { VariableNode } from "../../../../tree/nodes/variables/variableNode.js";
+import { doWhile } from "../../../../utils/doWhile.js";
+const getPropositions = (n, context) => {
+    const { answer, point, bounding } = context;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const pointObj = PointConstructor.fromIdentifiers(point);
+    const x = round(pointObj.x.evaluate(), 2);
+    const vNode = new VariableNode(pointObj.name.toLocaleLowerCase());
+    const correctLower = round(Math.floor(x / bounding) * bounding, 2);
+    const correctUpper = round(correctLower + bounding, 2);
+    while (propositions.length < n) {
+        let wrongLower = round(correctLower + randfloat(-2, 2, 1), 1);
+        let wrongUpper = round(correctUpper + randfloat(-2, 2, 1), 1);
+        const node = new InequationNode([wrongLower.toTree(), vNode, wrongUpper.toTree()], ["<", "<"]);
+        tryToAddWrongProp(propositions, node.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = ({ point, bounding }) => {
+    const pointObj = PointConstructor.fromIdentifiers(point);
+    const x = round(pointObj.x.evaluate(), 2);
+    const lowerBound = round(Math.floor(x / bounding) * bounding, 2);
+    const upperBound = round(lowerBound + bounding, 2);
+    const vNode = new VariableNode(pointObj.name.toLocaleLowerCase());
+    const inequation = new InequationNode([lowerBound.toTree(), vNode, upperBound.toTree()], ["<", "<"]);
+    return `${inequation.toTex()}`;
+};
+const getInstruction = ({ point, bounding }) => {
+    const pointObj = PointConstructor.fromIdentifiers(point);
+    return `Déterminer un encadrement décimal d'amplitude $${bounding.frenchify()}$ du nombre réel $${pointObj.name.toLocaleLowerCase()}$.
+  
+Donner une réponse sous la forme : $x < a < y$.`;
+};
+const getHint = ({ point }) => {
+    return `Pour encadrer le nombre, repère les deux nombres décimaux consécutifs de part et d'autre du nombre $${point.name.toLocaleLowerCase()}$. Cela donne un encadrement sous la forme $x<a<y$.
+  
+Par exemple, un encadrement à $10^{-1}$ de $14,25$ est : 
+
+$$
+14,2 < 14,25 < 14,3
+$$`;
+};
+const getCorrection = ({ point, bounding }) => {
+    const pointObj = PointConstructor.fromIdentifiers(point);
+    const x = round(pointObj.x.evaluate(), 2);
+    const firstDiv = round(x / bounding, 2);
+    const quotient = Math.floor(x / bounding);
+    const lowerBound = round(quotient * bounding, 2);
+    const upperBound = round(lowerBound + bounding, 2);
+    const inequation = getAnswer({ point, bounding });
+    const name = pointObj.name.toLocaleLowerCase();
+    return `On lit sur la droite que $${name} > ${lowerBound.frenchify()}$ et $${name} < ${upperBound.frenchify()}$. 
+  
+Ainsi, un encadrement à $${bounding.frenchify()}$ de $${name}$ est : 
+
+$$
+${inequation}
+$$`;
+};
+const getGGBOptions = ({ point, bounding }) => {
+    const A = PointConstructor.fromIdentifiers(point);
+    const commands = [
+        ...A.toGGBCommand({
+            style: 3,
+            size: 4,
+            label: "a",
+        }),
+    ];
+    const ggb = new GeogebraConstructor({
+        commands,
+        forbidShiftDragZoom: true,
+        // gridDistance: [0.5, 1],
+        xAxis: {
+            hideNumbers: false,
+            steps: 0.1,
+        },
+        yAxis: {
+            hidden: true,
+        },
+        maxHeight: 100,
+        fontSize: 20,
+    });
+    return ggb.getOptions({
+        coords: [A.x.evaluate() - 2.2, A.x.evaluate() + 2.2, -0.2, 0.2],
+    });
+};
+const getKeys = (identifiers) => {
+    return ["inf", "a"];
+};
+function parseInequationFromUser(input) {
+    const clean = input.replace(/\\text\{([A-Za-z])\}/g, "$1").replace(/\s/g, "");
+    const match = clean.match(/^([-\d,]+)(<|\\leq)([A-Za-z])(<|\\leq)([-\d,]+)$/);
+    if (!match)
+        return null;
+    const [, lowerStr, sym1, variableRaw, sym2, upperStr] = match;
+    const symbolMap = {
+        "<": "<",
+        "\\le": "\\le",
+    };
+    const variable = variableRaw.toUpperCase();
+    return {
+        lower: lowerStr.unfrenchify(),
+        upper: upperStr.unfrenchify(),
+        variable,
+        symbols: [symbolMap[sym1], symbolMap[sym2]],
+    };
+}
+function constructInequationNodeFromParsed(parsed) {
+    const lowerNode = parsed.lower.toTree();
+    const upperNode = parsed.upper.toTree();
+    const variableNode = new VariableNode(parsed.variable);
+    return new InequationNode([lowerNode, variableNode, upperNode], parsed.symbols);
+}
+const isAnswerValid = (ans, { point, bounding, answer }) => {
+    // const parsed = parseInequationFromUser(ans);
+    // if (!parsed) return false;
+    // const userNode = constructInequationNodeFromParsed(parsed);
+    // return userNode.toTex() === answer;
+    return ans === answer;
+};
+const getDecimalBoundingOnLineQuestion = () => {
+    const x = doWhile(() => randfloat(-5, 5, 7), (a) => Math.abs(round(a, 1) - a) < 0.025);
+    const point = new Point("A", x, 0);
+    // const bounding = randfloat(0.1, 0.4, 1);
+    const bounding = 0.1;
+    const pointIdentifier = point.toIdentifiers();
+    const identifiers = {
+        point: pointIdentifier,
+        bounding,
+    };
+    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),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const decimalBoundingOnLine = {
+    id: "decimalBoundingOnLine",
+    label: "Donner un encadrement d'un nombre placé sur une droite graduée",
+    isSingleStep: true,
+    generator: (nb) => getDistinctQuestions(() => getDecimalBoundingOnLineQuestion(), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/calcul/decimals/index.d.ts

@@ -1,3 +1,4 @@
 export * from "./multiplyDecimalByTens.js";
 export * from "./multiplyDecimalByNegativeTens.js";
+export * from "./decimalBoundingOnLine.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/calcul/decimals/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/decimals/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oCAAoC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/decimals/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oCAAoC,CAAC;AACnD,cAAc,4BAA4B,CAAC"}

package/lib/exercises/math/calcul/decimals/index.js

@@ -1,2 +1,3 @@
 export * from "./multiplyDecimalByTens.js";
 export * from "./multiplyDecimalByNegativeTens.js";
+export * from "./decimalBoundingOnLine.js";

package/lib/exercises/math/calcul/fractions/index.d.ts

@@ -14,7 +14,6 @@ export * from "./fractionsSumsPrimeDenominators.js";
 export * from "./fractionsOperations.js";
 export * from "./fractionSquare.js";
 export * from "./fractionsSubstraction.js";
-export * from "./powerNotation.js";
 export * from "./fractionForbiddenValue.js";
 export * from "./simplifyToFraction.js";
 export * from "./evalFractionExpression.js";

package/lib/exercises/math/calcul/fractions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,oBAAoB,CAAC;AACnC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/calcul/fractions/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,uBAAuB,CAAC;AACtC,cAAc,mBAAmB,CAAC;AAClC,cAAc,uBAAuB,CAAC;AACtC,cAAc,6CAA6C,CAAC;AAC5D,cAAc,gCAAgC,CAAC;AAC/C,cAAc,oCAAoC,CAAC;AACnD,cAAc,yCAAyC,CAAC;AACxD,cAAc,qCAAqC,CAAC;AACpD,cAAc,0BAA0B,CAAC;AACzC,cAAc,qBAAqB,CAAC;AACpC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mBAAmB,CAAC"}

package/lib/exercises/math/calcul/fractions/index.js

@@ -14,7 +14,6 @@ export * from "./fractionsSumsPrimeDenominators.js";
 export * from "./fractionsOperations.js";
 export * from "./fractionSquare.js";
 export * from "./fractionsSubstraction.js";
-export * from "./powerNotation.js";
 export * from "./fractionForbiddenValue.js";
 export * from "./simplifyToFraction.js";
 export * from "./evalFractionExpression.js";

package/lib/exercises/math/functions/basics/countFunctionZeroes.d.ts

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

package/lib/exercises/math/functions/basics/countFunctionZeroes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"countFunctionZeroes.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/countFunctionZeroes.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AA0BrC,KAAK,WAAW,GAAG;IAEjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyMF,eAAO,MAAM,mBAAmB,EAAE,QAAQ,CAAC,WAAW,CAiBrD,CAAC"}

package/lib/exercises/math/functions/basics/countFunctionZeroes.js

@@ -0,0 +1,197 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { Affine, AffineConstructor } from "../../../../math/polynomials/affine.js";
+import { randint } from "../../../../math/utils/random/randint.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 { parseAlgebraic } from "../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "0");
+    tryToAddWrongProp(propositions, "1");
+    tryToAddWrongProp(propositions, "2");
+    tryToAddWrongProp(propositions, "3");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    if (identifiers.type === 2) {
+        return "2";
+    }
+    if (identifiers.type === 0) {
+        return "0";
+    }
+    return "1";
+};
+const getFunc = (identifiers) => {
+    const { type, a, b, c, d } = identifiers;
+    if (type === 0) {
+        return a.frenchify();
+    }
+    if (type === 1) {
+        return new Affine(a, b).toTree().toTex();
+    }
+    if (type === 2) {
+        return multiply(new Affine(a, b).toTree(), new Affine(c, d).toTree()).toTex();
+    }
+    return frac(new Affine(a, b).toTree(), new Affine(c, d).toTree()).toTex();
+};
+const getInstruction = (identifiers) => {
+    return `Déterminer le nombre de valeurs d'annulation de la fonction suivante : 
+  
+$$
+f(x) = ${getFunc(identifiers)}
+$$`;
+};
+const getHint = (identifiers) => {
+    const { type, a, b, c, d } = identifiers;
+    switch (type) {
+        case 0:
+            break;
+        case 1:
+            break;
+        case 2:
+            break;
+        case 3:
+        default:
+            break;
+    }
+    return `Quelles sont les valeurs de $x$ telles que $f(x) = 0$ ?`;
+};
+const getCorrection = (identifiers) => {
+    const { type, a, b, c, d } = identifiers;
+    switch (type) {
+        case 0:
+            return `La fonction $f$ est constante égale à $${a.frenchify()}$.
+      
+Il n'y a donc aucune valeur de $x$ telle que $f(x) = 0$. 
+      `;
+        case 1:
+            return `La fonction $f$ est une fonction affine. 
+      
+Il y a une unique solution à l'équation $f(x) = 0$ : ici, c'est
+
+$$
+x = ${frac(-b, a).simplify().toTex()}
+$$`;
+        case 2:
+            return `Un produit est nul si et seulement si un des deux facteurs est nul. Ici, chacun des facteurs est une fonction affine. 
+      
+Il y a donc deux solutions à l'équation $f(x) = 0$. D'une part, 
+
+$$
+x = ${frac(-b, a).simplify().toTex()}
+$$
+
+et d'autre part,
+
+$$
+x = ${frac(-d, c).simplify().toTex()}
+$$`;
+            break;
+        case 3:
+        default:
+            return `Un quotient est nul si et seulement si le numérateur est nul et le dénominateur est non nul. Ici, le numérateur et le denominateur sont des fonctions affines.
+      
+Le numérateur est nul pour :
+
+$$
+x = ${frac(-b, a).simplify().toTex()}
+$$
+
+Pour cette valeur de $x$, le dénominateur n'est pas nul, puisqu'il vaut :
+
+$$
+${add(multiply(c, frac(-b, a).simplify()), d).toTex()}=${add(multiply(c, frac(-b, a)), d)
+                .simplify()
+                .toTex()}
+$$
+
+Il y a donc une seule valeur de $x$ telle que $f(x) = 0$. 
+      `;
+            break;
+    }
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const ansNode = parseAlgebraic(ans);
+        const answerNode = parseAlgebraic(answer);
+        return ansNode.simplify().equals(answerNode.simplify());
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getCountFunctionZeroes = () => {
+    const type = randint(0, 4);
+    //a
+    //ax+b
+    //(ax+b)(cx+d)
+    //(ax+b)/(cx+d)
+    let a = 0;
+    let b = 0;
+    let c = 0;
+    let d = 0;
+    switch (type) {
+        case 0:
+            a = randint(-10, 10, [0]);
+            break;
+        case 1:
+            const aff = AffineConstructor.random();
+            a = aff.a;
+            b = aff.b;
+            break;
+        case 2:
+            do {
+                a = randint(-10, 10, [0]);
+                b = randint(-10, 10);
+                c = randint(-10, 10, [0]);
+                d = randint(-10, 10, b === 0 ? [0] : undefined);
+            } while (d * b === a * c);
+            break;
+        case 3:
+        default:
+            do {
+                a = randint(-10, 10, [0]);
+                b = randint(-10, 10);
+                c = randint(-10, 10, [0]);
+                d = randint(-10, 10, b === 0 ? [0] : undefined);
+            } while (d * b === a * c);
+            break;
+    }
+    const identifiers = { a, b, c, d, type };
+    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 countFunctionZeroes = {
+    id: "countFunctionZeroes",
+    label: "Déterminer le nombre de valeurs d'annulation d'une fonction",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCountFunctionZeroes(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/functions/basics/findZeroesProductQuotient.d.ts

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

package/lib/exercises/math/functions/basics/findZeroesProductQuotient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findZeroesProductQuotient.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/functions/basics/findZeroesProductQuotient.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAqCrC,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;CACZ,CAAC;AA+MF,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,WAAW,CAkB3D,CAAC"}