math-exercises 3.0.192 → 3.0.193

package/lib/exercises/math/probaStat/stats2var/buildScatterPlotFromDataTable.js

@@ -0,0 +1,110 @@
+import { toolBarConstructor } from "../../../../exercises/utils/geogebra/toolBarConstructor.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../geogebra/geogebraConstructor.js";
+import { ggbPointToCoords } from "../../../../geogebra/parsers/ggbPointToCoords.js";
+import { parseGGBPoints } from "../../../../geogebra/parsers/parseGGBPoints.js";
+import { PointConstructor } from "../../../../math/geometry/point.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getInstruction = (identifiers) => {
+    return `On s'intéresse à l'évolution de la population de loups dans une zone protégée à partir de l'année $2000$ (année $0$). Le tableau suivant donne le nombre d'individus pour chaque année étudiée. 
+    
+${mdTable([
+        ["Année", ...identifiers.xs.map((e) => dollarize(e.frenchify()))],
+        [
+            "Nombre d'individus",
+            ...identifiers.ys.map((e) => dollarize(e.frenchify())),
+        ],
+    ])}
+
+Construire le nuage de points associé au tableau ci-dessus.`;
+};
+const getHint = () => {
+    return `Chaque colonne du tableau représente un point du nuage de points. La première ligne donne son abscisse, et la deuxième son ordonnée.`;
+};
+const getCorrection = (identifiers) => {
+    const { xs, ys } = identifiers;
+    const points = xs.map((x, i) => PointConstructor.fromCoords([x, ys[i]], `P_${i}`));
+    return `Le tableau nous donne les points suivants : 
+  
+- $${points.map((p) => p.toCoords()).join("$ \n - $")}$
+
+Il suffit ensuite de placer ces points dans la figure.
+`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { xs, ys } = identifiers;
+    const points = xs.map((x, i) => PointConstructor.fromCoords([x, ys[i]], `P_${i}`));
+    return [
+        ...points.flatMap((p) => p.toGGBCommand({
+            isFixed: true,
+            isSelectionnable: false,
+            showLabel: false,
+        })),
+    ];
+};
+const getStudentGGBOptions = () => {
+    const ggb = new GeogebraConstructor({
+        commands: [],
+        customToolBar: toolBarConstructor({ point: true }),
+    });
+    return ggb.getOptions({
+        coords: [-1, 11, -1, 11],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer, ...identifiers }) => {
+    const { xs, ys } = identifiers;
+    const points = xs.map((x, i) => PointConstructor.fromCoords([x, ys[i]], `P_${i}`));
+    const studentPoints = parseGGBPoints(ans)
+        .map((p) => ggbPointToCoords(p))
+        .sort((a, b) => a.x - b.x);
+    return studentPoints.every((p, i) => Math.abs(p.x - points[i].x.evaluate()) < 0.4 &&
+        Math.abs(p.y - points[i].y.evaluate()) < 0.4);
+};
+const getBuildScatterPlotFromDataTableQuestion = () => {
+    const xs = randTupleInt(4, {
+        from: 0,
+        to: 10,
+        allDifferent: true,
+        sorted: true,
+    });
+    const ys = randTupleInt(4, {
+        from: 0,
+        to: 10,
+        allDifferent: true,
+        sorted: true,
+    });
+    const identifiers = {
+        xs,
+        ys,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+export const buildScatterPlotFromDataTable = {
+    id: "buildScatterPlotFromDataTable",
+    label: "Construire le nuage de points associé à un tableau de données",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getBuildScatterPlotFromDataTableQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/stats2var/index.d.ts

@@ -1,3 +1,5 @@
 export * from "./averagePoint.js";
 export * from "./fineAdjustementExercise.js";
+export * from "./buildDataTableFromScatterplot.js";
+export * from "./buildScatterPlotFromDataTable.js";
 //# sourceMappingURL=index.d.ts.map

package/lib/exercises/math/probaStat/stats2var/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/stats2var/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,8BAA8B,CAAC;AAC7C,cAAc,oCAAoC,CAAC;AACnD,cAAc,oCAAoC,CAAC"}

package/lib/exercises/math/probaStat/stats2var/index.js

@@ -1,2 +1,4 @@
 export * from "./averagePoint.js";
 export * from "./fineAdjustementExercise.js";
+export * from "./buildDataTableFromScatterplot.js";
+export * from "./buildScatterPlotFromDataTable.js";

package/lib/exercises/math/sequences/geometric/graph/compareGeometricReasonWithOneFromGraph.d.ts

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

package/lib/exercises/math/sequences/geometric/graph/compareGeometricReasonWithOneFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compareGeometricReasonWithOneFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/compareGeometricReasonWithOneFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AAMrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAiFF,eAAO,MAAM,sCAAsC,EAAE,QAAQ,CAAC,WAAW,CAuBxE,CAAC"}

package/lib/exercises/math/sequences/geometric/graph/compareGeometricReasonWithOneFromGraph.js

@@ -0,0 +1,87 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { randfloat } from "../../../../../math/utils/random/randfloat.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    tryToAddWrongProp(propositions, "q>1");
+    tryToAddWrongProp(propositions, "q=1");
+    tryToAddWrongProp(propositions, "0<q<1");
+    tryToAddWrongProp(propositions, "q<0");
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { q } = identifiers;
+    return q > 1 ? "q>1" : "0<q<1";
+};
+const getInstruction = () => {
+    return `On donne ci-dessous le nuage de points représentant une suite géométrique $u$. 
+  
+Que peut-on dire sur la raison $q$ de cette suite ?`;
+};
+const getHint = () => {
+    return `La raison d'une suite géométrique est le nombre par lequel on multiplie un terme pour passer au suivant. 
+  
+Ici, le sens de variations de la suite te donne une indication sur ce nombre : les termes de la suite augmentent-ils en fonction du rang, ou bien diminuent-ils ?`;
+};
+const getCorrection = (identifiers) => {
+    const { q } = identifiers;
+    return `Le nuage de points de la suite $u$ montre qu'elle est ${q > 1 ? "croissante" : "décroissante"}.
+  
+Or, une suite géométrique est : 
+- croissante si et seulement si $q>1$;
+- décroissante si et seulement si $0<q<1$.
+
+Ici, on peut donc affirmer que $${getAnswer(identifiers)}$.`;
+};
+const getGGBOptions = (identifiers) => {
+    const { q, start } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [`Sequence((n, ${start}*${q}^n), n, 0, 50)`],
+        lockedAxesRatio: false,
+        gridDistance: false,
+    });
+    const max = Math.max(start, q ** 4 * start);
+    return ggb.getOptions({
+        coords: [-1, 5, Math.min(-1, -max * 0.1), 1.2 * max],
+    });
+};
+const getCompareGeometricReasonWithOneFromGraphQuestion = () => {
+    const start = randfloat(0.5, 4, 2);
+    const q = coinFlip() ? randfloat(0.1, 1, 2, [1]) : randfloat(1.1, 5, 2);
+    const identifiers = { q, start };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const compareGeometricReasonWithOneFromGraph = {
+    id: "compareGeometricReasonWithOneFromGraph",
+    label: "Comparer la raison d'une suite géométrique avec $1$ à partir de son nuage de points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getCompareGeometricReasonWithOneFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    answerType: "QCU",
+    hasHintAndCorrection: true,
+};

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

@@ -1,2 +1,5 @@
-export * from "./geometricPlaceFirstPoints.js";
+export * from "./recognizeGeometricFromGraph.js";
+export * from "./plausibleGeometricSequenceExpressionFromGraph.js";
+export * from "./readGeometricExpressionFromGraph.js";
+export * from "./compareGeometricReasonWithOneFromGraph.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/index.ts"],"names":[],"mappings":"AAAA,cAAc,gCAAgC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/index.ts"],"names":[],"mappings":"AAAA,cAAc,kCAAkC,CAAC;AACjD,cAAc,oDAAoD,CAAC;AACnE,cAAc,uCAAuC,CAAC;AACtD,cAAc,6CAA6C,CAAC"}

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

@@ -1 +1,4 @@
-export * from "./geometricPlaceFirstPoints.js";
+export * from "./recognizeGeometricFromGraph.js";
+export * from "./plausibleGeometricSequenceExpressionFromGraph.js";
+export * from "./readGeometricExpressionFromGraph.js";
+export * from "./compareGeometricReasonWithOneFromGraph.js";

package/lib/exercises/math/sequences/geometric/graph/plausibleGeometricSequenceExpressionFromGraph.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    q: number;
+    start: number;
+    fakeParams: {
+        start: number;
+        q: number;
+    }[];
+};
+export declare const plausibleGeometricSequenceExpressionFromGraph: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=plausibleGeometricSequenceExpressionFromGraph.d.ts.map

package/lib/exercises/math/sequences/geometric/graph/plausibleGeometricSequenceExpressionFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plausibleGeometricSequenceExpressionFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/plausibleGeometricSequenceExpressionFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAaT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,CAAC,EAAE,MAAM,CAAC;IACV,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;CAC5C,CAAC;AAyIF,eAAO,MAAM,6CAA6C,EAAE,QAAQ,CAAC,WAAW,CAwB7E,CAAC"}

package/lib/exercises/math/sequences/geometric/graph/plausibleGeometricSequenceExpressionFromGraph.js

@@ -0,0 +1,133 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { randfloat } from "../../../../../math/utils/random/randfloat.js";
+import { round } from "../../../../../math/utils/round.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+const getPropositions = (n, { answer, fakeParams }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    for (let i = 0; i < fakeParams.length; i++) {
+        tryToAddWrongProp(propositions, multiply(fakeParams[i].start, power(fakeParams[i].q, "n")).toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { start, q } = identifiers;
+    return multiply(start, power(q, "n")).toTex();
+};
+const getInstruction = () => {
+    return `On donne ci-dessous les premiers points d'un nuage de points représentant une suite géométrique $u$..
+
+Parmi les formes explicites suivantes, laquelle peut être celle de $u$ ?`;
+};
+const getHint = () => {
+    return `Le sens de variation de la suite peut t'aider. Si on note $q$ sa raison, alors : 
+  
+-  si $q>1$, la suite est strictement croissante;
+-  si $0<q<1$, la suite est strictement décroissante.
+  
+D'autre part, tu peux lire la valeur du premier terme de la suite.`;
+};
+const getCorrection = (identifiers) => {
+    const { q, start } = identifiers;
+    const sens = q < 1 ? "décroissante" : "croissante";
+    return `On sait que la forme explicite de la suite $u$ est de la forme :
+  
+$$
+u_n = u_0\\times q^n
+$$
+
+D'après le graphique, la suite $u$ est ${sens}. On en déduit donc que $q ${q < 1 ? "<1" : ">1"}$. Cela permet donc d'exclure deux des propositions.
+
+Ensuite, on lit le premier terme de la suite : on trouve $u_0 \\approx ${round(start, 1).frenchify()}$.
+
+On en conclut donc que la seule forme explicite possible pour $u$ est :
+
+$$
+u_n = ${getAnswer(identifiers)}
+$$`;
+};
+const getGGBOptions = (identifiers) => {
+    const { q, start } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [`Sequence((n, ${start}*${q}^n), n, 0, 50)`],
+        lockedAxesRatio: false,
+    });
+    const f2 = multiply(start, power(q, 2)).evaluate();
+    return ggb.getOptions({
+        coords: [-1, 5, -1, Math.max(start, f2) + 1],
+    });
+};
+const getPlausibleExponentialFunctionExpressionFromGraphQuestion = () => {
+    const start = randfloat(0.5, 4, 2);
+    const q = coinFlip() ? randfloat(0.1, 1, 2, [1]) : randfloat(1.1, 5, 2);
+    let fakeParams = [];
+    if (q > 1) {
+        const firstDescQ = randfloat(0.1, 1, 2, [1]);
+        const secondDescQ = randfloat(0.1, 1, 2, [firstDescQ]);
+        const thirdQ = randfloat(1.1, 5, 2, [q]);
+        const firstStart = start;
+        const secondStart = randfloat(0.1, 4, 2);
+        const delta = randfloat(1, 3, 2);
+        const thirdStart = round(start - delta > 0 ? start - delta : start + delta, 2);
+        fakeParams = [
+            { q: firstDescQ, start: firstStart },
+            { q: secondDescQ, start: secondStart },
+            { q: thirdQ, start: thirdStart },
+        ];
+    }
+    else {
+        const firstAscQ = randfloat(1.1, 5, 2);
+        const secondAscQ = randfloat(1.1, 5, 2, [firstAscQ]);
+        const thirdQ = randfloat(0.1, 1, 2, [1, q]);
+        const firstStart = start;
+        const secondStart = randfloat(0.1, 4, 2);
+        const delta = randfloat(1, 3, 2);
+        const thirdStart = round(start - delta > 0 ? start - delta : start + delta, 2);
+        fakeParams = [
+            { q: firstAscQ, start: firstStart },
+            { q: secondAscQ, start: secondStart },
+            { q: thirdQ, start: thirdStart },
+        ];
+    }
+    const identifiers = {
+        start,
+        q,
+        fakeParams,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const plausibleGeometricSequenceExpressionFromGraph = {
+    id: "plausibleGeometricSequenceExpressionFromGraph",
+    label: "Donner la forme explicite possible d'une suite géométrique à partir de son nuage de points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlausibleExponentialFunctionExpressionFromGraphQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    answerType: "QCU",
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/graph/readGeometricExpressionFromGraph.d.ts

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

package/lib/exercises/math/sequences/geometric/graph/readGeometricExpressionFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"readGeometricExpressionFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/readGeometricExpressionFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AAWrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,CAAC,EAAE,MAAM,CAAC;CACX,CAAC;AAqHF,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,CA0BlE,CAAC"}

package/lib/exercises/math/sequences/geometric/graph/readGeometricExpressionFromGraph.js

@@ -0,0 +1,132 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { GeogebraConstructor } from "../../../../../geogebra/geogebraConstructor.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const fakeStart = randint(2, 10);
+        const fakeQ = random([0.2, 0.5, 2, 3, 4, 5]);
+        tryToAddWrongProp(propositions, multiply(fakeStart, power(fakeQ, "n")).toTex());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { q, start } = identifiers;
+    return multiply(start, power(q, "n")).simplify().toTex();
+};
+const getInstruction = () => {
+    return `On donne ci-dessous le nuage de points d'une suite géométrique $u$.
+  
+Déterminer la forme explicite de $u$.`;
+};
+const getHint = () => {
+    return `La forme explicite d'une suite géométrique $u$ de premier terme $u_0$ et de raison $q$ est :
+
+$$
+u_n = u_0\\times q^n
+$$
+  
+Commence par lire le premier terme de la suite $u_0$.
+  
+Puis, détermine la raison de la suite en observant comment on passe d'un terme au suivant. `;
+};
+const getCorrection = (identifiers) => {
+    const { q, start } = identifiers;
+    return `On lit le premier terme de la suite : 
+
+$$
+u_0 = ${start.frenchify()}
+$$
+
+Puis, on détermine la raison de la suite. Pour cela, on remarque que : 
+
+$$
+u_1 = ${round(start * q, 2).frenchify()}
+$$
+
+Pour passer de $u_0$ à $u_1$, on a donc multiplié par $${q.frenchify()}$ : c'est la raison de la suite.
+
+La forme explicite de $u$ est donc : 
+
+$$
+u_n = ${getAnswer(identifiers)}
+$$
+`;
+};
+const getGGBOptions = (identifiers) => {
+    const { q, start } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [`Sequence((n, ${start}*${q}^n), n, 0, 50)`],
+        lockedAxesRatio: false,
+    });
+    return ggb.getOptions({
+        coords: [-1, 5, -1, 1.2 * Math.max(start, q * start, q * q * start)],
+    });
+};
+const getKeys = () => {
+    return ["n"];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        const parsed = parseAlgebraic(ans);
+        if (!parsed)
+            return false;
+        return parsed.simplify().toTex() === answer;
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getReadExponentialFunctionParamsOnGraphQuestion = () => {
+    const [start, q] = random([
+        [random([2, 4, 6, 8]), 0.5],
+        [random([0.2, 1, 2, 3, 4, 5]), 2],
+        [random([0.5, 2]), 3],
+    ]);
+    const identifiers = {
+        start,
+        q,
+    };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: getKeys(identifiers),
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+        ggbOptions: getGGBOptions(identifiers),
+    };
+};
+export const readGeometricExpressionFromGraph = {
+    id: "readGeometricExpressionFromGraph",
+    connector: "=",
+    label: "Déterminer la forme explicite d'une suite géométrique à partir de son nuage de points",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getReadExponentialFunctionParamsOnGraphQuestion(opts), nb, 10),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getCorrection,
+    getInstruction,
+    getAnswer,
+    getGGBOptions,
+    hasGeogebra: true,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+    maxAllowedQuestions: 10,
+};

package/lib/exercises/math/sequences/geometric/graph/recognizeGeometricFromGraph.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    isGeo: boolean;
+    sequence: number[];
+};
+type Options = {
+    firstTermRankOne?: boolean;
+};
+export declare const recognizeGeometricFromGraph: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=recognizeGeometricFromGraph.d.ts.map

package/lib/exercises/math/sequences/geometric/graph/recognizeGeometricFromGraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeGeometricFromGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/graph/recognizeGeometricFromGraph.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB,CAAC;AA8IF,KAAK,OAAO,GAAG;IACb,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B,CAAC;AASF,eAAO,MAAM,2BAA2B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBtE,CAAC"}