math-exercises 3.0.172 → 3.0.173

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

@@ -0,0 +1,191 @@
+import { addValidProp, tryToAddWrongProp, propWhile, } from "../../../../exercises/exercise.js";
+import { getOptionFirstTermRankOneStuff, } from "../../../../exercises/options/optionFirstTermRankOne.js";
+import { getDistinctQuestions } from "../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../math/utils/random/randint.js";
+import { round } from "../../../../math/utils/round.js";
+import { EqualNode, isEqualNode, } from "../../../../tree/nodes/equations/equalNode.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 { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { parseAlgebraic } from "../../../../tree/parsers/latexParser.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 } = identifiers;
+    return `Soit $u$ une suite arithmétique telle que $u_{${rank1}} = ${value1}$ et $u_{${rank2}} = ${value2}$. 
+  
+Donner l'expression de $u_n$ en fonction de $n$.`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { rank1, value1, rank2, value2 } = identifiers;
+    const reason = frac(substract(value2, value1), substract(rank2, rank1)).evaluate();
+    const valueFirstRank = value1 - (rank1 - firstRank) * reason;
+    const nodeFormula = add(valueFirstRank, multiply(reason, substract("n".toTree(), firstRank).simplify()));
+    const equalNode = new EqualNode("u_n".toTree(), nodeFormula);
+    return equalNode;
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerNode(identifiers, opts).toTex();
+};
+const getHint = (_, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    return `Commence par déterminer la raison $r$ de la suite $u$. 
+  
+Puis, utilise cette raison et un des termes connus de la suite pour déterminer $u_{${firstRank}}$.`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { rank1, value1, rank2, value2 } = identifiers;
+    const reason = round((value2 - value1) / (rank2 - rank1), 0);
+    const closest = Math.abs(firstRank - rank1) < Math.abs(firstRank - rank2) ? rank1 : rank2;
+    const diff = firstRank - closest;
+    const closestValue = closest === rank1 ? value1 : value2;
+    return `On commence par déterminer la raison $r$ de la suite $u$ : 
+  
+${alignTex([
+        ["r", "=", `\\frac{u_{${rank2}} - u_{${rank1}}}{${rank2}-${rank1}}`],
+        [
+            "",
+            "=",
+            frac(substract(value2, value1), substract(rank2, rank1).simplify()).toTex(),
+        ],
+        [
+            "",
+            "=",
+            frac(substract(value2, value1), substract(rank2, rank1)).simplify().toTex(),
+        ],
+    ])}
+
+On peut alors déterminer $u_{${firstRank}}$ en utilisant $u_{${closest}}$ et $r$. En effet, on a : 
+
+${alignTex([
+        [`u_{${firstRank}}`, "=", add(`u_{${closest}}`, multiply(diff, "r")).toTex()],
+        ["", "=", add(closestValue, multiply(diff, reason)).toTex()],
+        ["", "=", add(closestValue, multiply(diff, reason)).simplify().toTex()],
+    ])}
+
+On a donc : 
+
+${(() => {
+        const texFormulaAbstract = firstRank === 0 ? "u_0 + r \\times n" : "u_1 + r \\times (n-1)";
+        return alignTex([
+            ["u_n", "=", texFormulaAbstract],
+            ["", "=", getAnswerNode(identifiers, opts).rightChild.toTex()],
+        ]);
+    })()}
+
+`;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    // const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const { rank1, value1, rank2, value2 } = identifiers;
+    const reason = frac(substract(value2, value1), substract(rank2, rank1)).evaluate();
+    // const valueFirstRank = value1 - (rank1 - firstRank) * reason;
+    // //student: geometric instead of arithmetic
+    // {
+    //   const nodeFormula = multiply(
+    //     valueFirstRank,
+    //     power(reason, substract("n".toTree(), firstRank).simplify()),
+    //   );
+    //   const equalNode = new EqualNode("u_n".toTree(), nodeFormula);
+    //   tryToAddWrongProp(propositions, equalNode.toTex());
+    // }
+    //student: starts at rank1 instead of firstRank
+    {
+        const nodeFormula = add(value1, multiply(reason, substract("n".toTree(), rank1).simplify()));
+        const equalNode = new EqualNode("u_n".toTree(), nodeFormula);
+        tryToAddWrongProp(propositions, equalNode.toTex());
+    }
+    propWhile(propositions, n, () => {
+        const reasonWrong = reason + randint(-2, 2, [0]);
+        const value2 = reasonWrong * (rank2 - rank1) + value1;
+        const identifiersWrong = Object.assign({}, identifiers, { value2 });
+        const texAnswerWrong = getAnswer(identifiersWrong, opts);
+        tryToAddWrongProp(propositions, texAnswerWrong);
+    });
+    return shuffle(propositions);
+};
+const isAnswerValid = (ans, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    try {
+        if (!ans.includes("=")) {
+            return false;
+        }
+        //TODO faire fonctionner parseAlgebraic("u_n=3+2n") (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 getArithmeticFindExplicitFormulaFromTwoTermsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const rank1 = randint(firstRank + 1, 10);
+    const rank2 = rank1 + randint(2, 6);
+    const reason = randint(-10, 10, [0]);
+    const value1 = randint(-10, 10);
+    const value2 = reason * (rank2 - rank1) + value1;
+    const identifiers = { rank1, value1, rank2, value2 };
+    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 arithmeticFindExplicitFormulaFromTwoTerms = {
+    id: "arithmeticFindExplicitFormulaFromTwoTerms",
+    connector: "=",
+    label: "Connaissant deux termes d'une suite arithmétique, en donner une formule générale",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticFindExplicitFormulaFromTwoTermsQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindExplicitFormulaFromSituation.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 { SituationArithmeticSuperfluousData } from "../../../../../math/utils/sequences/situations/seqArithmeticSituations.js";
+type Identifiers = {
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: SituationArithmeticSuperfluousData;
+};
+type Options = OptionFirstTermRankOne & OptionIsWithSuperfluousData;
+export declare const arithmeticFindExplicitFormulaFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=arithmeticFindExplicitFormulaFromSituation.d.ts.map

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindExplicitFormulaFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindExplicitFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindExplicitFormulaFromSituation.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;AAGhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAgB1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;CACtD,CAAC;AA+MF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,0CAA0C,EAAE,QAAQ,CAC/D,WAAW,EACX,OAAO,CAoBR,CAAC"}

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindExplicitFormulaFromSituation.js

@@ -0,0 +1,153 @@
+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 { situationsArithmetic, } from "../../../../../math/utils/sequences/situations/seqArithmeticSituations.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 { 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 = situationsArithmetic;
+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: swaps(initial, reason)
+    tryToAddWrongProp(propositions, new EqualNode("u_n".toTree(), add(multiply(initial, nodeFactor), reason)).toTex());
+    //student: uses "x"
+    tryToAddWrongProp(propositions, new EqualNode("u_n".toTree(), add(multiply(reason, getNodeFactor(firstRank, "x")), initial)).toTex());
+    //student: u_n = initial * reason + n
+    tryToAddWrongProp(propositions, new EqualNode("u_n".toTree(), add(multiply(initial, reason), nodeFactor)).toTex());
+    //student: u_n = (initial + reason) * n
+    tryToAddWrongProp(propositions, new EqualNode("u_n".toTree(), multiply(add(initial, reason).simplify(), nodeFactor)).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+2n") (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 getArithmeticFindExplicitFormulaFromSituationQuestion = (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 arithmeticFindExplicitFormulaFromSituation = {
+    id: "arithmeticFindExplicitFormulaFromSituation",
+    connector: "=",
+    label: "À partir d'une situation décrivant une évolution arithmétique, exprimer $u_n$ en fonction de $n$",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticFindExplicitFormulaFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.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 { SituationArithmeticSuperfluousData } from "../../../../../math/utils/sequences/situations/seqArithmeticSituations.js";
+type Identifiers = {
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: SituationArithmeticSuperfluousData;
+    valueAsked: number;
+};
+type Options = OptionFirstTermRankOne & OptionIsWithSuperfluousData;
+export declare const arithmeticFindRankFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=arithmeticFindRankFromSituation.d.ts.map

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindRankFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.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;AAKhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAK1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;IACrD,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AA6NF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAmB1E,CAAC"}

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRankFromSituation.js

@@ -0,0 +1,184 @@
+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 { round } from "../../../../../math/utils/round.js";
+import { situationsArithmetic, } from "../../../../../math/utils/sequences/situations/seqArithmeticSituations.js";
+import { coinFlip } from "../../../../../utils/alea/coinFlip.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const situations = situationsArithmetic;
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, superfluousData, valueAsked } = 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);
+};
+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);
+};
+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;
+};
+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);
+    const arrNodeWrong = [];
+    //student: uses valueAsked as if it were rankAsked
+    {
+        const nodeWrong = situation.variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, valueAsked);
+        tryToAddWrongProp(propositions, nodeWrong.simplify().toTex());
+        arrNodeWrong.push(nodeWrong);
+    }
+    const rankValid = round(situation.variationFindRank
+        .getAnswerNode(initial, reason, firstRank, valueAsked)
+        .evaluate(), 0);
+    //pseudo terror
+    if (coinFlip()) {
+        if (coinFlip()) {
+            //student: rankValid - 1
+            {
+                const nodeWrong = (rankValid - 1).toTree();
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+                arrNodeWrong.push(nodeWrong);
+            }
+        }
+        else {
+            //student: rankValid + 1
+            {
+                const nodeWrong = (rankValid + 1).toTree();
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+                arrNodeWrong.push(nodeWrong);
+            }
+        }
+    }
+    //random around
+    {
+        const nodeWrong = Math.max(1, rankValid + randint(-5, 6, [0])).toTree();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+        arrNodeWrong.push(nodeWrong);
+    }
+    //terror
+    {
+        const nodePicked = random(arrNodeWrong);
+        if (coinFlip()) {
+            if (coinFlip()) {
+                //student: rankValid - 1
+                {
+                    const nodeWrong = (nodePicked.evaluate() - 1).toTree();
+                    tryToAddWrongProp(propositions, nodeWrong.toTex());
+                    arrNodeWrong.push(nodeWrong);
+                }
+            }
+            else {
+                //student: rankValid + 1
+                {
+                    const nodeWrong = (nodePicked.evaluate() + 1).toTree();
+                    tryToAddWrongProp(propositions, nodeWrong.toTex());
+                    arrNodeWrong.push(nodeWrong);
+                }
+            }
+        }
+    }
+    //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 getArithmeticFindRankFromSituationQuestion = (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 arithmeticFindRankFromSituation = {
+    id: "arithmeticFindRankFromSituation",
+    connector: "=",
+    label: "À partir d'une situation décrivant une évolution arithmétique, retrouver le rang d'une valeur donnée",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticFindRankFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRecurrenceFormulaFromSituation.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 { SituationArithmeticSuperfluousData } from "../../../../../math/utils/sequences/situations/seqArithmeticSituations.js";
+type Identifiers = {
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: SituationArithmeticSuperfluousData;
+};
+type Options = OptionFirstTermRankOne & OptionIsWithSuperfluousData;
+export declare const arithmeticFindRecurrenceFormulaFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=arithmeticFindRecurrenceFormulaFromSituation.d.ts.map

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindRecurrenceFormulaFromSituation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindRecurrenceFormulaFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindRecurrenceFormulaFromSituation.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;AAGhE,OAAO,EAEL,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAgB1E,KAAK,WAAW,GAAG;IACjB,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,eAAe,CAAC,EAAE,kCAAkC,CAAC;CACtD,CAAC;AAiRF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,4CAA4C,EAAE,QAAQ,CACjE,WAAW,EACX,OAAO,CAoBR,CAAC"}