math-exercises 3.0.172 → 3.0.173

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

@@ -0,0 +1,932 @@
+import { substract } from "../../../../tree/nodes/operators/substractNode.js";
+import { alignTex } from "../../../../utils/latex/alignTex.js";
+import { randfloat } from "../../random/randfloat.js";
+import { randint } from "../../random/randint.js";
+import { seqGeometricUtils } from "./seqGeometricUtils.js";
+const getStrFactor = (firstRank) => {
+    return firstRank === 0 ? "n" : "(n-1)";
+};
+//decoration
+const createSituationGeometricFromTemplate = (templateSituationsGeometric) => {
+    const { variationFindExplicitFormula, variationFindRecurrenceFormula, variationFindRandomTerm,
+    // variationFindRank,
+    // variationFindThreshold,
+     } = templateSituationsGeometric;
+    return Object.assign({}, templateSituationsGeometric, {
+        variationFindExplicitFormula: Object.assign({}, variationFindExplicitFormula, {
+            getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const { str: strRaw } = variationFindExplicitFormula.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                const str = `${strRaw}
+
+$$
+${seqGeometricUtils
+                    .getAnswerNodeExplicitFormula(initial, reason, firstRank)
+                    .toTex()}
+$$
+
+`;
+                return { str };
+            },
+        }),
+        variationFindRecurrenceFormula: Object.assign({}, variationFindRecurrenceFormula, {
+            getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const { str: strRaw, rank1, rank2, } = variationFindRecurrenceFormula.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                const str = `${strRaw}
+
+$$
+u_{${rank2.frenchify()}} = (${reason.frenchify()}) \\times u_{${rank1.frenchify()}}
+$$
+
+La relation de récurrence est, pour $n \\geq ${firstRank.frenchify()}$ :
+
+$$
+${seqGeometricUtils
+                    .getAnswerNodeRecurrenceFormula(initial, reason, firstRank)
+                    .toTex()}
+$$
+
+`;
+                return { str, rank1, rank2 };
+            },
+        }),
+        variationFindRandomTerm: Object.assign({}, variationFindRandomTerm, {
+            getCorrectionStuff: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const { str: strRaw } = variationFindRandomTerm.getCorrectionStuff(initial, reason, firstRank, ...otherArgs);
+                const answerNode = variationFindRandomTerm.getAnswerNode(initial, reason, firstRank, ...otherArgs);
+                const str = `${strRaw}
+
+Le terme général est :
+
+$$
+${seqGeometricUtils
+                    .getAnswerNodeExplicitFormula(initial, reason, firstRank)
+                    .toTex()}
+$$
+
+En particulier :
+
+${alignTex([
+                    [`u_{${rankAsked}}`, "=", answerNode.toTex()],
+                    ["", "=", answerNode.simplify().toTex()],
+                ])}
+
+`;
+                return { str };
+            },
+        }),
+    });
+};
+//raw material
+const templatesSituationsGeometric = [
+    //Armand
+    {
+        type: "evoPercentage",
+        randInitial: () => randint(20, 51) * 100,
+        randReason: () => 1 + randfloat(0, 4, 2, [0]) / 100, //expl: 1,0331
+        randThreshold: (initial, reason, firstRank) => seqGeometricUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const mockeponCardsPrice = 10 * randint(50, 150);
+                        values.push(mockeponCardsPrice);
+                    }
+                    break;
+                case 1:
+                    {
+                        const factorFriendWrtArmand = randint(2, 6);
+                        values.push(factorFriendWrtArmand);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            const evoPercentage = (reason - 1) * 100;
+            const strEvoPercentage = evoPercentage.frPretty(2);
+            if (superfluousData === undefined) {
+                return `Au premier janvier $2026$, Armand dépose $${initial.frenchify()} \\textrm{€}$ sur un compte épargne rémunéré au taux de $${strEvoPercentage}\\%$.        
+On note $u_n$ le capital disponible sur son compte épargne au premier janvier de l'année $2026+${substract("n".toTree(), firstRank)
+                    .simplify()
+                    .toTex()}$.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [mockeponCardsPrice] = superfluousData.values;
+                            return `Au premier janvier $2026$, Armand dépose $${initial.frenchify()} \\textrm{€}$ sur un compte épargne rémunéré au taux de $${strEvoPercentage}\\%$.
+La même journée, il a acheté pour $${mockeponCardsPrice} \\textrm{€}$ de cartes MockéPon.
+On note $u_n$ le capital disponible sur son compte épargne au premier janvier de l'année $2026+${substract("n".toTree(), firstRank)
+                                .simplify()
+                                .toTex()}$.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [factorFriendWrtArmand] = superfluousData.values;
+                            return `Au premier janvier $2026$, Armand dépose $${initial.frenchify()} \\textrm{€}$ sur un compte épargne rémunéré au taux de $${strEvoPercentage}\\%$.
+La même journée, son ami Mustapha lui apprend que la rémunération du compte épargne de son père est $${factorFriendWrtArmand.frenchify()}$ fois plus grande.
+On note $u_n$ le capital disponible sur son compte épargne au premier janvier de l'année $2026+${substract("n".toTree(), firstRank)
+                                .simplify()
+                                .toTex()}$.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver le capital au bout de $2$ ans ?
+
+Inspire toi de ce calcul pour déterminer le capital au bout de $${getStrFactor(firstRank)}$ ans.`,
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(2);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, le capital est multiplié par $${reason.frenchify()}$.
+Le capital en $\\textrm{€}$, au premier janvier de l'année $2026+${substract("n".toTree(), firstRank)
+                        .simplify()
+                        .toTex()}$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais le capital à la dixième année, comment fais-tu pour calculer le capital à la onzième année ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(2);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, le capital est multiplié par $${reason.frenchify()}$.
+Par exemple, le capital à la onzième année est égal à celui de la dixième année multiplié par $${reason.frenchify()}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqGeometricUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $u_n$ pour déterminer le capital pour l'année $2026+${target.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(2);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, le capital est multiplié par $${reason.frenchify()}$.
+Le capital en $\\textrm{€}$, au premier janvier de l'année $2026+${substract("n".toTree(), firstRank)
+                        .simplify()
+                        .toTex()}$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //Killian
+    {
+        type: "evoPercentage",
+        randInitial: () => randint(13, 30) * 1000,
+        randReason: () => 1 - (randint(10, 26, [0]) * 1.0) / 100, //expl: 0,80
+        randThreshold: (initial, reason, firstRank) => seqGeometricUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const equipmentPercentage = randint(5, 25);
+                        values.push(equipmentPercentage);
+                    }
+                    break;
+                case 1:
+                    {
+                        const friendsCarPrice = randint(25, 50) * 1000;
+                        values.push(friendsCarPrice);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            const evoPercentage = (reason - 1) * 100;
+            const strMinusEvoPercentage = (-evoPercentage).frPretty(0);
+            if (superfluousData === undefined) {
+                return `Au premier juillet $2025$, Killian a acheté une voiture au prix de $${initial.frenchify()} \\ \\textrm{€}$. 
+On estime que la valeur d'une voiture diminue de $${strMinusEvoPercentage}\\%$ par an. 
+Pour tout entier naturel $n>=${firstRank}$, on note $u_n$ la valeur estimée de la voiture de Killian au premier juillet de l'année $2025 + ${substract("n".toTree(), firstRank)
+                    .simplify()
+                    .toTex()}$.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [equipmentPercentage] = superfluousData.values;
+                            return `Au premier juillet $2025$, Killian a acheté une voiture au prix de $${initial.frenchify()} \\ \\textrm{€}$.
+Les options représentent $${equipmentPercentage.frenchify()}\\%$ de la valeur du véhicule. 
+On estime que la valeur d'une voiture diminue de $${strMinusEvoPercentage}\\%$ par an. 
+Pour tout entier naturel $n>=${firstRank}$, on note $u_n$ la valeur estimée de la voiture de Killian au premier juillet de l'année $2025 + ${substract("n".toTree(), firstRank)
+                                .simplify()
+                                .toTex()}$.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [friendsCarPrice] = superfluousData.values;
+                            return `Au premier juillet $2025$, Nahel a acheté une voiture au prix de $${friendsCarPrice.frenchify()} \\ \\textrm{€}$.
+Le même jour, Killian a acheté une voiture au prix de $${initial.frenchify()} \\ \\textrm{€}$. 
+On estime que la valeur d'une voiture diminue de $${strMinusEvoPercentage}\\%$ par an. 
+Pour tout entier naturel $n>=${firstRank}$, on note $u_n$ la valeur estimée de la voiture de Killian au premier juillet de l'année $2025 + ${substract("n".toTree(), firstRank)
+                                .simplify()
+                                .toTex()}$.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver la valeur de la voiture de Killian au bout de $2$ ans ?
+
+Inspire toi de ce calcul pour déterminer la valeur de la voiture de Killian au bout de $${getStrFactor(firstRank)}$ ans.`,
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(0);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, la valeur de la voiture de Killian est multipliée par $${reason.frenchify()}$.
+La valeur de la voiture de Killian en $\\textrm{€}$, au premier juillet de l'année $2026+n$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais la valeur de la voiture de Killian à la dixième année, comment fais-tu pour calculer la valeur de la voiture de Killian à la onzième année ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(0);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, la valeur de la voiture de Killian est multipliée par $${reason.frenchify()}$.
+Par exemple, la valeur à la onzième année est égale à celle de la dixième année multipliée par $${reason.frenchify()}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqGeometricUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $u_n$ pour déterminer la valeur de la voiture de Killian au premier juillet de l'année $2025+${target.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(0);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, la valeur de la voiture de Killian est multipliée par $${reason.frenchify()}$.
+La valeur de la voiture de Killian en $\\textrm{€}$, au premier juillet de l'année $2026+n$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //Balle rebondissante
+    {
+        type: "factorPercentage",
+        randInitial: () => randfloat(1, 2, 2),
+        randReason: () => 1 - (randint(10, 26, [0]) * 1.0) / 100, //expl: 0,80
+        randThreshold: (initial, reason, firstRank) => seqGeometricUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const phoneHeight = randfloat(0.1, 1, 2);
+                        values.push(phoneHeight);
+                    }
+                    break;
+                case 1:
+                    {
+                        const diameterOfBallInCm = randint(4, 12);
+                        values.push(diameterOfBallInCm);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            const factorPercentage = reason * 100;
+            const strFactorPercentage = factorPercentage.frPretty(0);
+            if (superfluousData === undefined) {
+                return `Une balle rebondissante est lachée d'une hauteur de $${initial.frenchify()} \\ \\textrm{m}$. 
+À chaque rebond, elle atteint une hauteur égale à $${strFactorPercentage} \\%$ de la hauteur du rebond précédent. 
+On note $u_{${firstRank}} = ${initial.frenchify()}$, et pour tout entier $n>=${firstRank + 1}$, $u_{n}$ la hauteur de la balle au $${substract("n".toTree(), firstRank)
+                    .simplify()
+                    .toTex()}$-ième rebond.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [phoneHeight] = superfluousData.values;
+                            return `Une balle rebondissante est lachée d'une hauteur de $${initial.frenchify()} \\ \\textrm{m}$.
+On la filme avec un téléphone placé à une hauteur de $${phoneHeight.frenchify()} \\ \\textrm{m}$.
+À chaque rebond, elle atteint une hauteur égale à $${strFactorPercentage} \\%$ de la hauteur du rebond précédent.
+On note $u_{${firstRank}} = ${initial.frenchify()}$, et pour tout entier $n>=${firstRank + 1}$, $u_{n}$ la hauteur de la balle au $${substract("n".toTree(), firstRank)
+                                .simplify()
+                                .toTex()}$-ième rebond.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [diameterOfBallInCm] = superfluousData.values;
+                            return `Une balle rebondissante de diamètre $${diameterOfBallInCm.frenchify()} \\ \\textrm{cm}$ est lachée d'une hauteur de $${initial.frenchify()} \\ \\textrm{m}$. 
+À chaque rebond, elle atteint une hauteur égale à $${strFactorPercentage} \\%$ de la hauteur du rebond précédent. 
+On note $u_{${firstRank}} = ${initial.frenchify()}$, et pour tout entier $n>=${firstRank + 1}$, $u_{n}$ la hauteur de la balle au $${substract("n".toTree(), firstRank)
+                                .simplify()
+                                .toTex()}$-ième rebond.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver la hauteur de la balle après $2$ rebonds ?
+
+Inspire toi de ce calcul pour déterminer la hauteur de la balle au $${substract("n".toTree(), firstRank)
+                .simplify()
+                .toTex()}$-ième rebond.`,
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                const factorPercentage = reason * 100;
+                const strFactorPercentage = factorPercentage.frPretty(0);
+                return {
+                    str: `Le coefficient multiplicateur est $${strFactorPercentage} \\%$ donc à chaque rebond, la hauteur de la balle est multipliée par $${reason.frenchify()}$.
+La hauteur de la balle est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais la hauteur après le dixième rebond, comment fais-tu pour calculer la hauteur après le onzième rebond ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                const factorPercentage = reason * 100;
+                const strFactorPercentage = factorPercentage.frPretty(0);
+                return {
+                    str: `Le coefficient multiplicateur est $${strFactorPercentage} \\%$ donc à chaque rebond, la hauteur de la balle est multipliée par $${reason.frenchify()}$.
+Par exemple, la hauteur après le onzième rebond est égale à celle après le dixième rebond multipliée par $${reason.frenchify()}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqGeometricUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $u_n$ pour déterminer la hauteur de la balle au $${target}$-ième rebond.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                const factorPercentage = reason * 100;
+                const strFactorPercentage = factorPercentage.frPretty(0);
+                return {
+                    str: `Le coefficient multiplicateur est $${strFactorPercentage} \\%$ donc à chaque rebond, la hauteur de la balle est multipliée par $${reason.frenchify()}$.
+La hauteur de la balle est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //Bactéries
+    {
+        type: "evoPercentage",
+        randInitial: () => randint(50, 101) * 100,
+        randReason: () => 1 + (randint(10, 40) * 1.0) / 100, //expl: 1,25
+        randThreshold: (initial, reason, firstRank) => seqGeometricUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const percentageMutantBacteria = randint(10, 60);
+                        values.push(percentageMutantBacteria);
+                    }
+                    break;
+                case 1:
+                    {
+                        const lightIntervalInMin = randint(15, 60);
+                        values.push(lightIntervalInMin);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            const evoPercentage = (reason - 1) * 100;
+            const strEvoPercentage = evoPercentage.frPretty(0);
+            if (superfluousData === undefined) {
+                return `Un biologiste étudie une population de bactéries. 
+La première heure, la population compte $${initial.frenchify()}$ individus. 
+Chaque heure, le nombre de bactéries augmente de $${strEvoPercentage}\\%$. 
+Pour tout entier naturel $n$, on note $u_n$ le nombre de bactéries au bout de $${getStrFactor(firstRank)}$ heures.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [percentageMutantBacteria] = superfluousData.values;
+                            return `Un biologiste étudie une population de bactéries. 
+La première heure, la population compte $${initial.frenchify()}$ individus, dont $${percentageMutantBacteria}\\%$ sont mutantes.
+Chaque heure, le nombre de bactéries augmente de $${strEvoPercentage}\\%$. 
+Pour tout entier naturel $n$, on note $u_n$ le nombre de bactéries au bout de $${getStrFactor(firstRank)}$ heures.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [lightIntervalInMin] = superfluousData.values;
+                            return `Un biologiste étudie une population de bactéries. 
+La première heure, la population compte $${initial.frenchify()}$ individus.
+Chaque heure, le nombre de bactéries augmente de $${strEvoPercentage}\\%$.
+On éclaire les bactéries toutes les $${lightIntervalInMin} \\ \\textrm{min}$ pendant $30 \\ \\textrm{s}$.
+Pour tout entier naturel $n>=${firstRank}$, on note $u_n$ le nombre de bactéries au bout de $${getStrFactor(firstRank)}$ heures.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver le nombre de bactéries au bout de $2$ heures ?
+
+Inspire toi de ce calcul pour déterminer le nombre de bactéries au bout de $${getStrFactor(firstRank)}$ heures.`,
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(0);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque heure, le nombre de bactéries est multiplié par $${reason.frenchify()}$.
+Le nombre de bactéries est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais le nombre de bactéries après $10$ heures, comment fais-tu pour calculer le nombre de bactéries après $11$ heures ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(2);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque heure, le nombre de bactéries est multiplié par $${reason.frenchify()}$.
+Par exemple, le nombre de bactéries après $10$ heures est égal à celui de la dixième année multiplié par $${reason.frenchify()}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqGeometricUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $u_n$ pour déterminer le nombre de bactéries après $${target.frenchify()}$ heures.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(0);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque heure, le nombre de bactéries est multiplié par $${reason.frenchify()}$.
+Le nombre de bactéries est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //Secret
+    {
+        type: "factor",
+        randInitial: () => randint(2, 8),
+        randReason: () => randint(2, 8),
+        randThreshold: (initial, reason, firstRank) => seqGeometricUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const numberOfFriends = randint(10, 20);
+                        values.push(numberOfFriends);
+                    }
+                    break;
+                case 1:
+                    {
+                        const numberOfUnreliable = randint(2, 5);
+                        values.push(numberOfUnreliable);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            if (superfluousData === undefined) {
+                return `Justine dévoile un secret à $${initial}$ de ses amies. 
+On estime que chaque jour, chaque personne connaissant le secret le révèle à $${reason}$ nouvelles personnes qui ne connaissent pas encore le secret. 
+Pour tout entier naturel $n>=${firstRank}$, on note $u_n$ le nombre de nouvelles personnes qui sont informées le jour $${substract("n".toTree(), firstRank)
+                    .simplify()
+                    .toTex()}$.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [numberOfFriends] = superfluousData.values;
+                            return `Justine a $${numberOfFriends}$ amies. 
+Justine dévoile un secret à $${initial}$ de ses amies. 
+On estime que chaque jour, chaque personne connaissant le secret le révèle à $${reason}$ nouvelles personnes qui ne connaissent pas encore le secret. 
+Pour tout entier naturel $n>=${firstRank}$, on note $u_n$ le nombre de nouvelles personnes qui sont informées le jour $${substract("n".toTree(), firstRank)
+                                .simplify()
+                                .toTex()}$.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [numberOfUnreliable] = superfluousData.values;
+                            return `Justine dévoile un secret à $${initial}$ de ses amies.
+Elle ne le dévoile pas aux $${numberOfUnreliable}$ autres car elle ne leur fait pas trop confiance.
+On estime que chaque jour, chaque personne connaissant le secret le révèle à $${reason}$ nouvelles personnes qui ne connaissent pas encore le secret. 
+Pour tout entier naturel $n>=${firstRank}$, on note $u_n$ le nombre de nouvelles personnes qui sont informées le jour $${substract("n".toTree(), firstRank)
+                                .simplify()
+                                .toTex()}$.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver le nombre de personnes informées le jour $2$ ?
+
+Inspire toi de ce calcul pour déterminer le nombre de personnes informées le jour $${substract("n".toTree(), firstRank)
+                .simplify()
+                .toTex()}$.`,
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Le coefficient multiplicateur est $${reason}$ donc, chaque jour, le nombre de personnes informées est multiplié par $${reason.frenchify()}$.
+Le nombre de personnes informées est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais le nombre de personnes informées le jour $10$ , comment fais-tu pour calculer le nombre de personnes informées le jour $11$ ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                return {
+                    str: `Le coefficient multiplicateur est $${reason}$ donc, chaque jour, le nombre de personnes informées est multiplié par $${reason.frenchify()}$.
+Par exemple, le nombre de personnes informées le jour $11$ est égal à celui du jour $10$ multiplié par $${reason.frenchify()}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqGeometricUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $u_n$ pour déterminer le nombre de personnes informées le jour $${target}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                return {
+                    str: `Le coefficient multiplicateur est $${reason}$ donc, chaque jour, le nombre de personnes informées est multiplié par $${reason.frenchify()}$.
+Le nombre de personnes informées est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //salaire de Sofiane
+    {
+        type: "evoPercentage",
+        randInitial: () => randint(28, 44) * 1000,
+        randReason: () => 1 + randint(2, 7) / 100, //expl: 1,05
+        randThreshold: (initial, reason, firstRank) => seqGeometricUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const offsetSalaryOfFriend = randint(1, 10) * 1000;
+                        values.push(offsetSalaryOfFriend);
+                    }
+                    break;
+                case 1:
+                    {
+                        const offsetEvoPercentageOfFriend = -1;
+                        values.push(offsetEvoPercentageOfFriend);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, firstRank, superfluousData) => {
+            const evoPercentage = (reason - 1) * 100;
+            const strEvoPercentage = evoPercentage.frPretty(0);
+            if (superfluousData === undefined) {
+                return `Durant l'année $2025$, Sofiane a reçu un salaire de $${initial} \\ \\textrm{€}$.
+Son contrat prévoit une augmentation annuelle de $${strEvoPercentage}\\%$.
+On note $u_n$ le salaire perçu par Sofiane au cours de l'année $2025+${substract("n".toTree(), firstRank)
+                    .simplify()
+                    .toTex()}$.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [offsetSalaryOfFriend] = superfluousData.values;
+                            const salaryOfFriend = initial + offsetSalaryOfFriend;
+                            return `Durant l'année $2025$, Sofiane a reçu un salaire de $${initial} \\ \\textrm{€}$. 
+Son contrat prévoit une augmentation annuelle de $${strEvoPercentage}\\%$.
+Son ami Hector a reçu un salaire de $${salaryOfFriend} \\ \\textrm{€}$ en $2025$.
+On note $u_n$ le salaire perçu par Sofiane au cours de l'année $2025+${substract("n".toTree(), firstRank)
+                                .simplify()
+                                .toTex()}$.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [offsetEvoPercentageOfFriend] = superfluousData.values;
+                            const evoPercentageOfFriend = evoPercentage + offsetEvoPercentageOfFriend;
+                            const strEvoPercentageOfFriend = evoPercentageOfFriend.frPretty(0);
+                            return `Durant l'année $2025$, Sofiane a reçu un salaire de $${initial} \\ \\textrm{€}$. 
+Son contrat prévoit une augmentation annuelle de $${strEvoPercentage}\\%$.
+Le contrat de son ami Hector prévoit pour Hector une augmentation annuelle de $${strEvoPercentageOfFriend}\\%$. 
+On note $u_n$ le salaire perçu par Sofiane au cours de l'année $2025+${substract("n".toTree(), firstRank)
+                                .simplify()
+                                .toTex()}$.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeExplicitFormula,
+            getHint: (firstRank) => `Quel calcul permet de trouver le salaire pour l'année $2027$ ?
+
+Inspire toi de ce calcul pour déterminer le salaire pour l'année $2025+${substract("n".toTree(), firstRank)
+                .simplify()
+                .toTex()}$.`,
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(2);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, le salaire est multiplié par $${reason.frenchify()}$.
+Le salaire en $\\textrm{€}$ pour l'année $2025+${substract("n".toTree(), firstRank)
+                        .simplify()
+                        .toTex()}$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais le salaire pour la dixième année, comment fais-tu pour calculer le salaire pour la onzième année ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(2);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, le salaire est multiplié par $${reason.frenchify()}$.
+Par exemple, le salaire à la onzième année est égal à celui de la dixième année multiplié par $${reason.frenchify()}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqGeometricUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $u_n$ pour déterminer le salaire pour l'année $2025+${target.frenchify()}$.`;
+            },
+            getCorrectionStuff: (initial, reason, firstRank) => {
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(2);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque année, le salaire est multiplié par $${reason.frenchify()}$.
+Le salaire en $\\textrm{€}$ pour l'année $2025+${substract("n".toTree(), firstRank)
+                        .simplify()
+                        .toTex()}$, est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+    //voiture de location
+    {
+        type: "evoPercentage",
+        randInitial: () => randint(28, 44) * 1000,
+        randReason: () => 1 + randint(2, 7) / 100, //expl: 1,05
+        randThreshold: (initial, reason, firstRank) => seqGeometricUtils.randThreshold(initial, reason, firstRank, 2),
+        randSuperfluousData: () => {
+            const rand = randint(0, 2);
+            const values = [];
+            switch (rand) {
+                case 0:
+                    {
+                        const fostipySubscription = randint(5, 10) + 0.99;
+                        values.push(fostipySubscription);
+                    }
+                    break;
+                case 1:
+                    {
+                        const priceOfCar = randint(8, 30) * 1000;
+                        values.push(priceOfCar);
+                    }
+                    break;
+            }
+            return {
+                rand,
+                values,
+            };
+        },
+        getStrSituation: (initial, reason, _firstRank, superfluousData) => {
+            const evoPercentage = (reason - 1) * 100;
+            const strEvoPercentage = evoPercentage.frPretty(0);
+            if (superfluousData === undefined) {
+                return `Pour sa voiture, Saïda paye un loyer mensuel de $${initial} \\ \\textrm{€}$. 
+Son contrat prévoit une augmentation mensuelle de $${strEvoPercentage}\\%$. 
+On note $u_n$ le loyer à payer le mois $n$.`;
+            }
+            else {
+                switch (superfluousData.rand) {
+                    case 0:
+                        {
+                            const [fostipySubscription] = superfluousData.values;
+                            return `Pour sa voiture, Saïda paye un loyer mensuel de $${initial} \\ \\textrm{€}$. 
+Son contrat prévoit une augmentation mensuelle de $${strEvoPercentage}\\%$.
+Pour écouter la musique dans la voiture, Saïda a souscrit un abonnement à Fostipy à $${fostipySubscription} \\ \\textrm{€}$. 
+On note $u_n$ le loyer à payer le mois $n$.`;
+                        }
+                        break;
+                    case 1:
+                        {
+                            const [priceOfCar] = superfluousData.values;
+                            return `Pour sa voiture, Saïda paye un loyer mensuel de $${initial} \\ \\textrm{€}$.
+Le prix à l'achat de la voiture est $${priceOfCar} \\ \\textrm{€}$.
+Son contrat prévoit une augmentation mensuelle de $${strEvoPercentage}\\%$. 
+On note $u_n$ le loyer à payer le mois $n$.`;
+                        }
+                        break;
+                    default:
+                        throw new Error("Unsupported superfluousData.rand: " + superfluousData.rand);
+                }
+            }
+        },
+        variationFindExplicitFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeExplicitFormula,
+            getHint: (_firstRank) => `Quel calcul permet de trouver le loyer pour le mois $2$ ?
+
+Inspire toi de ce calcul pour déterminer le loyer pour le mois $n$.`,
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(0);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque mois, le loyer est multiplié par $${reason.frenchify()}$.
+Le loyer en $\\textrm{€}$ pour le mois $n$ est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+        variationFindRecurrenceFormula: {
+            getAnswerNode: seqGeometricUtils.getAnswerNodeRecurrenceFormula,
+            getHint: (_firstRank) => `Si tu connais le loyer pour le mois $10$, comment fais-tu pour calculer le loyer pour le mois $11$ ?
+
+Déduis-en comment calculer $u_{n+1}$ à partir de $u_n$.`,
+            getCorrectionStuff: (_initial, reason, firstRank) => {
+                const target1 = 10;
+                const target2 = 11;
+                const [rank1, rank2] = [target1, target2].map((target) => target + firstRank);
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(2);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque mois, le loyer est multiplié par $${reason.frenchify()}$.
+Par exemple, le loyer du onzième mois est égal à celui du dixième mois multiplié par $${reason.frenchify()}$.`,
+                    rank1,
+                    rank2,
+                };
+            },
+        },
+        variationFindRandomTerm: {
+            getAnswerNode: (initial, reason, firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                return seqGeometricUtils.getAnswerNodeRandomTerm(initial, reason, firstRank, rankAsked);
+            },
+            getHint: (firstRank, ...otherArgs) => {
+                const [rankAsked] = otherArgs;
+                const target = rankAsked - firstRank;
+                return `Quelle est la nature de la suite $u_n$ ? 
+
+Utilise le terme général de $u_n$ pour déterminer le loyer pour le mois $${target}$.`;
+            },
+            getCorrectionStuff: (initial, reason, _firstRank) => {
+                const evoPercentage = (reason - 1) * 100;
+                const strEvoPercentage = evoPercentage.frPretty(0);
+                return {
+                    str: `Le pourcentage d'évolution est $${strEvoPercentage} \\%$ donc chaque mois, le loyer est multiplié par $${reason.frenchify()}$.
+Le loyer en $\\textrm{€}$ pour le mois $n$ est donc une suite géométrique de premier terme $${initial.frenchify()}$ et de raison $${reason.frenchify()}$.`,
+                };
+            },
+        },
+    },
+];
+export const situationsGeometric = templatesSituationsGeometric.map(createSituationGeometricFromTemplate);