math-exercises 3.0.158 → 3.0.159

package/lib/exercises/math/probaStat/randomVariable/findValueForFairRandomVariable.js

@@ -0,0 +1,141 @@
+import { addValidProp, shuffleProps, propWhile, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        throw Error("QCM not implemented");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { probasIds, valuesIds } = identifiers;
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    const xIndex = probas.findIndex((e) => !e.isNumeric) > -1
+        ? probas.findIndex((e) => !e.isNumeric)
+        : values.findIndex((e) => !e.isNumeric);
+    let esp = (xIndex === 0
+        ? multiply(values[1], probas[1])
+        : multiply(values[0], probas[0]));
+    for (let i = xIndex === 0 ? 2 : 1; i < values.length; i++) {
+        if (i === xIndex)
+            continue;
+        esp = add(esp, multiply(values[i], probas[i]));
+    }
+    const simp = esp.simplify();
+    const isXMissing = values.some((x) => !x.isNumeric);
+    const coeff = isXMissing ? probas[xIndex] : values[xIndex];
+    const x = frac(simp, coeff).simplify().evaluate();
+    return x.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { probasIds, valuesIds } = identifiers;
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    return `On joue à un jeu de hasard. On note $X$ la variable aléatoire égale au gain du joueur. La loi de probabilité de $X$ est donnée ci-dessous: 
+
+${mdTable([
+        ["$x_i$ (en $€$)", ...values.map((e) => e.toTex())],
+        ["$P(X=x_i)$", ...probas.map((e) => e.toTex())],
+    ])}
+
+Pour quelle valeur de $x$ le jeu est-il équitable ? `;
+};
+const getHint = () => {
+    return `Un jeu est équitable si l'espérance de gain est nulle. 
+  
+Calcule donc $E(X)$ en fonction de $x$, puis résous l'équation $E(x) = 0$.`;
+};
+const getCorrection = (identifiers) => {
+    return ``;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindProbaForFairGameQuestion = () => {
+    const xValues = [
+        0,
+        randint(1, 5),
+        randint(5, 10),
+        5 * randint(10, 20),
+        100 * randint(1, 10),
+    ];
+    const probas = [
+        randfloat(0.1, 0.3, 2),
+        randfloat(0.02, 0.04, 3),
+        randfloat(0.01, 0.02, 3),
+        randfloat(0.001, 0.009, 3),
+    ];
+    const left = round(1 - probas.reduce((acc, curr) => acc + curr, 0), 4);
+    probas.unshift(left);
+    const xNodes = xValues.map((e) => e.toTree());
+    const yNodes = probas.map((e) => e.toTree());
+    const isXMissing = coinFlip();
+    if (isXMissing) {
+        xNodes[randint(0, xValues.length)] = "x".toTree();
+    }
+    else {
+        yNodes[randint(0, xValues.length)] = "x".toTree();
+    }
+    const identifiers = {
+        valuesIds: xNodes.map((e) => e.toIdentifiers()),
+        probasIds: yNodes.map((e) => e.toIdentifiers()),
+    };
+    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),
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
+        },
+    };
+};
+export const findValueForFairRandomVariable = {
+    id: "findValueForFairRandomVariable",
+    connector: "=",
+    label: "Compléter la loi de probabilité d'une variable aléatoire pour rendre un jeu équitable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindProbaForFairGameQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/probaStat/randomVariable/findValueToMatchRandomVariableAverage.d.ts

@@ -0,0 +1,10 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+import { NodeIdentifiers } from "../../../../tree/nodes/nodeConstructor.js";
+type Identifiers = {
+    valuesIds: NodeIdentifiers[];
+    probasIds: NodeIdentifiers[];
+    avgIds: NodeIdentifiers;
+};
+export declare const findValueToMatchRandomVariableAverage: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=findValueToMatchRandomVariableAverage.d.ts.map

package/lib/exercises/math/probaStat/randomVariable/findValueToMatchRandomVariableAverage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"findValueToMatchRandomVariableAverage.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/findValueToMatchRandomVariableAverage.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AAOrC,OAAO,EACL,eAAe,EAEhB,MAAM,qCAAqC,CAAC;AAY7C,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,SAAS,EAAE,eAAe,EAAE,CAAC;IAC7B,MAAM,EAAE,eAAe,CAAC;CACzB,CAAC;AA6JF,eAAO,MAAM,qCAAqC,EAAE,QAAQ,CAAC,WAAW,CAmBvE,CAAC"}

package/lib/exercises/math/probaStat/randomVariable/findValueToMatchRandomVariableAverage.js

@@ -0,0 +1,174 @@
+import { addValidProp, shuffleProps, propWhile, tryToAddWrongProp, } from "../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { rationalVEA } from "../../../../exercises/vea/rationalVEA.js";
+import { randfloat } from "../../../../math/utils/random/randfloat.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { reifyAlgebraic, } from "../../../../tree/nodes/nodeConstructor.js";
+import { add, AddNode } from "../../../../tree/nodes/operators/addNode.js";
+import { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { multiply } from "../../../../tree/nodes/operators/multiplyNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { operatorComposition } from "../../../../tree/utilities/operatorComposition.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { dollarize } from "../../../../utils/latex/dollarize.js";
+import { mdTable } from "../../../../utils/markdown/mdTable.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const ansNb = answer.unfrenchify();
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, (ansNb + randfloat(-3, 3, 2)).frenchify());
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+    const { probasIds, valuesIds, avgIds } = identifiers;
+    const esp = reifyAlgebraic(avgIds);
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    const xIndex = probas.findIndex((e) => !e.isNumeric) > -1
+        ? probas.findIndex((e) => !e.isNumeric)
+        : values.findIndex((e) => !e.isNumeric);
+    let partialEsp = (xIndex === 0
+        ? multiply(values[1], probas[1])
+        : multiply(values[0], probas[0]));
+    for (let i = xIndex === 0 ? 2 : 1; i < values.length; i++) {
+        if (i === xIndex)
+            continue;
+        partialEsp = add(partialEsp, multiply(values[i], probas[i]));
+    }
+    const simp = partialEsp.simplify();
+    const sum = substract(esp, simp);
+    const isXMissing = values.some((x) => !x.isNumeric);
+    const coeff = isXMissing ? probas[xIndex] : values[xIndex];
+    const x = round(frac(sum, coeff).simplify().evaluate(), 5);
+    return x.frenchify();
+};
+const getInstruction = (identifiers) => {
+    const { probasIds, valuesIds, avgIds } = identifiers;
+    const avg = reifyAlgebraic(avgIds);
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    return `La loi de probabilité d'une variable aléatoire $X$ est donnée ci-dessous: 
+
+${mdTable([
+        ["$x_i$", ...values.map((e) => dollarize(e.toTex()))],
+        ["$P(X=x_i)$", ...probas.map((e) => dollarize(e.toTex()))],
+    ])}
+
+On sait de plus que l'espérance de $X$ vaut $E(X) = ${avg.toTex()}$.
+
+Que vaut $x$ ? `;
+};
+const getHint = () => {
+    return `Si $X$ est une variable aléatoire qui prend les valeurs $x_1$, $x_2$, $\\ldots$, $x_n$ de probabilités respectives $p_1$, $p_2$, $\\ldots$, $p_n$, alors son espérance $E(X)$ vaut : 
+  
+$$
+E(X) = x_1p_1 + x_2p_2 + \\ldots + x_np_n
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { probasIds, valuesIds, avgIds } = identifiers;
+    const avg = reifyAlgebraic(avgIds);
+    const probas = probasIds.map((e) => reifyAlgebraic(e));
+    const values = valuesIds.map((e) => reifyAlgebraic(e));
+    const sum = operatorComposition(AddNode, values.map((v, i) => multiply(v, probas[i])));
+    const sumSimp = sum.simplify();
+    return `On calcule l'espérance de $X$ : 
+  
+${alignTex([
+        ["", "E(X)"],
+        ["=", sum.toTex()],
+        ["=", sumSimp.toTex()],
+    ])}
+
+On résout alors l'équation $E(X) = ${avg.toTex()}$. Cela donne : 
+
+$$
+x = ${getAnswer(identifiers)}
+$$
+`;
+};
+const getKeys = () => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return rationalVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getFindProbaForFairGameQuestion = () => {
+    const xValues = [
+        0,
+        randint(1, 5),
+        randint(5, 10),
+        5 * randint(10, 20),
+        100 * randint(1, 10),
+    ];
+    const probas = [
+        randfloat(0.1, 0.3, 2),
+        randfloat(0.02, 0.04, 3),
+        randfloat(0.01, 0.02, 3),
+        randfloat(0.001, 0.009, 3),
+    ];
+    const left = round(1 - probas.reduce((acc, curr) => acc + curr, 0), 4);
+    probas.unshift(left);
+    const avg = round(xValues.reduce((acc, curr, i) => acc + curr * probas[i], 0), 5);
+    const xNodes = xValues.map((e) => e.toTree());
+    const yNodes = probas.map((e) => e.toTree());
+    const isXMissing = coinFlip();
+    if (isXMissing) {
+        xNodes[randint(0, xValues.length)] = "x".toTree();
+    }
+    else {
+        yNodes[randint(1, xValues.length)] = "x".toTree();
+    }
+    const identifiers = {
+        valuesIds: xNodes.map((e) => e.toIdentifiers()),
+        probasIds: yNodes.map((e) => e.toIdentifiers()),
+        avgIds: avg.toTree().toIdentifiers(),
+    };
+    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),
+        style: {
+            tableOptions: {
+                firstColumnIsHeader: true,
+                firstCellIsDivided: false,
+                firstRowIsHeader: false,
+            },
+        },
+    };
+};
+export const findValueToMatchRandomVariableAverage = {
+    id: "findValueToMatchRandomVariableAverage",
+    connector: "=",
+    label: "Compléter la loi de probabilité d'une variable aléatoire pour rendre un jeu équitable",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getFindProbaForFairGameQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -2,4 +2,5 @@ export * from "./randomVariableAverage.js";
 export * from "./randomVariableVariance.js";
 export * from "./isTableProbabilityLaw.js";
 export * from "./randomVariableStandardDeviation.js";
+export * from "./findValueToMatchRandomVariableAverage.js";
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/probaStat/randomVariable/index.ts"],"names":[],"mappings":"AAAA,cAAc,4BAA4B,CAAC;AAC3C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,4BAA4B,CAAC;AAC3C,cAAc,sCAAsC,CAAC;AAErD,cAAc,4CAA4C,CAAC"}

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

@@ -2,3 +2,5 @@ export * from "./randomVariableAverage.js";
 export * from "./randomVariableVariance.js";
 export * from "./isTableProbabilityLaw.js";
 export * from "./randomVariableStandardDeviation.js";
+// export * from "./findValueForFairRandomVariable.js";
+export * from "./findValueToMatchRandomVariableAverage.js";

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1 @@
+export {};

package/lib/exercises/math/sequences/generation/recognizeRecurrenceOrExplicit.d.ts

@@ -0,0 +1,8 @@
+import { Exercise } from '../../../../exercises/exercise.js';
+import { NodeIdentifiers } from '../../../../tree/nodes/nodeConstructor.js';
+type Identifiers = {
+    relations: NodeIdentifiers[];
+};
+export declare const recognizeRecurrenceOrExplicit: Exercise<Identifiers>;
+export {};
+//# sourceMappingURL=recognizeRecurrenceOrExplicit.d.ts.map

package/lib/exercises/math/sequences/generation/recognizeRecurrenceOrExplicit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recognizeRecurrenceOrExplicit.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/generation/recognizeRecurrenceOrExplicit.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,eAAe,EAAE,MAAM,qCAAqC,CAAC;AAGtE,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,eAAe,EAAE,CAAA;CAC7B,CAAC;AA2DF,eAAO,MAAM,6BAA6B,EAAE,QAAQ,CAAC,WAAW,CAiB/D,CAAC"}

package/lib/exercises/math/sequences/generation/recognizeRecurrenceOrExplicit.js

@@ -0,0 +1,63 @@
+import { addValidProp, shuffleProps, } from '../../../../exercises/exercise.js';
+import { getDistinctQuestions } from '../../../../exercises/utils/getDistinctQuestions.js';
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        throw Error("QCM not implemented");
+    });
+    return shuffleProps(propositions, n);
+};
+const getAnswer = (identifiers) => {
+};
+const getInstruction = (identifiers) => {
+};
+const getHint = (identifiers) => {
+};
+const getCorrection = (identifiers) => {
+};
+const getKeys = (identifiers) => {
+    return [];
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        throw Error("VEA not implemented");
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getRecognizeRecurrenceOrExplicitQuestion = (ops) => {
+    const identifiers = {};
+    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)
+    };
+};
+export const recognizeRecurrenceOrExplicit = {
+    id: 'recognizeRecurrenceOrExplicit',
+    connector: "",
+    label: undefined,
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getRecognizeRecurrenceOrExplicitQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getInstruction,
+    getHint,
+    getCorrection,
+    getAnswer,
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true
+};

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

@@ -0,0 +1,2 @@
+export * from "./placeFirstSequencePoints.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/graph/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC"}

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

@@ -0,0 +1 @@
+export * from "./placeFirstSequencePoints.js";

package/lib/exercises/math/sequences/graph/placeFirstSequencePoints.d.ts

@@ -0,0 +1,11 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    firstRank: number;
+    values: number[];
+};
+type Options = {
+    firstRank: string;
+};
+export declare const placeFirstSequencePoints: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=placeFirstSequencePoints.d.ts.map

package/lib/exercises/math/sequences/graph/placeFirstSequencePoints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placeFirstSequencePoints.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/graph/placeFirstSequencePoints.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAYT,MAAM,6BAA6B,CAAC;AASrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB,CAAC;AAyGF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAYF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBnE,CAAC"}

package/lib/exercises/math/sequences/graph/placeFirstSequencePoints.js

@@ -0,0 +1,113 @@
+import { GeneratorOptionTarget, GeneratorOptionType, } from "../../../../exercises/exercise.js";
+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 { randint } from "../../../../math/utils/random/randint.js";
+import { randTupleInt } from "../../../../math/utils/random/randTupleInt.js";
+const getInstruction = (identifiers) => {
+    const { firstRank, values } = identifiers;
+    return `On considère une suite $u$ de premier rang $${firstRank}$ et dont voici les premiers termes, dans l'ordre : 
+    
+$$
+${values.join("\\ ; \\ ")}
+$$
+
+Dans le repère ci-dessous, placer les termes connus de $u$.`;
+};
+const getHint = () => {
+    return `Une suite est représentée par un nuage de point. L'abscisse de chaque point est le rang du terme, et l'ordonnée est le terme en lui-même.`;
+};
+const getCorrection = (identifiers) => {
+    const { firstRank, values } = identifiers;
+    return `Une suite est représentée par un nuage de point. L'abscisse de chaque point est le rang du terme, et l'ordonnée est le terme en lui-même.
+  
+Les points du nuage sont donc ici les suivants : 
+
+${values
+        .map((e, i) => `$$
+A_${i + firstRank}(${i + firstRank};${e})
+$$`)
+        .join("\n \n")}
+`;
+};
+const getGGBAnswer = (identifiers) => {
+    const { firstRank, values } = identifiers;
+    return [...values.map((e, i) => `A_${i}= (${i + firstRank}, ${e})`)];
+};
+const getStudentGGBOptions = (identifiers) => {
+    const { values } = identifiers;
+    const ggb = new GeogebraConstructor({
+        commands: [],
+        customToolBar: toolBarConstructor({
+            point: true,
+        }),
+    });
+    const yMin = Math.min(...values);
+    const yMax = Math.max(...values);
+    return ggb.getOptions({
+        coords: [-1, 6, Math.min(yMin, 0) - 1, Math.max(yMax, 1) + 1],
+    });
+};
+const isGGBAnswerValid = (ans, { ggbAnswer: _ggbAns, values, firstRank }) => {
+    const points = parseGGBPoints(ans)
+        .map((p) => ggbPointToCoords(p))
+        .sort((a, b) => a.x - b.x);
+    const validPoints = values.map((e, i) => {
+        return { x: i + firstRank, y: e };
+    });
+    return points.every((p, i) => Math.abs(p.x - validPoints[i].x) < 0.4 &&
+        Math.abs(p.y - validPoints[i].y) < 0.4);
+};
+const getPlaceFirstSequencePointsQuestion = (opts) => {
+    const firstRank = opts?.firstRank === "$0$"
+        ? 0
+        : opts?.firstRank === "$1$"
+            ? 1
+            : randint(0, 2);
+    const values = randTupleInt(4, { from: -5, to: 6, allDifferent: true });
+    const identifiers = {
+        firstRank,
+        values,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    return {
+        ggbAnswer: getGGBAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        studentGgbOptions: getStudentGGBOptions(identifiers),
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+};
+const options = [
+    {
+        id: "firstRank",
+        label: "Premier rang",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["$0$", "$1$", "Les deux aléatoirement"],
+        defaultValue: "Les deux aléatoirement",
+    },
+];
+export const placeFirstSequencePoints = {
+    id: "placeFirstSequencePoints",
+    label: "Placer les premiers termes d'une suite dans un repère",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getPlaceFirstSequencePointsQuestion(opts), nb),
+    ggbTimer: 60,
+    isGGBAnswerValid,
+    subject: "Mathématiques",
+    getHint,
+    getInstruction,
+    getCorrection,
+    getGGBAnswer,
+    getStudentGGBOptions,
+    answerType: "GGB",
+    getQuestionFromIdentifiers,
+    options,
+    hasHintAndCorrection: true,
+};

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

@@ -5,4 +5,6 @@ export * from "./genericSequenceVariations.js";
 export * from "./recurrenceFormulaUsage.js";
 export * from "./sequenceEvaluation.js";
 export * from "./sequencePlot.js";
+export * from "./graph/index.js";
+export * from "./notation/index.js";
 //# 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,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/exercises/math/sequences/index.ts"],"names":[],"mappings":"AAAA,cAAc,uBAAuB,CAAC;AACtC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,yBAAyB,CAAC;AACxC,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,qBAAqB,CAAC"}

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

@@ -5,3 +5,5 @@ export * from "./genericSequenceVariations.js";
 export * from "./recurrenceFormulaUsage.js";
 export * from "./sequenceEvaluation.js";
 export * from "./sequencePlot.js";
+export * from "./graph/index.js";
+export * from "./notation/index.js";

package/lib/exercises/math/sequences/notation/identifyRankInSequenceTermsList.d.ts

@@ -0,0 +1,12 @@
+import { Exercise } from "../../../../exercises/exercise.js";
+type Identifiers = {
+    values: number[];
+    firstRank: number;
+    askedTerm: number;
+};
+type Options = {
+    firstRank: string;
+};
+export declare const identifyRankInSequenceTermsList: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=identifyRankInSequenceTermsList.d.ts.map

package/lib/exercises/math/sequences/notation/identifyRankInSequenceTermsList.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identifyRankInSequenceTermsList.d.ts","sourceRoot":"","sources":["../../../../../src/exercises/math/sequences/notation/identifyRankInSequenceTermsList.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,MAAM,EAAE,MAAM,EAAE,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+FF,KAAK,OAAO,GAAG;IACb,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAYF,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmB1E,CAAC"}