math-exercises 3.0.172 → 3.0.174

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

@@ -0,0 +1,210 @@
+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 la relation de récurrence pour la suite $(u_n)$.`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindRecurrenceFormula.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.variationFindRecurrenceFormula.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.variationFindRecurrenceFormula.getCorrectionStuff(initial, reason, firstRank).str;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason } = identifiers;
+    const situation = situations[situationIndex];
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //most to least probable mistakes:
+    //student: arithmetic -> geometric: u_{n+1} = u_n * reason
+    {
+        tryToAddWrongProp(propositions, new EqualNode("u_{n+1}".toTree(), multiply("u_{n}".toTree(), reason)).toTex());
+    }
+    //student: reason -> initial: u_{n+1} = u_n + initial
+    {
+        tryToAddWrongProp(propositions, new EqualNode("u_{n+1}".toTree(), add("u_{n}".toTree(), initial)).toTex());
+    }
+    //student: u_{n+1} = u_n + n * reason
+    {
+        tryToAddWrongProp(propositions, new EqualNode("u_{n+1}".toTree(), add("u_{n}".toTree(), multiply("n".toTree(), reason))).toTex());
+    }
+    //student: mixes explicit with recurrence: u_{n+1} = initial + u_n * reason
+    {
+        const strExplicitFormula = situation.variationFindExplicitFormula
+            .getAnswerNode(initial, reason, firstRank)
+            .toTex();
+        function strByReplacingVar(strSrc, strVar, strReplacement) {
+            const re = new RegExp(`(?!u.*\\{?.*)(${strVar})(?!.*\\}?)`, "g"); //capture n but not u_{n} u_{n+1} etc.
+            const matches = strSrc.match(re) ?? [];
+            return matches.reduce((acc, match) => {
+                return acc.replace(match, strReplacement);
+            }, strSrc);
+        }
+        const strWrong = strByReplacingVar(strExplicitFormula.replaceAll("u_{n}", "u_{n+1}"), "n", "u_{n}");
+        tryToAddWrongProp(propositions, strWrong);
+    }
+    //student: explicit formula
+    {
+        tryToAddWrongProp(propositions, situation.variationFindExplicitFormula
+            .getAnswerNode(initial, reason, firstRank)
+            .toTex());
+    }
+    //student: explicit formula for u_{n+1}
+    {
+        const nodeFormula = add(initial, multiply(reason, substract(add("n".toTree(), 1), firstRank).simplify())).simplify();
+        const equalNode = new EqualNode("u_{n+1}".toTree(), nodeFormula);
+        tryToAddWrongProp(propositions, equalNode.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer, ..._identifiers }, _optsIn) => {
+    try {
+        if (!ans.includes("=")) {
+            return false;
+        }
+        //TODO faire fonctionner parseAlgebraic("u_n=3+2n") (token _ not implemented)
+        // const nodeAns = parseAlgebraic(ans);
+        function workaroundParser(strSrc) {
+            function workaroundReplacer(strSrc) {
+                const dictFromTo = {
+                    u_n: "x",
+                    "u_{n+1}": "y",
+                };
+                return Object.entries(dictFromTo).reduce((acc, [strFrom, strTo]) => {
+                    return acc.replaceAll(strFrom, strTo);
+                }, strSrc);
+            }
+            const [lhs, rhs] = strSrc.split("=");
+            const [lhsRefined, rhsRefined] = [lhs, rhs].map(workaroundReplacer);
+            const [nodeLhs, nodeRhs] = [lhsRefined, rhsRefined].map((str) => parseAlgebraic(str));
+            return new EqualNode(nodeLhs, nodeRhs);
+        }
+        const nodeAns = workaroundParser(ans);
+        if (!isEqualNode(nodeAns)) {
+            return false;
+        }
+        // const nodeAnswer = getAnswerNode(identifiers, opts) as EqualNode;
+        const nodeAnswer = workaroundParser(answer);
+        const isValidLhs = () => {
+            // return (
+            //   substract(nodeAns.leftChild, nodeAnswer.leftChild)
+            //     .simplify()
+            //     .evaluate() === 0
+            // );
+            return [1, 10, 100].every((y) => {
+                return (substract(nodeAns.leftChild, nodeAnswer.leftChild).evaluate({
+                    y,
+                }) === 0);
+            });
+        };
+        const isValidRhs = () => {
+            // return (
+            //   substract(nodeAns.rightChild, nodeAnswer.rightChild)
+            //     .simplify()
+            //     .evaluate() === 0
+            // );
+            return [1, 10, 100].every((x) => {
+                return (substract(nodeAns.rightChild, nodeAnswer.rightChild).evaluate({
+                    x,
+                }) === 0);
+            });
+        };
+        return isValidLhs() && isValidRhs();
+    }
+    catch (e) {
+        return handleVEAError(e);
+    }
+};
+const getArithmeticFindRecurrenceFormulaFromSituationQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    // 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 = opts.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", "unplus1"],
+        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 arithmeticFindRecurrenceFormulaFromSituation = {
+    id: "arithmeticFindRecurrenceFormulaFromSituation",
+    connector: "=",
+    label: "À partir d'une situation décrivant une évolution arithmétique, exprimer la relation de récurrence",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticFindRecurrenceFormulaFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindTermFromSituation.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;
+    rankAsked: number;
+};
+type Options = OptionFirstTermRankOne & OptionIsWithSuperfluousData;
+export declare const arithmeticFindTermFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=arithmeticFindTermFromSituation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindTermFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindTermFromSituation.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,kCAAkC,EAEnC,MAAM,kEAAkE,CAAC;AAQ1E,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,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA+LF,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/arithmeticFindTermFromSituation.js

@@ -0,0 +1,161 @@
+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 { numberVEA } from "../../../../../exercises/vea/numberVEA.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { situationsArithmetic, } from "../../../../../math/utils/sequences/situations/seqArithmeticSituations.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 { coinFlip } from "../../../../../utils/alea/coinFlip.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, rankAsked } = identifiers;
+    const situation = situations[situationIndex];
+    return `${situation.getStrSituation(initial, reason, firstRank, superfluousData)}
+
+Que vaut $u_{${rankAsked}}$ ?`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, rankAsked } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, rankAsked);
+};
+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, rankAsked } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindRandomTerm.getHint(firstRank, rankAsked);
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, rankAsked } = identifiers;
+    const situation = situations[situationIndex];
+    return situation.variationFindRandomTerm.getCorrectionStuff(initial, reason, firstRank, rankAsked).str;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, rankAsked } = identifiers;
+    const situation = situations[situationIndex];
+    const propositions = [];
+    addValidProp(propositions, answer);
+    //student: arithmetic -> geometric
+    {
+        const nodeWrong = multiply(initial, power(reason, substract(rankAsked, firstRank))).simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    if (coinFlip()) {
+        if (coinFlip()) {
+            //student: rankAsked - 1
+            {
+                const nodeWrong = situation.variationFindRandomTerm
+                    .getAnswerNode(reason, initial, firstRank, rankAsked - 1)
+                    .simplify();
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+            }
+        }
+        else {
+            //student: rankAsked + 1
+            {
+                const nodeWrong = situation.variationFindRandomTerm
+                    .getAnswerNode(reason, initial, firstRank, rankAsked + 1)
+                    .simplify();
+                tryToAddWrongProp(propositions, nodeWrong.toTex());
+            }
+        }
+    }
+    //student: swaps(initial, reason)
+    {
+        const nodeWrong = situation.variationFindRandomTerm
+            .getAnswerNode(reason, initial, firstRank, rankAsked)
+            .simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: u_n = initial * reason + n
+    {
+        const nodeWrong = add(multiply(initial, reason), substract(rankAsked, firstRank)).simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    //student: u_n = (initial + reason) * n
+    {
+        const nodeWrong = multiply(add(initial, reason), substract(rankAsked, firstRank)).simplify();
+        tryToAddWrongProp(propositions, nodeWrong.toTex());
+    }
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (ans, { answer }) => {
+    try {
+        return numberVEA(ans, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getArithmeticFindTermFromSituationQuestion = (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 rankAsked = randint(4, 15);
+    const identifiers = {
+        situationIndex,
+        initial,
+        reason,
+        superfluousData,
+        rankAsked,
+    };
+    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 arithmeticFindTermFromSituation = {
+    id: "arithmeticFindTermFromSituation",
+    connector: "=",
+    label: "À partir d'une situation décrivant une évolution arithmétique, exprimer un terme de rang $n$ demandé",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticFindTermFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

package/lib/exercises/math/sequences/arithmetic/situations/arithmeticFindThresholdFromSituation.d.ts

@@ -0,0 +1,17 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { OptionIsWithSuperfluousData } from "../../../../../exercises/options/optionIsWithSuperfluousData.js";
+import { InegalitySymbols } from "../../../../../math/inequations/inequation.js";
+import { SituationArithmeticSuperfluousData } from "../../../../../math/utils/sequences/situations/seqArithmeticSituations.js";
+type Identifiers = {
+    situationIndex: number;
+    initial: number;
+    reason: number;
+    superfluousData?: SituationArithmeticSuperfluousData;
+    valueThreshold: number;
+    inegSymbol: InegalitySymbols;
+};
+type Options = OptionFirstTermRankOne & OptionIsWithSuperfluousData;
+export declare const arithmeticFindThresholdFromSituation: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=arithmeticFindThresholdFromSituation.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFindThresholdFromSituation.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/arithmeticFindThresholdFromSituation.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;AAGhE,OAAO,EACL,gBAAgB,EAGjB,MAAM,sCAAsC,CAAC;AAG9C,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,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AAyPF,KAAK,OAAO,GAAG,sBAAsB,GAAG,2BAA2B,CAAC;AAcpE,eAAO,MAAM,oCAAoC,EAAE,QAAQ,CACzD,WAAW,EACX,OAAO,CAoBR,CAAC"}

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

@@ -0,0 +1,188 @@
+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 { InequationSymbol, InequationSymbolConstructor, } from "../../../../../math/inequations/inequation.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, valueThreshold, inegSymbol, } = identifiers;
+    const situation = situations[situationIndex];
+    const inequationSymbol = new InequationSymbol(inegSymbol);
+    return `${situation.getStrSituation(initial, reason, firstRank, superfluousData)}
+
+${situation.variationFindThreshold.getStrQuestion(initial, reason, firstRank, valueThreshold, inequationSymbol)}`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, valueThreshold, inegSymbol } = identifiers;
+    const situation = situations[situationIndex];
+    const inequationSymbol = new InequationSymbol(inegSymbol);
+    return situation.variationFindThreshold.getAnswerNode(initial, reason, firstRank, valueThreshold, inequationSymbol);
+};
+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, valueThreshold, inegSymbol, reason } = identifiers;
+    const situation = situations[situationIndex];
+    const inequationSymbol = new InequationSymbol(inegSymbol);
+    return situation.variationFindThreshold.getHint(firstRank, valueThreshold, inequationSymbol, reason);
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, valueThreshold, inegSymbol } = identifiers;
+    const situation = situations[situationIndex];
+    const inequationSymbol = new InequationSymbol(inegSymbol);
+    return situation.variationFindThreshold.getCorrectionStuff(initial, reason, firstRank, valueThreshold, inequationSymbol).str;
+};
+const getPropositions = (n, { answer, ...identifiers }, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts?.firstTermRankOne ? 1 : 0;
+    const { situationIndex, initial, reason, valueThreshold, inegSymbol } = identifiers;
+    const situation = situations[situationIndex];
+    const inequationSymbol = new InequationSymbol(inegSymbol);
+    const propositions = [];
+    addValidProp(propositions, answer);
+    const arrNodeWrong = [];
+    const rankValid = round(situation.variationFindThreshold
+        .getAnswerNode(initial, reason, firstRank, valueThreshold, inequationSymbol)
+        .evaluate(), 0);
+    //student: gives u[threshold] instead of threshold
+    {
+        const nodeWrong = situation.variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, rankValid);
+        tryToAddWrongProp(propositions, nodeWrong.simplify().toTex());
+    }
+    //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 getArithmeticFindThresholdFromSituationQuestion = (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 valueThreshold = situation.randThreshold(initial, reason, firstRank);
+    const inegSymbol = InequationSymbolConstructor.randomSymbol();
+    const identifiers = {
+        situationIndex,
+        initial,
+        reason,
+        superfluousData,
+        valueThreshold,
+        inegSymbol,
+    };
+    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 arithmeticFindThresholdFromSituation = {
+    id: "arithmeticFindThresholdFromSituation",
+    connector: "=",
+    label: "À partir d'une situation décrivant une évolution arithmétique, calculer un seuil",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticFindThresholdFromSituationQuestion(opts), nb),
+    options,
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    getQuestionFromIdentifiers,
+    hasHintAndCorrection: true,
+};

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

@@ -0,0 +1,6 @@
+export * from "./arithmeticFindExplicitFormulaFromSituation.js";
+export * from "./arithmeticFindRecurrenceFormulaFromSituation.js";
+export * from "./arithmeticFindTermFromSituation.js";
+export * from "./arithmeticFindRankFromSituation.js";
+export * from "./arithmeticFindThresholdFromSituation.js";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/situations/index.ts"],"names":[],"mappings":"AAAA,cAAc,iDAAiD,CAAC;AAChE,cAAc,mDAAmD,CAAC;AAClE,cAAc,sCAAsC,CAAC;AACrD,cAAc,sCAAsC,CAAC;AACrD,cAAc,2CAA2C,CAAC"}

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

@@ -0,0 +1,5 @@
+export * from "./arithmeticFindExplicitFormulaFromSituation.js";
+export * from "./arithmeticFindRecurrenceFormulaFromSituation.js";
+export * from "./arithmeticFindTermFromSituation.js";
+export * from "./arithmeticFindRankFromSituation.js";
+export * from "./arithmeticFindThresholdFromSituation.js";

package/lib/exercises/math/sequences/arithmetic/sum/arithmeticComputeSumWithDots.d.ts

@@ -0,0 +1,15 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+type Identifiers = {
+    initial: number;
+    reason: number;
+    nbTerms: number;
+    lowRankDots: number;
+    highRankDots: number;
+};
+type Options = OptionFirstTermRankOne & {
+    isGiveCount: boolean;
+};
+export declare const arithmeticComputeSumWithDots: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=arithmeticComputeSumWithDots.d.ts.map

package/lib/exercises/math/sequences/arithmetic/sum/arithmeticComputeSumWithDots.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticComputeSumWithDots.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/sum/arithmeticComputeSumWithDots.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAwE3D,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,CAAC;IACpB,YAAY,EAAE,MAAM,CAAC;CACtB,CAAC;AA4NF,KAAK,OAAO,GAAG,sBAAsB,GAAG;IAAE,WAAW,EAAE,OAAO,CAAA;CAAE,CAAC;AAiBjE,eAAO,MAAM,4BAA4B,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAkBvE,CAAC"}