Entraînez-vous sur les suites numériques, avec un focus sur les suites géométriques et leurs applications en informatique. Utilisez Python et Trinket pour explorer les concepts et Xcas pour vérifier vos calculs.
Pour chacune des suites définies par une formule explicite, calculez les trois premiers termes ($U_0$, $U_1$, $U_2$).
$U_n = 3n + 2$
$U_n = 5 \times (0.8)^n$
$U_n = n^2 - 1$
Pour chacune des suites définies par une relation de récurrence simple, calculez les trois premiers termes ($U_0$, $U_1$, $U_2$).
$U_{n+1} = U_n + 4$, avec $U_0 = 1$
$U_{n+1} = 0,5 \times U_n$, avec $U_0 = 10$
$U_{n+1} = U_n - 2n$, avec $U_0 = 5$
Pour chacune des suites définies par une relation de récurrence double, calculez les trois premiers termes ($U_0$, $U_1$, $U_2$).
$U_{n+2} = U_{n+1} + U_n$, avec $U_0 = 0$, $U_1 = 1$ (Suite de Fibonacci)
$U_{n+2} = 2U_{n+1} - U_n + 1$, avec $U_0 = 2$, $U_1 = 3$
$U_{n+2} = U_{n+1} \times U_n$, avec $U_0 = 1$, $U_1 = 2$
Pour chacune des suites définies par une relation de récurrence double, calculez les trois premiers termes ($U_0$, $U_1$, $U_2$).
$U_{n+2} = \frac{U_{n+1} + U_n}{2}$, avec $U_0 = 4$, $U_1 = 6$
$U_{n+2} = 2U_{n+1} - (U_n)^2$, avec $U_0 = 1$, $U_1 = -1$
$U_{n+2} = \frac{U_{n+1}}{U_n + 2}$, avec $U_0 = -1$, $U_1 = 3$
Pour gérer un pic de trafic, une entreprise déploie de nouveaux serveurs en cascade. Au démarrage, 3 serveurs sont activés. Puis, à chaque étape, le nombre de nouveaux serveurs activés est multiplié par 2 par rapport à l'étape précédente. On note $V_n$ le nombre de serveurs activés à l'étape $n$, avec $V_0 = 3$.
Déterminez la nature de la suite $(V_n)$ et sa raison.
Exprimez $V_n$ en fonction de $n$.
Calculez le nombre de serveurs activés à l'étape 4.
En utilisant une boucle `for` en Python dans Trinket, calculez et affichez le nombre total de serveurs activés après 6 étapes (en incluant l'étape initiale).
On souhaite savoir après combien d'étapes le nombre total de serveurs activés dépasse 1000. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre d'étapes et l'afficher.
Un virus informatique se propage dans un réseau. Initialement, 5 ordinateurs sont infectés. Chaque jour, le nombre d'ordinateurs infectés double. On note $W_n$ le nombre d'ordinateurs infectés après $n$ jours, avec $W_0 = 5$.
Définissez la relation de récurrence pour la suite $(W_n)$.
Exprimez $W_n$ en fonction de $n$.
Calculez le nombre d'ordinateurs infectés après 7 jours.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour calculer et afficher le nombre d'ordinateurs infectés chaque jour pendant les 10 premiers jours.
On souhaite déterminer après combien de jours plus de la moitié des 1000 ordinateurs du réseau seront infectés. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de jours et l'afficher.
Utilisez le logarithme pour déterminer théoriquement après combien de jours le nombre d'ordinateurs infectés dépassera 500. Comparez avec le résultat de la question 5.
Un algorithme de compression d'image est amélioré de version en version. On estime qu'à chaque nouvelle version, la taille des fichiers compressés est réduite de 8% par rapport à la version précédente. La première version produit des fichiers de 200 Ko en moyenne. On note $X_n$ la taille des fichiers compressés avec la version $n$ de l'algorithme, avec $X_0 = 200$ Ko.
Justifiez que la suite $(X_n)$ est géométrique et déterminez sa raison.
Exprimez $X_n$ en fonction de $n$.
Quelle sera la taille des fichiers compressés avec la 5ème version de l'algorithme (version 4, car on commence à l'indice 0)? Arrondissez au Ko.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher la taille des fichiers compressés pour les 10 premières versions de l'algorithme.
En utilisant une boucle `while` en Python dans Trinket, déterminez à partir de quelle version la taille des fichiers compressés deviendra inférieure à 100 Ko. Affichez le numéro de cette version.
Une application mobile de productivité gagne de nouveaux utilisateurs grâce au bouche-à-oreille. On observe une augmentation hebdomadaire de 5% du nombre d'utilisateurs. Au lancement, l'application compte 5000 utilisateurs. On note $Y_n$ le nombre d'utilisateurs après $n$ semaines, avec $Y_0 = 5000$.
Montrez que la suite $(Y_n)$ est géométrique et donnez sa raison.
Donnez l'expression de $Y_n$ en fonction de $n$.
Combien d'utilisateurs l'application aura-t-elle après 10 semaines ? Arrondissez à l'entier le plus proche.
Utilisez une boucle `for` en Python dans Trinket pour afficher le nombre d'utilisateurs semaine après semaine pendant 12 semaines.
On souhaite savoir après combien de semaines le nombre total d'utilisateurs activés dépasse 10000. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de semaines et l'afficher.
Le coût du Go de stockage cloud diminue de 10% chaque année. Actuellement, le coût est de 0.10 € par Go et par mois. On note $Z_n$ le coût du Go de stockage cloud dans $n$ années, en € par Go et par mois, avec $Z_0 = 0.10$ €.
Justifiez que la suite $(Z_n)$ est géométrique et indiquez sa raison.
Exprimez $Z_n$ en fonction de $n$.
Quel sera le coût du Go de stockage dans 3 ans ? Arrondissez au centime d'euro.
Écrivez un code Python dans Trinket avec une boucle `for` pour afficher le coût du Go de stockage pour les 8 prochaines années.
À l'aide d'une boucle `while` en Python dans Trinket, déterminez après combien d'années le coût du Go de stockage deviendra inférieur à 0.05 €. Affichez le nombre d'années.
Utilisez le logarithme pour déterminer théoriquement après combien d'années le coût deviendra inférieur à 0.05€. Comparez avec la question 5.
Une plateforme de paiement en ligne traite initialement 100 transactions par seconde. Grâce à des optimisations régulières, la plateforme augmente sa capacité de 3% chaque trimestre. On note $T_n$ le nombre de transactions par seconde après $n$ trimestres, avec $T_0 = 100$.
Justifiez que la suite $(T_n)$ est géométrique et déterminez sa raison.
Exprimez $T_n$ en fonction de $n$.
Combien de transactions par seconde la plateforme pourra-t-elle traiter après 2 ans ? (8 trimestres). Arrondissez à l'entier le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le nombre de transactions par seconde chaque trimestre pendant 2 ans.
Déterminez à partir de combien de trimestres la plateforme pourra traiter plus de 150 transactions par seconde. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de trimestres et l'afficher.
Un algorithme de tri a un temps d'exécution initial de 5 secondes pour un certain volume de données. Après chaque optimisation, le temps d'exécution est réduit de 5%. On note $D_n$ le temps d'exécution après $n$ optimisations, avec $D_0 = 5$ secondes.
Justifiez que la suite $(D_n)$ est géométrique et déterminez sa raison.
Exprimez $D_n$ en fonction de $n$.
Quel sera le temps d'exécution après 10 optimisations ? Arrondissez au centième de seconde.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le temps d'exécution après chaque optimisation pendant les 10 premières optimisations.
Déterminez à partir de combien d'optimisations le temps d'exécution deviendra inférieur à 3 secondes. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre d'optimisations et l'afficher.
Dans un jeu vidéo de stratégie, un joueur commence avec 20 unités d'une ressource. Chaque heure, le joueur augmente sa production de ressources de 10%. On note $R_n$ le nombre d'unités de ressource après $n$ heures, avec $R_0 = 20$.
Justifiez que la suite $(R_n)$ est géométrique et déterminez sa raison.
Exprimez $R_n$ en fonction de $n$.
Combien d'unités de ressource le joueur aura-t-il après 12 heures ? Arrondissez à l'entier le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le nombre de ressources heure par heure pendant 12 heures.
Déterminez après combien d'heures le joueur dépassera 50 unités de ressource. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre d'heures et l'afficher.
Un serveur informatique a une valeur initiale de 5000€. On estime que sa valeur diminue de 15% chaque année. On note $V_n$ la valeur du serveur après $n$ années, avec $V_0 = 5000$€.
Justifiez que la suite $(V_n)$ est géométrique et déterminez sa raison.
Exprimez $V_n$ en fonction de $n$.
Quelle sera la valeur du serveur après 6 ans ? Arrondissez à l'euro le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher la valeur du serveur année après année pendant 6 ans.
Déterminez après combien d'années la valeur du serveur deviendra inférieure à 2000€. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre d'années et l'afficher.
Un projet logiciel démarre avec 10 000 lignes de code. On estime que le projet grandit de 20% en lignes de code chaque mois. On note $L_n$ le nombre de lignes de code après $n$ mois, avec $L_0 = 10000$.
Justifiez que la suite $(L_n)$ est géométrique et déterminez sa raison.
Exprimez $L_n$ en fonction de $n$.
Combien de lignes de code le projet aura-t-il après 9 mois ? Arrondissez à l'entier le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le nombre de lignes de code mois après mois pendant 9 mois.
Déterminez après combien de mois le projet dépassera 50 000 lignes de code. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de mois et l'afficher.
Une équipe de développement corrige 80 bugs pour la première version d'un logiciel. On espère réduire le nombre de bugs de 25% à chaque nouvelle version. On note $B_n$ le nombre de bugs corrigés pour la version $n$ (après la version initiale), avec $B_0 = 80$.
Justifiez que la suite $(B_n)$ est géométrique et déterminez sa raison.
Exprimez $B_n$ en fonction de $n$.
Combien de bugs seront corrigés pour la 4ème version (version 3, car on commence à l'indice 0) ? Arrondissez à l'entier le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le nombre de bugs corrigés version après version pendant 6 versions.
Déterminez à partir de quelle version le nombre de bugs corrigés deviendra inférieur à 20. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de versions et l'afficher.
Une API web reçoit initialement 500 requêtes par minute. On anticipe une augmentation de 8% du nombre de requêtes chaque mois. On note $Q_n$ le nombre de requêtes par minute après $n$ mois, avec $Q_0 = 500$.
Justifiez que la suite $(Q_n)$ est géométrique et déterminez sa raison.
Exprimez $Q_n$ en fonction de $n$.
Combien de requêtes par minute l'API recevra-t-elle après 1 an (12 mois) ? Arrondissez à l'entier le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le nombre de requêtes par minute mois après mois pendant 1 an.
Déterminez après combien de mois l'API dépassera 1200 requêtes par minute. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de mois et l'afficher.
Une campagne de publicité en ligne génère initialement 1000 impressions par jour. On prévoit une augmentation de 5% du nombre d'impressions chaque semaine. On note $I_n$ le nombre d'impressions par jour après $n$ semaines, avec $I_0 = 1000$.
Justifiez que la suite $(I_n)$ est géométrique et déterminez sa raison.
Exprimez $I_n$ en fonction de $n$.
Combien d'impressions par jour la publicité générera-t-elle après 6 semaines ? Arrondissez à l'entier le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le nombre d'impressions par jour semaine après semaine pendant 6 semaines.
Déterminez après combien de semaines la publicité dépassera 1500 impressions par jour. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de semaines et l'afficher.
Une bannière publicitaire a un taux de clics initial de 2%. On espère améliorer le taux de clics de 10% (relativement) chaque mois grâce à des tests A/B. On note $C_n$ le taux de clics après $n$ mois, avec $C_0 = 2\% = 0.02$.
Justifiez que la suite $(C_n)$ est géométrique et déterminez sa raison.
Exprimez $C_n$ en fonction de $n$.
Quel sera le taux de clics après 10 mois ? Exprimez le résultat en pourcentage avec deux décimales.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le taux de clics mois après mois pendant 10 mois.
Déterminez après combien de mois le taux de clics dépassera 4%. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de mois et l'afficher.
Un site web reçoit initialement 5000 visites par jour. Suite à une campagne de SEO, on prévoit une augmentation de 6% du nombre de visites chaque semaine. On note $N_n$ le nombre de visites par jour après $n$ semaines, avec $N_0 = 5000$.
Justifiez que la suite $(N_n)$ est géométrique et déterminez sa raison.
Exprimez $N_n$ en fonction de $n$.
Combien de visites par jour le site web recevra-t-il après 8 semaines ? Arrondissez à l'entier le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le nombre de visites par jour semaine après semaine pendant 8 semaines.
Déterminez après combien de semaines le site web dépassera 8000 visites par jour. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de semaines et l'afficher.
Un serveur web a un temps de réponse moyen initial de 200 ms. On vise à réduire le temps de réponse de 4% chaque mois grâce à des améliorations techniques. On note $R_n$ le temps de réponse moyen après $n$ mois, avec $R_0 = 200$ ms.
Justifiez que la suite $(R_n)$ est géométrique et déterminez sa raison.
Exprimez $R_n$ en fonction de $n$.
Quel sera le temps de réponse moyen après 1 an (12 mois) ? Arrondissez à l'entier le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le temps de réponse moyen mois après mois pendant 1 an.
Déterminez après combien de mois le temps de réponse moyen deviendra inférieur à 150 ms. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de mois et l'afficher.
Une entreprise étend son réseau WiFi. La borne principale couvre un rayon de 50 mètres. Chaque répéteur WiFi ajouté étend le rayon de couverture de 80% du rayon précédent. On note $E_n$ l'extension du rayon de couverture après l'ajout de $n$ répéteurs, avec $E_0 = 50$ mètres.
Justifiez que la suite $(E_n)$ est géométrique et déterminez sa raison.
Exprimez $E_n$ en fonction de $n$.
Quel sera le rayon de couverture après l'ajout de 4 répéteurs ? Arrondissez au mètre le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le rayon de couverture après l'ajout de 0 à 5 répéteurs.
En utilisant une boucle `while` en Python dans Trinket, déterminez le nombre minimal de répéteurs à ajouter pour que le rayon de couverture dépasse 100 mètres. Affichez ce nombre.
Historiquement, la capacité des disques durs a augmenté de manière exponentielle. Supposons qu'en 2010, un disque dur standard avait une capacité de 1 To (Téraoctet). Si la capacité doublait tous les 2 ans, on note $Cap_n$ la capacité en To après $2n$ années à partir de 2010, avec $Cap_0 = 1$.
Justifiez que la suite $(Cap_n)$ est géométrique et déterminez sa raison.
Exprimez $Cap_n$ en fonction de $n$.
Quelle serait la capacité d'un disque dur standard en 2020 (10 ans après 2010) selon ce modèle ?
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher la capacité des disques durs tous les 2 ans de 2010 à 2030.
En utilisant une boucle `while` en Python dans Trinket, déterminez en quelle année (à partir de 2010) la capacité des disques durs aurait dépassé 16 To selon ce modèle. Affichez l'année.
Une mise à jour logicielle est déployée progressivement. Le premier jour, 100 appareils sont mis à jour. Chaque jour suivant, le nombre d'appareils mis à jour est augmenté de 20%. On note $M_n$ le nombre d'appareils mis à jour le jour $n+1$ (en partant du jour 0), avec $M_0 = 100$.
Justifiez que la suite $(M_n)$ est géométrique et déterminez sa raison.
Exprimez $M_n$ en fonction de $n$.
Combien d'appareils seront mis à jour le 5ème jour (jour 4, en commençant à compter à partir de 0) ?
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le nombre d'appareils mis à jour chaque jour pendant les 7 premiers jours.
En utilisant une boucle `while` en Python dans Trinket, déterminez après combien de jours le nombre cumulé d'appareils mis à jour dépassera 1000. Affichez le nombre de jours.
Un algorithme de reconnaissance d'images a un taux d'erreur initial de 10%. Après chaque phase d'entraînement, on réduit le taux d'erreur de 15% (relativement). On note $Err_n$ le taux d'erreur après $n$ phases d'entraînement, avec $Err_0 = 0.10$.
Justifiez que la suite $(Err_n)$ est géométrique et déterminez sa raison.
Exprimez $Err_n$ en fonction de $n$.
Quel sera le taux d'erreur après 6 phases d'entraînement ? Exprimez le résultat en pourcentage avec deux décimales.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le taux d'erreur après chaque phase d'entraînement pendant les 8 premières phases.
En utilisant une boucle `while` en Python dans Trinket, déterminez après combien de phases d'entraînement le taux d'erreur deviendra inférieur à 5%. Affichez le nombre de phases.
Une plateforme e-commerce enregistre initialement 2000 transactions réussies par jour. Suite à des améliorations de l'interface utilisateur, on observe une augmentation de 4% du nombre de transactions réussies chaque semaine. On note $Succ_n$ le nombre de transactions réussies par jour après $n$ semaines, avec $Succ_0 = 2000$.
Justifiez que la suite $(Succ_n)$ est géométrique et déterminez sa raison.
Exprimez $Succ_n$ en fonction de $n$.
Combien de transactions réussies par jour la plateforme enregistrera-t-elle après 10 semaines ? Arrondissez à l'entier le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le nombre de transactions réussies par jour semaine après semaine pendant les 10 premières semaines.
En utilisant une boucle `while` en Python dans Trinket, déterminez après combien de semaines le nombre de transactions réussies par jour dépassera 2500. Affichez le nombre de semaines.
Un administrateur réseau cherche à optimiser la latence d'un serveur. La latence initiale est de 120 ms. Chaque optimisation réduit la latence de 6%. On note $L_n$ la latence après $n$ optimisations, avec $L_0 = 120$ ms.
Justifiez que la suite $(L_n)$ est géométrique et donnez sa raison.
Exprimez $L_n$ en fonction de $n$.
Calculez la latence après 8 optimisations. Arrondissez au centième de ms.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher la latence après chaque optimisation pour les 8 premières optimisations.
Déterminez le nombre minimal d'optimisations nécessaires pour que la latence devienne inférieure à 70 ms. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre.
Quelle est la réduction totale de latence (en ms) après les 8 premières optimisations ? (Calculer $L_0 - L_8$).
Un virus se propage dans un réseau de 5000 ordinateurs. Initialement, 10 ordinateurs sont infectés. Chaque jour, le nombre d'ordinateurs infectés augmente de 30%. On note $Inf_n$ le nombre d'ordinateurs infectés après $n$ jours, avec $Inf_0 = 10$.
Justifiez que la suite $(Inf_n)$ est géométrique et déterminez sa raison.
Exprimez $Inf_n$ en fonction de $n$.
Calculez le nombre d'ordinateurs infectés après 1 semaine (7 jours). Arrondissez à l'entier le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le nombre d'ordinateurs infectés chaque jour pendant 10 jours.
Déterminez après combien de jours la moitié du réseau sera infectée. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de jours.
Si le réseau devient instable lorsque plus de 60% des ordinateurs sont infectés, après combien de jours le réseau deviendra-t-il instable ? Utilisez une boucle `while` en Python dans Trinket.
Un site web e-commerce a un taux de conversion initial de 1.5%. On vise une augmentation de 12% du taux de conversion chaque mois grâce à des optimisations UX/UI. On note $Conv_n$ le taux de conversion après $n$ mois, avec $Conv_0 = 0.015$.
Justifiez que la suite $(Conv_n)$ est géométrique et déterminez sa raison.
Exprimez $Conv_n$ en fonction de $n$.
Quel sera le taux de conversion après 9 mois ? Exprimez le résultat en pourcentage avec deux décimales.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le taux de conversion mois après mois pendant 9 mois.
Déterminez après combien de mois le taux de conversion dépassera 3%. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de mois.
Si l'objectif est d'atteindre un taux de conversion de 5%, combien de mois supplémentaires (au-delà du seuil de 3%) seront nécessaires, en supposant le même taux de croissance ? Utilisez une boucle `while` en Python dans Trinket.
Le déploiement de la 5G dans une ville commence avec 5 antennes relais. On prévoit de multiplier par 1.5 le nombre de nouvelles antennes installées chaque mois par rapport au mois précédent. On note $Ant_n$ le nombre de nouvelles antennes installées le mois $n+1$ (en partant du mois 0), avec $Ant_0 = 5$.
Justifiez que la suite $(Ant_n)$ est géométrique et déterminez sa raison.
Exprimez $Ant_n$ en fonction de $n$.
Combien de nouvelles antennes seront installées durant le 6ème mois de déploiement (mois 5, en commençant à compter à partir de 0) ? Arrondissez à l'entier le plus proche.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le nombre de nouvelles antennes installées chaque mois pendant les 6 premiers mois.
Déterminez le nombre total d'antennes installées après 1 an (12 mois). Pour cela, calculez la somme des 12 premiers termes de la suite $(Ant_n)$ (de $Ant_0$ à $Ant_{11}$) et utilisez une boucle `for` en Python dans Trinket pour vérifier votre résultat.
Si le budget permet d'installer au maximum 500 antennes au total, après combien de mois le déploiement devra-t-il s'arrêter ? Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre de mois.
Un algorithme de réduction de bruit numérique dans les images réduit le bruit de 20% à chaque itération. Le niveau de bruit initial est de 50 unités arbitraires. On note $Bruit_n$ le niveau de bruit après $n$ itérations, avec $Bruit_0 = 50$.
Justifiez que la suite $(Bruit_n)$ est géométrique et déterminez sa raison.
Exprimez $Bruit_n$ en fonction de $n$.
Quel sera le niveau de bruit après 10 itérations ? Arrondissez à deux décimales.
Écrivez un code Python dans Trinket utilisant une boucle `for` pour afficher le niveau de bruit après chaque itération pour les 10 premières itérations.
Déterminez à partir de combien d'itérations le niveau de bruit deviendra inférieur à 10 unités. Utilisez une boucle `while` en Python dans Trinket pour trouver ce nombre d'itérations.
Si chaque itération prend 0.2 secondes de temps de calcul, combien de temps faudra-t-il pour atteindre un niveau de bruit inférieur à 10 unités ?
Utilité en Informatique : La suite logistique discrète est un modèle fondamental en informatique pour étudier les systèmes dynamiques et chaotiques, trouvant des applications dans la simulation, la cryptographie (génération de nombres pseudo-aléatoires) et la modélisation de systèmes complexes.
On considère la suite $(U_n)$ définie par $U_0 = 0.2$ et la relation de récurrence $U_{n+1} = 2.5 U_n (1 - U_n)$.
Partie 1 : Étude de la suite $(U_n)$
Calculez les trois premiers termes $U_1$, $U_2$, et $U_3$. Donnez les valeurs exactes puis des valeurs approchées à $10^{-3}$ près.
La suite $(U_n)$ est-elle géométrique ? Justifiez votre réponse.
Représentez graphiquement les 4 premiers termes de la suite $(U_n)$. Que conjecturez-vous sur le comportement de la suite ?
Partie 2 : Introduction d'une suite auxiliaire $(V_n)$
On pose $V_n = U_n - 0.6$. Exprimez $V_{n+1}$ en fonction de $V_n$ et $V_n^2$.
Linéarisation locale : Pour les petites valeurs de $V_n$, on peut négliger le terme $V_n^2$. On considère alors la suite $(W_n)$ définie par $W_{n+1} = -0.5 W_n$ et $W_0 = V_0$. Quelle est la nature de la suite $(W_n)$ ? Donnez l'expression de $W_n$ en fonction de $n$ et $W_0$.
Calculez $W_1$, $W_2$, $W_3$ et comparez ces valeurs avec $V_1$, $V_2$, $V_3$ calculées à partir des valeurs de $U_n$ de la partie 1. Commentez.
Partie 3 : Analyse de la convergence et Python
Étudiez la convergence de la suite $(W_n)$. Quelle est sa limite ?
Si la suite $(W_n)$ est une approximation de $(V_n)$ pour les petites valeurs, que peut-on conjecturer sur la limite de $(V_n)$ puis sur la limite de $(U_n)$ ?
Écrivez un code Python dans Trinket pour calculer et afficher les 10 premiers termes de la suite $(U_n)$. Observez les valeurs obtenues et comparez avec vos conjectures.
Utilité en Informatique : Les modèles de population sont essentiels en informatique pour la simulation de systèmes dynamiques, la gestion des ressources, la prédiction de tendances (trafic réseau, performance algorithmique) et l'analyse de systèmes complexes.
On considère une population initiale de 1000 insectes ($P_0 = 1000$). Chaque année, la population augmente de 20% mais 50 insectes quittent la zone par migration. On modélise la population par une suite $(P_n)$ où $P_n$ représente la population après $n$ années.
Partie 1 : Modélisation de la population
Exprimez la relation de récurrence entre $P_{n+1}$ et $P_n$. Précisez la valeur de $P_0$.
Calculez les populations $P_1$, $P_2$ et $P_3$.
La suite $(P_n)$ est-elle géométrique ? Justifiez.
Écrivez un algorithme en pseudo-code qui calcule et affiche la population après $N$ années, où $N$ est un entier donné.
Implémentez cet algorithme en Python dans Trinket et affichez la population après 10 ans.
Partie 2 : Suite auxiliaire et forme explicite
Considérez la suite auxiliaire $(Q_n)$ définie par $Q_n = P_n - 250$. Montrez que $(Q_n)$ est une suite géométrique. Déterminez sa raison et son premier terme $Q_0$.
Exprimez $Q_n$ en fonction de $n$.
En déduire l'expression de $P_n$ en fonction de $n$.
Calculez $P_{10}$ en utilisant la formule explicite trouvée et comparez avec le résultat obtenu par l'algorithme en Partie 1.e.
Partie 3 : Limite et interprétation
Déterminez la limite de la suite $(Q_n)$ lorsque $n \to +\infty$.
Déterminez la limite de la suite $(P_n)$ lorsque $n \to +\infty$.
Interprétez concrètement la limite de la suite $(P_n)$ dans le contexte du modèle de population.
Pour quelle population initiale $P_0$ la population reste-t-elle constante au fil des années ? Justifiez par le calcul.
Utilité en Informatique : Les suites récurrentes linéaires sont fondamentales en informatique pour générer des séquences pseudo-aléatoires, utilisées en cryptographie, simulations, tests d'algorithmes et dans divers domaines nécessitant des nombres aléatoires.
On considère la suite $(C_n)$ définie par $C_0 = 1$, $C_1 = 2$ et la relation de récurrence $C_{n+2} = 3C_{n+1} - 2C_n$.
Partie 1 : Étude de la suite $(C_n)$
Calculez les termes $C_2$, $C_3$, $C_4$ et $C_5$.
La suite $(C_n)$ est-elle géométrique ? Justifiez votre réponse.
Vérifiez que la relation de récurrence est linéaire et d'ordre 2. Quels sont les coefficients constants ?
Partie 2 : Recherche de suites géométriques solutions
On cherche des solutions de la forme $C_n = r^n$. Montrez que si $(C_n)$ est solution, alors $r$ doit vérifier l'équation caractéristique $r^2 - 3r + 2 = 0$.
Résolvez l'équation caractéristique. On notera $r_1$ et $r_2$ les deux solutions (avec $r_1 < r_2$).
Vérifiez que les suites $(r_1^n)$ et $(r_2^n)$ sont solutions de la relation de récurrence.
Partie 3 : Combinaison linéaire et forme explicite
Montrez que toute suite de la forme $C_n = \alpha r_1^n + \beta r_2^n$, où $\alpha$ et $\beta$ sont des constantes réelles, est solution de la relation de récurrence, quelle que soient les valeurs de $\alpha$ et $\beta$.
Déterminez les valeurs de $\alpha$ et $\beta$ pour que la solution $C_n = \alpha r_1^n + \beta r_2^n$ vérifie les conditions initiales $C_0 = 1$ et $C_1 = 2$. (Résolvez un système de deux équations à deux inconnues).
Donnez l'expression explicite de $C_n$ en fonction de $n$.
Calculez $C_{10}$ en utilisant la formule explicite et vérifiez avec un code Python dans Trinket calculant les termes de la suite par récurrence jusqu'à $C_{10}$.
Utilité en Informatique : Les suites de Fibonacci modifiées sont utilisées en cryptographie pour la génération de clés, dans les algorithmes nécessitant des séquences aux propriétés mathématiques spécifiques et pour la création de systèmes de sécurité.
On considère la suite $(F_n)$ définie par $F_0 = 3$, $F_1 = 5$ et la relation de récurrence $F_{n+2} = F_{n+1} + F_n$.
Partie 1 : Étude de la suite $(F_n)$
Calculez les termes $F_2$, $F_3$, $F_4$ et $F_5$.
Montrez que la suite $(F_n)$ n'est pas géométrique.
Vérifiez que la relation de récurrence est linéaire et d'ordre 2. Quels sont les coefficients constants ?
Partie 2 : Recherche de suites géométriques solutions
On cherche des solutions de la forme $F_n = r^n$. Montrez que $r$ doit vérifier l'équation caractéristique $r^2 - r - 1 = 0$.
Résolvez l'équation caractéristique. On notera $\phi$ et $\psi$ les deux solutions (avec $\phi > \psi$). Exprimez les valeurs exactes avec des racines carrées.
Vérifiez que les suites $(\phi^n)$ et $(\psi^n)$ sont solutions de la relation de récurrence.
Partie 3 : Combinaison linéaire et forme explicite
Montrez que toute suite de la forme $F_n = \alpha \phi^n + \beta \psi^n$ est solution de la relation de récurrence.
Déterminez les valeurs de $\alpha$ et $\beta$ pour que la solution $F_n = \alpha \phi^n + \beta \psi^n$ vérifie les conditions initiales $F_0 = 3$ et $F_1 = 5$.
Donnez l'expression explicite de $F_n$ en fonction de $n$, $\phi$ et $\psi$.
Calculez $F_{10}$ en utilisant la formule explicite et vérifiez avec un code Python dans Trinket calculant les termes de la suite par récurrence jusqu'à $F_{10}$.
En Informatique, les algorithmes de hachage sont cruciaux pour assurer l'intégrité des données et la sécurité des systèmes. Ils transforment des données de taille arbitraire en empreintes numériques de taille fixe. Cet exercice explore comment une suite récurrente linéaire, combinée à l'opération modulo, peut être utilisée pour construire un algorithme de hachage simple. Comprendre les propriétés de ces suites permet de concevoir ou d'analyser des fonctions de hachage. Un algorithme de hachage utilise une suite $(H_n)$ définie par $H_0 = 0$, $H_1 = 1$ et $H_{n+2} = 4H_{n+1} - 3H_n$. Les valeurs sont ensuite utilisées modulo un grand nombre premier.
Partie 1 : Étude de la suite $(H_n)$
Calculez les termes $H_2$, $H_3$, $H_4$ et $H_5$.
Montrez que la suite $(H_n)$ n'est pas géométrique.
Vérifiez que la relation de récurrence est linéaire et d'ordre 2. Quels sont les coefficients constants ?
Partie 2 : Recherche de suites géométriques solutions
On cherche des solutions de la forme $H_n = r^n$. Montrez que $r$ doit vérifier l'équation caractéristique $r^2 - 4r + 3 = 0$.
Résolvez l'équation caractéristique. On notera $r_1$ et $r_2$ les deux solutions (avec $r_1 < r_2$).
Vérifiez que les suites $(r_1^n)$ et $(r_2^n)$ sont solutions de la relation de récurrence.
Partie 3 : Combinaison linéaire et forme explicite
Montrez que toute suite de la forme $H_n = \alpha r_1^n + \beta r_2^n$ est solution de la relation de récurrence.
Déterminez les valeurs de $\alpha$ et $\beta$ pour que la solution $H_n = \alpha r_1^n + \beta r_2^n$ vérifie les conditions initiales $H_0 = 0$ et $H_1 = 1$.
Donnez l'expression explicite de $H_n$ en fonction de $n$, $r_1$ et $r_2$.
Calculez $H_{10}$ en utilisant la formule explicite et vérifiez avec un code Python dans Trinket calculant les termes de la suite par récurrence jusqu'à $H_{10}$.
Utilité en Informatique : Les suites utilisées dans les codes de détection d'erreurs sont essentielles pour assurer la fiabilité des transmissions de données, la correction d'erreurs et la robustesse des communications numériques et du stockage de données.
On considère la suite $(E_n)$ définie par $E_0 = 1$, $E_1 = -1$ et la relation de récurrence $E_{n+2} = 5E_{n+1} - 6E_n$.
Partie 1 : Étude de la suite $(E_n)$
Calculez les termes $E_2$, $E_3$, $E_4$ et $E_5$.
Montrez que la suite $(E_n)$ n'est pas géométrique.
Vérifiez que la relation de récurrence est linéaire et d'ordre 2. Quels sont les coefficients constants ?
Partie 2 : Recherche de suites géométriques solutions
On cherche des solutions de la forme $E_n = r^n$. Montrez que $r$ doit vérifier l'équation caractéristique $r^2 - 5r + 6 = 0$.
Résolvez l'équation caractéristique. On notera $r_1$ et $r_2$ les deux solutions (avec $r_1 < r_2$).
Vérifiez que les suites $(r_1^n)$ et $(r_2^n)$ sont solutions de la relation de récurrence.
Partie 3 : Combinaison linéaire et forme explicite
Montrez que toute suite de la forme $E_n = \alpha r_1^n + \beta r_2^n$ est solution de la relation de récurrence.
Déterminez les valeurs de $\alpha$ et $\beta$ pour que la solution $E_n = \alpha r_1^n + \beta r_2^n$ vérifie les conditions initiales $E_0 = 1$ et $E_1 = -1$.
Donnez l'expression explicite de $E_n$ en fonction de $n$, $r_1$ et $r_2$.
Calculez $E_{10}$ en utilisant la formule explicite et vérifiez avec un code Python dans Trinket calculant les termes de la suite par récurrence jusqu'à $E_{10}$.
Utilité en Informatique : Les générateurs de nombres pseudo-aléatoires simplifiés sont utilisés en informatique pour les simulations, les tests aléatoires d'algorithmes et dans les applications où une source de nombres aléatoires de base est nécessaire.
On considère la suite $(R_n)$ définie par $R_0 = 2$, $R_1 = 0$ et la relation de récurrence $R_{n+2} = -R_{n+1} + 2R_n$.
Partie 1 : Étude de la suite $(R_n)$
Calculez les termes $R_2$, $R_3$, $R_4$ et $R_5$.
Montrez que la suite $(R_n)$ n'est pas géométrique.
Vérifiez que la relation de récurrence est linéaire et d'ordre 2. Quels sont les coefficients constants ?
Partie 2 : Recherche de suites géométriques solutions
On cherche des solutions de la forme $R_n = r^n$. Montrez que $r$ doit vérifier l'équation caractéristique $r^2 + r - 2 = 0$.
Résolvez l'équation caractéristique. On notera $r_1$ et $r_2$ les deux solutions (avec $r_1 < r_2$).
Vérifiez que les suites $(r_1^n)$ et $(r_2^n)$ sont solutions de la relation de récurrence.
Partie 3 : Combinaison linéaire et forme explicite
Montrez que toute suite de la forme $R_n = \alpha r_1^n + \beta r_2^n$ est solution de la relation de récurrence.
Déterminez les valeurs de $\alpha$ et $\beta$ pour que la solution $R_n$ = $\alpha r_1^n$ + $\beta r_2^n$ vérifie les conditions initiales $R_0 = 2$ et $R_1 = 0$.
Donnez l'expression explicite de $R_n$ en fonction de $n$, $r_1$ et $r_2$.
Calculez $R_{10}$ en utilisant la formule explicite et vérifiez avec un code Python dans Trinket calculant les termes de la suite par récurrence jusqu'à $R_{10}$.
Utilité en Informatique : Les suites oscillatoires sont fondamentales dans le traitement du signal pour la génération d'ondes, l'analyse fréquentielle, la synthèse sonore et dans les simulations de phénomènes périodiques.
On considère la suite $(S_n)$ définie par $S_0 = 1$, $S_1 = 1$ et la relation de récurrence $S_{n+2} = 2S_{n+1} - 2S_n$.
Partie 1 : Étude de la suite $(S_n)$
Calculez les termes $S_2$, $S_3$, $S_4$ et $S_5$.
Montrez que la suite $(S_n)$ n'est pas géométrique.
Vérifiez que la relation de récurrence est linéaire et d'ordre 2. Quels sont les coefficients constants ?
Partie 2 : Recherche de suites géométriques solutions
On cherche des solutions de la forme $S_n = r^n$. Montrez que $r$ doit vérifier l'équation caractéristique $r^2 - 2r + 2 = 0$.
Résolvez l'équation caractéristique. On notera $r_1$ et $r_2$ les deux solutions complexes conjuguées.
Vérifiez que les suites $(r_1^n)$ et $(r_2^n)$ sont solutions de la relation de récurrence.
Partie 3 : Combinaison linéaire et forme explicite réelle
Montrez que toute suite de la forme $S_n = \alpha r_1^n + \beta r_2^n$ est solution de la relation de récurrence.
Déterminez les valeurs de $\alpha$ et $\beta$ pour que la solution $S_n = \alpha r_1^n + \beta r_2^n$ vérifie les conditions initiales $S_0 = 1$ et $S_1 = 1$.
Exprimez les racines $r_1$ et $r_2$ sous forme exponentielle complexe $r = \rho e^{\pm i\theta}$. Déterminez $\rho$ et $\theta$.
En déduire l'expression explicite réelle de $S_n$ en fonction de $n$, $\rho$ et $\theta$ sous la forme $S_n = A \rho^n \cos(n\theta + \phi)$. Déterminez $A$ et $\phi$ à partir de $\alpha$ et $\beta$.
Calculez $S_{10}$ avec la formule trigonométrique et vérifiez avec un code Python dans Trinket calculant les termes de la suite par récurrence jusqu'à $S_{10}$.
Utilité en Informatique : La modélisation de systèmes amortis critiques avec des suites est importante en informatique pour simuler des systèmes physiques, la théorie du contrôle, et les simulations impliquant la stabilité et le temps de réponse.
On considère la suite $(T_n)$ définie par $T_0 = 2$, $T_1 = 4$ et la relation de récurrence $T_{n+2} = 4T_{n+1} - 4T_n$.
Partie 1 : Étude de la suite $(T_n)$
Calculez les termes $T_2$, $T_3$, $T_4$ et $T_5$.
Montrez que la suite $(T_n)$ n'est pas géométrique.
Vérifiez que la relation de récurrence est linéaire et d'ordre 2. Quels sont les coefficients constants ?
Partie 2 : Recherche de suites géométriques solutions
On cherche des solutions de la forme $T_n = r^n$. Montrez que $r$ doit vérifier l'équation caractéristique $r^2 - 4r + 4 = 0$.
Résolvez l'équation caractéristique. Montrez qu'il y a une racine double $r_0$.
Vérifiez que la suite $(r_0^n)$ est solution de la relation de récurrence.
Partie 3 : Forme explicite avec racine double
Montrez que la suite $(n r_0^n)$ est aussi solution de la relation de récurrence (cas de racine double).
Montrez que toute suite de la forme $T_n = (\alpha + \beta n) r_0^n$ est solution de la relation de récurrence.
Déterminez les valeurs de $\alpha$ et $\beta$ pour que la solution $T_n = (\alpha + \beta n) r_0^n$ vérifie les conditions initiales $T_0 = 2$ et $T_1 = 4$.
Donnez l'expression explicite de $T_n$ en fonction de $n$ et $r_0$.
Calculez $T_{10}$ en utilisant la formule explicite et vérifiez avec un code Python dans Trinket calculant les termes de la suite par récurrence jusqu'à $T_{10}$.
Utilité en Informatique : Les suites affines récurrentes modélisent des compteurs numériques et sont utilisées dans la conception de systèmes embarqués, les automates finis et les systèmes de contrôle séquentiel.
On considère la suite $(Y_n)$ définie par $Y_0 = 0$, $Y_1 = 1$ et la relation de récurrence $Y_{n+2} = Y_{n+1} + Y_n + 1$.
Partie 1 : Étude de la suite $(Y_n)$
Calculez les termes $Y_2$, $Y_3$, $Y_4$ et $Y_5$.
Montrez que la suite $(Y_n)$ n'est pas géométrique.
Vérifiez que la relation de récurrence est linéaire et affine d'ordre 2 (à cause du terme constant +1).
Partie 2 : Suite auxiliaire pour homogénéiser la relation
On cherche une suite constante $(c)$ telle que $c = c + c + 1$. Est-ce possible ?
On cherche une suite constante $(c)$ telle que $c = c + c + 1$. Est-ce possible ? En fait, on cherche une solution particulière constante de la forme $Y_n = C$. Substituez $Y_n = C$ dans la relation de récurrence et déterminez $C$.
Considérez la suite auxiliaire $(Z_n)$ définie par $Z_n = Y_n + C$. Exprimez $Y_n$ en fonction de $Z_n$ et $C$, puis remplacez dans la relation de récurrence pour obtenir une relation de récurrence linéaire homogène d'ordre 2 pour $(Z_n)$.
Déterminez l'équation caractéristique associée à la suite $(Z_n)$. Résolvez-la et notez $\phi$ et $\psi$ les solutions.
Partie 3 : Forme explicite de $(Y_n)$
Donnez la forme générale de $Z_n$ en fonction de $n$, $\phi$, $\psi$, et des constantes $\alpha, \beta$.
Déterminez $Z_0$ et $Z_1$ en fonction de $Y_0$, $Y_1$ et $C$. Utilisez les conditions initiales pour déterminer $\alpha$ et $\beta$.
Donnez l'expression explicite de $Z_n$ puis de $Y_n$ en fonction de $n$, $\phi$, $\psi$ et $C$.
Calculez $Y_{10}$ en utilisant la formule explicite et vérifiez avec un code Python dans Trinket calculant les termes de la suite par récurrence jusqu'à $Y_{10}$.
Utilité en Informatique : Les suites oscillatoires avec discriminant négatif sont utilisées en traitement du signal et analyse fréquentielle pour modéliser et analyser les signaux périodiques, les filtres numériques et dans les algorithmes de transformation de Fourier.
On considère la suite $(X_n)$ définie par $X_0 = 1$, $X_1 = 0$ et la relation de récurrence $X_{n+2} = X_{n+1} - X_n$.
Partie 1 : Étude de la suite $(X_n)$
Calculez les termes $X_2$, $X_3$, $X_4$, $X_5$ et $X_6$.
Montrez que la suite $(X_n)$ n'est pas géométrique.
Vérifiez que la relation de récurrence est linéaire et d'ordre 2. Quels sont les coefficients constants ?
Partie 2 : Recherche de suites géométriques solutions
On cherche des solutions de la forme $X_n = r^n$. Montrez que $r$ doit vérifier l'équation caractéristique $r^2 - r + 1 = 0$.
Résolvez l'équation caractéristique. On notera $r_1$ et $r_2$ les deux solutions complexes conjuguées.
Vérifiez que les suites $(r_1^n)$ et $(r_2^n)$ sont solutions de la relation de récurrence.
Partie 3 : Forme explicite et périodicité
Donnez le module $\rho$ et l'argument principal $\theta$ des racines $r_1$ et $r_2$.
Exprimez la solution générale réelle de la suite $(X_n)$ sous forme trigonométrique $X_n = A \cos(n\theta + \phi)$.
Déterminez les valeurs de $A$ et $\phi$ en utilisant les conditions initiales $X_0 = 1$ et $X_1 = 0$.
Donnez l'expression explicite de $X_n$ sous forme trigonométrique. Quelle est la période de la suite $(X_n)$ ?
Calculez $X_{12}$ avec la formule explicite et vérifiez avec un code Python dans Trinket calculant les termes de la suite par récurrence jusqu'à $X_{12}$.
Utilité en Informatique : L'analyse de la complexité algorithmique est cruciale pour comprendre l'efficacité des algorithmes, optimiser le code et prédire les performances en fonction de la taille des entrées. Les suites récurrentes sont un outil fondamental pour analyser la complexité d'algorithmes récursifs.
Considérez l'algorithme récursif suivant en pseudo-code, qui calcule la somme des éléments d'un tableau :
FONCTION SommeTableauRecursif(tableau T, index debut, index fin)
SI debut > fin ALORS
RETOURNER 0
SINON SI debut == fin ALORS
RETOURNER T[debut]
SINON
milieu = (debut + fin) / 2 // Division entière
sommeGauche = SommeTableauRecursif(T, debut, milieu)
sommeDroite = SommeTableauRecursif(T, milieu + 1, fin)
RETOURNER sommeGauche + sommeDroite
FIN SI
FIN FONCTION
Soit $C(n)$ le nombre d'opérations (par exemple, additions, comparaisons, divisions) effectuées par cet algorithme pour un tableau de taille $n = fin - debut + 1$. Exprimez $C(n)$ sous forme d'une relation de récurrence. Considérez que les opérations dominantes sont les appels récursifs et l'addition finale.
Pour simplifier, supposez que si $n=1$, $C(1) = 1$ (opération de retour de la valeur) et si $n>1$, $C(n) = 2C(n/2) + k$, où $k$ est une constante représentant le coût des opérations non-récursives (division, addition finale). En supposant $k=1$ et pour simplifier l'analyse, considérez que $n$ est une puissance de 2, par exemple $n = 2^p$. Posez $c_p = C(2^p)$. Exprimez $c_p$ en fonction de $c_{p-1}$.
La suite $(c_p)$ est-elle géométrique ? Est-elle arithmético-géométrique ? Quelle est sa nature ?
Résolvez la relation de récurrence pour $(c_p)$. Exprimez $c_p$ en fonction de $p$.
Déduisez-en l'expression de $C(n)$ en fonction de $n$. Quelle est la complexité algorithmique de la fonction `SommeTableauRecursif` en notation grand O ?
Utilité en Informatique : Les générateurs de nombres pseudo-aléatoires (GNA) sont essentiels pour les simulations, les jeux, la cryptographie (dans certains contextes) et les tests algorithmiques. Le générateur linéaire congruentiel (LCG) est une méthode simple et largement utilisée pour générer des séquences de nombres pseudo-aléatoires.
Un générateur linéaire congruentiel (LCG) est défini par la relation de récurrence : $X_{n+1} = (aX_n + c) \pmod{m}$, où $X_0$ est la graine (valeur initiale), $a$ est le multiplicateur, $c$ est l'incrément, et $m$ est le module. Les paramètres sont choisis pour obtenir de bonnes propriétés statistiques et une longue période avant que la séquence ne se répète.
Considérons un LCG avec les paramètres suivants : $m = 2^{32}$, $a = 1664525$, $c = 1013904223$, et une graine initiale $X_0 = 42$.
Calculez les 5 premiers termes de la suite $(X_n)$ générée par ce LCG : $X_1$, $X_2$, $X_3$, $X_4$, $X_5$. Donnez les valeurs exactes.
Pour utiliser ces nombres pseudo-aléatoires dans un intervalle $[0, 1[$, on calcule $R_n = X_n / m$. Calculez les 5 premiers nombres aléatoires $R_1, R_2, R_3, R_4, R_5$. Donnez les valeurs approchées à $10^{-4}$ près.
Écrivez un court code Python qui implémente ce LCG et affiche les 10 premiers nombres aléatoires $R_n$.
Discutez brièvement de l'importance du choix des paramètres $a$, $c$, et $m$ pour la qualité du générateur de nombres pseudo-aléatoires. Que se passe-t-il si on choisit de mauvais paramètres ?
Utilité en Informatique : La suite de Syracuse, bien que provenant de la théorie des nombres, est souvent utilisée en informatique pour illustrer des concepts algorithmiques comme les boucles, les conditions, et la notion de terminaison d'algorithme. La conjecture de Collatz est un problème ouvert fascinant qui montre comment des suites simples peuvent mener à des comportements complexes et non résolus.
La suite de Syracuse (ou suite de Collatz) est définie de manièrePiecewise par : $U_{n+1} = \begin{cases} \frac{U_n}{2} & \text{si } U_n \text{ est pair} \\ 3U_n + 1 & \text{si } U_n \text{ est impair} \end{cases}$ Avec une valeur de départ $U_0$ (entier positif). La conjecture de Collatz affirme que, quel que soit l'entier de départ $U_0$, la suite finit toujours par atteindre la valeur 1.
Calculez les termes de la suite de Syracuse pour les valeurs initiales suivantes, jusqu'à atteindre la valeur 1 : a) $U_0 = 7$, b) $U_0 = 10$, c) $U_0 = 27$. Comptez le nombre d'étapes nécessaires pour atteindre 1 dans chaque cas.
Écrivez un algorithme en pseudo-code qui prend en entrée une valeur initiale $U_0$ et affiche tous les termes de la suite de Syracuse jusqu'à atteindre la valeur 1, ainsi que le nombre d'étapes.
Implémentez cet algorithme en Python dans Trinket. Testez avec $U_0 = 7$, $U_0 = 10$, $U_0 = 27$ et aussi avec une grande valeur de départ, par exemple $U_0 = 12345$.
La suite de Syracuse est-elle linéaire ? Est-elle géométrique ? Justifiez. Pourquoi est-il difficile d'analyser théoriquement la convergence de cette suite ?