math-exercises 3.0.171 → 3.0.173

package/lib/math/utils/sequences/situations/seqArithmeticSituations.js

@@ -0,0 +1,1928 @@
+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 { alignTex } from "../../../../utils/latex/alignTex.js";
+import { randfloat } from "../../random/randfloat.js";
+import { randint } from "../../random/randint.js";
+import { round } from "../../round.js";
+import { firstDegreeInequationResolutionTex } from "../../../../tree/nodes/inequations/inequationNode.js";
+import { Affine } from "../../../../math/polynomials/affine.js";
+import { seqArithmeticUtils } from "./seqArithmeticUtils.js";
+const getStrFactor = (firstRank) => {
+    return firstRank === 0 ? "n" : "(n-1)";
+};
+//decoration
+const createSituationArithmeticFromTemplate = (templateSituationsArithmetic) => {
+    const { variationFindExplicitFormula, variationFindRecurrenceFormula, variationFindRandomTerm, variationFindRank, variationFindThreshold, } = templateSituationsArithmetic;
+    return Object.assign({}, templateSituationsArithmetic, {
+        variationFindExplicitFormula: Object.assign({}, variationFindExplicitFormula, {
+            getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const { str: strRaw } = variationFindExplicitFormula.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                const str = `${strRaw}
+
+$$
+${seqArithmeticUtils
+                    .getAnswerNodeExplicitFormula(initial, reason, firstRank)
+                    .toTex()}
+$$
+
+`;
+                return { str };
+            },
+        }),
+        variationFindRecurrenceFormula: Object.assign({}, variationFindRecurrenceFormula, {
+            getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const { str: strRaw, rank1, rank2, } = variationFindRecurrenceFormula.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                const str = `${strRaw}
+
+$$
+u_{${rank2.frenchify()}} = u_{${rank1.frenchify()}} + (${reason.frenchify()})
+$$
+
+La relation de récurrence est, pour $n \\geq ${firstRank.frenchify()}$ :
+
+$$
+${seqArithmeticUtils
+                    .getAnswerNodeRecurrenceFormula(initial, reason, firstRank)
+                    .toTex()}
+$$
+
+`;
+                return { str, rank1, rank2 };
+            },
+        }),
+        variationFindRandomTerm: Object.assign({}, variationFindRandomTerm, {
+            getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const { str: strRaw } = variationFindRandomTerm.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                const answerNode = variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, ...otherArgs);
+                const str = `${strRaw}
+
+Le terme général est :
+
+$$
+${seqArithmeticUtils
+                    .getAnswerNodeExplicitFormula(initial, reason, firstRank)
+                    .toTex()}
+$$
+
+En particulier :
+
+${alignTex([
+                    [`u_{${rankAsked}}`, "=", answerNode.toTex()],
+                    ["", "=", answerNode.simplify().toTex()],
+                ])}
+
+`;
+                return { str };
+            },
+        }),
+        variationFindRank: Object.assign({}, variationFindRank, {
+            getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                const { str: strRaw } = variationFindRank.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                const answerNode = variationFindRank.getAnswerNode(initial, reason, firstRank, ...otherArgs);
+                const str = `${strRaw}
+
+On note $p$ le rang recherché. On a : 
+
+${alignTex([
+                    [`u_p`, "=", valueAsked.frenchify()],
+                    [
+                        `${add(initial, multiply(reason, "p".toTree())).toTex()}`,
+                        "=",
+                        valueAsked.frenchify(),
+                    ],
+                ])}
+
+On résout l'équation : 
+
+${alignTex([
+                    [`p`, "=", answerNode.toTex()],
+                    ["", "=", answerNode.simplify().toTex()],
+                ])}
+
+
+`;
+                return { str };
+            },
+        }),
+        variationFindThreshold: Object.assign({}, variationFindThreshold, {
+            getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                const { str: strRaw } = variationFindThreshold.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                const answerNode = variationFindThreshold.getAnswerNode(initial, reason, firstRank, ...otherArgs);
+                const str = `${strRaw}
+
+On note $p$ le rang recherché. On a : 
+
+${alignTex([
+                    [`u_p`, inequationSymbol.symbol, valueThreshold.frenchify()],
+                    [
+                        `${add(initial, multiply(reason, substract("p".toTree(), firstRank).simplify())).toTex()}`,
+                        inequationSymbol.symbol,
+                        valueThreshold.frenchify(),
+                    ],
+                ])}
+
+On résout l'inéquation : 
+
+$$
+${(() => {
+                    if (firstRank === 0) {
+                        return firstDegreeInequationResolutionTex(new Affine(reason, initial, "p"), inequationSymbol.symbol, valueThreshold.toTree());
+                    }
+                    else {
+                        return firstDegreeInequationResolutionTex(new Affine(reason, initial - reason, "p"), inequationSymbol.symbol, valueThreshold.toTree());
+                    }
+                })()}
+$$
+
+Le rang $p$ recherché est donc $${answerNode.toTex()}$.
+
+`;
+                return { str };
+            },
+        }),
+    });
+};
+//raw material
+const templatesSituationsArithmetic = [
+    //---------------------------------------------------------
+    //POSITIVE REASON
+    //---------------------------------------------------------
+    //plante
+    {
+        randInitial: () => randint(2, 20),
+        randReason: () => randfloat(0, 4, 2, [0]),
+        randThreshold: (initial, reason, firstRank) => seqArithmeticUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const wateringPeriodInDays = randint(2, 10);
+                        values.push(wateringPeriodInDays);
+                    }
+                    break;
+                case 1:
+                    {
+                        const potDiameterInCm = randint(14, 46);
+                        values.push(potDiameterInCm);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            if (superfluousData === undefined) {
+                return `On suppose qu'une plante, d'une hauteur initiale (jour $${firstRank.frenchify()}$) de $${initial.frenchify()}\\ \\textrm{cm}$, 
+croît chaque jour de $${reason.frenchify()}\\ \\textrm{cm}$.
+On note $u_n$ la hauteur de la plante relevée le jour $n$, en $\\textrm{cm}$.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [wateringPeriodInDays] = superfluousData.values;
+                            return `On suppose qu'une plante, d'une hauteur initiale (jour $${firstRank.frenchify()}$) de $${initial.frenchify()}\\ \\textrm{cm}$ et
+arrosée en moyenne tous les $${wateringPeriodInDays.frenchify()}$ jours,
+croît chaque jour de $${reason.frenchify()}\\ \\textrm{cm}$.
+On note $u_n$ la hauteur de la plante relevée le jour $n$, en $\\textrm{cm}$.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [potDiameterInCm] = superfluousData.values;
+                            return `On suppose qu'on a mis une plante dans un pot de diamètre $${potDiameterInCm.frenchify()} \\ \\textrm{cm}$.
+La plante a alors une hauteur initiale (jour $${firstRank.frenchify()}$) de $${initial.frenchify()}\\ \\textrm{cm}$. 
+La plante croît chaque jour de $${reason.frenchify()}\\ \\textrm{cm}$.
+On note $u_n$ la hauteur de la plante relevée le jour $n$, en $\\textrm{cm}$.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver la hauteur de la plante au bout de $10$ jours ?
+
+Inspire toi de ce calcul pour déterminer la hauteur de la plante au bout de $${getStrFactor(firstRank)}$ jours.`,
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque jour, la plante gagne $${reason.frenchify()}\\ \\textrm{cm}$.
+La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais la hauteur de la plante le jour $10$, comment fais-tu pour calculer la hauteur de la plante le jour $11$ ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                return {
+                    str: `Chaque jour, la plante gagne $${reason.frenchify()}\\ \\textrm{cm}$.
+Par exemple, la hauteur de la plante le jour $${target2.frenchify()}$ est égale à celle du jour $${target1.frenchify()}$ augmentée de $${reason.frenchify()}\\ \\textrm{cm}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $u_n$ pour déterminer la hauteur de la plante au bout de $${target.frenchify()}$ jours.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque jour, la plante gagne $${reason.frenchify()}\\ \\textrm{cm}$.
+La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quel jour la plante aura-t-elle atteint une hauteur de $${round(valueAsked, 2).frenchify()} \\ \\textrm{cm}$ ?`;
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $u_n$ pour déterminer quand $u_n = ${valueAsked.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque jour, la plante gagne $${reason.frenchify()}\\ \\textrm{cm}$.
+La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindThreshold: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                const isStrict = inequationSymbol.symbol === "<" || inequationSymbol.symbol === ">";
+                switch (inequationSymbol.symbol) {
+                    case "<":
+                    case "\\le":
+                        return `Quel sera le dernier jour où la hauteur de la plante sera ${isStrict ? "strictement" : ""} plus petite que $${valueThreshold.frenchify()} \\ \\textrm{cm}$ ?`;
+                    case ">":
+                    case "\\ge":
+                        return `Quel sera le premier jour où la hauteur de la plante sera ${isStrict ? "strictement" : ""} plus grande que $${valueThreshold.frenchify()} \\ \\textrm{cm}$ ?`;
+                }
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, reason] = otherArgs;
+                const inequationSymbolForRank = reason < 0 ? inequationSymbol.toReversed() : inequationSymbol;
+                const texP = (() => {
+                    switch (inequationSymbolForRank.symbol) {
+                        case "<":
+                        case "\\le":
+                            return "le plus grand entier";
+                        case ">":
+                        case "\\ge":
+                            return "le plus petit entier";
+                    }
+                })();
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque jour, la plante gagne $${reason.frenchify()}\\ \\textrm{cm}$.
+La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //taxi
+    {
+        randInitial: () => randint(10, 20),
+        randReason: () => randfloat(0, 0.5, 2, [0]),
+        randThreshold: (initial, reason, firstRank) => seqArithmeticUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const fuelConsumptionPer100Km = randint(10, 20);
+                        values.push(fuelConsumptionPer100Km);
+                    }
+                    break;
+                case 1:
+                    {
+                        const distanceToNextCityInKm = randint(6, 46);
+                        values.push(distanceToNextCityInKm);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            if (superfluousData === undefined) {
+                return `Une compagnie de taxis propose un tarif qui inclut un montant fixe de $${initial.frenchify()}\\ \\textrm{€}$
+et un montant variable de $${reason.frenchify()}\\ \\textrm{€}$ par kilomètre parcouru.
+On note $u_n$ le prix payé (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{km}$ parcourus.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [fuelConsumptionPer100Km] = superfluousData.values;
+                            return `Une compagnie de taxis propose un tarif qui inclut un montant fixe de $${initial.frenchify()}\\ \\textrm{€}$
+et un montant variable de $${reason.frenchify()}\\ \\textrm{€}$ par kilomètre parcouru.
+Le taxi consomme $${fuelConsumptionPer100Km.frenchify()} \\ \\textrm{L}$ d'essence tous les 100 kilomètres.
+On note $u_n$ le prix payé (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{km}$ parcourus.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [distanceToNextCityInKm] = superfluousData.values;
+                            return `Une compagnie de taxis propose un tarif qui inclut un montant fixe de $${initial.frenchify()}\\ \\textrm{€}$
+et un montant variable de $${reason.frenchify()}\\ \\textrm{€}$ par kilomètre parcouru.
+La distance à la ville la plus proche est de $${distanceToNextCityInKm.frenchify()} \\ \\textrm{km}$.
+On note $u_n$ le prix payé (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{km}$ parcourus.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver le prix payé pour $10 \\ \\textrm{km}$ ?
+
+Inspire toi de ce calcul pour déterminer la hauteur de la plante au bout de $${getStrFactor(firstRank)} \\ \\textrm{km}$.`,
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque kilomètre supplémentaire, la facture augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais la facture pour $10 \\ \\textrm{km}$, comment fais-tu pour calculer la facture pour $11 \\ \\textrm{km}$ ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                return {
+                    str: `Pour chaque kilomètre supplémentaire, la facture augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+Par exemple, la facture pour $${target2.frenchify()} \\ \\textrm{km}$ est égale à celle de $${target1.frenchify()} \\ \\textrm{km}$ augmentée de $${reason.frenchify()}\\ \\textrm{€}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ?
+
+Utilise le terme général de $u_n$ pour déterminer la facture pour $${target.frenchify()} \\ \\textrm{km}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque kilomètre supplémentaire, la facture augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()} \\ \\textrm{€}$ ?`;
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $(u_n)$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque kilomètre supplémentaire, la facture augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindThreshold: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                const isStrict = inequationSymbol.symbol === "<" || inequationSymbol.symbol === ">";
+                switch (inequationSymbol.symbol) {
+                    case "<":
+                    case "\\le":
+                        return `Quel est le plus grand rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus petit que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                    case ">":
+                    case "\\ge":
+                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                }
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, reason] = otherArgs;
+                const inequationSymbolForRank = reason < 0 ? inequationSymbol.toReversed() : inequationSymbol;
+                const texP = (() => {
+                    switch (inequationSymbolForRank.symbol) {
+                        case "<":
+                        case "\\le":
+                            return "le plus grand entier";
+                        case ">":
+                        case "\\ge":
+                            return "le plus petit entier";
+                    }
+                })();
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque kilomètre supplémentaire, la facture augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //électricité
+    {
+        randInitial: () => randint(10, 20),
+        randReason: () => randfloat(0, 0.5, 2, [0]),
+        randThreshold: (initial, reason, firstRank) => seqArithmeticUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const fridgeConsumptionPerMonth = randfloat(0.85, 0.95) * 30;
+                        values.push(fridgeConsumptionPerMonth);
+                    }
+                    break;
+                case 1:
+                    {
+                        const internetBill = randint(10, 30);
+                        values.push(internetBill);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            if (superfluousData === undefined) {
+                return `Pour l’électricité de sa maison, Jimmy paye
+un abonnement fixe de $${initial.frenchify()}\\ \\textrm{€}$
+puis il paye $${reason.frenchify()}\\ \\textrm{€}$ par kWh consommé.
+On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{kWh}$ consommés.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [fridgeConsumptionPerMonth] = superfluousData.values;
+                            return `Pour l’électricité de sa maison, Jimmy paye
+un abonnement fixe de $${initial.frenchify()}\\ \\textrm{€}$
+puis il paye $${reason.frenchify()}\\ \\textrm{€}$ par kWh consommé.
+Son refrigétateur consomme $${fridgeConsumptionPerMonth.frenchify()} \\ \\textrm{kWh}$ tous les mois.
+On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{kWh}$ consommés.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [internetBill] = superfluousData.values;
+                            return `Pour l’électricité de sa maison, Jimmy paye
+un abonnement fixe de $${initial.frenchify()}\\ \\textrm{€}$
+puis il paye $${reason.frenchify()}\\ \\textrm{€}$ par kWh consommé.
+Jimmy paye $${internetBill.frenchify()}\\ \\textrm{€}$ tous les mois pour son abonnement internet.
+On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{kWh}$ consommés.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver le prix payé pour $10 \\ \\textrm{kWh}$ ?
+
+Inspire toi de ce calcul pour déterminer le prix à payer pour $${getStrFactor(firstRank)} \\ \\textrm{kWh}$.`,
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque $\\textrm{kWh}$ supplémentaire, la facture augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais la facture pour $10 \\ \\textrm{kWh}$, comment fais-tu pour calculer la facture pour $11 \\ \\textrm{kWh}$ ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                return {
+                    str: `Pour chaque $\\textrm{kWh}$ supplémentaire, la facture augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+Par exemple, la facture pour $${target2.frenchify()} \\ \\textrm{kWh}$ est égale à celle de $${target1.frenchify()} \\ \\textrm{kWh}$ augmentée de $${reason.frenchify()}\\ \\textrm{€}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ?
+
+Utilise le terme général de $u_n$ pour déterminer la facture pour $${target.frenchify()} \\ \\textrm{kWh}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque $\\textrm{kWh}$ supplémentaire, la facture augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()} \\ \\textrm{€}$ ?`;
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $(u_n)$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque $\\textrm{kWh}$ supplémentaire, la facture augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindThreshold: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                const isStrict = inequationSymbol.symbol === "<" || inequationSymbol.symbol === ">";
+                switch (inequationSymbol.symbol) {
+                    case "<":
+                    case "\\le":
+                        return `Quel est le plus grand rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus petit que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                    case ">":
+                    case "\\ge":
+                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                }
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, reason] = otherArgs;
+                const inequationSymbolForRank = reason < 0 ? inequationSymbol.toReversed() : inequationSymbol;
+                const texP = (() => {
+                    switch (inequationSymbolForRank.symbol) {
+                        case "<":
+                        case "\\le":
+                            return "le plus grand entier";
+                        case ">":
+                        case "\\ge":
+                            return "le plus petit entier";
+                    }
+                })();
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque $\\textrm{kWh}$ supplémentaire, la facture augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //Dany
+    {
+        randInitial: () => randint(0, 10),
+        randReason: () => randfloat(0.5, 1, 2),
+        randThreshold: (initial, reason, firstRank) => seqArithmeticUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const fuelConsumptionPer100Km = randint(10, 20);
+                        values.push(fuelConsumptionPer100Km);
+                    }
+                    break;
+                case 1:
+                    {
+                        const distanceToNextBreakInKm = randint(150, 300);
+                        values.push(distanceToNextBreakInKm);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            if (superfluousData === undefined) {
+                return `Dany décide de partir au Sud de la France.
+Il part de Valenciennes où il fait $${initial.frenchify()} \\ \\textrm{°C}$.
+La température ambiante augmente de $${reason.frenchify()}\\ \\textrm{°C}$ à chaque centaine de $\\textrm{km}$ vers le Sud.
+On note $u_n$ la température ambiante (en $\\textrm{°C}$) pour $${getStrFactor(firstRank)}$ centaines de $\\textrm{km}$ parcourus vers le Sud.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [fuelConsumptionPer100Km] = superfluousData.values;
+                            return `Dany décide de partir au Sud de la France. Il part de Valenciennes où il fait $${initial.frenchify()} \\ \\textrm{°C}$.
+La température ambiante augmente de $${reason.frenchify()}\\ \\textrm{°C}$ à chaque centaine de $\\textrm{km}$ vers le Sud.
+Sa voiture consomme $${fuelConsumptionPer100Km.frenchify()} \\ \\textrm{L}$ d'essence tous les 100 kilomètres.
+On note $u_n$ la température ambiante (en $\\textrm{°C}$) pour $${getStrFactor(firstRank)}$ centaines de $\\textrm{km}$ parcourus vers le Sud.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [distanceToNextBreakInKm] = superfluousData.values;
+                            return `Dany décide de partir au Sud de la France. Il part de Valenciennes où il fait $${initial.frenchify()} \\ \\textrm{°C}$.
+La température ambiante augmente de $${reason.frenchify()}\\ \\textrm{°C}$ à chaque centaine de $\\textrm{km}$ vers le Sud.
+Il fait une pause en moyenne tous les $${distanceToNextBreakInKm.frenchify()}$ kilomètres.
+On note $u_n$ la température ambiante (en $\\textrm{°C}$) pour $${getStrFactor(firstRank)}$ centaines de $\\textrm{km}$ parcourus vers le Sud.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver la température pour $2$ centaines de $\\textrm{km}$ parcourus ?
+
+Inspire toi de ce calcul pour déterminer la température pour $${getStrFactor(firstRank)}$ centaines de $\\textrm{km}$ parcourus.`,
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                return {
+                    str: `Pour chaque centaine de $\\textrm{km}$ parcourue, la température augmente de $${reason.frenchify()} \\ \\textrm{°C}$.
+Au bout de $${getStrFactor(firstRank)}$ centaines de $\\textrm{km}$, la température augmente donc de $${getStrFactor(firstRank)} \\times ${reason.frenchify()} \\ \\textrm{°C}$.
+
+Au départ, la température est de $${initial.frenchify()} \\ \\textrm{°C}$.
+
+La température, en $\\textrm{°C}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais la température ambiante pour $300 \\ \\textrm{km}$ parcourus, comment fais-tu pour calculer la température ambiante pour $400 \\ \\textrm{km}$ parcourus ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 300;
+                const target2 = 400;
+                const [rank1, rank2] = [target1, target2].map((target) => target / 100 + firstRank);
+                return {
+                    str: `Pour chaque centaine de $\\textrm{km}$ supplémentaire, la température augmente de $${reason.frenchify()}\\ \\textrm{°C}$.
+Par exemple, la température après $${target2.frenchify()} \\ \\textrm{km}$ parcourus est égale à celle après $${target1.frenchify()} \\ \\textrm{km}$ augmentée de $${reason.frenchify()}\\ \\textrm{°C}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = (rankAsked - firstRank) * 100;
+                return `Quelle est la nature de la suite $u_n$ ?
+
+Utilise le terme général de $u_n$ pour déterminer la température pour $${target.frenchify()} \\ \\textrm{km}$ parcourus.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque centaine de $\\textrm{km}$ supplémentaire, la température ambiante augmente de $${reason.frenchify()}\\ \\textrm{°C}$.
+La température ambiante est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()} \\ \\textrm{€}$ ?`;
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $(u_n)$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque centaine de $\\textrm{km}$ supplémentaire, la température ambiante augmente de $${reason.frenchify()}\\ \\textrm{°C}$.
+La température ambiante est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindThreshold: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                const isStrict = inequationSymbol.symbol === "<" || inequationSymbol.symbol === ">";
+                switch (inequationSymbol.symbol) {
+                    case "<":
+                    case "\\le":
+                        return `Quel est le plus grand rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus petit que $${valueThreshold.frenchify()} \\ \\textrm{°C}$ ?`;
+                    case ">":
+                    case "\\ge":
+                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{°C}$ ?`;
+                }
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, reason] = otherArgs;
+                const inequationSymbolForRank = reason < 0 ? inequationSymbol.toReversed() : inequationSymbol;
+                const texP = (() => {
+                    switch (inequationSymbolForRank.symbol) {
+                        case "<":
+                        case "\\le":
+                            return "le plus grand entier";
+                        case ">":
+                        case "\\ge":
+                            return "le plus petit entier";
+                    }
+                })();
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque centaine de $\\textrm{km}$ supplémentaire, la température ambiante augmente de $${reason.frenchify()}\\ \\textrm{°C}$.
+La température ambiante est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //Emma
+    {
+        randInitial: () => randint(12, 17) * 100,
+        randReason: () => randfloat(20, 50, 2),
+        randThreshold: (initial, reason, firstRank) => seqArithmeticUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const ageWhenHired = randint(20, 40);
+                        values.push(ageWhenHired);
+                    }
+                    break;
+                case 1:
+                    {
+                        const salaryOfCoworker = randint(1500, 3600);
+                        values.push(salaryOfCoworker);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            if (superfluousData === undefined) {
+                return `Emma est salariée. Son salaire net était
+de $${initial.frenchify()}\\ \\textrm{€}$ à son entrée dans l'entreprise,
+et augmente de $${reason.frenchify()}$ € tous les ans.
+On note $u_n$ son salaire net (en $\\textrm{€}$) quand elle aura $${getStrFactor(firstRank)}$ années d'ancienneté.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [ageWhenHired] = superfluousData.values;
+                            return `Emma est salariée.
+Son salaire net était de $${initial.frenchify()}\\ \\textrm{€}$ à son entrée dans l'entreprise.
+Elle avait alors $${ageWhenHired.frenchify()}$ ans.
+Son salaire augmente de $${reason.frenchify()}\\ \\textrm{€}$ tous les ans.
+
+On note $u_n$ son salaire net (en $\\textrm{€}$) quand elle aura $${getStrFactor(firstRank)}$ années d'ancienneté.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [salaryOfCoworker] = superfluousData.values;
+                            return `Emma est salariée.
+Son salaire net était de $${initial.frenchify()}\\ \\textrm{€}$ à son entrée dans l'entreprise.
+Sa collègue Flora gagnait alors $${salaryOfCoworker.frenchify()} \\ \\textrm{€}$.
+Son salaire augmente de $${reason.frenchify()} \\ \\textrm{€}$ tous les ans.
+
+On note $u_n$ son salaire net (en $\\textrm{€}$) quand elle aura $${getStrFactor(firstRank)}$ années d'ancienneté.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver son salaire net pour $10$ années d'ancienneté ?
+
+Inspire toi de ce calcul pour déterminer son salaire net pour $${getStrFactor(firstRank)}$ années d'ancienneté.
+`,
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                return {
+                    str: `Chaque année, son salaire net augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+Au bout de $${getStrFactor(firstRank)}$ années, son salaire net aura augmenté de $${getStrFactor(firstRank)} \\times ${reason.frenchify()}\\ \\textrm{€}$.
+
+Au départ, son salaire net était de $${initial.frenchify()}\\ \\textrm{€}$.
+
+Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais le salaire d'Emma pour $10$ ans d'ancienneté, comment fais-tu pour calculer son salaire pour $11$ ans d'ancienneté ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                return {
+                    str: `Pour chaque année supplémentaire, le salaire d'Emma augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+Par exemple, son salaire pour $${target2.frenchify()}$ ans d'ancienneté est égal à celui pour $${target1.frenchify()}$ ans augmenté de $${reason.frenchify()}\\ \\textrm{€}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = (rankAsked - firstRank) * 100;
+                return `Quelle est la nature de la suite $u_n$ ?
+
+Utilise le terme général de $u_n$ pour déterminer le salaire d'Emma pour $${target.frenchify()}$ ans d'ancienneté.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque année supplémentaire, le salaire d'Emma augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+Par exemple, son salaire pour $11$ ans d'ancienneté est égal à celui pour $10$ ans augmenté de $${reason.frenchify()}\\ \\textrm{€}$.
+
+Au départ, son salaire net était de $${initial.frenchify()}\\ \\textrm{€}$.
+
+Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()} \\ \\textrm{€}$ ?`;
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $(u_n)$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque année supplémentaire, le salaire d'Emma augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindThreshold: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                const isStrict = inequationSymbol.symbol === "<" || inequationSymbol.symbol === ">";
+                switch (inequationSymbol.symbol) {
+                    case "<":
+                    case "\\le":
+                        return `Quel est le plus grand rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus petit que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                    case ">":
+                    case "\\ge":
+                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                }
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, reason] = otherArgs;
+                const inequationSymbolForRank = reason < 0 ? inequationSymbol.toReversed() : inequationSymbol;
+                const texP = (() => {
+                    switch (inequationSymbolForRank.symbol) {
+                        case "<":
+                        case "\\le":
+                            return "le plus grand entier";
+                        case ">":
+                        case "\\ge":
+                            return "le plus petit entier";
+                    }
+                })();
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Pour chaque année supplémentaire, le salaire d'Emma augmente de $${reason.frenchify()}\\ \\textrm{€}$.
+Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //---------------------------------------------------------
+    //NEGATIVE REASON
+    //---------------------------------------------------------
+    //Salaire de l'été vs loisirs hebdomadaires
+    {
+        randInitial: () => randint(5, 13) * 100,
+        randReason: () => -randint(20, 100),
+        randThreshold: (initial, reason, firstRank) => seqArithmeticUtils.randThreshold(initial, reason, firstRank, 0),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const numberOfFriends = randint(2, 7);
+                        values.push(numberOfFriends);
+                    }
+                    break;
+                case 1:
+                    {
+                        const pocketMoneyOfFriend = randint(10, 50);
+                        values.push(pocketMoneyOfFriend);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            if (superfluousData === undefined) {
+                return `Manon a gagné un peu d'argent cet été. Début septembre, elle a $${initial.frenchify()}\\ \\textrm{€}$ d'économies.
+Chaque semaine, elle dépense en moyenne $${(-reason).frenchify()}\\ \\textrm{€}$ pour ses loisirs.
+On note $u_n$ le montant de ses économies (en $\\textrm{€}$), $${getStrFactor(firstRank)}$ semaines après le début de septembre.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [numberOfFriends] = superfluousData.values;
+                            return `Manon a gagné un peu d'argent cet été. Début septembre, elle a $${initial.frenchify()}\\ \\textrm{€}$ d'économies.
+Elle sort souvent avec ses $${numberOfFriends}$ amis.
+Chaque semaine, elle dépense en moyenne $${(-reason).frenchify()}\\ \\textrm{€}$ pour ses loisirs.
+On note $u_n$ le montant de ses économies (en $\\textrm{€}$), $${getStrFactor(firstRank)}$ semaines après le début de septembre.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [pocketMoneyOfFriend] = superfluousData.values;
+                            return `Manon a gagné un peu d'argent cet été. Début septembre, elle a $${initial.frenchify()}\\ \\textrm{€}$ d'économies.
+Chaque semaine, elle dépense en moyenne $${(-reason).frenchify()}\\ \\textrm{€}$ pour ses loisirs.
+Sa meilleure amie à $${pocketMoneyOfFriend}\\ \\textrm{€}$ d'argent de poche toutes les semaines.
+On note $u_n$ le montant de ses économies (en $\\textrm{€}$), $${getStrFactor(firstRank)}$ semaines après le début de septembre.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver le montant de ses économies $10$ semaines après le début de septembre ?
+
+Inspire toi de ce calcul pour déterminer le montant de ses économies $${getStrFactor(firstRank)}$ semaines après le début de septembre.
+`,
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                return {
+                    str: `Chaque semaine, ses économies diminuent de $${(-reason).frenchify()}\\ \\textrm{€}$.
+Au bout de $${getStrFactor(firstRank)}$ semaines, ses économies auront diminué de $${getStrFactor(firstRank)} \\times ${(-reason).frenchify()}\\ \\textrm{€}$.
+
+Au départ, le montant de ses économies était de $${initial.frenchify()}\\ \\textrm{€}$.
+
+Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais le montant des économies de Manon après $10$ semaines de dépenses, comment fais-tu pour calculer ses économies après $11$ semaines de dépenses ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                return {
+                    str: `Après chaque semaine de dépenses supplémentaire, les économies de Manon diminuent de $${(-reason).frenchify()}\\ \\textrm{€}$.
+Par exemple, le montant de ses économies après $${target2.frenchify()}$ semaines est égal à celui pour $${target1.frenchify()}$ semaines diminué de $${(-reason).frenchify()}\\ \\textrm{€}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ?
+
+Utilise le terme général de $u_n$ pour déterminer le montant des économies de Manon $${target.frenchify()}$ semaines après le début de septembre.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank, ..._otherArgs) => {
+                const target1 = 10;
+                const target2 = 11;
+                return {
+                    str: `Après chaque semaine de dépenses supplémentaire, les économies de Manon diminuent de $${(-reason).frenchify()}\\ \\textrm{€}$.
+Par exemple, le montant de ses économies après $${target2.frenchify()}$ semaines est égal à celui pour $${target1.frenchify()}$ semaines diminué de $${(-reason).frenchify()}\\ \\textrm{€}$.
+
+Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()} \\ \\textrm{€}$ ?`;
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $(u_n)$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Après chaque semaine de dépenses supplémentaire, les économies de Manon diminuent de $${(-reason).frenchify()}\\ \\textrm{€}$.
+Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindThreshold: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                const isStrict = inequationSymbol.symbol === "<" || inequationSymbol.symbol === ">";
+                switch (inequationSymbol.symbol) {
+                    case "<":
+                    case "\\le":
+                        return `Quel est le plus grand rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus petit que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                    case ">":
+                    case "\\ge":
+                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                }
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, reason] = otherArgs;
+                const inequationSymbolForRank = reason < 0 ? inequationSymbol.toReversed() : inequationSymbol;
+                const texP = (() => {
+                    switch (inequationSymbolForRank.symbol) {
+                        case "<":
+                        case "\\le":
+                            return "le plus grand entier";
+                        case ">":
+                        case "\\ge":
+                            return "le plus petit entier";
+                    }
+                })();
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Après chaque semaine de dépenses supplémentaire, les économies de Manon diminuent de $${(-reason).frenchify()}\\ \\textrm{€}$.
+Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //Score de quiz
+    {
+        randInitial: () => randint(10, 21) * 1000,
+        randReason: () => -randint(1, 6) * 100,
+        randThreshold: (initial, reason, firstRank) => seqArithmeticUtils.randThreshold(initial, reason, firstRank, 0),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const roundedMeanDuration = randint(2, 7);
+                        values.push(roundedMeanDuration);
+                    }
+                    break;
+                case 1:
+                    {
+                        const indexOfQuestion = randint(1, 21);
+                        values.push(indexOfQuestion);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            if (superfluousData === undefined) {
+                return `Pablo joue à un jeu de quiz. Pour chaque question, le score commence à $${initial.frenchify()}$ points.
+Puis il décroît de $${(-reason).frenchify()}$ points pour chaque seconde qui s'écoule avant que le joueur réponde correctement.
+On note $u_n$ le score si l'on répond correctement $${getStrFactor(firstRank)}$ secondes après le début de la question.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [roundedMeanDuration] = superfluousData.values;
+                            return `Pablo joue à un jeu de quiz. Pour chaque question, le score commence à $${initial.frenchify()}$ points.
+Puis il décroît de $${(-reason).frenchify()}$ points pour chaque seconde qui s'écoule avant que le joueur réponde correctement.
+Pablo met, la plupart du temps, $${roundedMeanDuration} \\ \\textrm{s}$ pour répondre.
+On note $u_n$ le score si l'on répond correctement $${getStrFactor(firstRank)}$ secondes après le début de la question.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [indexOfQuestion] = superfluousData.values;
+                            return `Pablo joue à un jeu de quiz. Pour chaque question, le score commence à $${initial.frenchify()}$ points.
+Puis il décroît de $${(-reason).frenchify()}$ points pour chaque seconde qui s'écoule avant que le joueur réponde correctement.
+Pablo est actuellement à la question numéro $${indexOfQuestion}$.
+On note $u_n$ le score si l'on répond correctement $${getStrFactor(firstRank)}$ secondes après le début de la question.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver le score pour une durée de réponse de $10 \\ \\textrm{s}$ ?
+
+Inspire toi de ce calcul pour déterminer le score pour une durée de réponse de $${getStrFactor(firstRank)} \\ \\textrm{s}$.
+`,
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                return {
+                    str: `Chaque seconde, le score diminue de $${-reason.frenchify()}$ points.
+Au bout de $${getStrFactor(firstRank)}$ secondes, le score aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frenchify()}$ points.
+
+Au départ, le score est de $${initial.frenchify()}$ points.
+
+Le score est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais le score $10$ secondes après le début, comment fais-tu pour calculer le score $11$ secondes après le début ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                return {
+                    str: `Chaque seconde, le score diminue de $${-reason.frenchify()}$ points.
+Par exemple, le score après $${target2.frenchify()} \\ \\textrm{s}$ est égal à celui après $${target1.frenchify()} \\ \\textrm{s}$ diminué de $${(-reason).frenchify()}$ points.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ?
+
+Utilise le terme général de $u_n$ pour déterminer le score $${target.frenchify()}$ secondes après le début de la question.`;
+            },
+            getCorrectionStuff: (initial, reason, firstRank, ..._otherArgs) => {
+                return {
+                    str: `Chaque seconde, le score diminue de $${-reason.frenchify()}$ points.
+Au bout de $${getStrFactor(firstRank)}$ secondes, le score aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frenchify()}$ points.
+
+Au départ, le score est de $${initial.frenchify()}$ points.
+
+Le score est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()}$ points ?`;
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $(u_n)$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque seconde, le score diminue de $${-reason.frenchify()}$ points.
+Le score est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindThreshold: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                const isStrict = inequationSymbol.symbol === "<" || inequationSymbol.symbol === ">";
+                switch (inequationSymbol.symbol) {
+                    case "<":
+                    case "\\le":
+                        return `Quel est le plus grand rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus petit que $${valueThreshold.frenchify()}$ points ?`;
+                    case ">":
+                    case "\\ge":
+                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()}$ points ?`;
+                }
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, reason] = otherArgs;
+                const inequationSymbolForRank = reason < 0 ? inequationSymbol.toReversed() : inequationSymbol;
+                const texP = (() => {
+                    switch (inequationSymbolForRank.symbol) {
+                        case "<":
+                        case "\\le":
+                            return "le plus grand entier";
+                        case ">":
+                        case "\\ge":
+                            return "le plus petit entier";
+                    }
+                })();
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque seconde, le score diminue de $${-reason.frenchify()}$ points.
+Le score est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //Niveau de charge de la batterie
+    {
+        randInitial: () => randfloat(70, 100, 2),
+        randReason: () => -randfloat(0, 4, 2, [0]),
+        randThreshold: (initial, reason, firstRank) => seqArithmeticUtils.randThreshold(initial, reason, firstRank, 0),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const roundedMeanDuration = randint(2, 7);
+                        values.push(roundedMeanDuration);
+                    }
+                    break;
+                case 1:
+                    {
+                        const thresholdBatteryLow = randint(5, 21);
+                        values.push(thresholdBatteryLow);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            if (superfluousData === undefined) {
+                return `Daryl utilise un phare à batterie sur son chantier, qu'il laisse allumé.
+Quand il a commencé la journée, le niveau de charge de la batterie était de $${initial.frenchify()} \\%$.
+Le niveau décroît chaque heure de $${(-reason).frenchify()} \\%$.
+On note $u_n$ le niveau de charge après $${getStrFactor(firstRank)} \\ \\textrm{h}$.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [roundedMeanDuration] = superfluousData.values;
+                            return `Daryl utilise un phare à batterie sur son chantier, qu'il laisse allumé.
+Quand il a commencé la journée, le niveau de charge de la batterie était de $${initial.frenchify()} \\%$.
+La plupart du temps, Daryl utilise le phare $${roundedMeanDuration} \\ \\textrm{h}$.
+Le niveau décroît chaque heure de $${(-reason).frenchify()} \\%$.
+On note $u_n$ le niveau de charge après $${getStrFactor(firstRank)} \\ \\textrm{h}$.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [thresholdBatteryLow] = superfluousData.values;
+                            return `Daryl utilise un phare à batterie sur son chantier, qu'il laisse allumé.
+Quand il a commencé la journée, le niveau de charge de la batterie était de $${initial.frenchify()} \\%$.
+Le niveau décroît chaque heure de $${(-reason).frenchify()} \\%$.
+Un signal sonore est émis quand le niveau de charge passe en dessous de $${thresholdBatteryLow.frenchify()} \\%$.
+On note $u_n$ le niveau de charge après $${getStrFactor(firstRank)} \\ \\textrm{h}$.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver le niveau de charge après de $4 \\ \\textrm{h}$ d'utilisation ?
+
+Inspire toi de ce calcul pour déterminer le niveau de charge pour une durée d'utilisation de $${getStrFactor(firstRank)} \\ \\textrm{h}$.
+`,
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                return {
+                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frenchify()} \\%$.
+Au bout de $${getStrFactor(firstRank)} \\ \\textrm{h}$, le niveau aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frenchify()} \\%$.
+
+Au départ, le niveau est de $${initial.frenchify()} \\%$.
+
+Le niveau de charge est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais le niveau $4$ heures après le début, comment fais-tu pour calculer le niveau $5$ heures après le début ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 4;
+                const target2 = 5;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                return {
+                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frenchify()} \\%$.
+Par exemple, le niveau après $${target2.frenchify()} \\ \\textrm{h}$ d'utilisation est égal à celui après $${target1.frenchify()} \\ \\textrm{h}$ d'utilisation diminué de $${(-reason).frenchify()} \\%$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ?
+
+Utilise le terme général de $u_n$ pour déterminer le niveau de charge après $${target.frenchify()} \\ \\textrm{h}$ d'utilisation.`;
+            },
+            getCorrectionStuff: (initial, reason, firstRank, ..._otherArgs) => {
+                return {
+                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frenchify()} \\%$.
+Au bout de $${getStrFactor(firstRank)} \\ \\textrm{h}$, le niveau aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frenchify()} \\%$.
+
+Au départ, le niveau est de $${initial.frenchify()} \\%$.
+
+Le niveau de charge est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()} \\%$ ?`;
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $(u_n)$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frenchify()} \\%$.
+Le niveau de charge est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindThreshold: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                const isStrict = inequationSymbol.symbol === "<" || inequationSymbol.symbol === ">";
+                switch (inequationSymbol.symbol) {
+                    case "<":
+                    case "\\le":
+                        return `Quel est le plus grand rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus petit que $${valueThreshold.frenchify()} \\%$  ?`;
+                    case ">":
+                    case "\\ge":
+                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\%$  ?`;
+                }
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, reason] = otherArgs;
+                const inequationSymbolForRank = reason < 0 ? inequationSymbol.toReversed() : inequationSymbol;
+                const texP = (() => {
+                    switch (inequationSymbolForRank.symbol) {
+                        case "<":
+                        case "\\le":
+                            return "le plus grand entier";
+                        case ">":
+                        case "\\ge":
+                            return "le plus petit entier";
+                    }
+                })();
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frenchify()} \\%$.
+Le niveau de charge est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //Buffet et amuse-bouches
+    {
+        randInitial: () => randint(30, 60) * 100,
+        randReason: () => -randint(8, 17) * 10,
+        randThreshold: (initial, reason, firstRank) => seqArithmeticUtils.randThreshold(initial, reason, firstRank, 0),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const numberOfPeople = randint(20, 70) * 10;
+                        values.push(numberOfPeople);
+                    }
+                    break;
+                case 1:
+                    {
+                        const nbOfGlassesPerMinute = randint(10, 21) * 10;
+                        values.push(nbOfGlassesPerMinute);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            if (superfluousData === undefined) {
+                return `Un gigantesque buffet est organisé. Au départ, sur les tables de service, il y a $${initial.frenchify()}$ amuse-bouches.
+$${(-reason).frenchify()}$ amuse-bouches sont mangés toutes les minutes.
+On note $u_n$ le nombre d'amuse-bouches restant après $${getStrFactor(firstRank)} \\ \\textrm{min}$.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [numberOfPeople] = superfluousData.values;
+                            return `Un gigantesque buffet est organisé. Au départ, sur les tables de service, il y a $${initial.frenchify()}$ amuse-bouches.
+$${(-reason).frenchify()}$ amuse-bouches sont mangés toutes les minutes.
+Il y a en tout $${numberOfPeople.frenchify()}$ convives.
+On note $u_n$ le nombre d'amuse-bouches restant après $${getStrFactor(firstRank)} \\ \\textrm{min}$.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [nbOfGlassesPerMinute] = superfluousData.values;
+                            return `Un gigantesque buffet est organisé. Au départ, sur les tables de service, il y a $${initial.frenchify()}$ amuse-bouches.
+$${nbOfGlassesPerMinute.frenchify()}$ verres sont servis toutes les minutes.
+$${(-reason).frenchify()}$ amuse-bouches sont mangés toutes les minutes.
+On note $u_n$ le nombre d'amuse-bouches restant après $${getStrFactor(firstRank)} \\ \\textrm{min}$.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver le nombre d'amuse-bouches restant après $4 \\ \\textrm{min}$ ?
+
+Inspire toi de ce calcul pour déterminer le nombre d'amuse-bouches restant après $${getStrFactor(firstRank)} \\ \\textrm{min}$.
+`,
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                return {
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${-reason.frenchify()}$.
+Au bout de $${getStrFactor(firstRank)} \\ \\textrm{min}$, le nombre d'amuse-bouches aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frenchify()}$.
+
+Au départ, il y en a $${initial.frenchify()}$.
+
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais le nombre d'amuse-bouches $4$ minutes après le début, comment fais-tu pour calculer le nombre d'amuse-bouches $5$ minutes après le début ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 4;
+                const target2 = 5;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                return {
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${-reason.frenchify()}$.
+Par exemple, le nombre d'amuse-bouches restant après $${target2.frenchify()} \\ \\textrm{min}$ est égal à celui après $${target1.frenchify()} \\ \\textrm{min}$ d'utilisation diminué de $${(-reason).frenchify()}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ?
+
+Utilise le terme général de $u_n$ pour déterminer le nombre d'amuse-bouches restant après $${target.frenchify()} \\ \\textrm{min}$ de buffet.`;
+            },
+            getCorrectionStuff: (initial, reason, firstRank, ..._otherArgs) => {
+                return {
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${-reason.frenchify()}$.
+Au bout de $${getStrFactor(firstRank)} \\ \\textrm{min}$, le nombre d'amuse-bouches aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frenchify()}$.
+
+Au départ, il y en a $${initial.frenchify()}$.
+
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()}$ ?`;
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $(u_n)$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${-reason.frenchify()}$.
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindThreshold: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                const isStrict = inequationSymbol.symbol === "<" || inequationSymbol.symbol === ">";
+                switch (inequationSymbol.symbol) {
+                    case "<":
+                    case "\\le":
+                        return `Quel est le plus grand rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus petit que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                    case ">":
+                    case "\\ge":
+                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                }
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, reason] = otherArgs;
+                const inequationSymbolForRank = reason < 0 ? inequationSymbol.toReversed() : inequationSymbol;
+                const texP = (() => {
+                    switch (inequationSymbolForRank.symbol) {
+                        case "<":
+                        case "\\le":
+                            return "le plus grand entier";
+                        case ">":
+                        case "\\ge":
+                            return "le plus petit entier";
+                    }
+                })();
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${-reason.frenchify()}$.
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //Locket Rig
+    {
+        randInitial: () => randint(210, 300) * 1000,
+        randReason: () => -randint(8, 17) * 1000,
+        randThreshold: (initial, reason, firstRank) => seqArithmeticUtils.randThreshold(initial, reason, firstRank, 0),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const numberOfPlayersOfNordFight = randint(500, 1700) * 1000;
+                        values.push(numberOfPlayersOfNordFight);
+                    }
+                    break;
+                case 1:
+                    {
+                        const nbOfSpectatorsAtPhysicalEvent = randint(2, 11) * 1000;
+                        values.push(nbOfSpectatorsAtPhysicalEvent);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            if (superfluousData === undefined) {
+                return `L'année de la sortie du jeu vidéo Locket Rig, ce même jeu avait $${initial.frenchify()}$ joueurs réguliers.
+Tous les ans, $${(-reason).frenchify()}$ joueurs arrêtent de jouer régulièrement à Locket Rig.
+On note $u_n$ le nombre de joueurs réguliers de Locket Rig $${getStrFactor(firstRank)}$ années après sa sortie.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [numberOfPlayersOfNordFight] = superfluousData.values;
+                            return `L'année de la sortie du jeu vidéo Locket Rig, ce même jeu avait $${initial.frenchify()}$ joueurs réguliers.
+Tous les ans, $${(-reason).frenchify()}$ joueurs arrêtent de jouer régulièrement à Locket Rig.
+Actuellement, $${numberOfPlayersOfNordFight.frenchify()}$ jouent régulièrement au jeu vidéo Nord Fight.
+On note $u_n$ le nombre de joueurs réguliers de Locket Rig $${getStrFactor(firstRank)}$ années après sa sortie.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [nbOfSpectatorsAtPhysicalEvent] = superfluousData.values;
+                            return `L'année de la sortie du jeu vidéo Locket Rig, ce même jeu avait $${initial.frenchify()}$ joueurs réguliers.
+Il y avait $${nbOfSpectatorsAtPhysicalEvent.frenchify()}$ spectateurs au premier tournoi organisé dans une grande salle de concert.
+Tous les ans, $${(-reason).frenchify()}$ joueurs arrêtent de jouer régulièrement à Locket Rig.
+On note $u_n$ le nombre de joueurs réguliers de Locket Rig $${getStrFactor(firstRank)}$ années après sa sortie.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver le nombre de joueurs $4$ années après la sortie ?
+
+Inspire toi de ce calcul pour déterminer le nombre de joueurs $${getStrFactor(firstRank)}$ années après la sortie.
+`,
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                return {
+                    str: `Chaque année, le nombre de joueurs diminue de $${-reason.frenchify()}$.
+Au bout de $${getStrFactor(firstRank)}$ années, le nombre de joueurs aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frenchify()}$.
+
+Au départ, il y en avait $${initial.frenchify()}$.
+
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqArithmeticUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais le nombre de joueurs $4$ années après la sortie, comment fais-tu pour calculer le nombre de joueurs $5$ années après la sortie ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 4;
+                const target2 = 5;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                return {
+                    str: `Chaque année, le nombre de joueurs diminue de $${-reason.frenchify()}$.
+Par exemple, le nombre de joueurs restant après $${target2.frenchify()}$ années est égal à celui après $${target1.frenchify()}$ années diminué de $${(-reason).frenchify()}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ?
+
+Utilise le terme général de $u_n$ pour déterminer le nombre de joueurs restant après $${target.frenchify()}$ années.`;
+            },
+            getCorrectionStuff: (initial, reason, firstRank, ..._otherArgs) => {
+                return {
+                    str: `Chaque année, le nombre de joueurs diminue de $${-reason.frenchify()}$.
+Au bout de $${getStrFactor(firstRank)}$ années, le nombre de joueurs aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frenchify()}$.
+
+Au départ, il y en avait $${initial.frenchify()}$.
+
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRank: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()}$ ?`;
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueAsked] = otherArgs;
+                return `Quelle est la nature de la suite $(u_n)$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque année, le nombre de joueurs diminue de $${-reason.frenchify()}$.
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindThreshold: {
+            getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                const isStrict = inequationSymbol.symbol === "<" || inequationSymbol.symbol === ">";
+                switch (inequationSymbol.symbol) {
+                    case "<":
+                    case "\\le":
+                        return `Quel est le plus grand rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus petit que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                    case ">":
+                    case "\\ge":
+                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                }
+            },
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol] = otherArgs;
+                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            },
+            getHint: (_firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, reason] = otherArgs;
+                const inequationSymbolForRank = reason < 0 ? inequationSymbol.toReversed() : inequationSymbol;
+                const texP = (() => {
+                    switch (inequationSymbolForRank.symbol) {
+                        case "<":
+                        case "\\le":
+                            return "le plus grand entier";
+                        case ">":
+                        case "\\ge":
+                            return "le plus petit entier";
+                    }
+                })();
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Chaque année, le nombre de joueurs diminue de $${-reason.frenchify()}$.
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+];
+export const situationsArithmetic = templatesSituationsArithmetic.map(createSituationArithmeticFromTemplate);