math-exercises 3.0.172 → 3.0.173

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

@@ -0,0 +1,260 @@
+import { addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../exercises/options/optionFirstTermRankOne.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../exercises/vea/numberVEA.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 { frac } from "../../../../tree/nodes/operators/fractionNode.js";
+import { power } from "../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { coinFlip } from "../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../utils/alea/random.js";
+import { shuffle } from "../../../../utils/alea/shuffle.js";
+import { handleVEAError } from "../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+const getInstruction = (identifiers) => {
+    const { rank1, value1, rank2, value2, rankAsked } = identifiers;
+    return `Soit $u$ une suite géométrique telle que $u_{${rank1.frenchify()}} = ${value1.frenchify()}$ et $u_{${rank2.frenchify()}} = ${value2.frenchify()}$. 
+  
+Que vaut $u_{${rankAsked}}$ ?`;
+};
+const getAnswerStuff = (identifiers, _opts) => {
+    const { rank1, value1, rank2, value2, precisionInitial, precisionReason, rankAsked, } = identifiers;
+    const reason = round(power(frac(value2, value1), frac(1, substract(rank2, rank1))).evaluate(), precisionReason);
+    const valueAsked = round(frac(value1, power(reason, rank1 - rankAsked)).evaluate(), precisionInitial);
+    return {
+        reason,
+        answerNode: valueAsked.toTree(),
+    };
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerStuff(identifiers, opts).answerNode.toTex();
+};
+const getHint = (identifiers, _optsIn) => {
+    const { rankAsked } = identifiers;
+    return `Commence par déterminer la raison $q$ de la suite $u$. 
+  
+Puis, utilise cette raison et un des termes connus de la suite pour déterminer $u_{${rankAsked}}$.`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { rank1, value1, rank2, value2, rankAsked } = identifiers;
+    const diff = rankAsked - rank1;
+    const { reason, answerNode } = getAnswerStuff(identifiers, opts);
+    return `On commence par déterminer la raison $q$ de la suite $u$.
+
+On a :
+
+${alignTex([
+        [
+            `u_{${rank1}}`,
+            "=",
+            `u_{${firstRank}} \\times q^{${rank1.frenchify()} - ${firstRank.frenchify()}}`,
+        ],
+        [
+            `u_{${rank2}}`,
+            "=",
+            `u_{${firstRank}} \\times q^{${rank2.frenchify()} - ${firstRank.frenchify()}}`,
+        ],
+    ])}
+
+On forme le quotient :
+
+${alignTex([
+        [
+            `\\frac{u_{${rank2}}}{u_{${rank1}}}`,
+            "=",
+            `q^{${rank2.frenchify()} - ${rank1.frenchify()}}`,
+        ],
+        [
+            `\\frac{${value2.frenchify()}}{${value1.frenchify()}}`,
+            "=",
+            `q^{${(rank2 - rank1).frenchify()}}`,
+        ],
+    ])}
+
+On peut ainsi calculer $q$ :
+
+${alignTex([
+        [
+            `{\\left(\\frac{${value2.frenchify()}}{${value1.frenchify()}}\\right)}^{\\frac{1}{${(rank2 - rank1).frenchify()}}}`,
+            "=",
+            `q`,
+        ],
+        [`${reason.frenchify()}`, "=", `q`],
+    ])}
+
+
+On peut alors déterminer $u_{${rankAsked.frenchify()}}$ en utilisant $u_{${rank1.frenchify()}}$ et $q$. En effet, on a : 
+
+${alignTex([
+        [
+            `u_{${rankAsked.frenchify()}}`,
+            "=",
+            `\\frac{u_{${rank1.frenchify()}}}{q^{${(-diff).frenchify()}}}`,
+        ],
+        ["", "=", frac(value1, power(reason, -diff)).toTex()],
+        ["", "=", answerNode.toTex()],
+    ])}
+
+`;
+};
+const getPropositions = (n, { answer, ..._identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        const identifiersWrong = createRandomIdentifiersCurated(opts);
+        const texWrong = getAnswer(identifiersWrong, opts);
+        tryToAddWrongProp(propositions, texWrong);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const createRandomIdentifiersRaw = (opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const isDivergent = coinFlip();
+    const isReasonNegative = coinFlip();
+    const signReason = isReasonNegative ? -1 : +1;
+    function createGeometricDivergent() {
+        const precisionInitial = 1;
+        const initial = randfloat(1, 10, precisionInitial, [1]);
+        const precisionReason = 0;
+        const reason = signReason * randint(2, 10);
+        return [initial, precisionInitial, reason, precisionReason];
+    }
+    function createGeometricConvergent() {
+        const poolReasonStuff = [
+            {
+                q: 0.5,
+                precision: 1,
+                invQ: 2,
+            },
+            {
+                q: 0.25,
+                precision: 2,
+                invQ: 4,
+            },
+            {
+                q: 0.2,
+                precision: 1,
+                invQ: 5,
+            },
+            {
+                q: 0.1,
+                precision: 1,
+                invQ: 10,
+            },
+            {
+                q: 0.05,
+                precision: 2,
+                invQ: 20,
+            },
+        ];
+        const { q, invQ, precision: precisionReason } = random(poolReasonStuff);
+        const reason = signReason * q;
+        const precisionInitial = 0;
+        const initial = round(randint(10, 100) * Math.pow(invQ, 8), precisionInitial);
+        return [initial, precisionInitial, reason, precisionReason];
+    }
+    const [initial, precisionInitial, reason, precisionReason] = (() => {
+        if (isDivergent) {
+            return createGeometricDivergent();
+        }
+        else {
+            return createGeometricConvergent();
+        }
+    })();
+    const rank1 = randint(firstRank + 1, 5);
+    const rank2 = rank1 + randint(1, 5);
+    const rankAsked = randint(2, 9, [rank1, rank2]);
+    function valueForRank(initial, reason, rank) {
+        return initial * Math.pow(reason, rank);
+    }
+    const [value1, value2] = [rank1, rank2].map((rank) => round(valueForRank(initial, reason, rank), 4));
+    const identifiers = {
+        rank1,
+        value1,
+        rank2,
+        value2,
+        precisionInitial,
+        precisionReason,
+        rankAsked,
+    };
+    return identifiers;
+};
+const createRandomIdentifiersCurated = (opts) => {
+    let identifiers;
+    let isValid = false;
+    let counter = -1;
+    while (!isValid && counter < 100) {
+        counter++;
+        const identifiersCandidate = createRandomIdentifiersRaw(opts);
+        const answer = getAnswer(identifiersCandidate, opts);
+        isValid = !answer.includes("NaN");
+        if (isValid) {
+            identifiers = identifiersCandidate;
+        }
+    }
+    if (!isValid) {
+        //2.5 * 2^n
+        const identifiersDefault = {
+            rank1: 2,
+            value1: 10,
+            rank2: 5,
+            value2: 40,
+            precisionInitial: 1,
+            precisionReason: 0,
+            rankAsked: 9,
+        };
+        identifiers = identifiersDefault;
+    }
+    return identifiers;
+};
+const getGeometricFindRandomTermFromTwoTermsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const identifiers = createRandomIdentifiersCurated(opts);
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: ["un", "equal", "n"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne);
+const options = [generatorOptionFirstTermRankOne];
+export const geometricFindRandomTermFromTwoTerms = {
+    id: "geometricFindRandomTermFromTwoTerms",
+    connector: "=",
+    label: "Connaissant deux termes d'une suite géométrique, en donner une formule générale",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindRandomTermFromTwoTermsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/situations/geometricFindExplicitFormulaFromSituation.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { OptionIsWithSuperfluousData } from "../../../../../exercises/options/optionIsWithSuperfluousData.js";
+import { SituationGeometricSuperfluousData } from "../../../../../math/utils/sequences/situations/seqGeometricSituations.js";
+type Identifiers = {
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: SituationGeometricSuperfluousData;
+};
+type Options = OptionFirstTermRankOne & OptionIsWithSuperfluousData;
+export declare const geometricFindExplicitFormulaFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricFindExplicitFormulaFromSituation.d.ts.map

package/lib/exercises/math/sequences/geometric/situations/geometricFindExplicitFormulaFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindExplicitFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/geometricFindExplicitFormulaFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAIhE,OAAO,EAEL,iCAAiC,EAElC,MAAM,iEAAiE,CAAC;AAiBzE,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,iCAAiC,CAAC;CACrD,CAAC;AA8OF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,yCAAyC,EAAE,QAAQ,CAC9D,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/sequences/geometric/situations/geometricFindExplicitFormulaFromSituation.js

@@ -0,0 +1,186 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { getOptionIsWithSuperfluousData, } from "../../../../../exercises/options/optionIsWithSuperfluousData.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { situationsGeometric, } from "../../../../../math/utils/sequences/situations/seqGeometricSituations.js";
+import { EqualNode, isEqualNode, } from "../../../../../tree/nodes/equations/equalNode.js";
+import { add } from "../../../../../tree/nodes/operators/addNode.js";
+import { multiply } from "../../../../../tree/nodes/operators/multiplyNode.js";
+import { power } from "../../../../../tree/nodes/operators/powerNode.js";
+import { substract } from "../../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../../tree/parsers/latexParser.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const getNodeFactor = (firstRank, varName = "n") => {
+    const nodeN = varName.toTree();
+    return firstRank === 0 ? nodeN : substract(nodeN, 1);
+};
+const situations = situationsGeometric;
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, superfluousData } = identifiers;
+    const situation = situations[situationIndex];
+    return `${situation.getStrSituation(initial, reason, firstRank, superfluousData)}
+
+Donner l'expression de $u_n$ en fonction de $n$.`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindExplicitFormula.getAnswerNode(initial, reason, firstRank);
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerNode(identifiers, opts).toTex();
+};
+const getHint = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindExplicitFormula.getHint(firstRank);
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindExplicitFormula.getCorrectionStuff(initial, reason, firstRank).str;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const propositions = [];
+    const { initial, reason } = identifiers;
+    const nodeFactor = getNodeFactor(firstRank);
+    addValidProp(propositions, answer);
+    //student: type-specific mistake
+    {
+        const { situationIndex } = identifiers;
+        const situation = situations[situationIndex];
+        switch (situation.type) {
+            case "factor":
+                {
+                    (() => { })();
+                }
+                break;
+            case "factorPercentage":
+                {
+                    (() => { })();
+                }
+                break;
+            case "evo":
+                {
+                    (() => { })();
+                }
+                break;
+            case "evoPercentage":
+                {
+                    const evoPercentage = round((reason - 1) * 100, 2);
+                    //student: reason = evoPercentage
+                    {
+                        tryToAddWrongProp(propositions, new EqualNode("u_n".toTree(), multiply(initial, power(evoPercentage, nodeFactor))).toTex());
+                    }
+                    //student: reason = 100 + evoPercentage
+                    {
+                        tryToAddWrongProp(propositions, new EqualNode("u_n".toTree(), multiply(initial, power(100 + evoPercentage, nodeFactor))).toTex());
+                    }
+                }
+                break;
+        }
+    }
+    //student: swaps(initial, reason)
+    tryToAddWrongProp(propositions, new EqualNode("u_n".toTree(), multiply(reason, power(initial, nodeFactor))).toTex());
+    //student: u_n = initial + reason * n
+    tryToAddWrongProp(propositions, new EqualNode("u_n".toTree(), add(initial, multiply(nodeFactor, reason))).toTex());
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    try {
+        if (!ans.includes("=")) {
+            return false;
+        }
+        //TODO faire fonctionner parseAlgebraic("u_n = 3 \\times 2^n") (token _ not implemented)
+        // const nodeAns = parseAlgebraic(ans);
+        const nodeAns = (() => {
+            const [lhs, rhs] = ans.split("=");
+            const nodeLhs = lhs.toTree();
+            const nodeRhs = parseAlgebraic(rhs);
+            return new EqualNode(nodeLhs, nodeRhs);
+        })();
+        if (!isEqualNode(nodeAns)) {
+            return false;
+        }
+        const nodeAnswer = getAnswerNode(identifiers, opts);
+        const isValidLhs = () => nodeAns.leftChild.toTex() === nodeAnswer.leftChild.toTex();
+        const isValidRhs = () => {
+            const nodeAnsRhs = nodeAns.rightChild;
+            const nodeAnswerRhs = nodeAnswer.rightChild;
+            return [0, 1, 2, 10].every((n) => {
+                return (substract(nodeAnsRhs.evaluate({ n }), nodeAnswerRhs.evaluate({ n })).evaluate() === 0);
+            });
+        };
+        return isValidLhs() && isValidRhs();
+    }
+    catch (e) {
+        handleVEAError(e);
+        return false;
+    }
+};
+const getGeometricFindExplicitFormulaFromSituationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isWithSuperfluousData } = opts;
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const initial = situation.randInitial();
+    const reason = situation.randReason();
+    const superfluousData = isWithSuperfluousData
+        ? situation.randSuperfluousData()
+        : undefined;
+    const identifiers = {
+        situationIndex,
+        initial,
+        reason,
+        superfluousData,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: ["un", "equal", "n"],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const optionsStuffFirstTermRankOne = getOptionFirstTermRankOneStuff(false);
+const optionsStuffIsWithSuperfluousData = getOptionIsWithSuperfluousData(false);
+const optsDefault = Object.assign({}, optionsStuffFirstTermRankOne.optsDefaultFirstTermRankOne, optionsStuffIsWithSuperfluousData.optsDefaultIsWithSuperfluousData);
+const options = [
+    optionsStuffFirstTermRankOne.generatorOptionFirstTermRankOne,
+    optionsStuffIsWithSuperfluousData.generatorOptionIsWithSuperfluousData,
+];
+export const geometricFindExplicitFormulaFromSituation = {
+    id: "geometricFindExplicitFormulaFromSituation",
+    connector: "=",
+    label: "À partir d'une situation décrivant une évolution géométrique, exprimer $u_n$ en fonction de $n$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindExplicitFormulaFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/situations/geometricFindRankFromSituation.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { OptionIsWithSuperfluousData } from "../../../../../exercises/options/optionIsWithSuperfluousData.js";
+import { SituationGeometricSuperfluousData } from "../../../../../math/utils/sequences/situations/seqGeometricSituations.js";
+type Identifiers = {
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: SituationGeometricSuperfluousData;
+    valueAsked: number;
+};
+type Options = OptionFirstTermRankOne & OptionIsWithSuperfluousData;
+export declare const geometricFindRankFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricFindRankFromSituation.d.ts.map

package/lib/exercises/math/sequences/geometric/situations/geometricFindRankFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindRankFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/geometricFindRankFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAIhE,OAAO,EAEL,iCAAiC,EAElC,MAAM,iEAAiE,CAAC;AAGzE,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,iCAAiC,CAAC;IACpD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA0JF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,8BAA8B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmBzE,CAAC"}

package/lib/exercises/math/sequences/geometric/situations/geometricFindRankFromSituation.js

@@ -0,0 +1,142 @@
+import { addValidProp, shuffleProps, tryToAddWrongProp, propWhile, } from "../../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { getOptionIsWithSuperfluousData, } from "../../../../../exercises/options/optionIsWithSuperfluousData.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { numberVEA } from "../../../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { situationsGeometric, } from "../../../../../math/utils/sequences/situations/seqGeometricSituations.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const situations = situationsGeometric;
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, superfluousData } = identifiers;
+    const situation = situations[situationIndex];
+    return `${situation.getStrSituation(initial, reason, firstRank, superfluousData)}
+
+situation.variationFindRank.getStrQuestion!(
+  initial,
+  reason,
+  firstRank,
+  valueAsked,
+)`;
+};
+const getAnswerNode = (_identifiers, _opts) => {
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    // const { situationIndex, initial, reason, valueAsked } = identifiers;
+    // const situation = situations[situationIndex];
+    // return situation.variationFindRank.getAnswerNode(
+    //   initial,
+    //   reason,
+    //   firstRank,
+    //   valueAsked,
+    // );
+    return (0).toTree();
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerNode(identifiers, opts).simplify().toTex();
+};
+const getHint = (_identifiers, _optsIn) => {
+    // const opts = optsIn ?? optsDefault;
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    // const { situationIndex, valueAsked } = identifiers;
+    // const situation = situations[situationIndex];
+    // return situation.variationFindRank.getHint(firstRank, valueAsked);
+    return "hint";
+};
+const getCorrection = (_identifiers, _optsIn) => {
+    // const opts = optsIn ?? optsDefault;
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    // const { situationIndex, initial, reason, valueAsked } = identifiers;
+    // const situation = situations[situationIndex];
+    // return situation.variationFindRank.getCorrectionStuff(
+    //   initial,
+    //   reason,
+    //   firstRank,
+    //   valueAsked,
+    // ).str as string;
+    return "correction";
+};
+const getPropositions = (n, { answer, ..._identifiers }, _optsIn) => {
+    // const opts = optsIn ?? optsDefault;
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    // const { situationIndex, initial, reason, valueAsked } = identifiers;
+    // const situation = situations[situationIndex];
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //filler
+    {
+        propWhile(propositions, n, () => {
+            tryToAddWrongProp(propositions, randint(1, 25).frenchify());
+        });
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getGeometricFindRankFromSituationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isWithSuperfluousData } = opts;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const situationIndex = randint(0, situations.length);
+    const situation = situations[situationIndex];
+    const initial = situation.randInitial();
+    const reason = situation.randReason();
+    const superfluousData = isWithSuperfluousData
+        ? situation.randSuperfluousData()
+        : undefined;
+    const rankAsked = randint(4, 15);
+    const valueAsked = situation.variationFindRandomTerm
+        .getAnswerNode(initial, reason, firstRank, rankAsked)
+        .evaluate();
+    const identifiers = {
+        situationIndex,
+        initial,
+        reason,
+        superfluousData,
+        valueAsked,
+    };
+    return getQuestionFromIdentifiers(identifiers, opts);
+};
+const getQuestionFromIdentifiers = (identifiers, opts) => {
+    const question = {
+        answer: getAnswer(identifiers, opts),
+        instruction: getInstruction(identifiers, opts),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers, opts),
+        correction: getCorrection(identifiers, opts),
+        options: opts,
+    };
+    return question;
+};
+const optionsStuffFirstTermRankOne = getOptionFirstTermRankOneStuff(false);
+const optionsStuffIsWithSuperfluousData = getOptionIsWithSuperfluousData(false);
+const optsDefault = Object.assign({}, optionsStuffFirstTermRankOne.optsDefaultFirstTermRankOne, optionsStuffIsWithSuperfluousData.optsDefaultIsWithSuperfluousData);
+const options = [
+    optionsStuffFirstTermRankOne.generatorOptionFirstTermRankOne,
+    optionsStuffIsWithSuperfluousData.generatorOptionIsWithSuperfluousData,
+];
+export const geometricFindRankFromSituation = {
+    id: "geometricFindRankFromSituation",
+    connector: "=",
+    label: "À partir d'une situation décrivant une évolution géométrique, retrouver le rang d'une valeur donnée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getGeometricFindRankFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/geometric/situations/geometricFindRecurrenceFormulaFromSituation.d.ts

@@ -0,0 +1,14 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { OptionIsWithSuperfluousData } from "../../../../../exercises/options/optionIsWithSuperfluousData.js";
+import { SituationGeometricSuperfluousData } from "../../../../../math/utils/sequences/situations/seqGeometricSituations.js";
+type Identifiers = {
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: SituationGeometricSuperfluousData;
+};
+type Options = OptionFirstTermRankOne & OptionIsWithSuperfluousData;
+export declare const geometricFindRecurrenceFormulaFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=geometricFindRecurrenceFormulaFromSituation.d.ts.map

package/lib/exercises/math/sequences/geometric/situations/geometricFindRecurrenceFormulaFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometricFindRecurrenceFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/geometric/situations/geometricFindRecurrenceFormulaFromSituation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAeT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAC3D,OAAO,EAEL,2BAA2B,EAC5B,MAAM,wDAAwD,CAAC;AAIhE,OAAO,EAEL,iCAAiC,EAElC,MAAM,iEAAiE,CAAC;AAkBzE,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,iCAAiC,CAAC;CACrD,CAAC;AAgRF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,2CAA2C,EAAE,QAAQ,CAChE,WAAW,EACX,OAAO,CAoBR,CAAC"}