math-exercises 2.0.34 → 2.0.35

package/lib/exercises/probaStat/probaFromTableWithContext.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.probaFromTableWithContext = void 0;
+const exercise_1 = require("../../exercises/exercise");
+const getDistinctQuestions_1 = require("../../exercises/utils/getDistinctQuestions");
+const rational_1 = require("../../math/numbers/rationals/rational");
+const randint_1 = require("../../math/utils/random/randint");
+const fractionNode_1 = require("../../tree/nodes/operators/fractionNode");
+const random_1 = require("../../utils/random");
+const getProbaFromTableWithContextQuestion = () => {
+    const aCapB = (0, randint_1.randint)(1, 20);
+    const aCapBBarre = (0, randint_1.randint)(1, 20);
+    const aBarreCapB = (0, randint_1.randint)(1, 20);
+    const aBarreCapBBarre = (0, randint_1.randint)(1, 20);
+    const total = aBarreCapB + aBarreCapBBarre + aCapB + aCapBBarre;
+    const aTotal = aCapB + aCapBBarre;
+    const bTotal = aCapB + aBarreCapB;
+    const aBarreTotal = aBarreCapB + aBarreCapBBarre;
+    const bBarreTotal = aBarreCapBBarre + aCapBBarre;
+    let event = "";
+    let proba = [];
+    const type = (0, random_1.random)([
+        "singleEvent",
+        "intersection",
+        "union",
+    ]);
+    switch (type) {
+        case "singleEvent":
+            [event, proba] = (0, random_1.random)([
+                ["une fille", [aTotal, total]],
+                ["une élève qui porte des lunettes", [bTotal, total]],
+                ["un garçons", [aBarreTotal, total]],
+                ["une élève qui ne porte pas de lunettes", [bBarreTotal, total]],
+            ]);
+            break;
+        case "intersection":
+            [event, proba] = (0, random_1.random)([
+                ["une fille qui porte des lunettes", [aCapB, total]],
+                ["un garçon qui porte des lunettes", [aBarreCapB, total]],
+                ["une fille qui ne porte pas de lunettes", [aCapBBarre, total]],
+                ["un garçon qui ne porte pas de lunettes", [aBarreCapBBarre, total]],
+            ]);
+            break;
+        case "union":
+            [event, proba] = (0, random_1.random)([
+                [
+                    "une fille ou un élève qui porte des lunettes",
+                    [total - aBarreCapBBarre, total],
+                ],
+                [
+                    "une fille ou un élève qui ne porte pas de lunettes",
+                    [total - aBarreCapB, total],
+                ],
+                [
+                    "un garçon ou un élève qui porte des lunettes",
+                    [total - aCapBBarre, total],
+                ],
+                [
+                    "un garçon ou un élève qui ne porte pas de lunettes",
+                    [total - aCapB, total],
+                ],
+            ]);
+            break;
+    }
+    const answer = new rational_1.Rational(proba[0], proba[1]).simplify().toTree().toTex();
+    const question = {
+        answer,
+        instruction: `Le tableau suivant donne le nombre de filles et de garçons portant des lunettes dans un lycée : 
+
+|       | Porte des lunettes     | Ne porte pas de lunettes   |
+|-------|:----------------------:|----------------------------|
+|Filles   |${aCapB}   |${aCapBBarre}|
+|Garçons   |${aBarreCapB}   |${aBarreCapBBarre}   |
+    
+On choisit un élève au hasard. Quelle est la probabilité de tomber sur ${event} ?
+    `,
+        keys: [],
+        answerFormat: "tex",
+        identifiers: {
+            aBarreCapB,
+            aBarreCapBBarre,
+            aCapB,
+            aCapBBarre,
+            event,
+            type,
+            probaFrac: proba,
+        },
+    };
+    return question;
+};
+const getPropositions = (n, { answer, aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre }) => {
+    const propositions = [];
+    (0, exercise_1.addValidProp)(propositions, answer);
+    while (propositions.length < n) {
+        (0, exercise_1.tryToAddWrongProp)(propositions, new rational_1.Rational((0, random_1.random)([aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre]), (0, random_1.random)([aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre]) +
+            (0, random_1.random)([aBarreCapB, aBarreCapBBarre, aCapB, aCapBBarre]))
+            .simplify()
+            .toTree()
+            .toTex());
+    }
+    return (0, exercise_1.shuffleProps)(propositions, n);
+};
+const isAnswerValid = (ans, { answer, probaFrac }) => {
+    const fracTexs = new fractionNode_1.FractionNode(probaFrac[0].toTree(), probaFrac[1].toTree())
+        .simplify()
+        .toAllValidTexs();
+    return fracTexs.includes(ans);
+};
+exports.probaFromTableWithContext = {
+    id: "probaFromTableWithContext",
+    connector: "=",
+    label: "Utiliser un tableau à double entrée pour calculer une probabilité (avec contexte)",
+    levels: ["1rePro", "1reSpé", "1reTech", "1reESM", "2ndPro"],
+    isSingleStep: true,
+    sections: ["Probabilités"],
+    generator: (nb) => (0, getDistinctQuestions_1.getDistinctQuestions)(getProbaFromTableWithContextQuestion, nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+};

package/lib/exercises/python/index.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=index.d.ts.map

package/lib/exercises/python/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/exercises/python/index.ts"],"names":[],"mappings":""}

package/lib/exercises/python/index.js

@@ -0,0 +1 @@
+"use strict";

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

@@ -5,4 +5,8 @@ export * from "./arithmeticReasonUsage";
 export * from "./arithmeticRecurrenceFormulaUsage";
 export * from "./arithmeticThresholdFind";
 export * from "./firstIntegersSum";
+export * from "./recognizeArithmeticFromFirstTerms";
+export * from "./recognizeReasonFromFirstTerms";
+export * from "./recognizeReasonFromGraph";
+export * from "./recognizeArithmeticFromGraph";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/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"}

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

@@ -21,3 +21,7 @@ __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);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeArithmeticFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/arithmetic/recognizeArithmeticFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EAUb,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,YAAY,CAAC,WAAW,CAavE,CAAC"}

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

@@ -0,0 +1,71 @@
+"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",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeArithmeticFromGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/arithmetic/recognizeArithmeticFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,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,YAAY,CAAC,WAAW,CAalE,CAAC"}

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

@@ -0,0 +1,87 @@
+"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",
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeReasonFromFirstTerms.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/arithmetic/recognizeReasonFromFirstTerms.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,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,YAAY,CAAC,WAAW,CAanE,CAAC"}

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

@@ -0,0 +1,44 @@
+"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,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeReasonFromGraph.d.ts","sourceRoot":"","sources":["../../../../src/exercises/sequences/arithmetic/recognizeReasonFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EASb,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,YAAY,CAAC,WAAW,CAa9D,CAAC"}

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

@@ -0,0 +1,58 @@
+"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,
+};

package/lib/exercises/utils/getDistinctQuestions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getDistinctQuestions.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getDistinctQuestions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,WAOnD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,cACpB,MAAM,SAAS,GAAG,CAAC,MAC1B,MAAM,QACJ,MAAM,KACX,SAAS,GAAG,CAAC,EAkBf,CAAC"}
+{"version":3,"file":"getDistinctQuestions.d.ts","sourceRoot":"","sources":["../../../src/exercises/utils/getDistinctQuestions.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAEvC,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,WAOnD;AAED;;;;;;GAMG;AACH,eAAO,MAAM,oBAAoB,cACpB,MAAM,SAAS,GAAG,CAAC,MAC1B,MAAM,QACJ,MAAM,KACX,SAAS,GAAG,CAAC,EAmBf,CAAC"}

package/lib/exercises/utils/getDistinctQuestions.js

@@ -29,6 +29,7 @@ const getDistinctQuestions = (generator, nb, max) => {
         do {
             question = generator();
         } while (res.some((q) => q.instruction === question.instruction &&
+            q.answer === question.answer &&
             (!q.commands || equalTab(q.commands, question.commands))));
         res.push(question);
     }

package/lib/geogebra/geogebraConstructor.d.ts

@@ -5,6 +5,7 @@ type GeogebraOptions = {
     hideGrid?: boolean;
     isGridBold?: boolean;
     isGridSimple?: boolean;
+    isXAxesNatural?: boolean;
 };
 type GetAdaptedCoords = {
     xMin: number;
@@ -21,6 +22,7 @@ export declare class GeogebraConstructor {
     isGridSimple: boolean;
     isGridBold: boolean;
     isAxesRatioFixed: boolean;
+    isXAxesNatural: boolean;
     constructor(commands: string[], options: GeogebraOptions | undefined);
     getAdaptedCoords({ xMin, xMax, yMin, yMax, forceShowAxes, }: GetAdaptedCoords): number[];
     getOptions(): GeogebraOptions;

package/lib/geogebra/geogebraConstructor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;CACxB,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;gBACd,QAAQ,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,eAAe,GAAG,SAAS;IAUpE,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAmBnB,UAAU,IAAI,eAAe;CAU9B"}
+{"version":3,"file":"geogebraConstructor.d.ts","sourceRoot":"","sources":["../../src/geogebra/geogebraConstructor.ts"],"names":[],"mappings":"AAAA,KAAK,eAAe,GAAG;IACrB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACxC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,CAAC;AAEF,KAAK,gBAAgB,GAAG;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,qBAAa,mBAAmB;IAC9B,QAAQ,EAAE,MAAM,EAAE,CAAC;IACnB,YAAY,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,KAAK,CAAC;IACvC,QAAQ,EAAE,OAAO,CAAC;IAClB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,OAAO,CAAC;IACtB,UAAU,EAAE,OAAO,CAAC;IACpB,gBAAgB,EAAE,OAAO,CAAC;IAC1B,cAAc,EAAE,OAAO,CAAC;gBAEZ,QAAQ,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,eAAe,GAAG,SAAS;IAWpE,gBAAgB,CAAC,EACf,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,IAAI,EACJ,aAAa,GACd,EAAE,gBAAgB;IAmBnB,UAAU,IAAI,eAAe;CAW9B"}

package/lib/geogebra/geogebraConstructor.js

@@ -10,6 +10,7 @@ class GeogebraConstructor {
         this.hideAxes = options?.hideAxes ?? false;
         this.isGridBold = options?.isGridBold ?? false;
         this.isGridSimple = options?.isGridSimple ?? false;
+        this.isXAxesNatural = options?.isXAxesNatural ?? false;
     }
     getAdaptedCoords({ xMin, xMax, yMin, yMax, forceShowAxes, }) {
         const showAxes = forceShowAxes ?? this.hideAxes ? false : true;
@@ -37,6 +38,7 @@ class GeogebraConstructor {
             isGridSimple: this.isGridSimple,
             gridDistance: this.gridDistance,
             isAxesRatioFixed: this.isAxesRatioFixed,
+            isXAxesNatural: this.isXAxesNatural,
         };
     }
 }

package/lib/index.d.ts

@@ -208,6 +208,15 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     rand: number;
     polynome1Coeffs: number[];
     polynome2Coeffs: number[];
+}> | import("./exercises/exercise").MathExercise<{
+    firstTermIsAffine: boolean;
+    a: number;
+    b: number;
+    c: number;
+    d: number;
+    e: number;
+    f: number;
+    g: number;
 }> | import("./exercises/exercise").MathExercise<{
     word: string;
 }> | import("./exercises/exercise").MathExercise<{
@@ -345,6 +354,11 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
 }> | import("./exercises/exercise").MathExercise<{
     a: number;
     initialY: number;
+}> | import("./exercises/exercise").MathExercise<{
+    type: string;
+    d: number;
+    e: number;
+    f: number | undefined;
 }> | import("./exercises/exercise").MathExercise<{
     a: number;
     b: number;
@@ -461,6 +475,17 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     b: number;
     c: number;
     ineqType: import("./math/inequations/inequation").InegalitySymbols;
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+    b: number;
+    c: number;
+}> | import("./exercises/exercise").MathExercise<{
+    roots: number[];
+    a: number;
+}> | import("./exercises/exercise").MathExercise<{
+    a: number;
+    b: number;
+    c: number;
 }> | import("./exercises/exercise").MathExercise<{
     a: number;
     k: number;
@@ -626,6 +651,10 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     yB: number;
     yC: number;
     yD: number;
+}> | import("./exercises/exercise").MathExercise<{
+    caracAsked: string;
+    uPoints: number[][];
+    vPoints: number[][];
 }> | import("./exercises/exercise").MathExercise<{
     coeffs: number[];
     to: string;
@@ -663,6 +692,11 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     b: string;
     c: string;
     d: string;
+}> | import("./exercises/exercise").MathExercise<{
+    AiCoeff: number;
+    AjCoeff: number;
+    BiCoeff: number;
+    BjCoeff: number;
 }> | import("./exercises/exercise").MathExercise<{
     randNbr: number;
     randPercent: number;
@@ -808,6 +842,24 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     pA: number;
     pB: number;
     pUnion: number;
+}> | import("./exercises/exercise").MathExercise<{
+    questionType: string;
+}> | import("./exercises/exercise").MathExercise<{
+    aCapB: number;
+    aCapBBarre: number;
+    aBarreCapB: number;
+    aBarreCapBBarre: number;
+    event: string;
+    type: string;
+    probaFrac: number[];
+}> | import("./exercises/exercise").MathExercise<{
+    aCapB: number;
+    aCapBBarre: number;
+    aBarreCapB: number;
+    aBarreCapBBarre: number;
+    event: string;
+    type: string;
+    probaFrac: number[];
 }> | import("./exercises/exercise").MathExercise<{
     firstValue: number;
     askedRank: number;
@@ -833,6 +885,18 @@ declare const mathExercises: (import("./exercises/exercise").MathExercise<{
     randValue: number;
 }> | import("./exercises/exercise").MathExercise<{
     final: number;
+}> | import("./exercises/exercise").MathExercise<{
+    sequences: number[][];
+    answerIndex: number;
+}> | import("./exercises/exercise").MathExercise<{
+    reason: number;
+    sequence: number[];
+}> | import("./exercises/exercise").MathExercise<{
+    reason: number;
+    sequence: number[];
+}> | import("./exercises/exercise").MathExercise<{
+    isAri: boolean;
+    sequence: number[];
 }> | import("./exercises/exercise").MathExercise<{
     firstValue: number;
     reason: number;

package/lib/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF;AA6CD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAtCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO4C,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAGA,OAAO,CAAC,MAAM,CAAC;IACb,UAAU,MAAM;QACd,MAAM,EAAE,MAAM,aAAa,CAAC;KAC7B;CACF;AA6CD,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAC3D,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAtCnB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCA/BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+BE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAO4C,CAAC;AAE/C,OAAO,EAAE,aAAa,EAAE,CAAC"}