math-exercises 2.0.44 → 2.1.0

package/lib/exercises/math/sequences/arithmetic/arithmeticReasonUsage.d.ts

@@ -0,0 +1,9 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    reason: number;
+    startRank: number;
+    startValue: number;
+};
+export declare const arithmeticReasonUsage: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=arithmeticReasonUsage.d.ts.map

package/lib/exercises/math/sequences/arithmetic/arithmeticReasonUsage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticReasonUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticReasonUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAmCF,eAAO,MAAM,qBAAqB,EAAE,QAAQ,CAAC,WAAW,CAavD,CAAC"}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arithmeticReasonUsage = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getArithmeticReasonUsage = () => {
+    const reason = (0, randint_1.randint)(-10, 10, [0]);
+    const startRank = (0, randint_1.randint)(0, 20);
+    const askedRank = startRank + 1;
+    const startValue = (0, randint_1.randint)(-10, 10);
+    const answer = (startValue + reason).toString();
+    const question = {
+        instruction: `$(u_n)$ est une suite arithmétique de raison $r = ${reason}$ et on sait que $u_{${startRank}} = ${startValue}$. Calculer : $u_{${askedRank}}$`,
+        startStatement: `u_{${askedRank}}`,
+        answer,
+        keys: ["u", "underscore", "equal"],
+        answerFormat: "tex",
+        identifiers: { reason, startRank, startValue },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, Number(answer) + (0, randint_1.randint)(-5, 6, [0]) + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer, startRank }) => {
+    return [
+        answer,
+        `u_${startRank + 1}=${answer}`,
+        `u_{${startRank + 1}}=${answer}`,
+    ].includes(ans);
+};
+exports.arithmeticReasonUsage = {
+    id: "arithmeticReasonUsage",
+    connector: "=",
+    label: "Utiliser la raison d'une suite arithmétique",
+    levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
+    sections: ["Suites"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getArithmeticReasonUsage, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/sequences/arithmetic/arithmeticRecurrenceFormulaUsage.d.ts

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

package/lib/exercises/math/sequences/arithmetic/arithmeticRecurrenceFormulaUsage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticRecurrenceFormulaUsage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticRecurrenceFormulaUsage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC;AAsCF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CAclE,CAAC"}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arithmeticRecurrenceFormulaUsage = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getArithmeticRecurrenceFormulaUsage = () => {
+    const firstRank = (0, randint_1.randint)(1, 20);
+    const firstValue = (0, randint_1.randint)(-10, 10);
+    const reason = (0, randint_1.randint)(-10, 10, [0]);
+    const askedRank = firstRank + 1;
+    const answer = (firstValue + reason).toString();
+    const question = {
+        instruction: `$(u_n)$ est une suite définie par $u_{n+1} = ${reason} + u_n$ et $u_{${firstRank}} = ${firstValue}$. Calculer : $u_{${askedRank}}$`,
+        startStatement: `u_{${askedRank}}`,
+        answer,
+        keys: ["u", "underscore", "equal"],
+        answerFormat: "tex",
+        identifiers: { firstRank, firstValue, reason },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, Number(answer) + (0, randint_1.randint)(-5, 6, [0]) + "");
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer, firstRank }) => {
+    return [
+        answer,
+        `u_${firstRank + 1}=${answer}`,
+        `u_{${firstRank + 1}}=${answer}`,
+    ].includes(ans);
+};
+exports.arithmeticRecurrenceFormulaUsage = {
+    id: "arithmeticRecurrenceFormulaUsage",
+    connector: "=",
+    label: "Utiliser la formule de récurrence d'une suite arithmétique",
+    levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
+    sections: ["Suites"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getArithmeticRecurrenceFormulaUsage, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/sequences/arithmetic/arithmeticThresholdFind.d.ts

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

package/lib/exercises/math/sequences/arithmetic/arithmeticThresholdFind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticThresholdFind.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/arithmeticThresholdFind.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,QAAQ,EAQT,MAAM,mBAAmB,CAAC;AAG3B,KAAK,WAAW,GAAG;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAuDF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,CAczD,CAAC"}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arithmeticThresholdFind = void 0;
+const polynomial_1 = require("../../../../math/polynomials/polynomial");
+const randint_1 = require("../../../../math/utils/random/randint");
+const shuffle_1 = require("../../../../utils/shuffle");
+const exercise_1 = require("../../../exercise");
+const getDistinctQuestions_1 = require("../../../utils/getDistinctQuestions");
+const getArithmeticThresholdFind = () => {
+    const firstValue = (0, randint_1.randint)(-10, 10);
+    const reason = (0, randint_1.randint)(-10, 10, [0]);
+    let randValue = firstValue;
+    const formula = new polynomial_1.Polynomial([firstValue, reason], "n");
+    let instruction = `$(u_n)$ est une suite arithmétique définie par $u_n = ${formula
+        .toTree()
+        .toTex()}$. `;
+    if (reason > 0) {
+        randValue += (0, randint_1.randint)(reason, 100);
+        instruction += `À partir de quel rang $n$ a-t-on $u_n > ${randValue}$ ?`;
+    }
+    else {
+        randValue += (0, randint_1.randint)(-100, reason);
+        instruction += `À partir de quel rang $n$ a-t-on $u_n < ${randValue}$ ?`;
+    }
+    const answer = (Math.floor((randValue - firstValue) / reason) + 1).toString();
+    const question = {
+        instruction,
+        startStatement: `n`,
+        answer,
+        keys: ["r", "n", "u", "underscore", "inf", "sup", "approx"],
+        answerFormat: "tex",
+        identifiers: { randValue, firstValue, reason },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, randValue, firstValue, reason }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, (Math.floor((randValue - firstValue) / reason) + (0, randint_1.randint)(-5, 6, [1])).toString());
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.arithmeticThresholdFind = {
+    id: "arithmeticThresholdFind",
+    connector: "=",
+    label: "Calculer un seuil à l'aide d'une suite arithmétique",
+    levels: ["1reESM", "1reSpé", "1reTech", "1rePro", "TermTech", "TermPro"],
+    sections: ["Suites"],
+    isSingleStep: false,
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getArithmeticThresholdFind, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/sequences/arithmetic/firstIntegersSum.d.ts

@@ -0,0 +1,7 @@
+import { Exercise } from "../../../../exercises/exercise";
+type Identifiers = {
+    final: number;
+};
+export declare const firstIntegersSum: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=firstIntegersSum.d.ts.map

package/lib/exercises/math/sequences/arithmetic/firstIntegersSum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"firstIntegersSum.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/firstIntegersSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAQT,MAAM,0BAA0B,CAAC;AAKlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAiCF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAclD,CAAC"}

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

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firstIntegersSum = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const shuffle_1 = require("../../../../utils/shuffle");
+const getFirstIntegersSumQuestion = () => {
+    const final = (0, randint_1.randint)(20, 100);
+    const answer = `${(final * (final + 1)) / 2}`;
+    const question = {
+        answer,
+        instruction: `Calculer la somme suivante : $1+2+3+\\ldots + ${final}$`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { final },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, final }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${(final * (final - 1)) / 2}`);
+    (0, exercise_1.tryToAddWrongProp)(propositions, `${final * (final + 1)}`);
+    while (propositions.length < n) {
+        const wrongAnswer = (0, randint_1.randint)(30, 200) + "";
+        (0, exercise_1.tryToAddWrongProp)(propositions, wrongAnswer);
+    }
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.firstIntegersSum = {
+    id: "firstIntegersSum",
+    connector: "=",
+    label: "Somme des $n$ premiers entiers",
+    levels: ["1rePro", "1reTech", "1reSpé", "1reESM"],
+    isSingleStep: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getFirstIntegersSumQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

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

@@ -0,0 +1,13 @@
+export * from "./arithmeticExplicitFormulaUsage";
+export * from "./arithmeticFindExplicitFormula";
+export * from "./arithmeticFindReason";
+export * from "./arithmeticReasonUsage";
+export * from "./arithmeticRecurrenceFormulaUsage";
+export * from "./arithmeticThresholdFind";
+export * from "./firstIntegersSum";
+export * from "./recognizeArithmeticFromFirstTerms";
+export * from "./recognizeReasonFromFirstTerms";
+export * from "./recognizeReasonFromGraph";
+export * from "./recognizeArithmeticFromGraph";
+export * from "./arithmeticFirstTermsSum";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,iCAAiC,CAAC;AAChD,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,oCAAoC,CAAC;AACnD,cAAc,2BAA2B,CAAC;AAC1C,cAAc,oBAAoB,CAAC;AACnC,cAAc,qCAAqC,CAAC;AACpD,cAAc,iCAAiC,CAAC;AAChD,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,2BAA2B,CAAC"}

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

@@ -0,0 +1,28 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./arithmeticExplicitFormulaUsage"), exports);
+__exportStar(require("./arithmeticFindExplicitFormula"), exports);
+__exportStar(require("./arithmeticFindReason"), exports);
+__exportStar(require("./arithmeticReasonUsage"), exports);
+__exportStar(require("./arithmeticRecurrenceFormulaUsage"), exports);
+__exportStar(require("./arithmeticThresholdFind"), exports);
+__exportStar(require("./firstIntegersSum"), exports);
+__exportStar(require("./recognizeArithmeticFromFirstTerms"), exports);
+__exportStar(require("./recognizeReasonFromFirstTerms"), exports);
+__exportStar(require("./recognizeReasonFromGraph"), exports);
+__exportStar(require("./recognizeArithmeticFromGraph"), exports);
+__exportStar(require("./arithmeticFirstTermsSum"), exports);

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromFirstTerms.d.ts

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

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromFirstTerms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeArithmeticFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAUT,MAAM,0BAA0B,CAAC;AAOlC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,EAAE,EAAE,CAAC;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB,CAAC;AAsEF,eAAO,MAAM,iCAAiC,EAAE,QAAQ,CAAC,WAAW,CAcnE,CAAC"}

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recognizeArithmeticFromFirstTerms = 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 shuffle_1 = require("../../../../utils/shuffle");
+const getRecognizeArithmeticFromFirstTermsQuestion = () => {
+    const sequences = [];
+    const firstGeoTerm = (0, randint_1.randint)(1, 4);
+    const geoReason = (0, random_1.random)([2, 3]);
+    sequences[0] = new Array(5)
+        .fill(0)
+        .map((el, index) => firstGeoTerm * geoReason ** index);
+    const firstBernoulliTerm = (0, randint_1.randint)(1, 10);
+    const secondBernoulliTerm = (0, randint_1.randint)(1, 10, [firstBernoulliTerm]);
+    sequences[1] = new Array(5)
+        .fill(0)
+        .map((el, index) => (index % 2 ? firstBernoulliTerm : secondBernoulliTerm));
+    const firstFakeAriTerm = (0, randint_1.randint)(1, 20);
+    sequences[2] = new Array(5)
+        .fill(0)
+        .map((el, index) => firstFakeAriTerm + (0, randint_1.randint)(1, 4));
+    const disruptionIndex = (0, randint_1.randint)(0, 5);
+    sequences[2][disruptionIndex] =
+        sequences[2][disruptionIndex] + (0, random_1.random)([-1, 1]);
+    (0, shuffle_1.shuffle)(sequences);
+    const firstTerm = (0, randint_1.randint)(1, 20);
+    const reason = (0, randint_1.randint)(-5, 6, [0]);
+    const rightSequence = new Array(5)
+        .fill(0)
+        .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 question = {
+        answer,
+        instruction: `Parmi les suites suivantes, laquelle semble être arithmétique ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { sequences, answerIndex },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, sequences, answerIndex }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    sequences.forEach((sequence, index) => {
+        if (index === answerIndex)
+            return;
+        (0, exercise_1.addWrongProp)(propositions, `\\text{Suite ${index + 1} : }${sequence.join("\\ ; \\ ")}`);
+    });
+    return (0, shuffle_1.shuffle)(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.recognizeArithmeticFromFirstTerms = {
+    id: "recognizeArithmeticFromFirstTerms",
+    label: "Reconnaître une suite arithmétique via ses premiers termes",
+    levels: ["1reSpé", "1rePro", "1reTech", "1reESM"],
+    isSingleStep: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRecognizeArithmeticFromFirstTermsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    answerType: "QCM",
+    subject: "Mathématiques",
+};

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.d.ts

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

package/lib/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeArithmeticFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeArithmeticFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAQlC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA4EF,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,CAe9D,CAAC"}

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recognizeArithmeticFromGraph = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const point_1 = require("../../../../math/geometry/point");
+const randint_1 = require("../../../../math/utils/random/randint");
+const coinFlip_1 = require("../../../../utils/coinFlip");
+const random_1 = require("../../../../utils/random");
+const getRandomFirstNonAriTerms = () => {
+    const type = (0, randint_1.randint)(0, 3);
+    switch (type) {
+        case 0:
+            const firstGeoTerm = (0, randint_1.randint)(1, 4);
+            const geoReason = (0, random_1.random)([2, 3]);
+            return new Array(5)
+                .fill(0)
+                .map((el, index) => firstGeoTerm * geoReason ** index);
+        case 1:
+            const firstBernoulliTerm = (0, randint_1.randint)(1, 10);
+            const secondBernoulliTerm = (0, randint_1.randint)(1, 10, [firstBernoulliTerm]);
+            return new Array(5)
+                .fill(0)
+                .map((el, index) => index % 2 ? firstBernoulliTerm : secondBernoulliTerm);
+        case 2:
+        default:
+            const firstFakeAriTerm = (0, randint_1.randint)(1, 20);
+            const res = new Array(5)
+                .fill(0)
+                .map((el, index) => firstFakeAriTerm + (0, randint_1.randint)(1, 4));
+            const disruptionIndex = (0, randint_1.randint)(0, 5);
+            res[disruptionIndex] = res[disruptionIndex] + (0, random_1.random)([-1, 1]);
+            return res;
+    }
+};
+const getRecognizeArithmeticFromGraphQuestion = () => {
+    const isAri = (0, coinFlip_1.coinFlip)();
+    const firstAriTerm = (0, randint_1.randint)(-5, 10);
+    const reason = (0, randint_1.randint)(-4, 6, [0]);
+    const sequence = isAri
+        ? new Array(5).fill(0).map((el, index) => firstAriTerm + reason * index)
+        : getRandomFirstNonAriTerms();
+    const answer = isAri ? "Oui" : "Non";
+    const commands = sequence.map((nb, index) => new point_1.Point(`A_${index}`, index.toTree(), nb.toTree()).toGGBCommand());
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isAxesRatioFixed: false,
+        isXAxesNatural: true,
+        isGridSimple: true,
+    });
+    const yMin = Math.min(...sequence);
+    const yMax = Math.max(...sequence);
+    const question = {
+        answer,
+        instruction: `La suite $u$ représentée ci-dessous semble-t-elle arithmétique ?`,
+        keys: [],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: [-1, 7, Math.min(-1, yMin - 2), Math.max(1, yMax + 2)],
+        answerFormat: "tex",
+        identifiers: { sequence, isAri },
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer, "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Oui", "raw");
+    (0, exercise_1.tryToAddWrongProp)(propositions, "Non", "raw");
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.recognizeArithmeticFromGraph = {
+    id: "recognizeArithmeticFromGraph",
+    label: "Reconnaître graphiquement si une suite est arithmétique",
+    levels: ["1reESM", "1rePro", "1reSpé", "1reTech"],
+    isSingleStep: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRecognizeArithmeticFromGraphQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    answerType: "QCM",
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/sequences/arithmetic/recognizeReasonFromFirstTerms.d.ts

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

package/lib/exercises/math/sequences/arithmetic/recognizeReasonFromFirstTerms.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeReasonFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeReasonFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAIlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAoCF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAc/D,CAAC"}

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

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recognizeReasonFromFirstTerms = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const randint_1 = require("../../../../math/utils/random/randint");
+const getRecognizeReasonFromFirstTermsQuestion = () => {
+    const firstTerm = (0, randint_1.randint)(1, 20);
+    const reason = (0, randint_1.randint)(-5, 6, [0]);
+    const sequence = new Array(5)
+        .fill(0)
+        .map((el, index) => firstTerm + index * reason);
+    const question = {
+        answer: reason + "",
+        instruction: `Voici les premiers termes d'une suite arithmétique $u$ : $${sequence.join("\\ ; \\ ")}$. Quelle est la raison de $u$ ?`,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: { sequence, reason },
+    };
+    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)(-5, 6) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.recognizeReasonFromFirstTerms = {
+    id: "recognizeReasonFromFirstTerms",
+    label: "Reconnaître la raison d'une suite arithmétique via ses premiers termes",
+    levels: ["1reESM", "1rePro", "1reSpé", "1reTech"],
+    isSingleStep: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRecognizeReasonFromFirstTermsQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+};

package/lib/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.d.ts

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

package/lib/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeReasonFromGraph.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/arithmetic/recognizeReasonFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAST,MAAM,0BAA0B,CAAC;AAMlC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AAgDF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,CAe1D,CAAC"}

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.recognizeReasonFromGraph = void 0;
+const exercise_1 = require("../../../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../../../exercises/utils/getDistinctQuestions");
+const geogebraConstructor_1 = require("../../../../geogebra/geogebraConstructor");
+const point_1 = require("../../../../math/geometry/point");
+const randint_1 = require("../../../../math/utils/random/randint");
+const getRecognizeReasonFromGraphQuestion = () => {
+    const firstTerm = (0, randint_1.randint)(1, 20);
+    const reason = (0, randint_1.randint)(-5, 6, [0]);
+    const sequence = new Array(5)
+        .fill(0)
+        .map((el, index) => firstTerm + index * reason);
+    const yMin = Math.min(...sequence);
+    const yMax = Math.max(...sequence);
+    const commands = sequence.map((nb, index) => new point_1.Point(`A_${index}`, index.toTree(), nb.toTree()).toGGBCommand());
+    const ggb = new geogebraConstructor_1.GeogebraConstructor(commands, {
+        isGridSimple: true,
+        isXAxesNatural: true,
+        isAxesRatioFixed: false,
+    });
+    const answer = reason + "";
+    const question = {
+        answer,
+        instruction: `Déterminer la raison de la suite arithmétique $u$ représentée ci-dessous :`,
+        keys: [],
+        commands: ggb.commands,
+        options: ggb.getOptions(),
+        coords: [-1, 7, Math.min(-1, yMin - 2), Math.max(1, yMax + 2)],
+        answerFormat: "tex",
+        identifiers: { reason, sequence },
+    };
+    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)(-5, 6) + "");
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+exports.recognizeReasonFromGraph = {
+    id: "recognizeReasonFromGraph",
+    label: "Reconnaître graphiquement la raison d'une suite arithmétique",
+    levels: ["1reESM", "1reSpé", "1rePro", "1reTech"],
+    isSingleStep: true,
+    sections: ["Suites"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getRecognizeReasonFromGraphQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    hasGeogebra: true,
+    subject: "Mathématiques",
+};