math-exercises 3.0.171 → 3.0.173

package/lib/exercises/math/sequences/arithmetic/sum/arithmeticComputeSumWithDots.js

@@ -0,0 +1,233 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } 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 { randint } from "../../../../../math/utils/random/randint.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 { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+import { alignTex } from "../../../../../utils/latex/alignTex.js";
+const strForValue = (v) => {
+    return v < 0 ? `(${v.frenchify()})` : `${v.frenchify()}`;
+};
+const valueForRank = (initial, reason, rank) => {
+    return initial + reason * rank;
+};
+const strSumWithDots = (initial, reason, firstRank, lowRankDots, highRankDots, lastRank) => {
+    const arrRankStart = [...Array(lowRankDots - firstRank).keys()].map((i) => i + firstRank);
+    const arrRankEnd = [...Array(lastRank - highRankDots).keys()].map((i) => i + highRankDots + 1);
+    const [arrValueStart, arrValueEnd] = [arrRankStart, arrRankEnd].map((arrRank) => arrRank.map((rank) => strForValue(valueForRank(initial, reason, rank))));
+    const [strStart, strEnd] = [arrValueStart, arrValueEnd].map((arrValue) => arrValue.join(" + "));
+    const strFlat = [strStart, strEnd].join(` + \\ldots + `);
+    const maxStrLength = 40;
+    if (strFlat.length < maxStrLength) {
+        return `
+
+$$
+${strFlat}
+$$
+
+`;
+    }
+    else {
+        return `
+
+$$
+${strStart}
+$$
+
+$$
++ \\ldots
+$$
+
+$$
++ \\ ${strEnd}
+$$
+
+`;
+    }
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isGiveCount } = opts;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { initial, reason, nbTerms, lowRankDots, highRankDots } = identifiers;
+    const lastRank = firstRank + nbTerms - 1;
+    return `Soit $u$ une suite arithmétique. 
+
+Calculer la somme des premiers termes de $u$ ${isGiveCount
+        ? `(la somme contient en tout $${nbTerms.frenchify()}$ termes)`
+        : ""}: 
+
+${strSumWithDots(initial, reason, firstRank, lowRankDots, highRankDots, lastRank)}
+
+`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { initial, reason, nbTerms } = identifiers;
+    const lastRank = firstRank + nbTerms - 1;
+    const nodeAnswer = multiply(nbTerms, frac(add(valueForRank(initial, reason, firstRank), valueForRank(initial, reason, lastRank)), 2));
+    return nodeAnswer;
+};
+const getAnswer = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    return getAnswerNode(identifiers, opts).simplify().toTex();
+};
+const getHint = (_, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isGiveCount } = opts;
+    return `La somme $S$ des $n$ premiers termes d'une suite arithmétique s'obtient par la formule : 
+  
+$$
+S = n \\times \\frac{1^{\\text{er}}\\text{terme} + \\text{dernier terme}}{2}
+$$
+
+${!isGiveCount
+        ? "Il te faut donc déterminer combien il y a de termes dans la somme donnée."
+        : ""}`;
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isGiveCount } = opts;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { initial, nbTerms, reason } = identifiers;
+    const firstValue = valueForRank(initial, reason, firstRank);
+    const lastRank = firstRank + nbTerms - 1;
+    const lastValue = valueForRank(initial, reason, lastRank);
+    const answerNode = getAnswerNode(identifiers, opts);
+    return `La somme $S$ des $n$ premiers termes d'une suite arithmétique s'obtient par la formule : 
+  
+$$
+S = n \\times \\frac{1^{\\text{er}}\\text{terme} + \\text{dernier terme}}{2}
+$$
+
+${(() => {
+        if (isGiveCount) {
+            return "";
+        }
+        else {
+            return `On a le premier et le dernier terme mais il faut déterminer combien il y a de termes en tout.
+
+On calcule la raison de la suite : 
+
+${alignTex([
+                [
+                    "r",
+                    "=",
+                    `u_{${(firstRank + 1).frenchify()}} - u_{${firstRank.frenchify()}}`,
+                ],
+                [
+                    "r",
+                    "=",
+                    `${strForValue(valueForRank(initial, reason, firstRank + 1))} - ${strForValue(valueForRank(initial, reason, firstRank))}`,
+                ],
+                ["r", "=", `${reason.frenchify()}`],
+            ])}
+
+On calcule le nombre de termes :
+
+$$
+\\text{dernier terme} = {1^{\\text{er}}\\text{terme}} + r \\times (n-1)   
+$$
+
+${alignTex([
+                [
+                    "n",
+                    "=",
+                    `\\frac{${strForValue(lastValue)} - ${strForValue(firstValue)}}{${reason.frenchify()}} + 1`,
+                ],
+                ["n", "=", `${nbTerms.frenchify()}`],
+            ])}
+
+`;
+        }
+    })()}
+
+La somme des $${nbTerms}$ premiers termes de $u$ vaut donc :
+
+$$
+${answerNode.toTex({ forceParenthesis: true })} = ${answerNode
+        .simplify()
+        .toTex()}  
+$$`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-100, 100) + "");
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (studentAns, { answer }) => {
+    try {
+        return numberVEA(studentAns, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getArithmeticComputeSumWithDotsQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const { isGiveCount } = opts;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const initial = randint(-9, 10);
+    const reason = randint(-5, 5, [0]);
+    const nbTerms = randint(7, 15);
+    const minRankDots = isGiveCount ? firstRank + 1 : firstRank + 2;
+    const lastRank = firstRank + nbTerms - 1;
+    const lowRankDots = randint(minRankDots, Math.min(minRankDots + randint(1, 4), lastRank));
+    const highRankDots = randint(Math.max(lastRank - randint(1, 4), lowRankDots), lastRank);
+    const identifiers = {
+        initial,
+        reason,
+        nbTerms,
+        lowRankDots,
+        highRankDots,
+    };
+    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 { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne, {
+    isGiveCount: true,
+});
+const options = [
+    generatorOptionFirstTermRankOne,
+    {
+        id: "isGiveCount",
+        label: "Donner $n$",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.checkbox,
+        defaultValue: optsDefault.isGiveCount,
+    },
+];
+export const arithmeticComputeSumWithDots = {
+    id: "arithmeticComputeSumWithDots",
+    connector: "=",
+    label: "Calculer une somme donnée avec $\\ldots$ (suite arithmétique)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticComputeSumWithDotsQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    options,
+};

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+type Identifiers = {
+    firstRank: number;
+    firstValue: number;
+    reason: number;
+    nbTerms: number;
+};
+type Options = {
+    firstTermRank: string;
+};
+export declare const arithmeticFirstTermsSum: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=arithmeticFirstTermsSum.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFirstTermsSum.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/sum/arithmeticFirstTermsSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAkBT,MAAM,6BAA6B,CAAC;AAQrC,KAAK,WAAW,GAAG;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC;AAqGF,KAAK,OAAO,GAAG;IACb,aAAa,EAAE,MAAM,CAAC;CACvB,CAAC;AAeF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAelE,CAAC"}

package/lib/exercises/math/sequences/arithmetic/sum/arithmeticFirstTermsSum.js

@@ -0,0 +1,111 @@
+import { GeneratorOptionTarget, GeneratorOptionType, addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } from "../../../../../exercises/exercise.js";
+import { getDistinctQuestions } from "../../../../../exercises/utils/getDistinctQuestions.js";
+import { randint } from "../../../../../math/utils/random/randint.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 { random } from "../../../../../utils/alea/random.js";
+const getHint = () => {
+    return `La somme $S$ des $n$ premiers termes d'une suite arithmétique s'obtient par la formule : 
+  
+$$
+S = n \\times \\frac{1^{\\text{er}}\\text{terme} + \\text{dernier terme}}{2}
+$$`;
+};
+const getCorrection = (identifiers) => {
+    const { firstRank, firstValue, nbTerms, reason } = identifiers;
+    const lastRank = firstRank + nbTerms - 1;
+    const lastValue = firstValue + reason * (nbTerms - 1);
+    return `La somme $S$ des $n$ premiers termes d'une suite arithmétique s'obtient par la formule : 
+  
+$$
+S = n \\times \\frac{1^{\\text{er}}\\text{terme} + \\text{dernier terme}}{2}
+$$
+
+On calcule le dernier terme de la somme : 
+
+$$
+u_{${lastRank}} = ${add(firstValue, multiply(nbTerms - 1, reason)).toTex()} = ${lastValue}
+$$
+
+La somme des $${nbTerms}$ premiers termes de $u$ vaut donc :
+
+$$
+${multiply(nbTerms, frac(add(firstValue, lastValue), 2)).toTex()} = ${getAnswer(identifiers)}
+$$`;
+};
+const getInstruction = (identifiers) => {
+    const { firstRank, firstValue, reason, nbTerms } = identifiers;
+    return `Soit $u$ une suite arithmétique de premier terme $u_${firstRank} = ${firstValue}$ et de raison $${reason}$. 
+
+Calculer la somme des $${nbTerms}$ premiers termes de $u$.`;
+};
+const getAnswer = (identifiers) => {
+    const { firstRank, firstValue, reason, nbTerms } = identifiers;
+    const lastRank = firstRank + nbTerms - 1;
+    const answer = (lastRank - firstRank + 1) *
+        (firstRank === 0 ? firstValue : firstValue - reason) +
+        (reason * (lastRank * (lastRank + 1))) / 2;
+    const answerTex = answer + "";
+    return answerTex;
+};
+const getArithmeticFirstTermsSumQuestion = (opts) => {
+    const firstRank = opts?.firstTermRank === "$u_{0}$"
+        ? 0
+        : opts?.firstTermRank === "$u_{1}$"
+            ? 1
+            : random([0, 1]);
+    const firstValue = randint(-9, 10);
+    const reason = randint(-5, 5, [0]);
+    const nbTerms = randint(4, 9);
+    const identifiers = { firstRank, firstValue, reason, nbTerms };
+    return getQuestionFromIdentifiers(identifiers);
+};
+const getQuestionFromIdentifiers = (identifiers) => {
+    const question = {
+        answer: getAnswer(identifiers),
+        instruction: getInstruction(identifiers),
+        keys: [],
+        answerFormat: "tex",
+        identifiers,
+        hint: getHint(identifiers),
+        correction: getCorrection(identifiers),
+    };
+    return question;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-100, 100) + "");
+    });
+    return shuffleProps(propositions, n);
+};
+const options = [
+    {
+        id: "firstTermRank",
+        label: "Rang du premier terme",
+        target: GeneratorOptionTarget.generation,
+        type: GeneratorOptionType.select,
+        values: ["$u_{0}$", "$u_{1}$", "L'un ou l'autre"],
+        defaultValue: "L'un ou l'autre",
+    },
+];
+const isAnswerValid = (ans, { answer }) => {
+    return ans === answer;
+};
+export const arithmeticFirstTermsSum = {
+    id: "arithmeticFirstTermsSum",
+    connector: "=",
+    label: "Calculer la somme des premiers termes d'une suite arithmétique",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticFirstTermsSumQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    options,
+};

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

@@ -0,0 +1,13 @@
+import { Exercise } from "../../../../../exercises/exercise.js";
+import { OptionFirstTermRankOne } from "../../../../../exercises/options/optionFirstTermRankOne.js";
+import { InegalitySymbols } from "../../../../../math/inequations/inequation.js";
+type Identifiers = {
+    initial: number;
+    reason: number;
+    valueThreshold: number;
+    inegSymbol: InegalitySymbols;
+};
+type Options = OptionFirstTermRankOne;
+export declare const arithmeticFirstTermsSumThreshold: Exercise<Identifiers, Options>;
+export {};
+//# sourceMappingURL=arithmeticFirstTermsSumThreshold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arithmeticFirstTermsSumThreshold.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/sum/arithmeticFirstTermsSumThreshold.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAgBT,MAAM,6BAA6B,CAAC;AACrC,OAAO,EAEL,sBAAsB,EACvB,MAAM,mDAAmD,CAAC;AAG3D,OAAO,EACL,gBAAgB,EAEjB,MAAM,sCAAsC,CAAC;AAY9C,KAAK,WAAW,GAAG;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,gBAAgB,CAAC;CAC9B,CAAC;AA6PF,KAAK,OAAO,GAAG,sBAAsB,CAAC;AAMtC,eAAO,MAAM,gCAAgC,EAAE,QAAQ,CAAC,WAAW,EAAE,OAAO,CAoBzE,CAAC"}

package/lib/exercises/math/sequences/arithmetic/sum/arithmeticFirstTermsSumThreshold.js

@@ -0,0 +1,216 @@
+import { addValidProp, propWhile, shuffleProps, tryToAddWrongProp, } 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 { InequationSymbol, } from "../../../../../math/inequations/inequation.js";
+import { Trinom } from "../../../../../math/polynomials/trinom.js";
+import { randint } from "../../../../../math/utils/random/randint.js";
+import { round } from "../../../../../math/utils/round.js";
+import { seqArithmeticUtils } from "../../../../../math/utils/sequences/situations/seqArithmeticUtils.js";
+import { random } from "../../../../../utils/alea/random.js";
+import { handleVEAError } from "../../../../../utils/errors/handleVEAError.js";
+const strForValue = (v) => {
+    return v < 0 ? `(${v.frenchify()})` : `${v.frenchify()}`;
+};
+const getInstruction = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { initial, reason, valueThreshold, inegSymbol } = identifiers;
+    const inequationSymbol = new InequationSymbol(inegSymbol);
+    const firstValue = seqArithmeticUtils.valueForRank(initial, reason, firstRank);
+    return `Soit $u$ une suite arithmétique de raison $${reason.frenchify()}$ et de premier terme $${firstValue.frenchify()}$. 
+
+Pour $k$ entier supérieur ou égal à $${firstRank + 1}$, on note $S_{k}$ la somme des $k$ premiers termes de $u$ :
+
+$$
+S_{k} = u_{${firstRank}} + ... + u_{${firstRank === 0 ? "k-1" : "k"}}
+$$
+
+À partir de quel rang $k$, la somme est-elle ${inequationSymbol.toWord(false, true)} à $${valueThreshold}$ ?
+
+`;
+};
+const getAnswerNode = (identifiers, opts) => {
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { initial, reason, valueThreshold, inegSymbol } = identifiers;
+    const inequationSymbol = new InequationSymbol(inegSymbol);
+    return seqArithmeticUtils.getAnswerNodeSumThresholdRank(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 { valueThreshold, inegSymbol } = identifiers;
+    if (firstRank === 0) {
+        return `Pour $k$ entier supérieur ou égal à $${firstRank + 1}$, la somme $S$ des $k$ premiers termes d'une suite arithmétique s'obtient par la formule : 
+  
+$$
+S_k = k \\times \\frac{u_0 + u_{k-1}}{2}
+$$
+
+Utilise la formule explicite : 
+
+$$
+u_{k-1} = u_0 + (k-1)r
+$$
+
+pour réécrire $S_k$ uniquement en fonction de $k$.
+
+Tu devras ensuite résoudre l'inéquation : 
+
+$$
+S_k ${inegSymbol} ${valueThreshold.frenchify()}
+$$
+
+`;
+    }
+    else {
+        return `Pour $k$ entier supérieur ou égal à $${firstRank + 1}$, la somme $S$ des $k$ premiers termes d'une suite arithmétique s'obtient par la formule : 
+  
+$$
+S_k = k \\times \\frac{u_1 + u_{k}}{2}
+$$
+
+Utilise la formule explicite : 
+
+$$
+u_{k} = u_0 + kr
+$$
+
+pour réécrire $S_k$ uniquement en fonction de $k$.
+
+Tu devras ensuite résoudre l'inéquation $S_k ${inegSymbol} ${valueThreshold.frenchify()}$.`;
+    }
+};
+const getCorrection = (identifiers, optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const { initial, reason, valueThreshold, inegSymbol } = identifiers;
+    const firstValue = seqArithmeticUtils.valueForRank(initial, reason, firstRank);
+    const root = (() => {
+        const a = reason / 2;
+        const b = firstValue - a;
+        const c = -valueThreshold;
+        const trinom = new Trinom(a, b, c);
+        const [_nodeKLow, nodeKHigh] = trinom
+            .getRootsNode()
+            .toSorted((v1, v2) => v1.evaluate() - v2.evaluate());
+        const kHigh = nodeKHigh.evaluate();
+        return kHigh;
+    })();
+    const isIntegerRoot = round(root, 0) === root;
+    return `${(() => {
+        if (firstRank === 0) {
+            return `Pour $k$ entier supérieur ou égal à $${firstRank + 1}$, la somme $S$ des $k$ premiers termes d'une suite arithmétique s'obtient par la formule : 
+  
+$$
+S_k = k \\times \\frac{u_0 + u_{k-1}}{2}
+$$
+
+On utilise la formule explicite : 
+
+$$
+u_{k-1} = u_0 + (k-1)r
+$$
+
+pour réécrire $S_k$ uniquement en fonction de $k$ :
+
+$$
+S_k = (\\frac{r}{2})k^2 + (u_0-\\frac{r}{2})k
+$$
+
+`;
+        }
+        else {
+            return `Pour $k$ entier supérieur ou égal à $${firstRank + 1}$, la somme $S$ des $k$ premiers termes d'une suite arithmétique s'obtient par la formule : 
+  
+$$
+S_k = k \\times \\frac{u_1 + u_{k}}{2}
+$$
+
+Utilise la formule explicite : 
+
+$$
+u_{k} = u_1 + (k-1)r
+$$
+
+pour réécrire $S_k$ uniquement en fonction de $k$ :
+
+$$
+S_k = (\\frac{r}{2})k^2 + (u_1-\\frac{r}{2})k
+$$`;
+        }
+    })()}  
+
+On doit donc résoudre l'inéquation $S_k ${inegSymbol} ${valueThreshold.frenchify()}$.
+
+L'équation $S_k - ${strForValue(valueThreshold)} = 0$ a deux racines.
+On ne garde que la racine positive qui vaut ${isIntegerRoot ? "" : "environ"} $${round(root, 2).frenchify()}$.
+
+Le rang recherché est donc $${getAnswer(identifiers, opts)}$.`;
+};
+const getPropositions = (n, { answer }) => {
+    const propositions = [];
+    addValidProp(propositions, answer);
+    propWhile(propositions, n, () => {
+        tryToAddWrongProp(propositions, randint(-100, 100) + "");
+    });
+    return shuffleProps(propositions, n);
+};
+const isAnswerValid = (studentAns, { answer }) => {
+    try {
+        return numberVEA(studentAns, answer);
+    }
+    catch (err) {
+        return handleVEAError(err);
+    }
+};
+const getArithmeticFirstTermsSumThresholdQuestion = (optsIn) => {
+    const opts = optsIn ?? optsDefault;
+    const firstRank = opts.firstTermRankOne ? 1 : 0;
+    const initial = randint(-9, 10);
+    const reason = randint(-5, 5, [0]);
+    const valueThreshold = seqArithmeticUtils.randThreshold(initial, reason, firstRank, 0);
+    const inegSymbol = reason > 0 ? random([">", "\\ge"]) : random(["<", "\\le"]);
+    const identifiers = {
+        initial,
+        reason,
+        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 { optsDefaultFirstTermRankOne, generatorOptionFirstTermRankOne } = getOptionFirstTermRankOneStuff(false);
+const optsDefault = Object.assign({}, optsDefaultFirstTermRankOne);
+const options = [generatorOptionFirstTermRankOne];
+export const arithmeticFirstTermsSumThreshold = {
+    id: "arithmeticFirstTermsSumThreshold",
+    connector: "=",
+    label: "Déterminer le rang à partir duquel une somme franchit un seuil donné (suite arithmétique)",
+    isSingleStep: true,
+    generator: (nb, opts) => getDistinctQuestions(() => getArithmeticFirstTermsSumThresholdQuestion(opts), nb),
+    qcmTimer: 60,
+    freeTimer: 60,
+    getPropositions,
+    isAnswerValid,
+    subject: "Mathématiques",
+    hasHintAndCorrection: true,
+    getQuestionFromIdentifiers,
+    options,
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"firstIntegersSum.d.ts","sourceRoot":"","sources":["../../../../../../src/exercises/math/sequences/arithmetic/sum/firstIntegersSum.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EAcT,MAAM,6BAA6B,CAAC;AAOrC,KAAK,WAAW,GAAG;IACjB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAoFF,eAAO,MAAM,gBAAgB,EAAE,QAAQ,CAAC,WAAW,CAkBlD,CAAC"}