math-exercises 3.0.176 → 3.0.178

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

@@ -36,10 +36,10 @@ $$
                 const str = `${strRaw}
 
 $$
-u_{${rank2.frenchify()}} = u_{${rank1.frenchify()}} + (${reason.frenchify()})
+u_{${rank2.frPretty(2)}} = u_{${rank1.frPretty(2)}} + (${reason.frPretty(2)})
 $$
 
-La relation de récurrence est, pour $n \\geq ${firstRank.frenchify()}$ :
+La relation de récurrence est, pour $n \\geq ${firstRank.frPretty(2)}$ :
 
 $$
 ${seqArithmeticUtils
@@ -79,31 +79,36 @@ ${alignTex([
         }),
         variationFindRank: Object.assign({}, variationFindRank, {
             getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueAsked] = otherArgs;
+                const [valueAsked, _rankDecoder] = otherArgs;
                 const { str: strRaw } = variationFindRank.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
-                const answerNode = variationFindRank.getAnswerNode(initial, reason, firstRank, ...otherArgs);
+                const { answerNode, rankNode } = variationFindRank.getAnswerStuff(initial, reason, firstRank, ...otherArgs);
+                const texRankSimplified = rankNode.evaluate().frPretty(0);
+                const texAnswer = [
+                    ...new Set([answerNode.toTex(), answerNode.evaluate().frPretty(2)]),
+                ].join(" = ");
                 const str = `${strRaw}
 
 On note $p$ le rang recherché. On a : 
 
 ${alignTex([
-                    [`u_p`, "=", valueAsked.frenchify()],
+                    [`u_p`, "=", valueAsked.frPretty(2)],
                     [
                         `${add(initial, multiply(reason, "p".toTree())).toTex()}`,
                         "=",
-                        valueAsked.frenchify(),
+                        valueAsked.frPretty(2),
                     ],
                 ])}
 
 On résout l'équation : 
 
 ${alignTex([
-                    [`p`, "=", answerNode.toTex()],
-                    ["", "=", answerNode.simplify().toTex()],
+                    [`p`, "=", rankNode.toTex()],
+                    ["", "=", texRankSimplified],
                 ])}
 
+Le rang $p$ est donc $${texRankSimplified}$.
 
-`;
+Le nombre recherché est donc $${texAnswer}$.`;
                 return { str };
             },
         }),
@@ -111,17 +116,21 @@ ${alignTex([
             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 { answerNode, rankNode } = variationFindThreshold.getAnswerStuff(initial, reason, firstRank, ...otherArgs);
+                const texRankSimplified = rankNode.evaluate().frPretty(0);
+                const texAnswer = [
+                    ...new Set([answerNode.toTex(), answerNode.evaluate().frPretty(2)]),
+                ].join(" = ");
                 const str = `${strRaw}
 
 On note $p$ le rang recherché. On a : 
 
 ${alignTex([
-                    [`u_p`, inequationSymbol.symbol, valueThreshold.frenchify()],
+                    [`u_p`, inequationSymbol.symbol, valueThreshold.frPretty(2)],
                     [
                         `${add(initial, multiply(reason, substract("p".toTree(), firstRank).simplify())).toTex()}`,
                         inequationSymbol.symbol,
-                        valueThreshold.frenchify(),
+                        valueThreshold.frPretty(2),
                     ],
                 ])}
 
@@ -138,9 +147,9 @@ ${(() => {
                 })()}
 $$
 
-Le rang $p$ recherché est donc $${answerNode.toTex()}$.
+Le rang $p$ est donc $${texRankSimplified}$.
 
-`;
+Le nombre recherché est donc $${texAnswer}$.`;
                 return { str };
             },
         }),
@@ -178,10 +187,14 @@ const templatesSituationsArithmetic = [
                 values,
             };
         },
+        rankDecoder: {
+            targetFromRank: (rank, _firstRank) => rank.toTree(),
+            rankFromTarget: (nodeTarget, _firstRank) => nodeTarget.evaluate(),
+        },
         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}$.
+                return `On suppose qu'une plante, d'une hauteur initiale (jour $${firstRank.frPretty(2)}$) de $${initial.frPretty(2)}\\ \\textrm{cm}$, 
+croît chaque jour de $${reason.frPretty(2)}\\ \\textrm{cm}$.
 On note $u_n$ la hauteur de la plante relevée le jour $n$, en $\\textrm{cm}$.`;
             }
             else {
@@ -189,18 +202,18 @@ On note $u_n$ la hauteur de la plante relevée le jour $n$, en $\\textrm{cm}$.`;
                     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}$.
+                            return `On suppose qu'une plante, d'une hauteur initiale (jour $${firstRank.frPretty(2)}$) de $${initial.frPretty(2)}\\ \\textrm{cm}$ et
+arrosée en moyenne tous les $${wateringPeriodInDays.frPretty(2)}$ jours,
+croît chaque jour de $${reason.frPretty(2)}\\ \\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}$.
+                            return `On suppose qu'on a mis une plante dans un pot de diamètre $${potDiameterInCm.frPretty(2)} \\ \\textrm{cm}$.
+La plante a alors une hauteur initiale (jour $${firstRank.frPretty(2)}$) de $${initial.frPretty(2)}\\ \\textrm{cm}$. 
+La plante croît chaque jour de $${reason.frPretty(2)}\\ \\textrm{cm}$.
 On note $u_n$ la hauteur de la plante relevée le jour $n$, en $\\textrm{cm}$.`;
                         }
                         break;
@@ -216,8 +229,8 @@ On note $u_n$ la hauteur de la plante relevée le jour $n$, en $\\textrm{cm}$.`;
 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()}$.`,
+                    str: `Chaque jour, la plante gagne $${reason.frPretty(2)}\\ \\textrm{cm}$.
+La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -231,8 +244,8 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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}$.`,
+                    str: `Chaque jour, la plante gagne $${reason.frPretty(2)}\\ \\textrm{cm}$.
+Par exemple, la hauteur de la plante le jour $${target2.frPretty(2)}$ est égale à celle du jour $${target1.frPretty(2)}$ augmentée de $${reason.frPretty(2)}\\ \\textrm{cm}$.`,
                     rank1,
                     rank2,
                 };
@@ -248,34 +261,36 @@ Par exemple, la hauteur de la plante le jour $${target2.frenchify()}$ est égale
                 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.`;
+Utilise le terme général de $u_n$ pour déterminer la hauteur de la plante au bout de $${target.frPretty(2)}$ 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()}$.`,
+                    str: `Chaque jour, la plante gagne $${reason.frPretty(2)}\\ \\textrm{cm}$.
+La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
         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}$ ?`;
+                return `Quel jour la plante aura-t-elle atteint une hauteur de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{cm}$ ?`;
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueAsked] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer $n$ tel que $u_n = ${valueAsked.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Chaque jour, la plante gagne $${reason.frPretty(2)}\\ \\textrm{cm}$.
+La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -286,15 +301,17 @@ La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une su
                 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}$ ?`;
+                        return `Quel sera le dernier jour où la hauteur de la plante sera ${isStrict ? "strictement" : ""} en dessous de $${valueThreshold.frPretty(2)} \\ \\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}$ ?`;
+                        return `Quel sera le jour où la hauteur de la plante ${isStrict ? "dépassera" : "atteindra ou dépassera"} $${valueThreshold.frPretty(2)} \\ \\textrm{cm}$ ?`;
                 }
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueThreshold, inequationSymbol] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             getHint: (_firstRank, ...otherArgs) => {
                 const [valueThreshold, inequationSymbol, reason] = otherArgs;
@@ -311,12 +328,12 @@ La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une su
                 })();
                 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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Chaque jour, la plante gagne $${reason.frPretty(2)}\\ \\textrm{cm}$.
+La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -348,10 +365,14 @@ La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une su
                 values,
             };
         },
+        rankDecoder: {
+            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+        },
         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.
+                return `Une compagnie de taxis propose un tarif qui inclut un montant fixe de $${initial.frPretty(2)}\\ \\textrm{€}$
+et un montant variable de $${reason.frPretty(2)}\\ \\textrm{€}$ par kilomètre parcouru.
 On note $u_n$ le prix payé (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{km}$ parcourus.`;
             }
             else {
@@ -359,18 +380,18 @@ On note $u_n$ le prix payé (en $\\textrm{€}$) pour $${getStrFactor(firstRank)
                     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.
+                            return `Une compagnie de taxis propose un tarif qui inclut un montant fixe de $${initial.frPretty(2)}\\ \\textrm{€}$
+et un montant variable de $${reason.frPretty(2)}\\ \\textrm{€}$ par kilomètre parcouru.
+Le taxi consomme $${fuelConsumptionPer100Km.frPretty(2)} \\ \\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}$.
+                            return `Une compagnie de taxis propose un tarif qui inclut un montant fixe de $${initial.frPretty(2)}\\ \\textrm{€}$
+et un montant variable de $${reason.frPretty(2)}\\ \\textrm{€}$ par kilomètre parcouru.
+La distance à la ville la plus proche est de $${distanceToNextCityInKm.frPretty(2)} \\ \\textrm{km}$.
 On note $u_n$ le prix payé (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{km}$ parcourus.`;
                         }
                         break;
@@ -386,8 +407,8 @@ On note $u_n$ le prix payé (en $\\textrm{€}$) pour $${getStrFactor(firstRank)
 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()}$.`,
+                    str: `Pour chaque kilomètre supplémentaire, la facture augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -401,8 +422,8 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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{€}$.`,
+                    str: `Pour chaque kilomètre supplémentaire, la facture augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+Par exemple, la facture pour $${target2.frPretty(2)} \\ \\textrm{km}$ est égale à celle de $${target1.frPretty(2)} \\ \\textrm{km}$ augmentée de $${reason.frPretty(2)}\\ \\textrm{€}$.`,
                     rank1,
                     rank2,
                 };
@@ -418,34 +439,40 @@ Par exemple, la facture pour $${target2.frenchify()} \\ \\textrm{km}$ est égale
                 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}$.`;
+Utilise le terme général de $u_n$ pour déterminer la facture pour $${target.frPretty(2)} \\ \\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()}$.`,
+                    str: `Pour chaque kilomètre supplémentaire, la facture augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
         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);
+                // return `Quel est le rang $p$ pour lequel $u_{p} = ${round(
+                //   valueAsked,
+                //   2,
+                // ).frPretty(2)} \\ \\textrm{€}$ ?`;
+                return `Pour combien de kilomètres la facture sera-t-elle de $${round(valueAsked, 2).frPretty(2)} ?`;
+            },
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Pour chaque kilomètre supplémentaire, la facture augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -456,15 +483,17 @@ La facture est donc une suite arithmétique de premier terme $${initial.frenchif
                 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{€}$ ?`;
+                        return `Quel est le nombre maximum de kilomètres que l'on peut parcourir sans que la facture ne dépasse $${valueThreshold.frPretty(2)} \\ \\textrm{€}$ ?`;
                     case ">":
                     case "\\ge":
-                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                        return `Combien de kilomètres aura-t-on parcouru quand la facture viendra ${isStrict ? "de dépasser" : "d'égaler ou de dépasser"} $${valueThreshold.frPretty(2)} \\ \\textrm{€}$ ?`;
                 }
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueThreshold, inequationSymbol] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             getHint: (_firstRank, ...otherArgs) => {
                 const [valueThreshold, inequationSymbol, reason] = otherArgs;
@@ -481,12 +510,12 @@ La facture est donc une suite arithmétique de premier terme $${initial.frenchif
                 })();
                 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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Pour chaque kilomètre supplémentaire, la facture augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -521,8 +550,8 @@ La facture est donc une suite arithmétique de premier terme $${initial.frenchif
         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é.
+un abonnement fixe de $${initial.frPretty(2)}\\ \\textrm{€}$
+puis il paye $${reason.frPretty(2)}\\ \\textrm{€}$ par kWh consommé.
 On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{kWh}$ consommés.`;
             }
             else {
@@ -531,9 +560,9 @@ On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \
                         {
                             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.
+un abonnement fixe de $${initial.frPretty(2)}\\ \\textrm{€}$
+puis il paye $${reason.frPretty(2)}\\ \\textrm{€}$ par kWh consommé.
+Son refrigétateur consomme $${fridgeConsumptionPerMonth.frPretty(2)} \\ \\textrm{kWh}$ tous les mois.
 On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{kWh}$ consommés.`;
                         }
                         break;
@@ -541,9 +570,9 @@ On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \
                         {
                             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.
+un abonnement fixe de $${initial.frPretty(2)}\\ \\textrm{€}$
+puis il paye $${reason.frPretty(2)}\\ \\textrm{€}$ par kWh consommé.
+Jimmy paye $${internetBill.frPretty(2)}\\ \\textrm{€}$ tous les mois pour son abonnement internet.
 On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{kWh}$ consommés.`;
                         }
                         break;
@@ -552,6 +581,10 @@ On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \
                 }
             }
         },
+        rankDecoder: {
+            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+        },
         variationFindExplicitFormula: {
             getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
             getHint: (firstRank) => `Quel calcul permet de trouver le prix payé pour $10 \\ \\textrm{kWh}$ ?
@@ -559,8 +592,8 @@ On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \
 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()}$.`,
+                    str: `Pour chaque $\\textrm{kWh}$ supplémentaire, la facture augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -574,8 +607,8 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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{€}$.`,
+                    str: `Pour chaque $\\textrm{kWh}$ supplémentaire, la facture augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+Par exemple, la facture pour $${target2.frPretty(2)} \\ \\textrm{kWh}$ est égale à celle de $${target1.frPretty(2)} \\ \\textrm{kWh}$ augmentée de $${reason.frPretty(2)}\\ \\textrm{€}$.`,
                     rank1,
                     rank2,
                 };
@@ -591,34 +624,40 @@ Par exemple, la facture pour $${target2.frenchify()} \\ \\textrm{kWh}$ est égal
                 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}$.`;
+Utilise le terme général de $u_n$ pour déterminer la facture pour $${target.frPretty(2)} \\ \\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()}$.`,
+                    str: `Pour chaque $\\textrm{kWh}$ supplémentaire, la facture augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
         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);
+                // return `Quel est le rang $p$ pour lequel $u_{p} = ${round(
+                //   valueAsked,
+                //   2,
+                // ).frPretty(2)} \\ \\textrm{€}$ ?`;
+                return `Pour combien de $\\textrm{kWh}$ la facture sera-t-elle de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{€}$ ?`;
+            },
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Pour chaque $\\textrm{kWh}$ supplémentaire, la facture augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -629,15 +668,17 @@ La facture est donc une suite arithmétique de premier terme $${initial.frenchif
                 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{€}$ ?`;
+                        return `Quel est le nombre maximum de $\\textrm{kWh}$ que l'on peut consommer sans que la facture ne dépasse $${valueThreshold.frPretty(2)} \\ \\textrm{€}$ ?`;
                     case ">":
                     case "\\ge":
-                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                        return `Combien de $\\textrm{kWh}$ aura-t-on consommé quand la facture viendra ${isStrict ? "de dépasser" : "d'égaler ou de dépasser"} $${valueThreshold.frPretty(2)} \\ \\textrm{€}$ ?`;
                 }
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueThreshold, inequationSymbol] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             getHint: (_firstRank, ...otherArgs) => {
                 const [valueThreshold, inequationSymbol, reason] = otherArgs;
@@ -654,12 +695,12 @@ La facture est donc une suite arithmétique de premier terme $${initial.frenchif
                 })();
                 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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Pour chaque $\\textrm{kWh}$ supplémentaire, la facture augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+La facture est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -691,11 +732,15 @@ La facture est donc une suite arithmétique de premier terme $${initial.frenchif
                 values,
             };
         },
+        rankDecoder: {
+            targetFromRank: (rank, firstRank) => (100 * (rank - firstRank)).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() / 100 + firstRank,
+        },
         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.
+Il part de Valenciennes où il fait $${initial.frPretty(2)} \\ \\textrm{°C}$.
+La température ambiante augmente de $${reason.frPretty(2)}\\ \\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 {
@@ -703,18 +748,18 @@ On note $u_n$ la température ambiante (en $\\textrm{°C}$) pour $${getStrFactor
                     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.
+                            return `Dany décide de partir au Sud de la France. Il part de Valenciennes où il fait $${initial.frPretty(2)} \\ \\textrm{°C}$.
+La température ambiante augmente de $${reason.frPretty(2)}\\ \\textrm{°C}$ à chaque centaine de $\\textrm{km}$ vers le Sud.
+Sa voiture consomme $${fuelConsumptionPer100Km.frPretty(2)} \\ \\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.
+                            return `Dany décide de partir au Sud de la France. Il part de Valenciennes où il fait $${initial.frPretty(2)} \\ \\textrm{°C}$.
+La température ambiante augmente de $${reason.frPretty(2)}\\ \\textrm{°C}$ à chaque centaine de $\\textrm{km}$ vers le Sud.
+Il fait une pause en moyenne tous les $${distanceToNextBreakInKm.frPretty(2)}$ 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;
@@ -730,12 +775,12 @@ On note $u_n$ la température ambiante (en $\\textrm{°C}$) pour $${getStrFactor
 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}$.
+                    str: `Pour chaque centaine de $\\textrm{km}$ parcourue, la température augmente de $${reason.frPretty(2)} \\ \\textrm{°C}$.
+Au bout de $${getStrFactor(firstRank)}$ centaines de $\\textrm{km}$, la température augmente donc de $${getStrFactor(firstRank)} \\times ${reason.frPretty(2)} \\ \\textrm{°C}$.
 
-Au départ, la température est de $${initial.frenchify()} \\ \\textrm{°C}$.
+Au départ, la température est de $${initial.frPretty(2)} \\ \\textrm{°C}$.
 
-La température, en $\\textrm{°C}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+La température, en $\\textrm{°C}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -749,8 +794,8 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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}$.`,
+                    str: `Pour chaque centaine de $\\textrm{km}$ supplémentaire, la température augmente de $${reason.frPretty(2)}\\ \\textrm{°C}$.
+Par exemple, la température après $${target2.frPretty(2)} \\ \\textrm{km}$ parcourus est égale à celle après $${target1.frPretty(2)} \\ \\textrm{km}$ augmentée de $${reason.frPretty(2)}\\ \\textrm{°C}$.`,
                     rank1,
                     rank2,
                 };
@@ -766,34 +811,36 @@ Par exemple, la température après $${target2.frenchify()} \\ \\textrm{km}$ par
                 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.`;
+Utilise le terme général de $u_n$ pour déterminer la température pour $${target.frPretty(2)} \\ \\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()}$.`,
+                    str: `Pour chaque centaine de $\\textrm{km}$ supplémentaire, la température ambiante augmente de $${reason.frPretty(2)}\\ \\textrm{°C}$.
+La température ambiante est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()} \\ \\textrm{€}$ ?`;
+                return `Pour combien kilomètres parcourus $p$ la température sera-t-elle de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{°C}$ ?`;
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueAsked] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Pour chaque centaine de $\\textrm{km}$ supplémentaire, la température ambiante augmente de $${reason.frPretty(2)}\\ \\textrm{°C}$.
+La température ambiante est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -804,15 +851,17 @@ La température ambiante est donc une suite arithmétique de premier terme $${in
                 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}$ ?`;
+                        return `Quel est le nombre maximum de kilomètres que l'on peut parcourir sans que la température ne dépasse $${valueThreshold.frPretty(2)} \\ \\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}$ ?`;
+                        return `Combien de kilomètres aura-t-on parcouru quand la température viendra ${isStrict ? "de dépasser" : "d'égaler ou de dépasser"} $${valueThreshold.frPretty(2)} \\ \\textrm{°C}$ ?`;
                 }
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueThreshold, inequationSymbol] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             getHint: (_firstRank, ...otherArgs) => {
                 const [valueThreshold, inequationSymbol, reason] = otherArgs;
@@ -829,12 +878,12 @@ La température ambiante est donc une suite arithmétique de premier terme $${in
                 })();
                 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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Pour chaque centaine de $\\textrm{km}$ supplémentaire, la température ambiante augmente de $${reason.frPretty(2)}\\ \\textrm{°C}$.
+La température ambiante est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -866,11 +915,15 @@ La température ambiante est donc une suite arithmétique de premier terme $${in
                 values,
             };
         },
+        rankDecoder: {
+            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+        },
         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.
+de $${initial.frPretty(2)}\\ \\textrm{€}$ à son entrée dans l'entreprise,
+et augmente de $${reason.frPretty(2)}$ € tous les ans.
 On note $u_n$ son salaire net (en $\\textrm{€}$) quand elle aura $${getStrFactor(firstRank)}$ années d'ancienneté.`;
             }
             else {
@@ -879,9 +932,9 @@ On note $u_n$ son salaire net (en $\\textrm{€}$) quand elle aura $${getStrFact
                         {
                             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.
+Son salaire net était de $${initial.frPretty(2)}\\ \\textrm{€}$ à son entrée dans l'entreprise.
+Elle avait alors $${ageWhenHired.frPretty(2)}$ ans.
+Son salaire augmente de $${reason.frPretty(2)}\\ \\textrm{€}$ tous les ans.
 
 On note $u_n$ son salaire net (en $\\textrm{€}$) quand elle aura $${getStrFactor(firstRank)}$ années d'ancienneté.`;
                         }
@@ -890,9 +943,9 @@ On note $u_n$ son salaire net (en $\\textrm{€}$) quand elle aura $${getStrFact
                         {
                             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.
+Son salaire net était de $${initial.frPretty(2)}\\ \\textrm{€}$ à son entrée dans l'entreprise.
+Sa collègue Flora gagnait alors $${salaryOfCoworker.frPretty(2)} \\ \\textrm{€}$.
+Son salaire augmente de $${reason.frPretty(2)} \\ \\textrm{€}$ tous les ans.
 
 On note $u_n$ son salaire net (en $\\textrm{€}$) quand elle aura $${getStrFactor(firstRank)}$ années d'ancienneté.`;
                         }
@@ -910,12 +963,12 @@ Inspire toi de ce calcul pour déterminer son salaire net pour $${getStrFactor(f
 `,
             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{€}$.
+                    str: `Chaque année, son salaire net augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+Au bout de $${getStrFactor(firstRank)}$ années, son salaire net aura augmenté de $${getStrFactor(firstRank)} \\times ${reason.frPretty(2)}\\ \\textrm{€}$.
 
-Au départ, son salaire net était de $${initial.frenchify()}\\ \\textrm{€}$.
+Au départ, son salaire net était de $${initial.frPretty(2)}\\ \\textrm{€}$.
 
-Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -929,8 +982,8 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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{€}$.`,
+                    str: `Pour chaque année supplémentaire, le salaire d'Emma augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+Par exemple, son salaire pour $${target2.frPretty(2)}$ ans d'ancienneté est égal à celui pour $${target1.frPretty(2)}$ ans augmenté de $${reason.frPretty(2)}\\ \\textrm{€}$.`,
                     rank1,
                     rank2,
                 };
@@ -946,38 +999,40 @@ Par exemple, son salaire pour $${target2.frenchify()}$ ans d'ancienneté est ég
                 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é.`;
+Utilise le terme général de $u_n$ pour déterminer le salaire d'Emma pour $${target.frPretty(2)}$ 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{€}$.
+                    str: `Pour chaque année supplémentaire, le salaire d'Emma augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+Par exemple, son salaire pour $11$ ans d'ancienneté est égal à celui pour $10$ ans augmenté de $${reason.frPretty(2)}\\ \\textrm{€}$.
 
-Au départ, son salaire net était de $${initial.frenchify()}\\ \\textrm{€}$.
+Au départ, son salaire net était de $${initial.frPretty(2)}\\ \\textrm{€}$.
 
-Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()} \\ \\textrm{€}$ ?`;
+                return `Quelle est l'année où le salaire d'Emma sera de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{€}$ ?`;
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueAsked] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Pour chaque année supplémentaire, le salaire d'Emma augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -988,15 +1043,17 @@ Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premi
                 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{€}$ ?`;
+                        return `Quelle sera la dernière année où le salaire d'Emma sera ${isStrict ? "inférieur" : "inférieur ou égal"} à $${valueThreshold.frPretty(2)} \\ \\textrm{€}$ ?`;
                     case ">":
                     case "\\ge":
-                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                        return `Quelle sera l'année où le salaire d'Emma ${isStrict ? "dépassera" : "égalera ou dépassera"} $${valueThreshold.frPretty(2)} \\ \\textrm{€}$ ?`;
                 }
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueThreshold, inequationSymbol] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             getHint: (_firstRank, ...otherArgs) => {
                 const [valueThreshold, inequationSymbol, reason] = otherArgs;
@@ -1013,12 +1070,12 @@ Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premi
                 })();
                 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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Pour chaque année supplémentaire, le salaire d'Emma augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
+Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1053,10 +1110,14 @@ Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premi
                 values,
             };
         },
+        rankDecoder: {
+            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+        },
         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.
+                return `Manon a gagné un peu d'argent cet été. Début septembre, elle a $${initial.frPretty(2)}\\ \\textrm{€}$ d'économies.
+Chaque semaine, elle dépense en moyenne $${(-reason).frPretty(2)}\\ \\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 {
@@ -1064,17 +1125,17 @@ On note $u_n$ le montant de ses économies (en $\\textrm{€}$), $${getStrFactor
                     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.
+                            return `Manon a gagné un peu d'argent cet été. Début septembre, elle a $${initial.frPretty(2)}\\ \\textrm{€}$ d'économies.
 Elle sort souvent avec ses $${numberOfFriends}$ amis.
-Chaque semaine, elle dépense en moyenne $${(-reason).frenchify()}\\ \\textrm{€}$ pour ses loisirs.
+Chaque semaine, elle dépense en moyenne $${(-reason).frPretty(2)}\\ \\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.
+                            return `Manon a gagné un peu d'argent cet été. Début septembre, elle a $${initial.frPretty(2)}\\ \\textrm{€}$ d'économies.
+Chaque semaine, elle dépense en moyenne $${(-reason).frPretty(2)}\\ \\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.`;
                         }
@@ -1092,12 +1153,12 @@ Inspire toi de ce calcul pour déterminer le montant de ses économies $${getStr
 `,
             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{€}$.
+                    str: `Chaque semaine, ses économies diminuent de $${(-reason).frPretty(2)}\\ \\textrm{€}$.
+Au bout de $${getStrFactor(firstRank)}$ semaines, ses économies auront diminué de $${getStrFactor(firstRank)} \\times ${(-reason).frPretty(2)}\\ \\textrm{€}$.
 
-Au départ, le montant de ses économies était de $${initial.frenchify()}\\ \\textrm{€}$.
+Au départ, le montant de ses économies était de $${initial.frPretty(2)}\\ \\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()}$.`,
+Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1111,8 +1172,8 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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{€}$.`,
+                    str: `Après chaque semaine de dépenses supplémentaire, les économies de Manon diminuent de $${(-reason).frPretty(2)}\\ \\textrm{€}$.
+Par exemple, le montant de ses économies après $${target2.frPretty(2)}$ semaines est égal à celui pour $${target1.frPretty(2)}$ semaines diminué de $${(-reason).frPretty(2)}\\ \\textrm{€}$.`,
                     rank1,
                     rank2,
                 };
@@ -1128,38 +1189,40 @@ Par exemple, le montant de ses économies après $${target2.frenchify()}$ semain
                 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.`;
+Utilise le terme général de $u_n$ pour déterminer le montant des économies de Manon $${target.frPretty(2)}$ 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{€}$.
+                    str: `Après chaque semaine de dépenses supplémentaire, les économies de Manon diminuent de $${(-reason).frPretty(2)}\\ \\textrm{€}$.
+Par exemple, le montant de ses économies après $${target2.frPretty(2)}$ semaines est égal à celui pour $${target1.frPretty(2)}$ semaines diminué de $${(-reason).frPretty(2)}\\ \\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()}$.`,
+Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()} \\ \\textrm{€}$ ?`;
+                return `Après combien de semaines les économies de Manon seront elles de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{€}$ ?`;
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueAsked] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Après chaque semaine de dépenses supplémentaire, les économies de Manon diminuent de $${(-reason).frPretty(2)}\\ \\textrm{€}$.
+Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1170,15 +1233,17 @@ Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arith
                 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{€}$ ?`;
+                        return `Quelle sera la dernière semaine (comptée à partir du moment où elle commence à dépenser) où Manon aura ${isStrict ? "plus que" : "au moins"} $${valueThreshold.frPretty(2)} \\ \\textrm{€}$ ?`;
                     case ">":
                     case "\\ge":
-                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                        return `Quelle sera la semaine (comptée à partir du moment où elle commence à dépenser) où ses économies seront ${isStrict ? "strictement inférieures" : "inférieures"} à $${valueThreshold.frPretty(2)} \\ \\textrm{€}$ ?`;
                 }
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueThreshold, inequationSymbol] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             getHint: (_firstRank, ...otherArgs) => {
                 const [valueThreshold, inequationSymbol, reason] = otherArgs;
@@ -1195,12 +1260,12 @@ Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arith
                 })();
                 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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Après chaque semaine de dépenses supplémentaire, les économies de Manon diminuent de $${(-reason).frPretty(2)}\\ \\textrm{€}$.
+Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1232,10 +1297,14 @@ Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arith
                 values,
             };
         },
+        rankDecoder: {
+            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+        },
         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.
+                return `Pablo joue à un jeu de quiz. Pour chaque question, le score commence à $${initial.frPretty(2)}$ points.
+Puis il décroît de $${(-reason).frPretty(2)}$ 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 {
@@ -1243,8 +1312,8 @@ On note $u_n$ le score si l'on répond correctement $${getStrFactor(firstRank)}$
                     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.
+                            return `Pablo joue à un jeu de quiz. Pour chaque question, le score commence à $${initial.frPretty(2)}$ points.
+Puis il décroît de $${(-reason).frPretty(2)}$ 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.`;
                         }
@@ -1252,8 +1321,8 @@ On note $u_n$ le score si l'on répond correctement $${getStrFactor(firstRank)}$
                     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.
+                            return `Pablo joue à un jeu de quiz. Pour chaque question, le score commence à $${initial.frPretty(2)}$ points.
+Puis il décroît de $${(-reason).frPretty(2)}$ 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.`;
                         }
@@ -1271,12 +1340,12 @@ Inspire toi de ce calcul pour déterminer le score pour une durée de réponse d
 `,
             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.
+                    str: `Chaque seconde, le score diminue de $${-reason.frPretty(2)}$ points.
+Au bout de $${getStrFactor(firstRank)}$ secondes, le score aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)}$ points.
 
-Au départ, le score est de $${initial.frenchify()}$ points.
+Au départ, le score est de $${initial.frPretty(2)}$ points.
 
-Le score est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+Le score est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1290,8 +1359,8 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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.`,
+                    str: `Chaque seconde, le score diminue de $${-reason.frPretty(2)}$ points.
+Par exemple, le score après $${target2.frPretty(2)} \\ \\textrm{s}$ est égal à celui après $${target1.frPretty(2)} \\ \\textrm{s}$ diminué de $${(-reason).frPretty(2)}$ points.`,
                     rank1,
                     rank2,
                 };
@@ -1307,38 +1376,40 @@ Par exemple, le score après $${target2.frenchify()} \\ \\textrm{s}$ est égal
                 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.`;
+Utilise le terme général de $u_n$ pour déterminer le score $${target.frPretty(2)}$ 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.
+                    str: `Chaque seconde, le score diminue de $${-reason.frPretty(2)}$ points.
+Au bout de $${getStrFactor(firstRank)}$ secondes, le score aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)}$ points.
 
-Au départ, le score est de $${initial.frenchify()}$ points.
+Au départ, le score est de $${initial.frPretty(2)}$ points.
 
-Le score est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+Le score est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()}$ points ?`;
+                return `Après combien de secondes le score sera-t-il de $${round(valueAsked, 2).frPretty(2)}$ points ?`;
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueAsked] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Chaque seconde, le score diminue de $${-reason.frPretty(2)}$ points.
+Le score est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1349,15 +1420,17 @@ Le score est donc une suite arithmétique de premier terme $${initial.frenchify(
                 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 ?`;
+                        return `Pour quelle durée de réponse maximum le score sera t-il ${isStrict ? "supérieur" : "supérieur ou égal"} à $${valueThreshold.frPretty(2)}$ points ?`;
                     case ">":
                     case "\\ge":
-                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()}$ points ?`;
+                        return `Quelle est la durée de réponse pour laquelle le score ${isStrict ? "sera en dessous de" : "égalera ou sera en dessous de"} $${valueThreshold.frPretty(2)}$ points ?`;
                 }
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueThreshold, inequationSymbol] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             getHint: (_firstRank, ...otherArgs) => {
                 const [valueThreshold, inequationSymbol, reason] = otherArgs;
@@ -1374,12 +1447,12 @@ Le score est donc une suite arithmétique de premier terme $${initial.frenchify(
                 })();
                 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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Chaque seconde, le score diminue de $${-reason.frPretty(2)}$ points.
+Le score est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1411,11 +1484,15 @@ Le score est donc une suite arithmétique de premier terme $${initial.frenchify(
                 values,
             };
         },
+        rankDecoder: {
+            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+        },
         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()} \\%$.
+Quand il a commencé la journée, le niveau de charge de la batterie était de $${initial.frPretty(2)} \\%$.
+Le niveau décroît chaque heure de $${(-reason).frPretty(2)} \\%$.
 On note $u_n$ le niveau de charge après $${getStrFactor(firstRank)} \\ \\textrm{h}$.`;
             }
             else {
@@ -1424,9 +1501,9 @@ On note $u_n$ le niveau de charge après $${getStrFactor(firstRank)} \\ \\textrm
                         {
                             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()} \\%$.
+Quand il a commencé la journée, le niveau de charge de la batterie était de $${initial.frPretty(2)} \\%$.
 La plupart du temps, Daryl utilise le phare $${roundedMeanDuration} \\ \\textrm{h}$.
-Le niveau décroît chaque heure de $${(-reason).frenchify()} \\%$.
+Le niveau décroît chaque heure de $${(-reason).frPretty(2)} \\%$.
 On note $u_n$ le niveau de charge après $${getStrFactor(firstRank)} \\ \\textrm{h}$.`;
                         }
                         break;
@@ -1434,9 +1511,9 @@ On note $u_n$ le niveau de charge après $${getStrFactor(firstRank)} \\ \\textrm
                         {
                             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()} \\%$.
+Quand il a commencé la journée, le niveau de charge de la batterie était de $${initial.frPretty(2)} \\%$.
+Le niveau décroît chaque heure de $${(-reason).frPretty(2)} \\%$.
+Un signal sonore est émis quand le niveau de charge passe en dessous de $${thresholdBatteryLow.frPretty(2)} \\%$.
 On note $u_n$ le niveau de charge après $${getStrFactor(firstRank)} \\ \\textrm{h}$.`;
                         }
                         break;
@@ -1453,12 +1530,12 @@ Inspire toi de ce calcul pour déterminer le niveau de charge pour une durée d'
 `,
             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()} \\%$.
+                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frPretty(2)} \\%$.
+Au bout de $${getStrFactor(firstRank)} \\ \\textrm{h}$, le niveau aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)} \\%$.
 
-Au départ, le niveau est de $${initial.frenchify()} \\%$.
+Au départ, le niveau est de $${initial.frPretty(2)} \\%$.
 
-Le niveau de charge est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+Le niveau de charge est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1472,8 +1549,8 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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()} \\%$.`,
+                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frPretty(2)} \\%$.
+Par exemple, le niveau après $${target2.frPretty(2)} \\ \\textrm{h}$ d'utilisation est égal à celui après $${target1.frPretty(2)} \\ \\textrm{h}$ d'utilisation diminué de $${(-reason).frPretty(2)} \\%$.`,
                     rank1,
                     rank2,
                 };
@@ -1489,38 +1566,40 @@ Par exemple, le niveau après $${target2.frenchify()} \\ \\textrm{h}$ d'utilisat
                 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.`;
+Utilise le terme général de $u_n$ pour déterminer le niveau de charge après $${target.frPretty(2)} \\ \\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()} \\%$.
+                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frPretty(2)} \\%$.
+Au bout de $${getStrFactor(firstRank)} \\ \\textrm{h}$, le niveau aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)} \\%$.
 
-Au départ, le niveau est de $${initial.frenchify()} \\%$.
+Au départ, le niveau est de $${initial.frPretty(2)} \\%$.
 
-Le niveau de charge est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+Le niveau de charge est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()} \\%$ ?`;
+                return `Après combien d'heures d'utilisation la charge sera-t-elle de $${round(valueAsked, 2).frPretty(2)} \\%$ ?`;
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueAsked] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frPretty(2)} \\%$.
+Le niveau de charge est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1531,15 +1610,17 @@ Le niveau de charge est donc une suite arithmétique de premier terme $${initial
                 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()} \\%$  ?`;
+                        return `Quelle est la durée maximum d'utilisation pour garder un niveau de charge ${isStrict ? "strictement supérieur" : "supérieur"} à $${valueThreshold.frPretty(2)} \\%$ ?`;
                     case ">":
                     case "\\ge":
-                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\%$  ?`;
+                        return `Quelle est la durée d'utilisation minimum pour passer le niveau de charge ${isStrict ? "strictement en dessous de" : "en dessous de ou égal à"} $${valueThreshold.frPretty(2)} \\%$ ?`;
                 }
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueThreshold, inequationSymbol] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             getHint: (_firstRank, ...otherArgs) => {
                 const [valueThreshold, inequationSymbol, reason] = otherArgs;
@@ -1556,12 +1637,12 @@ Le niveau de charge est donc une suite arithmétique de premier terme $${initial
                 })();
                 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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frPretty(2)} \\%$.
+Le niveau de charge est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1593,10 +1674,14 @@ Le niveau de charge est donc une suite arithmétique de premier terme $${initial
                 values,
             };
         },
+        rankDecoder: {
+            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+        },
         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.
+                return `Un gigantesque buffet est organisé. Au départ, sur les tables de service, il y a $${initial.frPretty(2)}$ amuse-bouches.
+$${(-reason).frPretty(2)}$ 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 {
@@ -1604,18 +1689,18 @@ On note $u_n$ le nombre d'amuse-bouches restant après $${getStrFactor(firstRank
                     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.
+                            return `Un gigantesque buffet est organisé. Au départ, sur les tables de service, il y a $${initial.frPretty(2)}$ amuse-bouches.
+$${(-reason).frPretty(2)}$ amuse-bouches sont mangés toutes les minutes.
+Il y a en tout $${numberOfPeople.frPretty(2)}$ 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.
+                            return `Un gigantesque buffet est organisé. Au départ, sur les tables de service, il y a $${initial.frPretty(2)}$ amuse-bouches.
+$${nbOfGlassesPerMinute.frPretty(2)}$ verres sont servis toutes les minutes.
+$${(-reason).frPretty(2)}$ 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;
@@ -1632,12 +1717,12 @@ Inspire toi de ce calcul pour déterminer le nombre d'amuse-bouches restant apr
 `,
             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()}$.
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${-reason.frPretty(2)}$.
+Au bout de $${getStrFactor(firstRank)} \\ \\textrm{min}$, le nombre d'amuse-bouches aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)}$.
 
-Au départ, il y en a $${initial.frenchify()}$.
+Au départ, il y en a $${initial.frPretty(2)}$.
 
-Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1651,8 +1736,8 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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()}$.`,
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${-reason.frPretty(2)}$.
+Par exemple, le nombre d'amuse-bouches restant après $${target2.frPretty(2)} \\ \\textrm{min}$ est égal à celui après $${target1.frPretty(2)} \\ \\textrm{min}$ d'utilisation diminué de $${(-reason).frPretty(2)}$.`,
                     rank1,
                     rank2,
                 };
@@ -1668,38 +1753,40 @@ Par exemple, le nombre d'amuse-bouches restant après $${target2.frenchify()} \\
                 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.`;
+Utilise le terme général de $u_n$ pour déterminer le nombre d'amuse-bouches restant après $${target.frPretty(2)} \\ \\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()}$.
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${-reason.frPretty(2)}$.
+Au bout de $${getStrFactor(firstRank)} \\ \\textrm{min}$, le nombre d'amuse-bouches aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)}$.
 
-Au départ, il y en a $${initial.frenchify()}$.
+Au départ, il y en a $${initial.frPretty(2)}$.
 
-Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()}$ ?`;
+                return `Après combien de minutes le nombre d'amuse-bouches sera-t-il de $${round(valueAsked, 2).frPretty(2)}$ ?`;
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueAsked] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${-reason.frPretty(2)}$.
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1710,15 +1797,19 @@ Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${i
                 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{€}$ ?`;
+                        return `Quelle sera la dernière minute où le nombre d'amuse-bouches sera ${isStrict ? "supérieur" : "supérieur ou égal"} à $${valueThreshold.frPretty(2)}$ ?`;
                     case ">":
                     case "\\ge":
-                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                        return `Quelle sera la minute où le nombre d'amuse-bouches ${isStrict
+                            ? "passera strictement en dessous de"
+                            : "égalera ou passera en dessous de"} $${valueThreshold.frPretty(2)} \\ \\textrm{€}$ ?`;
                 }
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueThreshold, inequationSymbol] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             getHint: (_firstRank, ...otherArgs) => {
                 const [valueThreshold, inequationSymbol, reason] = otherArgs;
@@ -1735,12 +1826,12 @@ Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${i
                 })();
                 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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${-reason.frPretty(2)}$.
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1772,10 +1863,14 @@ Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${i
                 values,
             };
         },
+        rankDecoder: {
+            targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
+            rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
+        },
         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.
+                return `L'année de la sortie du jeu vidéo Locket Rig, ce même jeu avait $${initial.frPretty(2)}$ joueurs réguliers.
+Tous les ans, $${(-reason).frPretty(2)}$ 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 {
@@ -1783,18 +1878,18 @@ On note $u_n$ le nombre de joueurs réguliers de Locket Rig $${getStrFactor(firs
                     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.
+                            return `L'année de la sortie du jeu vidéo Locket Rig, ce même jeu avait $${initial.frPretty(2)}$ joueurs réguliers.
+Tous les ans, $${(-reason).frPretty(2)}$ joueurs arrêtent de jouer régulièrement à Locket Rig.
+Actuellement, $${numberOfPlayersOfNordFight.frPretty(2)}$ 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.
+                            return `L'année de la sortie du jeu vidéo Locket Rig, ce même jeu avait $${initial.frPretty(2)}$ joueurs réguliers.
+Il y avait $${nbOfSpectatorsAtPhysicalEvent.frPretty(2)}$ spectateurs au premier tournoi organisé dans une grande salle de concert.
+Tous les ans, $${(-reason).frPretty(2)}$ 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;
@@ -1811,12 +1906,12 @@ Inspire toi de ce calcul pour déterminer le nombre de joueurs $${getStrFactor(f
 `,
             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()}$.
+                    str: `Chaque année, le nombre de joueurs diminue de $${-reason.frPretty(2)}$.
+Au bout de $${getStrFactor(firstRank)}$ années, le nombre de joueurs aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)}$.
 
-Au départ, il y en avait $${initial.frenchify()}$.
+Au départ, il y en avait $${initial.frPretty(2)}$.
 
-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()}$.`,
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1830,8 +1925,8 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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()}$.`,
+                    str: `Chaque année, le nombre de joueurs diminue de $${-reason.frPretty(2)}$.
+Par exemple, le nombre de joueurs restant après $${target2.frPretty(2)}$ années est égal à celui après $${target1.frPretty(2)}$ années diminué de $${(-reason).frPretty(2)}$.`,
                     rank1,
                     rank2,
                 };
@@ -1847,38 +1942,40 @@ Par exemple, le nombre de joueurs restant après $${target2.frenchify()}$ année
                 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.`;
+Utilise le terme général de $u_n$ pour déterminer le nombre de joueurs restant après $${target.frPretty(2)}$ 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()}$.
+                    str: `Chaque année, le nombre de joueurs diminue de $${-reason.frPretty(2)}$.
+Au bout de $${getStrFactor(firstRank)}$ années, le nombre de joueurs aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)}$.
 
-Au départ, il y en avait $${initial.frenchify()}$.
+Au départ, il y en avait $${initial.frPretty(2)}$.
 
-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()}$.`,
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                return `Quel est le rang $p$ pour lequel $u_{p} = ${round(valueAsked, 2).frenchify()}$ ?`;
+                return `Après combien d'années le nombre de joueurs sera-t-il de $${round(valueAsked, 2).frPretty(2)}$ ?`;
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueAsked] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Chaque année, le nombre de joueurs diminue de $${-reason.frPretty(2)}$.
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },
@@ -1889,15 +1986,19 @@ Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique d
                 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{€}$ ?`;
+                        return `Quelle sera la dernière année où le nombre de joueurs sera ${isStrict ? "supérieur" : "supérieur ou égal"} à $${valueThreshold.frPretty(2)}$ ?`;
                     case ">":
                     case "\\ge":
-                        return `Quel est le plus petit rang $p$ où $u_{p}$ est ${isStrict ? "strictement" : ""} plus grand que $${valueThreshold.frenchify()} \\ \\textrm{€}$ ?`;
+                        return `Quelle sera l'année où le nombre de joueurs ${isStrict
+                            ? "passera strictement en dessous de"
+                            : "égalera ou passera en dessous de"} $${valueThreshold.frPretty(2)}$ ?`;
                 }
             },
-            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueThreshold, inequationSymbol] = otherArgs;
-                return seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+            getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [valueThreshold, inequationSymbol, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeThresholdRank(initial, reason, firstRank, valueThreshold, inequationSymbol);
+                const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
+                return { answerNode, rankNode };
             },
             getHint: (_firstRank, ...otherArgs) => {
                 const [valueThreshold, inequationSymbol, reason] = otherArgs;
@@ -1914,12 +2015,12 @@ Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique d
                 })();
                 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()}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(2)}$.`;
             },
             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()}$.`,
+                    str: `Chaque année, le nombre de joueurs diminue de $${-reason.frPretty(2)}$.
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
             },
         },