math-exercises 3.0.184 → 3.0.186

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

@@ -36,10 +36,10 @@ $$
                 const str = `${strRaw}
 
 $$
-u_{${rank2.frPretty(2)}} = u_{${rank1.frPretty(2)}} + (${reason.frPretty(2)})
+u_{${rank2.frPretty(0)}} = u_{${rank1.frPretty(0)}} + (${reason.frPretty(0)})
 $$
 
-La relation de récurrence est, pour $n \\geq ${firstRank.frPretty(2)}$ :
+La relation de récurrence est, pour $n \\geq ${firstRank.frPretty(0)}$ :
 
 $$
 ${seqArithmeticUtils
@@ -79,23 +79,26 @@ ${alignTex([
         }),
         variationFindRank: Object.assign({}, variationFindRank, {
             getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueAsked, _rankDecoder] = otherArgs;
+                const [valueAsked, _rankDecoder, digitsValue, digitsTarget] = otherArgs;
                 const { str: strRaw } = variationFindRank.getCorrectionStuff(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)]),
+                    ...new Set([
+                        answerNode.toTex(),
+                        answerNode.evaluate().frPretty(digitsTarget),
+                    ]),
                 ].join(" = ");
                 const str = `${strRaw}
 
 On note $p$ le rang recherché. On a : 
 
 ${alignTex([
-                    [`u_p`, "=", valueAsked.frPretty(2)],
+                    [`u_p`, "=", valueAsked.frPretty(digitsValue)],
                     [
                         `${add(initial, multiply(reason, "p".toTree())).toTex()}`,
                         "=",
-                        valueAsked.frPretty(2),
+                        valueAsked.frPretty(digitsValue),
                     ],
                 ])}
 
@@ -114,23 +117,26 @@ Le nombre recherché est donc $${texAnswer}$.`;
         }),
         variationFindThreshold: Object.assign({}, variationFindThreshold, {
             getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
-                const [valueThreshold, inequationSymbol] = otherArgs;
+                const [valueThreshold, inequationSymbol, digitsValue, digitsTarget] = otherArgs;
                 const { str: strRaw } = variationFindThreshold.getCorrectionStuff(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)]),
+                    ...new Set([
+                        answerNode.toTex(),
+                        answerNode.evaluate().frPretty(digitsTarget),
+                    ]),
                 ].join(" = ");
                 const str = `${strRaw}
 
 On note $p$ le rang recherché. On a : 
 
 ${alignTex([
-                    [`u_p`, inequationSymbol.symbol, valueThreshold.frPretty(2)],
+                    [`u_p`, inequationSymbol.symbol, valueThreshold.frPretty(digitsValue)],
                     [
                         `${add(initial, multiply(reason, substract("p".toTree(), firstRank).simplify())).toTex()}`,
                         inequationSymbol.symbol,
-                        valueThreshold.frPretty(2),
+                        valueThreshold.frPretty(digitsValue),
                     ],
                 ])}
 
@@ -191,6 +197,8 @@ const templatesSituationsArithmetic = [
             targetFromRank: (rank, _firstRank) => rank.toTree(),
             rankFromTarget: (nodeTarget, _firstRank) => nodeTarget.evaluate(),
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             if (superfluousData === undefined) {
                 return `On suppose qu'une plante, d'une hauteur initiale (jour $${firstRank.frenchify()}$) de $${initial.frPretty(2)}\\ \\textrm{cm}$, 
@@ -203,7 +211,7 @@ On note $u_n$ la hauteur de la plante relevée le jour $n$, en $\\textrm{cm}$.`;
                         {
                             const [wateringPeriodInDays] = superfluousData.values;
                             return `On suppose qu'une plante, d'une hauteur initiale (jour $${firstRank.frenchify()}$) de $${initial.frPretty(2)}\\ \\textrm{cm}$ et
-arrosée en moyenne tous les $${wateringPeriodInDays.frPretty(2)}$ jours,
+arrosée en moyenne tous les $${wateringPeriodInDays.frPretty(0)}$ 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}$.`;
                         }
@@ -245,7 +253,7 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
                 return {
                     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}$.`,
+Par exemple, la hauteur de la plante le jour $${target2.frPretty(0)}$ est égale à celle du jour $${target1.frPretty(0)}$ augmentée de $${reason.frPretty(2)}\\ \\textrm{cm}$.`,
                     rank1,
                     rank2,
                 };
@@ -261,7 +269,7 @@ Par exemple, la hauteur de la plante le jour $${target2.frPretty(2)}$ 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.frPretty(2)}$ jours.`;
+Utilise le terme général de $u_n$ pour déterminer la hauteur de la plante au bout de $${target.frPretty(0)}$ jours.`;
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
@@ -369,6 +377,8 @@ La hauteur de la plante relevée chaque jour, en $\\textrm{cm}$, est donc une su
             targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
             rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             if (superfluousData === undefined) {
                 return `Une compagnie de taxis propose un tarif qui inclut un montant fixe de $${initial.frPretty(2)}\\ \\textrm{€}$
@@ -382,7 +392,7 @@ On note $u_n$ le prix payé (en $\\textrm{€}$) pour $${getStrFactor(firstRank)
                             const [fuelConsumptionPer100Km] = superfluousData.values;
                             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.
+Le taxi consomme $${fuelConsumptionPer100Km.frPretty(0)} \\ \\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;
@@ -391,7 +401,7 @@ On note $u_n$ le prix payé (en $\\textrm{€}$) pour $${getStrFactor(firstRank)
                             const [distanceToNextCityInKm] = superfluousData.values;
                             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}$.
+La distance à la ville la plus proche est de $${distanceToNextCityInKm.frPretty(0)} \\ \\textrm{km}$.
 On note $u_n$ le prix payé (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{km}$ parcourus.`;
                         }
                         break;
@@ -402,9 +412,9 @@ On note $u_n$ le prix payé (en $\\textrm{€}$) pour $${getStrFactor(firstRank)
         },
         variationFindExplicitFormula: {
             getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
-            getHint: (firstRank) => `Quel calcul permet de trouver le prix payé pour $10 \\ \\textrm{km}$ ?
+            getHint: (firstRank) => `Quel calcul permet de trouver le prix à payer pour $10 \\ \\textrm{km}$ ?
 
-Inspire toi de ce calcul pour déterminer la hauteur de la plante au bout de $${getStrFactor(firstRank)} \\ \\textrm{km}$.`,
+Inspire toi de ce calcul pour déterminer le prix à payer pour $${getStrFactor(firstRank)} \\ \\textrm{km}$.`,
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
                     str: `Pour chaque kilomètre supplémentaire, la facture augmente de $${reason.frPretty(2)}\\ \\textrm{€}$.
@@ -423,7 +433,7 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
                 return {
                     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{€}$.`,
+Par exemple, la facture pour $${target2.frPretty(0)} \\ \\textrm{km}$ est égale à celle de $${target1.frPretty(0)} \\ \\textrm{km}$ augmentée de $${reason.frPretty(2)}\\ \\textrm{€}$.`,
                     rank1,
                     rank2,
                 };
@@ -439,7 +449,7 @@ Par exemple, la facture pour $${target2.frPretty(2)} \\ \\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.frPretty(2)} \\ \\textrm{km}$.`;
+Utilise le terme général de $u_n$ pour déterminer la facture pour $${target.frPretty(0)} \\ \\textrm{km}$.`;
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
@@ -451,15 +461,11 @@ La facture est donc une suite arithmétique de premier terme $${initial.frPretty
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                // 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)} ?`;
+                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 [valueAsked, rankDecoder] = otherArgs;
+                const rankNode = seqArithmeticUtils.getAnswerNodeRandomRank(initial, reason, firstRank, valueAsked);
                 const answerNode = rankDecoder.targetFromRank(rankNode.evaluate(), firstRank);
                 return { answerNode, rankNode };
             },
@@ -531,7 +537,7 @@ La facture est donc une suite arithmétique de premier terme $${initial.frPretty
             switch (rand) {
                 case 0:
                     {
-                        const fridgeConsumptionPerMonth = randfloat(0.85, 0.95) * 30;
+                        const fridgeConsumptionPerMonth = Math.floor(randfloat(0.85, 0.95) * 30);
                         values.push(fridgeConsumptionPerMonth);
                     }
                     break;
@@ -562,7 +568,7 @@ On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \
                             return `Pour l’électricité de sa maison, Jimmy paye
 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.
+Son refrigétateur consomme $${fridgeConsumptionPerMonth.frPretty(0)} \\ \\textrm{kWh}$ tous les mois.
 On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \\ \\textrm{kWh}$ consommés.`;
                         }
                         break;
@@ -585,6 +591,8 @@ On note $u_n$ la facture (en $\\textrm{€}$) pour $${getStrFactor(firstRank)} \
             targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
             rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         variationFindExplicitFormula: {
             getAnswerNode: seqArithmeticUtils.getAnswerNodeExplicitFormula,
             getHint: (firstRank) => `Quel calcul permet de trouver le prix payé pour $10 \\ \\textrm{kWh}$ ?
@@ -608,7 +616,7 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
                 return {
                     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{€}$.`,
+Par exemple, la facture pour $${target2.frPretty(0)} \\ \\textrm{kWh}$ est égale à celle de $${target1.frPretty(0)} \\ \\textrm{kWh}$ augmentée de $${reason.frPretty(2)}\\ \\textrm{€}$.`,
                     rank1,
                     rank2,
                 };
@@ -736,6 +744,8 @@ La facture est donc une suite arithmétique de premier terme $${initial.frPretty
             targetFromRank: (rank, firstRank) => (100 * (rank - firstRank)).toTree(),
             rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() / 100 + firstRank,
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             if (superfluousData === undefined) {
                 return `Dany décide de partir au Sud de la France.
@@ -750,7 +760,7 @@ On note $u_n$ la température ambiante (en $\\textrm{°C}$) pour $${getStrFactor
                             const [fuelConsumptionPer100Km] = superfluousData.values;
                             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.
+Sa voiture consomme $${fuelConsumptionPer100Km.frPretty(0)} \\ \\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;
@@ -759,7 +769,7 @@ On note $u_n$ la température ambiante (en $\\textrm{°C}$) pour $${getStrFactor
                             const [distanceToNextBreakInKm] = superfluousData.values;
                             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.
+Il fait une pause en moyenne tous les $${distanceToNextBreakInKm.frPretty(0)}$ 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;
@@ -786,7 +796,7 @@ La température, en $\\textrm{°C}$, est donc une suite arithmétique de premier
         },
         variationFindRecurrenceFormula: {
             getAnswerNode: seqArithmeticUtils.getAnswerNodeRecurrenceFormula,
-            getHint: (_firstRank) => `Si tu connais la température ambiante pour $300 \\ \\textrm{km}$ parcourus, comment fais-tu pour calculer la température ambiante pour $400 \\ \\textrm{km}$ parcourus ?
+            getHint: (_firstRank) => `Si tu connais la température ambiante pour $300 \\ \\textrm{km}$ (autrement dit $3$ centaines de $\\textrm{km}$) parcourus , comment fais-tu pour calculer la température ambiante pour $400 \\ \\textrm{km}$ parcourus ?
 
 Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
             getCorrectionStuff: (_initial, reason, firstRank) => {
@@ -795,7 +805,7 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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.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}$.`,
+Par exemple, la température après $${target2.frPretty(0)} \\ \\textrm{km}$ parcourus est égale à celle après $${target1.frPretty(0)} \\ \\textrm{km}$ augmentée de $${reason.frPretty(2)}\\ \\textrm{°C}$.`,
                     rank1,
                     rank2,
                 };
@@ -811,7 +821,7 @@ Par exemple, la température après $${target2.frPretty(2)} \\ \\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.frPretty(2)} \\ \\textrm{km}$ parcourus.`;
+Utilise le terme général de $u_n$ pour déterminer la température pour $${target.frPretty(0)} \\ \\textrm{km}$ parcourus.`;
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
@@ -823,7 +833,7 @@ La température ambiante est donc une suite arithmétique de premier terme $${in
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                return `Pour combien kilomètres parcourus $p$ la température sera-t-elle de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{°C}$ ?`;
+                return `Pour combien de kilomètres parcourus $p$ la température sera-t-elle de $${round(valueAsked, 2).frPretty(2)} \\ \\textrm{°C}$ ?`;
             },
             getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
                 const [valueAsked, rankDecoder] = otherArgs;
@@ -919,6 +929,8 @@ La température ambiante est donc une suite arithmétique de premier terme $${in
             targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
             rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             if (superfluousData === undefined) {
                 return `Emma est salariée. Son salaire net était
@@ -933,7 +945,7 @@ 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.frPretty(2)}\\ \\textrm{€}$ à son entrée dans l'entreprise.
-Elle avait alors $${ageWhenHired.frPretty(2)}$ ans.
+Elle avait alors $${ageWhenHired.frPretty(0)}$ 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é.`;
@@ -983,7 +995,7 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
                 return {
                     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{€}$.`,
+Par exemple, son salaire pour $${target2.frPretty(0)}$ ans d'ancienneté est égal à celui pour $${target1.frPretty(0)}$ ans augmenté de $${reason.frPretty(2)}\\ \\textrm{€}$.`,
                     rank1,
                     rank2,
                 };
@@ -999,7 +1011,7 @@ Par exemple, son salaire pour $${target2.frPretty(2)}$ 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.frPretty(2)}$ ans d'ancienneté.`;
+Utilise le terme général de $u_n$ pour déterminer le salaire d'Emma pour $${target.frPretty(0)}$ ans d'ancienneté.`;
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
@@ -1114,6 +1126,8 @@ Le salaire d'Emma, en $\\textrm{€}$, est donc une suite arithmétique de premi
             targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
             rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
         },
+        digitsValue: 0,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             if (superfluousData === undefined) {
                 return `Manon a gagné un peu d'argent cet été. Début septembre, elle a $${initial.frPretty(2)}\\ \\textrm{€}$ d'économies.
@@ -1173,7 +1187,7 @@ Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
                 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).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{€}$.`,
+Par exemple, le montant de ses économies après $${target2.frPretty(0)}$ semaines est égal à celui pour $${target1.frPretty(0)}$ semaines diminué de $${(-reason).frPretty(2)}\\ \\textrm{€}$.`,
                     rank1,
                     rank2,
                 };
@@ -1196,7 +1210,7 @@ Utilise le terme général de $u_n$ pour déterminer le montant des économies d
                 const target2 = 11;
                 return {
                     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{€}$.
+Par exemple, le montant de ses économies après $${target2.frPretty(0)}$ semaines est égal à celui pour $${target1.frPretty(0)}$ 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.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
                 };
@@ -1301,10 +1315,12 @@ Le montant des économies de Manon, en $\\textrm{€}$, est donc une suite arith
             targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
             rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
         },
+        digitsValue: 0,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             if (superfluousData === undefined) {
-                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.
+                return `Pablo joue à un jeu de quiz. Pour chaque question, le score commence à $${initial.frPretty(0)}$ points.
+Puis il décroît de $${(-reason).frPretty(0)}$ 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 {
@@ -1312,8 +1328,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.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.
+                            return `Pablo joue à un jeu de quiz. Pour chaque question, le score commence à $${initial.frPretty(0)}$ points.
+Puis il décroît de $${(-reason).frPretty(0)}$ 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.`;
                         }
@@ -1321,8 +1337,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.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.
+                            return `Pablo joue à un jeu de quiz. Pour chaque question, le score commence à $${initial.frPretty(0)}$ points.
+Puis il décroît de $${(-reason).frPretty(0)}$ 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.`;
                         }
@@ -1340,12 +1356,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.frPretty(2)}$ points.
-Au bout de $${getStrFactor(firstRank)}$ secondes, le score aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)}$ points.
+                    str: `Chaque seconde, le score diminue de $${(-reason).frPretty(0)}$ points.
+Au bout de $${getStrFactor(firstRank)}$ secondes, le score aura diminué de $${getStrFactor(firstRank)} \\times ${(-reason).frPretty(0)}$ points.
 
-Au départ, le score est de $${initial.frPretty(2)}$ points.
+Au départ, le score est de $${initial.frPretty(0)}$ points.
 
-Le score est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
+Le score est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },
@@ -1359,8 +1375,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.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.`,
+                    str: `Chaque seconde, le score diminue de $${(-reason).frPretty(0)}$ points.
+Par exemple, le score après $${target2.frPretty(0)} \\ \\textrm{s}$ est égal à celui après $${target1.frPretty(0)} \\ \\textrm{s}$ diminué de $${(-reason).frPretty(0)}$ points.`,
                     rank1,
                     rank2,
                 };
@@ -1376,23 +1392,23 @@ Par exemple, le score après $${target2.frPretty(2)} \\ \\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.frPretty(2)}$ 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(0)}$ secondes après le début de la question.`;
             },
             getCorrectionStuff: (initial, reason, firstRank, ..._otherArgs) => {
                 return {
-                    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.
+                    str: `Chaque seconde, le score diminue de $${(-reason).frPretty(0)}$ points.
+Au bout de $${getStrFactor(firstRank)}$ secondes, le score aura diminué de $${getStrFactor(firstRank)} \\times ${(-reason).frPretty(0)}$ points.
 
-Au départ, le score est de $${initial.frPretty(2)}$ points.
+Au départ, le score est de $${initial.frPretty(0)}$ points.
 
-Le score est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
+Le score est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                return `Après combien de secondes le score sera-t-il de $${round(valueAsked, 2).frPretty(2)}$ points ?`;
+                return `Après combien de secondes le score sera-t-il de $${round(valueAsked, 0).frPretty(0)}$ points ?`;
             },
             getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
                 const [valueAsked, rankDecoder] = otherArgs;
@@ -1404,12 +1420,12 @@ Le score est donc une suite arithmétique de premier terme $${initial.frPretty(2
                 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.frPretty(2)}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(0)}$.`;
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
-                    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)}$.`,
+                    str: `Chaque seconde, le score diminue de $${(-reason).frPretty(0)}$ points.
+Le score est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },
@@ -1420,10 +1436,10 @@ Le score est donc une suite arithmétique de premier terme $${initial.frPretty(2
                 switch (inequationSymbol.symbol) {
                     case "<":
                     case "\\le":
-                        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 ?`;
+                        return `Pour quelle durée de réponse maximum le score sera t-il ${isStrict ? "supérieur" : "supérieur ou égal"} à $${valueThreshold.frPretty(0)}$ points ?`;
                     case ">":
                     case "\\ge":
-                        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 ?`;
+                        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(0)}$ points ?`;
                 }
             },
             getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
@@ -1447,12 +1463,12 @@ Le score est donc une suite arithmétique de premier terme $${initial.frPretty(2
                 })();
                 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.frPretty(2)}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(0)}$.`;
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
-                    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)}$.`,
+                    str: `Chaque seconde, le score diminue de $${(-reason).frPretty(0)}$ points.
+Le score est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },
@@ -1488,6 +1504,8 @@ Le score est donc une suite arithmétique de premier terme $${initial.frPretty(2
             targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
             rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
         },
+        digitsValue: 2,
+        digitsTarget: 0,
         getStrSituation: (initial, reason, firstRank, superfluousData) => {
             if (superfluousData === undefined) {
                 return `Daryl utilise un phare à batterie sur son chantier, qu'il laisse allumé.
@@ -1530,8 +1548,8 @@ 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.frPretty(2)} \\%$.
-Au bout de $${getStrFactor(firstRank)} \\ \\textrm{h}$, le niveau aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)} \\%$.
+                    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.frPretty(2)} \\%$.
 
@@ -1549,8 +1567,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.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)} \\%$.`,
+                    str: `Chaque heure, le niveau de charge diminue de $${(-reason).frPretty(2)} \\%$.
+Par exemple, le niveau après $${target2.frPretty(0)} \\ \\textrm{h}$ d'utilisation est égal à celui après $${target1.frPretty(0)} \\ \\textrm{h}$ d'utilisation diminué de $${(-reason).frPretty(2)} \\%$.`,
                     rank1,
                     rank2,
                 };
@@ -1566,12 +1584,12 @@ Par exemple, le niveau après $${target2.frPretty(2)} \\ \\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.frPretty(2)} \\ \\textrm{h}$ d'utilisation.`;
+Utilise le terme général de $u_n$ pour déterminer le niveau de charge après $${target.frPretty(0)} \\ \\textrm{h}$ d'utilisation.`;
             },
             getCorrectionStuff: (initial, reason, firstRank, ..._otherArgs) => {
                 return {
-                    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)} \\%$.
+                    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.frPretty(2)} \\%$.
 
@@ -1598,7 +1616,7 @@ Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
-                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frPretty(2)} \\%$.
+                    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)}$.`,
                 };
             },
@@ -1641,7 +1659,7 @@ Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
-                    str: `Chaque heure, le niveau de charge diminue de $${-reason.frPretty(2)} \\%$.
+                    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)}$.`,
                 };
             },
@@ -1678,6 +1696,8 @@ Le niveau de charge est donc une suite arithmétique de premier terme $${initial
             targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
             rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
         },
+        digitsValue: 0,
+        digitsTarget: 0,
         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.
@@ -1690,17 +1710,17 @@ On note $u_n$ le nombre d'amuse-bouches restant après $${getStrFactor(firstRank
                         {
                             const [numberOfPeople] = superfluousData.values;
                             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.
+$${(-reason).frPretty(0)}$ amuse-bouches sont mangés toutes les minutes.
+Il y a en tout $${numberOfPeople.frPretty(0)}$ 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.frPretty(2)}$ amuse-bouches.
-$${nbOfGlassesPerMinute.frPretty(2)}$ verres sont servis toutes les minutes.
-$${(-reason).frPretty(2)}$ 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(0)}$ amuse-bouches.
+$${nbOfGlassesPerMinute.frPretty(0)}$ verres sont servis toutes les minutes.
+$${(-reason).frPretty(0)}$ 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;
@@ -1717,12 +1737,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.frPretty(2)}$.
-Au bout de $${getStrFactor(firstRank)} \\ \\textrm{min}$, le nombre d'amuse-bouches aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)}$.
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${(-reason).frPretty(0)}$.
+Au bout de $${getStrFactor(firstRank)} \\ \\textrm{min}$, le nombre d'amuse-bouches aura diminué de $${getStrFactor(firstRank)} \\times ${(-reason).frPretty(0)}$.
 
-Au départ, il y en a $${initial.frPretty(2)}$.
+Au départ, il y en a $${initial.frPretty(0)}$.
 
-Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },
@@ -1736,8 +1756,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.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)}$.`,
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${(-reason).frPretty(0)}$.
+Par exemple, le nombre d'amuse-bouches restant après $${target2.frPretty(0)} \\ \\textrm{min}$ est égal à celui après $${target1.frPretty(0)} \\ \\textrm{min}$ d'utilisation diminué de $${(-reason).frPretty(0)}$.`,
                     rank1,
                     rank2,
                 };
@@ -1753,23 +1773,23 @@ Par exemple, le nombre d'amuse-bouches restant après $${target2.frPretty(2)} \\
                 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.frPretty(2)} \\ \\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(0)} \\ \\textrm{min}$ de buffet.`;
             },
             getCorrectionStuff: (initial, reason, firstRank, ..._otherArgs) => {
                 return {
-                    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)}$.
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${(-reason).frPretty(0)}$.
+Au bout de $${getStrFactor(firstRank)} \\ \\textrm{min}$, le nombre d'amuse-bouches aura diminué de $${getStrFactor(firstRank)} \\times ${(-reason).frPretty(0)}$.
 
-Au départ, il y en a $${initial.frPretty(2)}$.
+Au départ, il y en a $${initial.frPretty(0)}$.
 
-Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frPretty(2)}$ et de raison $${reason.frPretty(2)}$.`,
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                return `Après combien de minutes le nombre d'amuse-bouches sera-t-il de $${round(valueAsked, 2).frPretty(2)}$ ?`;
+                return `Après combien de minutes le nombre d'amuse-bouches sera-t-il de $${round(valueAsked, 0).frPretty(0)}$ ?`;
             },
             getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
                 const [valueAsked, rankDecoder] = otherArgs;
@@ -1781,12 +1801,12 @@ Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${i
                 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.frPretty(2)}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(0)}$.`;
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
-                    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)}$.`,
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${(-reason).frPretty(0)}$.
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },
@@ -1797,12 +1817,12 @@ Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${i
                 switch (inequationSymbol.symbol) {
                     case "<":
                     case "\\le":
-                        return `Quelle sera la dernière minute où le nombre d'amuse-bouches sera ${isStrict ? "supérieur" : "supérieur ou égal"} à $${valueThreshold.frPretty(2)}$ ?`;
+                        return `Quelle sera la dernière minute où le nombre d'amuse-bouches sera ${isStrict ? "supérieur" : "supérieur ou égal"} à $${valueThreshold.frPretty(0)}$ ?`;
                     case ">":
                     case "\\ge":
                         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{€}$ ?`;
+                            : "égalera ou passera en dessous de"} $${valueThreshold.frPretty(0)}$ ?`;
                 }
             },
             getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
@@ -1826,12 +1846,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.frPretty(2)}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(0)}$.`;
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
-                    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)}$.`,
+                    str: `Chaque minute, le nombre d'amuse-bouches diminue de $${(-reason).frPretty(0)}$.
+Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },
@@ -1867,10 +1887,12 @@ Le nombre d'amuse-bouches est donc une suite arithmétique de premier terme $${i
             targetFromRank: (rank, firstRank) => (rank - firstRank).toTree(),
             rankFromTarget: (nodeTarget, firstRank) => nodeTarget.evaluate() + firstRank,
         },
+        digitsValue: 0,
+        digitsTarget: 0,
         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.frPretty(2)}$ joueurs réguliers.
-Tous les ans, $${(-reason).frPretty(2)}$ 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(0)}$ joueurs réguliers.
+Tous les ans, $${(-reason).frPretty(0)}$ 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 {
@@ -1878,18 +1900,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.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.
+                            return `L'année de la sortie du jeu vidéo Locket Rig, ce même jeu avait $${initial.frPretty(0)}$ joueurs réguliers.
+Tous les ans, $${(-reason).frPretty(0)}$ joueurs arrêtent de jouer régulièrement à Locket Rig.
+Actuellement, $${numberOfPlayersOfNordFight.frPretty(0)}$ 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.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.
+                            return `L'année de la sortie du jeu vidéo Locket Rig, ce même jeu avait $${initial.frPretty(0)}$ joueurs réguliers.
+Il y avait $${nbOfSpectatorsAtPhysicalEvent.frPretty(0)}$ spectateurs au premier tournoi organisé dans une grande salle de concert.
+Tous les ans, $${(-reason).frPretty(0)}$ 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;
@@ -1906,12 +1928,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.frPretty(2)}$.
-Au bout de $${getStrFactor(firstRank)}$ années, le nombre de joueurs aura diminué de $${getStrFactor(firstRank)} \\times ${-reason.frPretty(2)}$.
+                    str: `Chaque année, le nombre de joueurs diminue de $${(-reason).frPretty(0)}$.
+Au bout de $${getStrFactor(firstRank)}$ années, le nombre de joueurs aura diminué de $${getStrFactor(firstRank)} \\times ${(-reason).frPretty(0)}$.
 
-Au départ, il y en avait $${initial.frPretty(2)}$.
+Au départ, il y en avait $${initial.frPretty(0)}$.
 
-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)}$.`,
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },
@@ -1925,8 +1947,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.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)}$.`,
+                    str: `Chaque année, le nombre de joueurs diminue de $${(-reason).frPretty(0)}$.
+Par exemple, le nombre de joueurs restant après $${target2.frPretty(0)}$ années est égal à celui après $${target1.frPretty(0)}$ années diminué de $${(-reason).frPretty(0)}$.`,
                     rank1,
                     rank2,
                 };
@@ -1942,23 +1964,23 @@ Par exemple, le nombre de joueurs restant après $${target2.frPretty(2)}$ 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.frPretty(2)}$ années.`;
+Utilise le terme général de $u_n$ pour déterminer le nombre de joueurs restant après $${target.frPretty(0)}$ années.`;
             },
             getCorrectionStuff: (initial, reason, firstRank, ..._otherArgs) => {
                 return {
-                    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)}$.
+                    str: `Chaque année, le nombre de joueurs diminue de $${(-reason).frPretty(0)}$.
+Au bout de $${getStrFactor(firstRank)}$ années, le nombre de joueurs aura diminué de $${getStrFactor(firstRank)} \\times ${(-reason).frPretty(0)}$.
 
-Au départ, il y en avait $${initial.frPretty(2)}$.
+Au départ, il y en avait $${initial.frPretty(0)}$.
 
-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)}$.`,
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },
         variationFindRank: {
             getStrQuestion: (_initial, _reason, _firstRank, ...otherArgs) => {
                 const [valueAsked] = otherArgs;
-                return `Après combien d'années le nombre de joueurs sera-t-il de $${round(valueAsked, 2).frPretty(2)}$ ?`;
+                return `Après combien d'années le nombre de joueurs sera-t-il de $${round(valueAsked, 0).frPretty(0)}$ ?`;
             },
             getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
                 const [valueAsked, rankDecoder] = otherArgs;
@@ -1970,12 +1992,12 @@ Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique d
                 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.frPretty(2)}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer quand $u_p = ${valueAsked.frPretty(0)}$.`;
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
-                    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)}$.`,
+                    str: `Chaque année, le nombre de joueurs diminue de $${(-reason).frPretty(0)}$.
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },
@@ -1986,12 +2008,12 @@ Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique d
                 switch (inequationSymbol.symbol) {
                     case "<":
                     case "\\le":
-                        return `Quelle sera la dernière année où le nombre de joueurs sera ${isStrict ? "supérieur" : "supérieur ou égal"} à $${valueThreshold.frPretty(2)}$ ?`;
+                        return `Quelle sera la dernière année où le nombre de joueurs sera ${isStrict ? "supérieur" : "supérieur ou égal"} à $${valueThreshold.frPretty(0)}$ ?`;
                     case ">":
                     case "\\ge":
                         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)}$ ?`;
+                            : "égalera ou passera en dessous de"} $${valueThreshold.frPretty(0)}$ ?`;
                 }
             },
             getAnswerStuff: (initial, reason, firstRank, ...otherArgs) => {
@@ -2015,12 +2037,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.frPretty(2)}$.`;
+Utilise le terme général de $(u_n)$ pour déterminer ${texP} $p$ tel que $u_p ${inequationSymbol.symbol} ${valueThreshold.frPretty(0)}$.`;
             },
             getCorrectionStuff: (initial, reason, _firstRank) => {
                 return {
-                    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)}$.`,
+                    str: `Chaque année, le nombre de joueurs diminue de $${(-reason).frPretty(0)}$.
+Le nombre de joueurs réguliers de Locket Rig est donc une suite arithmétique de premier terme $${initial.frPretty(0)}$ et de raison $${reason.frPretty(0)}$.`,
                 };
             },
         },