math-exercises 2.1.25 → 2.1.26

package/lib/exercises/functions/square/squareImageInterval.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.squareImageInterval = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const closure_1 = require("../../../tree/nodes/sets/closure");
+const intervalNode_1 = require("../../../tree/nodes/sets/intervalNode");
+// a < x < b avec a > 0  ==> a^2 < x^2 < b^2
+// a < x < b avec b < 0  ==> b^2 < x^2 < a^2
+// a < x < b avec a<0 et b>0 ==> 0 < x^2 < max(|a|,|b|)^2
+const getAnswer = (a, b, type, closure) => {
+    switch (type) {
+        case 1:
+            return new intervalNode_1.IntervalNode((a ** 2).toTree(), (b ** 2).toTree(), closure);
+        case 2:
+            return new intervalNode_1.IntervalNode((b ** 2).toTree(), (a ** 2).toTree(), closure_1.Closure.switch(closure));
+        case 3:
+        default:
+            const max = Math.max(Math.abs(a), Math.abs(b));
+            const maxClosure = Math.abs(a) === Math.abs(b)
+                ? closure !== closure_1.ClosureType.OO
+                    ? "F"
+                    : "O"
+                : max === Math.abs(a)
+                    ? closure === closure_1.ClosureType.FF || closure === closure_1.ClosureType.FO
+                        ? "F"
+                        : "O"
+                    : closure === closure_1.ClosureType.FF || closure === closure_1.ClosureType.OF
+                        ? "F"
+                        : "O";
+            const ansClosure = maxClosure === "F" ? closure_1.ClosureType.FF : closure_1.ClosureType.FO;
+            return new intervalNode_1.IntervalNode((0).toTree(), (Math.max(Math.abs(a), Math.abs(b)) ** 2).toTree(), ansClosure);
+    }
+};
+const getSquareImageIntervalQuestion = () => {
+    let a;
+    let b;
+    let instruction = "";
+    let closure;
+    const type = (0, randint_1.randint)(1, 4);
+    switch (type) {
+        case 1:
+            a = (0, randint_1.randint)(0, 8);
+            b = (0, randint_1.randint)(a + 1, a + 5);
+            closure = closure_1.Closure.random();
+            instruction = new intervalNode_1.IntervalNode(a.toTree(), b.toTree(), closure)
+                .toInequality()
+                .toTex();
+            break;
+        case 2:
+            b = (0, randint_1.randint)(-5, 0);
+            a = (0, randint_1.randint)(b - 5, b);
+            closure = closure_1.Closure.random();
+            instruction = new intervalNode_1.IntervalNode(a.toTree(), b.toTree(), closure)
+                .toInequality()
+                .toTex();
+            break;
+        case 3:
+        default:
+            a = (0, randint_1.randint)(-9, 0);
+            b = (0, randint_1.randint)(1, 10);
+            closure = closure_1.Closure.random();
+            instruction = new intervalNode_1.IntervalNode(a.toTree(), b.toTree(), closure)
+                .toInequality()
+                .toTex();
+            break;
+    }
+    const answer = getAnswer(a, b, type, closure).toTex();
+    const question = {
+        answer,
+        instruction: `Soit $${instruction}$. A quel intervalle appartient $x^2$ ?`,
+        keys: ["lbracket", "semicolon", "rbracket"],
+        answerFormat: "tex",
+        identifiers: { a, b, closure, type },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, type, closure }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, new intervalNode_1.IntervalNode(a.toTree(), b.toTree(), closure).toTex());
+    if (type === 3) {
+        const min = Math.min(Math.abs(a), Math.abs(b)) ** 2;
+        const max = Math.max(Math.abs(a), Math.abs(b)) ** 2;
+        (0, exercise_1.tryToAddWrongProp)(propositions, new intervalNode_1.IntervalNode(min.toTree(), max.toTree(), closure).toTex());
+    }
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer(a, b, type, closure_1.Closure.random()).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, b, closure, type }) => {
+    const interval = getAnswer(a, b, type, closure);
+    const texs = interval.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.squareImageInterval = {
+    id: "squareImageInterval",
+    label: "Passer une inégalité au carré",
+    levels: ["2nde"],
+    isSingleStep: true,
+    sections: ["Fonctions de référence", "Ensembles et intervalles"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSquareImageIntervalQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/alphaBetaFromDevForm.d.ts

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

package/lib/exercises/functions/trinoms/alphaBetaFromDevForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alphaBetaFromDevForm.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/alphaBetaFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAqCF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAa1D,CAAC"}

package/lib/exercises/functions/trinoms/alphaBetaFromDevForm.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alphaBetaFromDevForm = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getAlphaBetaFromDevFormQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.randomCanonical();
+    const param = (0, coinFlip_1.coinFlip)() ? "\\alpha" : "\\beta";
+    const alphaTex = trinom.getAlphaNode().toTex();
+    const betaTex = trinom.getBetaNode().toTex();
+    const answer = param === "\\alpha" ? alphaTex : betaTex;
+    const question = {
+        answer: answer,
+        keys: ["x", "alpha", "beta"],
+        instruction: `Soit $f$ la fonction définie par $f(x) = ${trinom
+            .toTree()
+            .toTex()}$. Que vaut $${param}$ ?`,
+        answerFormat: "tex",
+        startStatement: param,
+        identifiers: { coeffs: trinom.coefficients, param },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 11).toString());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.alphaBetaFromDevForm = {
+    id: "alphaBetaFromDevForm",
+    connector: "=",
+    label: "Déterminer $\\alpha$ ou $\\beta$ à partir de la forme développée",
+    levels: ["1reSpé"],
+    isSingleStep: false,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAlphaBetaFromDevFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/alphaBetaInCanonicalForm.d.ts

@@ -0,0 +1,10 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    param: string;
+    a: number;
+    alpha: number;
+    beta: number;
+};
+export declare const alphaBetaInCanonicalForm: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=alphaBetaInCanonicalForm.d.ts.map

package/lib/exercises/functions/trinoms/alphaBetaInCanonicalForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alphaBetaInCanonicalForm.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/alphaBetaInCanonicalForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AASlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;CACd,CAAC;AA4DF,eAAO,MAAM,wBAAwB,EAAE,YAAY,CAAC,WAAW,CAa9D,CAAC"}

package/lib/exercises/functions/trinoms/alphaBetaInCanonicalForm.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.alphaBetaInCanonicalForm = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const oppositeNode_1 = require("../../../tree/nodes/functions/oppositeNode");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getAlphaBetaInCanonicalFormQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.randomCanonical();
+    const param = (0, coinFlip_1.coinFlip)() ? "\\alpha" : "\\beta";
+    const alpha = trinom.getAlpha();
+    const beta = trinom.getBeta();
+    const alphaTex = trinom.getAlphaNode().toTex();
+    const betaTex = trinom.getBetaNode().toTex();
+    const answer = param === "\\alpha" ? alphaTex : betaTex;
+    const question = {
+        instruction: `Soit $f$ la fonction définie par $f(x) = ${trinom
+            .getCanonicalForm()
+            .toTex()}$. Que vaut $${param}$ ?`,
+        answer: answer,
+        keys: ["x", "alpha", "beta"],
+        answerFormat: "tex",
+        startStatement: param,
+        identifiers: { param, a: trinom.a, alpha, beta },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, param, alpha, beta, a }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const alphaNode = new numberNode_1.NumberNode(alpha);
+    const alphaTex = alphaNode.toTex();
+    const betaTex = new numberNode_1.NumberNode(beta).toTex();
+    (0, exercise_1.tryToAddWrongProp)(propositions, param === "\\alpha" ? betaTex : alphaTex);
+    (0, exercise_1.tryToAddWrongProp)(propositions, new oppositeNode_1.OppositeNode(new numberNode_1.NumberNode(alpha)).toTex());
+    (0, exercise_1.tryToAddWrongProp)(propositions, a.toString());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (0, randint_1.randint)(-10, 11) + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, alpha, beta, param }) => {
+    if (param === "\\alpha") {
+        return ans === alpha.toString();
+    }
+    else {
+        return ans === beta.toString();
+    }
+};
+exports.alphaBetaInCanonicalForm = {
+    id: "alphaInCanonicalForm",
+    connector: "=",
+    label: "Identifier $\\alpha$ et $\\beta$ dans la forme canonique",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getAlphaBetaInCanonicalFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/canonicalFromDevForm.d.ts

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

package/lib/exercises/functions/trinoms/canonicalFromDevForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalFromDevForm.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/canonicalFromDevForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAyCF,eAAO,MAAM,oBAAoB,EAAE,YAAY,CAAC,WAAW,CAa1D,CAAC"}

package/lib/exercises/functions/trinoms/canonicalFromDevForm.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.canonicalFromDevForm = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const shuffle_1 = require("../../../utils/shuffle");
+const getCanonicalFromDevFormQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.randomCanonical();
+    const answer = trinom.getCanonicalForm().toTex();
+    const question = {
+        answer,
+        keys: ["x", "equal", "alpha", "beta"],
+        instruction: `Déterminer la forme canonique de la fonction $f$ définie par $f(x) = ${trinom
+            .toTree()
+            .toTex()}$`,
+        answerFormat: "tex",
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, trinom_1.TrinomConstructor.randomCanonical({ from: [a, -a] })
+            .getCanonicalForm()
+            .toTex());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const trinom = new trinom_1.Trinom(a, b, c);
+    const node = trinom.getCanonicalForm();
+    const texs = node.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.canonicalFromDevForm = {
+    id: "canonicalFromDevForm",
+    connector: "\\iff",
+    label: "Déterminer la forme canonique à partir de la forme développée",
+    levels: ["1reSpé"],
+    isSingleStep: false,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getCanonicalFromDevFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/deltaTrinom.d.ts

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

package/lib/exercises/functions/trinoms/deltaTrinom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deltaTrinom.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/deltaTrinom.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAwCF,eAAO,MAAM,WAAW,EAAE,YAAY,CAAC,WAAW,CAajD,CAAC"}

package/lib/exercises/functions/trinoms/deltaTrinom.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deltaTrinom = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const shuffle_1 = require("../../../utils/shuffle");
+const getDeltaTrinomQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.random();
+    const answer = trinom.getDelta() + "";
+    const question = {
+        answer: answer,
+        instruction: `Soit $f(x) = ${trinom
+            .toTree()
+            .toTex()}$. Calculer le discriminant $\\Delta$.`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const bMinus4ac = b - 4 * a * c;
+    (0, exercise_1.tryToAddWrongProp)(propositions, bMinus4ac + "");
+    const bSquarePlus4ac = b ** 2 + a * c;
+    (0, exercise_1.tryToAddWrongProp)(propositions, bSquarePlus4ac + "");
+    while (propositions.length < n) {
+        const wrongAnswer = (0, randint_1.randint)(-100, 100) + "";
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const delta = b ** 2 - 4 * a * c;
+    return ans === delta.toString();
+};
+exports.deltaTrinom = {
+    id: "deltaTrinom",
+    connector: "=",
+    getPropositions,
+    label: "Calculer le discriminant d'un trinôme",
+    levels: ["1reSpé", "TermSpé", "MathComp"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getDeltaTrinomQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/extremumFromCanonicalForm.d.ts

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

package/lib/exercises/functions/trinoms/extremumFromCanonicalForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extremumFromCanonicalForm.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/extremumFromCanonicalForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiDF,eAAO,MAAM,yBAAyB,EAAE,YAAY,CAAC,WAAW,CAc/D,CAAC"}

package/lib/exercises/functions/trinoms/extremumFromCanonicalForm.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extremumFromCanonicalForm = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const randint_1 = require("../../../math/utils/random/randint");
+const pointNode_1 = require("../../../tree/nodes/geometry/pointNode");
+const shuffle_1 = require("../../../utils/shuffle");
+const getExtremumFromCanonicalFormQuestion = () => {
+    const trinom = trinom_1.TrinomConstructor.randomCanonical();
+    const answer = trinom.getSommet().toTexWithCoords();
+    const question = {
+        answer: answer,
+        instruction: `Soit $f$ la fonction définie par $${trinom
+            .getCanonicalForm()
+            .toTex()}$. Quelles sont les coordonnées du sommet $S$ de la parabole représentative de $f$ ?`,
+        keys: ["S", "semicolon"],
+        answerFormat: "tex",
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, b, c }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const trinom = new trinom_1.Trinom(a, b, c);
+    const alpha = trinom.getAlpha();
+    const beta = trinom.getBeta();
+    (0, exercise_1.tryToAddWrongProp)(propositions, `S\\left(${beta};${alpha}\\right)`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `S\\left(${-alpha};${beta}\\right)`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `S\\left(${alpha};${-beta}\\right)`);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, `S\\left(${(0, randint_1.randint)(-10, 11)};${(0, randint_1.randint)(-10, 11)}\\right)`);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { a, b, c }) => {
+    const trinom = new trinom_1.Trinom(a, b, c);
+    const sommet = trinom.getSommet();
+    const answer = new pointNode_1.PointNode(sommet);
+    const texs = answer.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.extremumFromCanonicalForm = {
+    id: "extremumFromCanonicalForm",
+    connector: "=",
+    label: "Déterminer les coordonnées du sommet d'une parabole à partir de la forme canonique",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getExtremumFromCanonicalFormQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/extremumTypeFromAlgebricForm.d.ts

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

package/lib/exercises/functions/trinoms/extremumTypeFromAlgebricForm.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extremumTypeFromAlgebricForm.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/extremumTypeFromAlgebricForm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAQb,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAiCF,eAAO,MAAM,4BAA4B,EAAE,YAAY,CAAC,WAAW,CAalE,CAAC"}

package/lib/exercises/functions/trinoms/extremumTypeFromAlgebricForm.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extremumTypeFromAlgebricForm = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const trinom_1 = require("../../../math/polynomials/trinom");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const shuffle_1 = require("../../../utils/shuffle");
+const getExtremumTypeFromAlgebricFormQuestion = () => {
+    const isDevForm = (0, coinFlip_1.coinFlip)();
+    const trinom = isDevForm
+        ? trinom_1.TrinomConstructor.random()
+        : trinom_1.TrinomConstructor.randomCanonical();
+    const answer = trinom.a > 0 ? "Un minimum" : "Un maximum";
+    const question = {
+        answer: answer,
+        instruction: `La fonction $f$ définie par $f(x) = ${isDevForm ? trinom.toTree().toTex() : trinom.getCanonicalForm().toTex()}$ admet-elle un maximum ou un minimum ?`,
+        answerFormat: "raw",
+        keys: [],
+        identifiers: { a: trinom.a, b: trinom.b, c: trinom.c },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, a < 0 ? "Un minimum" : "Un maximum", "raw");
+    (0, exercise_1.addWrongProp)(propositions, "Ni l'un ni l'autre", "raw");
+    (0, exercise_1.addWrongProp)(propositions, "On ne peut pas savoir", "raw");
+    return (0, shuffle_1.shuffle)(propositions);
+};
+exports.extremumTypeFromAlgebricForm = {
+    id: "extremumTypeFromAlgebricForm",
+    label: "Déterminer le type d'extremum d'une fonction du second degré via sa forme algébrique",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getExtremumTypeFromAlgebricFormQuestion, nb),
+    answerType: "QCM",
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+};

package/lib/exercises/functions/trinoms/factorizedFormFromRoots.d.ts

@@ -0,0 +1,8 @@
+import { MathExercise } from "../../../exercises/exercise";
+type Identifiers = {
+    roots: number[];
+    a: number;
+};
+export declare const factorizedFormFromRoots: MathExercise<Identifiers>;
+export {};
+//# sourceMappingURL=factorizedFormFromRoots.d.ts.map

package/lib/exercises/functions/trinoms/factorizedFormFromRoots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"factorizedFormFromRoots.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/factorizedFormFromRoots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AA8EF,eAAO,MAAM,uBAAuB,EAAE,YAAY,CAAC,WAAW,CAa7D,CAAC"}

package/lib/exercises/functions/trinoms/factorizedFormFromRoots.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factorizedFormFromRoots = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../math/utils/random/randint");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const powerNode_1 = require("../../../tree/nodes/operators/powerNode");
+const substractNode_1 = require("../../../tree/nodes/operators/substractNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const probaFlip_1 = require("../../../utils/probaFlip");
+const getAnswer = (roots, a) => {
+    const isSingleRoot = roots.length === 1;
+    return isSingleRoot
+        ? new multiplyNode_1.MultiplyNode(a.toTree(), new powerNode_1.SquareNode(new substractNode_1.SubstractNode(new variableNode_1.VariableNode("x"), roots[0].toTree()))).simplify({ keepPowers: true })
+        : new multiplyNode_1.MultiplyNode(new multiplyNode_1.MultiplyNode(a.toTree(), new substractNode_1.SubstractNode(new variableNode_1.VariableNode("x"), roots[0].toTree())), new substractNode_1.SubstractNode(new variableNode_1.VariableNode("x"), roots[1].toTree())).simplify();
+};
+const getFactorizedFormFromRootsQuestion = () => {
+    const a = (0, randint_1.randint)(-10, 10, [0]);
+    const firstRoot = (0, randint_1.randint)(-10, 10);
+    const secondRoot = (0, randint_1.randint)(-10, 10, [firstRoot]);
+    const isSingleRoot = (0, probaFlip_1.probaFlip)(0.3);
+    const roots = isSingleRoot
+        ? [firstRoot]
+        : [firstRoot, secondRoot].sort((a, b) => a - b);
+    const answer = getAnswer(roots, a);
+    const answerTex = answer.toTex();
+    const question = {
+        answer: answerTex,
+        instruction: `Soit $f(x) = ax^2 + bx + c$ un polynôme du second degré avec $a = ${a}$ et qui a ${roots.length === 1
+            ? `une racine : $${roots[0]}$`
+            : `deux racines : $${roots[0]}$ et $${roots[1]}$`}. Déterminer la forme factorisée de $f$.`,
+        keys: ["x"],
+        answerFormat: "tex",
+        identifiers: { a, roots },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, a, roots }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer(roots.map((r) => -r), a).toTex());
+    while (propositions.length < n) {
+        const x1 = (0, randint_1.randint)(-10, 10);
+        const x2 = (0, randint_1.randint)(-10, 10, [x1]);
+        (0, exercise_1.tryToAddWrongProp)(propositions, getAnswer([x1, x2].sort((a, b) => a - b), (0, randint_1.randint)(-10, 10, [0])).toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, a, roots }) => {
+    const answerNode = getAnswer(roots, a);
+    const texs = answerNode.toAllValidTexs();
+    return texs.includes(ans);
+};
+exports.factorizedFormFromRoots = {
+    id: "factorizedFormFromRoots",
+    connector: "=",
+    label: "Déterminer la forme factorisée en connaissant les racines",
+    levels: ["1rePro", "1reSpé"],
+    isSingleStep: true,
+    sections: ["Second degré"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFactorizedFormFromRootsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/functions/trinoms/index.d.ts

@@ -0,0 +1,17 @@
+export * from "./alphaBetaFromDevForm";
+export * from "./alphaBetaInCanonicalForm";
+export * from "./canonicalFromDevForm";
+export * from "./deltaTrinom";
+export * from "./extremumFromCanonicalForm";
+export * from "./extremumTypeFromAlgebricForm";
+export * from "./niceRootsFromDevForm";
+export * from "./rootsFromDevForm";
+export * from "./rootsFromFactorizedForm";
+export * from "./variationsFromAlgebricForm";
+export * from "./secondDegreeInequation";
+export * from "./rootsReading";
+export * from "./factorizedFormFromRoots";
+export * from "./summitReading";
+export * from "./summitAbscissFromRoots";
+export * from "./summitAbscissFromDevForm";
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/functions/trinoms/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/functions/trinoms/index.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC;AACvC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,wBAAwB,CAAC;AACvC,cAAc,eAAe,CAAC;AAC9B,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AACnC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,0BAA0B,CAAC;AACzC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,2BAA2B,CAAC;AAC1C,cAAc,iBAAiB,CAAC;AAChC,cAAc,0BAA0B,CAAC;AACzC,cAAc,4BAA4B,CAAC"}