math-exercises 2.2.9 → 2.2.11

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromFirstTerms.js

@@ -33,12 +33,15 @@ const getRecognizeArithmeticFromFirstTermsQuestion = () => {
         .map((el, index) => firstTerm + index * reason);
     const answerIndex = (0, randint_1.randint)(0, 4);
     sequences.splice(answerIndex, 0, rightSequence);
-    const answer = `\\text{Suite ${answerIndex + 1} : }${rightSequence.join("\\ ; \\ ")}`;
+    const names = ["u", "v", "w", "z"];
+    const answer = `\\text{Suite } ${names[answerIndex]} : \\quad ${rightSequence.join("\\ ; \\ ")}`;
     const question = {
         answer,
         instruction: `Parmi les suites suivantes, laquelle semble être arithmétique ?`,
         keys: [],
         answerFormat: "tex",
+        hint: `Une suite est arithmétique lorsque, pour passer d'un terme au suivant, on additionne ou on soustrait toujours par le même nombre.`,
+        correction: `La suite $${names[answerIndex]}$ semble bien être arithmétique, puisque pour passer d'un terme au suivant, on additionne par $${reason}$.`,
         identifiers: { sequences, answerIndex },
     };
     return question;
@@ -46,10 +49,11 @@ const getRecognizeArithmeticFromFirstTermsQuestion = () => {
 const getPropositions = (n, { answer, sequences, answerIndex }) => {
     const propositions = [];
     (0, exercise_1.addValidProp)(propositions, answer);
+    const names = ["u", "v", "w", "z"];
     sequences.forEach((sequence, index) => {
         if (index === answerIndex)
             return;
-        (0, exercise_1.addWrongProp)(propositions, `\\text{Suite ${index + 1} : }${sequence.join("\\ ; \\ ")}`);
+        (0, exercise_1.addWrongProp)(propositions, `\\text{Suite } ${names[index]} : \\quad ${sequence.join("\\ ; \\ ")}`);
     });
     return (0, shuffle_1.shuffle)(propositions);
 };
@@ -69,4 +73,5 @@ exports.recognizeArithmeticFromFirstTerms = {
     isAnswerValid,
     answerType: "QCU",
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/geometric/geometricFindTerm.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometricFindTerm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindTerm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAqCF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAenD,CAAC"}
+{"version":3,"file":"geometricFindTerm.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFindTerm.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAyFF,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,WAAW,CAgBnD,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricFindTerm.js

@@ -4,6 +4,11 @@ exports.geometricFindTerm = 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 alignTex_1 = require("../../../../utils/alignTex");
 const random_1 = require("../../../../utils/random");
 const getGeometricFindTermQuestion = () => {
     const firstRank = (0, random_1.random)([0, 1]);
@@ -16,6 +21,42 @@ const getGeometricFindTermQuestion = () => {
         instruction: `Soit $u$ la suite géométrique de premier terme $u_${firstRank} = ${firstTerm}$ et de raison $q = ${reason}$. Calculer $u_{${askedRank}}$.`,
         keys: [],
         answerFormat: "tex",
+        hint: `Le terme général d'une suite geométrique est : 
+    
+${!firstRank
+            ? `$u_n = u_0 \\times q^n$, où $u_0$`
+            : `$u_n = u_1 \\times q^{n-1}$, où $u_1$`} est le premier terme et $q$ la raison.`,
+        correction: `Le terme général de la suite $u$ est : 
+
+${!firstRank
+            ? (0, alignTex_1.alignTex)([
+                [`u_n`, "=", `u_0 \\times q^n`],
+                [
+                    "",
+                    "=",
+                    new multiplyNode_1.MultiplyNode(firstTerm.toTree(), new powerNode_1.PowerNode(reason.toTree(), new variableNode_1.VariableNode("n"))).toTex(),
+                ],
+            ])
+            : (0, alignTex_1.alignTex)([
+                [`u_n`, "=", `u_1 \\times q^{n-1}`],
+                [
+                    "",
+                    "=",
+                    new multiplyNode_1.MultiplyNode(firstTerm.toTree(), new powerNode_1.PowerNode(reason.toTree(), new substractNode_1.SubstractNode(new variableNode_1.VariableNode("n"), (1).toTree()))).toTex(),
+                ],
+            ])}    
+
+Il suffit alors de remplacer $n$ par $${askedRank}$ dans la formule : 
+
+${(0, alignTex_1.alignTex)([
+            [
+                `u_{${askedRank}}`,
+                "=",
+                `${new multiplyNode_1.MultiplyNode(firstTerm.toTree(), new powerNode_1.PowerNode(reason.toTree(), (askedRank - firstRank).toTree())).toTex()}`,
+            ],
+            ["", "=", `${answer}`],
+        ])}
+    `,
         identifiers: { firstRank, askedRank, firstTerm, reason },
     };
     return question;
@@ -45,4 +86,5 @@ exports.geometricFindTerm = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    firstRank: number;
+    firstValue: number;
+    reason: number;
+    nbTerms: number;
+};
+export declare const geometricFirstTermsGeneralSum: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=geometricFirstTermsGeneralSum.d.ts.map

package/lib/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFirstTermsGeneralSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AA+CF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}

package/lib/exercises/math/sequences/geometric/geometricFirstTermsGeneralSum.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.geometricFirstTermsGeneralSum = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const random_1 = require("../../../../utils/random");
+const getGeometricFirstTermsGeneralSumQuestion = () => {
+    const firstRank = (0, random_1.random)([0, 1]);
+    const firstValue = (0, randint_1.randint)(-9, 10, [0]);
+    const reason = (0, randint_1.randint)(-5, 5, [0, 1]);
+    const nbTerms = (0, randint_1.randint)(4, 9);
+    const answer = (firstValue * (1 - Math.pow(reason, nbTerms))) / (1 - reason);
+    const question = {
+        answer: answer + "",
+        instruction: `Soit $u$ une suite géométrique de premier terme $u_${firstRank} = ${firstValue}$ et de raison $${reason}$. Calculer la somme des $${nbTerms}$ premiers termes de $u$.`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            firstRank,
+            firstValue,
+            reason,
+            nbTerms,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, firstRank, firstValue, reason, nbTerms }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        const fake = (firstValue *
+            (1 -
+                Math.pow(reason === -1 ? (0, randint_1.randint)(2, 5) : reason, (0, randint_1.randint)(3, 10)))) /
+            (1 - reason);
+        (0, exercise_1.tryToAddWrongProp)(propositions, fake.frenchify());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.geometricFirstTermsGeneralSum = {
+    id: "geometricFirstTermsGeneralSum",
+    connector: "=",
+    label: "Somme des termes d'une suite géométrique (cas général)",
+    levels: [],
+    isSingleStep: true,
+    sections: [],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getGeometricFirstTermsGeneralSumQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/sequences/geometric/index.d.ts

@@ -7,4 +7,5 @@ export * from "./geometricRecurrenceFormulaUsage";
 export * from "./geometricFindExplicitFormulaFirstTermRandom";
 export * from "./geometricFindTerm";
 export * from "./geometricRecognizeReasonFromFirstTerms";
+export * from "./geometricFirstTermsGeneralSum";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/geometric/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,qBAAqB,CAAC;AACpC,cAAc,0CAA0C,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/geometric/index.ts"],"names":[],"mappings":"AAAA,cAAc,iCAAiC,CAAC;AAChD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,wBAAwB,CAAC;AACvC,cAAc,mCAAmC,CAAC;AAClD,cAAc,+CAA+C,CAAC;AAC9D,cAAc,qBAAqB,CAAC;AACpC,cAAc,0CAA0C,CAAC;AACzD,cAAc,iCAAiC,CAAC"}

package/lib/exercises/math/sequences/geometric/index.js

@@ -23,3 +23,4 @@ __exportStar(require("./geometricRecurrenceFormulaUsage"), exports);
 __exportStar(require("./geometricFindExplicitFormulaFirstTermRandom"), exports);
 __exportStar(require("./geometricFindTerm"), exports);
 __exportStar(require("./geometricRecognizeReasonFromFirstTerms"), exports);
+__exportStar(require("./geometricFirstTermsGeneralSum"), exports);

package/lib/exercises/math/sequences/index.d.ts

@@ -3,4 +3,6 @@ export * from "./geometric";
 export * from "./explicitFormulaUsage";
 export * from "./genericSequenceVariations";
 export * from "./recurrenceFormulaUsage";
+export * from "./sequenceEvaluation";
+export * from "./sequencePlot";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/sequences/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,wBAAwB,CAAC;AACvC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,gBAAgB,CAAC"}

package/lib/exercises/math/sequences/index.js

@@ -19,3 +19,5 @@ __exportStar(require("./geometric"), exports);
 __exportStar(require("./explicitFormulaUsage"), exports);
 __exportStar(require("./genericSequenceVariations"), exports);
 __exportStar(require("./recurrenceFormulaUsage"), exports);
+__exportStar(require("./sequenceEvaluation"), exports);
+__exportStar(require("./sequencePlot"), exports);

package/lib/exercises/math/sequences/sequenceEvaluation.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    termeid: number;
+    affine: number[];
+    termeAdd: number;
+    termeMult: number;
+};
+export declare const sequenceEvaluation: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sequenceEvaluation.d.ts.map

package/lib/exercises/math/sequences/sequenceEvaluation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequenceEvaluation.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequenceEvaluation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAYlC,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAoLF,eAAO,MAAM,kBAAkB,EAAE,QAAQ,CAAC,WAAW,CAapD,CAAC"}

package/lib/exercises/math/sequences/sequenceEvaluation.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequenceEvaluation = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const affine_1 = require("../../../math/polynomials/affine");
+const randint_1 = require("../../../math/utils/random/randint");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
+const addNode_1 = require("../../../tree/nodes/operators/addNode");
+const multiplyNode_1 = require("../../../tree/nodes/operators/multiplyNode");
+const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const getSequenceEvaluationQuestion = () => {
+    const termeid = (0, randint_1.randint)(1, 3);
+    const a = (0, randint_1.randint)(-10, 10, [0]);
+    const b = (0, randint_1.randint)(-10, 10);
+    const affine = new affine_1.Affine(a, b, "n");
+    let terme;
+    let termeAdd = 0;
+    let termeMult = 1;
+    if (termeid === 1) {
+        termeAdd = (0, randint_1.randint)(1, 4);
+        terme = new addNode_1.AddNode(new variableNode_1.VariableNode("n"), new numberNode_1.NumberNode(termeAdd));
+    }
+    else if (termeid === 2) {
+        termeMult = (0, randint_1.randint)(2, 4);
+        terme = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n"));
+    }
+    else {
+        termeAdd = (0, randint_1.randint)(1, 4);
+        termeMult = (0, randint_1.randint)(1, 4);
+        terme = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(termeAdd));
+    }
+    let answer;
+    if (termeid === 1) {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        answer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else if (termeid === 2) {
+        const innerTerm = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n"));
+        answer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        answer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    const question = {
+        answer: answer.toTex(),
+        instruction: `Soit $(u_n)$ une suite telle que $u_n = ${affine.toTex()}$. Exprimer $u_{${terme.toTex()}}$.`,
+        keys: ["n"],
+        answerFormat: "tex",
+        identifiers: {
+            termeid,
+            affine: [a, b],
+            termeAdd,
+            termeMult,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, termeid, affine, termeAdd, termeMult }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const a = affine[0];
+    const b = affine[1];
+    let wrongAnswer;
+    if (termeid === 1) {
+        const wrongInnerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * (termeAdd + (0, randint_1.randint)(-2, 2))));
+        wrongAnswer = new addNode_1.AddNode(wrongInnerTerm, new numberNode_1.NumberNode(b + (0, randint_1.randint)(-5, 5))).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else if (termeid === 2) {
+        const wrongInnerTerm = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * (termeMult + (0, randint_1.randint)(-1, 1))), new variableNode_1.VariableNode("n"));
+        wrongAnswer = new addNode_1.AddNode(wrongInnerTerm, new numberNode_1.NumberNode(b + (0, randint_1.randint)(-5, 5))).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else {
+        const wrongInnerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * (termeMult + (0, randint_1.randint)(-1, 1))), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * (termeAdd + (0, randint_1.randint)(-2, 2))));
+        wrongAnswer = new addNode_1.AddNode(wrongInnerTerm, new numberNode_1.NumberNode(b + (0, randint_1.randint)(-5, 5))).simplify({
+            forbidFactorize: true,
+        });
+    }
+    (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer.toTex());
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new affine_1.Affine((0, randint_1.randint)(-10, 10, [0]), (0, randint_1.randint)(-10, 10), "n").toTree().toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { affine, termeid, termeAdd, termeMult }) => {
+    const a = affine[0];
+    const b = affine[1];
+    let terme;
+    if (termeid === 1) {
+        terme = new addNode_1.AddNode(new variableNode_1.VariableNode("n"), new numberNode_1.NumberNode(termeAdd));
+    }
+    else if (termeid === 2) {
+        terme = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n"));
+    }
+    else {
+        terme = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(termeAdd));
+    }
+    let validanswer;
+    if (termeid === 1) {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        validanswer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else if (termeid === 2) {
+        const innerTerm = new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n"));
+        validanswer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    else {
+        const innerTerm = new addNode_1.AddNode(new multiplyNode_1.MultiplyNode(new numberNode_1.NumberNode(a * termeMult), new variableNode_1.VariableNode("n")), new numberNode_1.NumberNode(a * termeAdd));
+        validanswer = new addNode_1.AddNode(innerTerm, new numberNode_1.NumberNode(b)).simplify({
+            forbidFactorize: true,
+        });
+    }
+    const latexs = validanswer.toAllValidTexs();
+    return latexs.includes(ans);
+};
+exports.sequenceEvaluation = {
+    id: "sequenceEvaluation",
+    label: "Exprimer $u_{f(n)}$ en connaissant $u_n$",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequenceEvaluationQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/sequences/sequencePlot.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../exercises/exercise";
+type Identifiers = {
+    nValue: number;
+    points: number[][];
+    isArithmetic: boolean;
+};
+export declare const sequencePlot: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=sequencePlot.d.ts.map

package/lib/exercises/math/sequences/sequencePlot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencePlot.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/sequencePlot.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;IACnB,YAAY,EAAE,OAAO,CAAC;CACvB,CAAC;AA2FF,eAAO,MAAM,YAAY,EAAE,QAAQ,CAAC,WAAW,CAe9C,CAAC"}

package/lib/exercises/math/sequences/sequencePlot.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sequencePlot = void 0;
+const exercise_1 = require("../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
+const randfloat_1 = require("../../../math/utils/random/randfloat");
+const randint_1 = require("../../../math/utils/random/randint");
+const geogebraConstructor_1 = require("../../../geogebra/geogebraConstructor");
+const coinFlip_1 = require("../../../utils/coinFlip");
+const getSequencePlotQuestion = () => {
+    const isArithmetic = (0, coinFlip_1.coinFlip)();
+    const a = isArithmetic ? (0, randfloat_1.randfloat)(0.1, 0.5, 1) : (0, randfloat_1.randfloat)(1.01, 1.1, 2);
+    const b = (0, randint_1.randint)(2, 10);
+    const nMax = 10;
+    const points = [];
+    for (let n = 0; n <= nMax; n++) {
+        let u_n;
+        if (isArithmetic) {
+            const noise = (0, randfloat_1.randfloat)(-2, 2, 1);
+            u_n = a * n + b + noise;
+        }
+        else {
+            const noise = (0, randfloat_1.randfloat)(-2, 2, 1);
+            u_n = b * Math.pow(a, n) + noise;
+        }
+        points.push([n, Math.round(u_n)]);
+    }
+    const nValue = (0, randint_1.randint)(0, nMax);
+    const u_nValue = points[nValue][1];
+    const commands = points.map((point, index) => {
+        return `A${index}=(${point[0]},${point[1]})`;
+    });
+    commands.push(...points.map((_, index) => {
+        return `SetFixed(A${index},true)`;
+    }), ...points.map((_, index) => {
+        return `SetLabelMode(A${index},1)`;
+    }));
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        hideAxes: false,
+        hideGrid: false,
+        isXAxesNatural: true,
+        isGridSimple: true,
+    });
+    const answer = u_nValue.toString();
+    const question = {
+        answer,
+        instruction: `Ci-dessous est tracé un nuage de points représentant les valeurs d'une suite $(u_n)$. Quelle est la valeur de $u_{${nValue}}$ ?`,
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: ggb.getAdaptedCoords({
+            xMin: 0,
+            xMax: nMax,
+            yMin: Math.min(...points.map((p) => p[1])) - 2,
+            yMax: Math.max(...points.map((p) => p[1])) + 2,
+        }),
+        keys: [],
+        answerFormat: "raw",
+        identifiers: { nValue, points, isArithmetic },
+        hint: `$u_{${nValue}}$ est l'ordonnée du point d'absicsse $${nValue}$ dans le nuage de points.`,
+        correction: `$u_{${nValue}}$ est l'ordonnée du point d'absicsse $${nValue}$ dans le nuage de points.
+
+On lit donc : $u_{${nValue}}=${answer}$.
+    `,
+    };
+    return question;
+};
+const getPropositions = (n, { answer, nValue, points }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    const correctValue = parseInt(answer);
+    while (propositions.length < n) {
+        const wrongAnswer = (correctValue + (0, randint_1.randint)(-2, 2)).toString();
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.sequencePlot = {
+    id: "sequencePlot",
+    label: "Lire graphiquement un terme d'une suite à partir d'un nuage de points",
+    levels: ["1reSpé"],
+    isSingleStep: true,
+    hasGeogebra: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getSequencePlotQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sets/intervals/intervalsIntersection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAMlC,OAAO,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAG5D,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AAwDF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAcvD,CAAC"}
+{"version":3,"file":"intervalsIntersection.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sets/intervals/intervalsIntersection.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAOlC,OAAO,EAAW,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAQrE,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,WAAW,CAAC;CAC1B,CAAC;AA6EF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAevD,CAAC"}

package/lib/exercises/math/sets/intervals/intervalsIntersection.js

@@ -4,11 +4,13 @@ exports.intervalsIntersection = void 0;
 const exercise_1 = require("../../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
 const intervals_1 = require("../../../../math/sets/intervals/intervals");
+const discreteSetNode_1 = require("../../../../tree/nodes/sets/discreteSetNode");
+const intervalNode_1 = require("../../../../tree/nodes/sets/intervalNode");
 const shuffle_1 = require("../../../../utils/shuffle");
 const getIntervalsIntersectionQuestion = () => {
     const [int1, int2] = intervals_1.IntervalConstructor.differentRandoms(2);
     const inter = int1.intersection(int2);
-    const answer = inter.tex;
+    const answer = inter.toTex();
     const question = {
         answer,
         instruction: `Soit $I = ${int1.toTex()}$ et $J = ${int2.toTex()}$. Déterminer $I\\cap J$.`,
@@ -20,6 +22,8 @@ const getIntervalsIntersectionQuestion = () => {
             "semicolon",
             "cup",
             "cap",
+            "lbrace",
+            "rbrace",
         ],
         answerFormat: "tex",
         identifiers: {
@@ -30,6 +34,19 @@ const getIntervalsIntersectionQuestion = () => {
             int2Max: int2.max,
             int2Min: int2.min,
         },
+        hint: `Détermine l'ensemble des nombres qui appartiennent à la fois à $I$ et à $J$.`,
+        correction: `$I$ contient les nombres ${int1.toTree().toText(true, false)}. 
+    
+$J$ contient les nombres ${int2.toTree().toText(false, false)}.
+    
+${(0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 0
+            ? `Il n'y a donc aucun nombre commun aux intervalles $I$ et $J$.`
+            : (0, discreteSetNode_1.isDiscreteSetNode)(inter) && inter.elements.length === 1
+                ? `Il n'y a donc qu'un nombre commun aux intervalles $I$ et $J$ : $${inter.elements[0].toTex()}$.`
+                : (0, intervalNode_1.isIntervalNode)(inter) &&
+                    `Les nombres communs à $I$ et $J$ sont donc les nombres ${inter.toText(true, false)}.`}
+    
+Ainsi, $I\\cap J = ${answer}$`,
     };
     return question;
 };
@@ -61,4 +78,5 @@ exports.intervalsIntersection = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/math/sets/intervals/intervalsUnion.js

@@ -30,7 +30,7 @@ const getPropositions = (n, { answer, int1Closure, int1Max, int1Min, int2Closure
     (0, exercise_1.addValidProp)(propositions, answer);
     const int1 = new intervals_1.Interval(int1Min.toTree(), int1Max.toTree(), int1Closure);
     const int2 = new intervals_1.Interval(int2Min.toTree(), int2Max.toTree(), int2Closure);
-    (0, exercise_1.tryToAddWrongProp)(propositions, int1.intersection(int2).tex);
+    (0, exercise_1.tryToAddWrongProp)(propositions, int1.intersection(int2).toTex());
     while (propositions.length < n) {
         const wrongAnswer = intervals_1.IntervalConstructor.random().tex;
         (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);

package/lib/exercises/math/trigonometry/arcValue.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arcValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/arcValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAUlC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AAoEF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAY1C,CAAC"}
+{"version":3,"file":"arcValue.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/trigonometry/arcValue.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAclC,KAAK,WAAW,GAAG;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,EAAE,MAAM,CAAC;CACxB,CAAC;AA6FF,eAAO,MAAM,QAAQ,EAAE,QAAQ,CAAC,WAAW,CAa1C,CAAC"}

package/lib/exercises/math/trigonometry/arcValue.js

@@ -5,10 +5,15 @@ const exercise_1 = require("../../../exercises/exercise");
 const getDistinctQuestions_1 = require("../../../exercises/utils/getDistinctQuestions");
 const randint_1 = require("../../../math/utils/random/randint");
 const round_1 = require("../../../math/utils/round");
+const numberNode_1 = require("../../../tree/nodes/numbers/numberNode");
 const sinNode_1 = require("../../../tree/nodes/functions/sinNode");
 const cosNode_1 = require("../../../tree/nodes/functions/cosNode");
 const tanNode_1 = require("../../../tree/nodes/functions/tanNode");
 const variableNode_1 = require("../../../tree/nodes/variables/variableNode");
+const arcSinNode_1 = require("../../../tree/nodes/functions/arcSinNode");
+const arccosNode_1 = require("../../../tree/nodes/functions/arccosNode");
+const alignTex_1 = require("../../../utils/alignTex");
+const arctanNode_1 = require("../../../tree/nodes/functions/arctanNode");
 const getArcValueQuestion = () => {
     const trigFunctions = ["sin", "cos", "tan"];
     const selectedFunction = trigFunctions[(0, randint_1.randint)(0, trigFunctions.length)];
@@ -41,6 +46,11 @@ const getArcValueQuestion = () => {
         : selectedFunction === "cos"
             ? new cosNode_1.CosNode(new variableNode_1.VariableNode("\\theta"))
             : new tanNode_1.TanNode(new variableNode_1.VariableNode("\\theta"));
+    const reciprocalFunction = selectedFunction === "sin"
+        ? { name: "arcsin", otherName: "\\sin^{-1}", node: arcSinNode_1.ArcsinNode }
+        : selectedFunction === "cos"
+            ? { name: "arccos", otherName: "\\cos^{-1}", node: arccosNode_1.ArccosNode }
+            : { name: "arctan", otherName: "\\tan^{-1}", node: arctanNode_1.ArctanNode };
     const instruction = `Quelle est la valeur en degrés de l'angle $\\theta$ sachant que $${trigNode.toTex()} = ${trigValue.frenchify()}$ ? Arrondir à l'unité.`;
     const answer = (0, round_1.round)(angleInDegrees, 0).toTree().toTex();
     const question = {
@@ -48,6 +58,18 @@ const getArcValueQuestion = () => {
         instruction: instruction,
         keys: [],
         answerFormat: "tex",
+        hint: `La valeur de $\\theta$ s'obtient en calculant l'${reciprocalFunction.name} (ou $${reciprocalFunction.otherName}$) de la valeur $${trigValue.frenchify()}$, avec la calculatrice.`,
+        correction: `On calcule l'${reciprocalFunction.name} (ou $${reciprocalFunction.otherName}$) de  $${trigValue.frenchify()}$ avec la calculatrice : 
+    
+${(0, alignTex_1.alignTex)([
+            [
+                `${new reciprocalFunction.node(new numberNode_1.NumberNode(trigValue)).toTex()}`,
+                "\\approx",
+                (0, round_1.round)(angleInDegrees, 3).toTree().toTex(),
+            ],
+        ])}
+
+En arrondissant à l'unité, on a donc $\\theta \\approx ${answer}°$.`,
         identifiers: { trigFunction: selectedFunction, trigValue, angleInDegrees },
     };
     return question;
@@ -75,4 +97,5 @@ exports.arcValue = {
     getPropositions,
     isAnswerValid,
     subject: "Mathématiques",
+    hasHintAndCorrection: true,
 };

package/lib/exercises/pc/chemicalReactions/stoichiometricReaction.js

@@ -64,6 +64,6 @@ exports.stoichiometricReaction = {
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
-    answerType: "QCM",
+    answerType: "QCU",
     subject: "Physique",
 };

package/lib/exercises/pc/electricity/ohmicConductorOrGenerator.js

@@ -88,7 +88,7 @@ exports.ohmicConductorOrGenerator = {
     freeTimer: 60,
     getPropositions,
     isAnswerValid,
-    answerType: "QCM",
+    answerType: "QCU",
     maxAllowedQuestions: 10,
     subject: "Physique",
     hasHintAndCorrection: true,

package/lib/exercises/pc/motion/typeOfAcceleration.js

@@ -92,6 +92,6 @@ exports.typeOfAcceleration = {
     getPropositions,
     isAnswerValid,
     hasGeogebra: true,
-    answerType: "QCM",
+    answerType: "QCU",
     subject: "Physique",
 };

package/lib/exercises/pc/motion/typeOfMovement.js

@@ -106,6 +106,6 @@ exports.typeOfMovement = {
     qcmTimer: 60,
     freeTimer: 60,
     getPropositions,
-    answerType: "QCM",
+    answerType: "QCU",
     subject: "Physique",
 };