Suite arithmético-géométrique : \(u_0 = 1\) et \(u_{n+1} = 2u_n + 3\).
- Initialiser le premier terme
- Itérer la relation de récurrence
- Calculer chaque terme à partir du précédent
- Stocker ou afficher les résultats
Variables u, i, n : entiers
Début
n ← 10
u ← 1 // u₀ = 1
Afficher("u₀ = ", u)
Pour i de 1 à n-1 Faire
u ← 2*u + 3 // uₙ₊₁ = 2uₙ + 3
Afficher("u", i, " = ", u)
FinPour
Fin
u₀ = 1
u₁ = 2×1 + 3 = 5
u₂ = 2×5 + 3 = 13
u₃ = 2×13 + 3 = 29
u₄ = 2×29 + 3 = 61
La suite peut être exprimée comme : \(u_n = 2 \times 2^n - 3 = 2^{n+1} - 3\)
| n | uₙ |
|---|---|
| 0 | 1 |
| 1 | 5 |
| 2 | 13 |
| 3 | 29 |
| 4 | 61 |
| 5 | 125 |
Les 10 premiers termes sont calculés en itérant la relation de récurrence uₙ₊₁ = 2uₙ + 3.
• Itération : Chaque terme est calculé à partir du précédent
• Récurrence : Relation entre termes successifs
• Initialisation : Valeur de départ indispensable
La suite croît exponentiellement à cause du facteur 2
Chaque itération double le terme précédent et ajoute 3
Somme des carrés : \(S_n = \sum_{i=1}^{n} i^2 = 1^2 + 2^2 + 3^2 + ... + n^2\).
Variables n, i, somme : entiers
Début
Afficher("Entrez la valeur de n : ")
Lire(n)
somme ← 0 // Initialisation de l'accumulateur
Pour i de 1 à n Faire
somme ← somme + i*i // Ajouter le carré de i
FinPour
Afficher("La somme des carrés de 1 à ", n, " est : ", somme)
Fin
Variables : n (entrée), i (compteur), somme (accumulateur)
somme ← 0 (initialisation indispensable pour l'addition)
Pour i de 1 à n : i prend successivement les valeurs 1, 2, ..., n
somme ← somme + i*i : chaque carré est ajouté à la somme
i=1: somme=0+1²=1
i=2: somme=1+2²=1+4=5
i=3: somme=5+3²=5+9=14
i=4: somme=14+4²=14+16=30
La somme des carrés a une formule close : \(S_n = \frac{n(n+1)(2n+1)}{6}\)
Pour n=4 : S₄ = 4×5×9/6 = 180/6 = 30 ✓
L'algorithme calcule la somme des carrés en itérant et accumulant chaque carré.
• Accumulation : L'accumulateur doit être initialisé à 0
• Itération : Chaque terme est calculé et ajouté
• Validation : Comparaison avec la formule mathématique
L'initialisation de l'accumulateur est cruciale pour le bon fonctionnement
Chaque itération ajoute un terme supplémentaire à la somme
Factorielle : \(n! = 1 \times 2 \times 3 \times ... \times n\), avec \(0! = 1\).
Variables n, i, fact : entiers
Début
Afficher("Entrez la valeur de n : ")
Lire(n)
Si n = 0 Alors
fact ← 1 // 0! = 1 par définition
Sinon
fact ← 1 // Initialisation pour la multiplication
Pour i de 1 à n Faire
fact ← fact * i // Multiplier par i
FinPour
FinSi
Afficher("La factorielle de ", n, " est : ", fact)
Fin
0! = 1 par convention mathématique
fact ← 1 (initialisation à 1 pour la multiplication)
Pour i de 1 à n : i prend les valeurs 1, 2, ..., n
fact ← fact * i : chaque valeur est multipliée à la factorielle
i=1: fact=1×1=1
i=2: fact=1×2=2
i=3: fact=2×3=6
i=4: fact=6×4=24
i=5: fact=24×5=120
La factorielle croît très rapidement : 5!=120, 10!=3,628,800
L'algorithme calcule la factorielle en itérant et multipliant chaque entier.
• Initialisation : Pour la multiplication, initialiser à 1
• Itération : Chaque facteur est multiplié successivement
• Cas particulier : Gérer le cas n=0
Pour les produits, initialiser l'accumulateur à 1 (élément neutre)
La factorielle croît très rapidement avec n
Méthode de Héron : \(u_{n+1} = \frac{u_n + \frac{a}{u_n}}{2}\) pour approcher \(\sqrt{a}\).
Variables a, u, u_prec, precision : réels
Variables i, max_iter : entiers
Début
Afficher("Entrez le nombre dont vous voulez la racine : ")
Lire(a)
Afficher("Entrez la précision souhaitée : ")
Lire(precision)
u ← a/2 // Estimation initiale
max_iter ← 100 // Limite d'itérations
Pour i de 1 à max_iter Faire
u_prec ← u
u ← (u + a/u) / 2 // Formule de Héron
Si |u - u_prec| < precision Alors
Afficher("Racine carrée de ", a, " ≈ ", u)
Afficher("Trouvée en ", i, " itérations")
Sortir de la boucle
FinSi
FinPour
Si i = max_iter Alors
Afficher("La méthode n'a pas convergé")
FinSi
Fin
u ← a/2 (estimation initiale raisonnable)
max_iter ← 100 (limite pour éviter boucle infinie)
\(u_{n+1} = \frac{u_n + \frac{a}{u_n}}{2}\)
Chaque itération rapproche u de \(\sqrt{a}\)
Arrêt quand |u - u_prec| < précision
Ou après un nombre maximal d'itérations
u₀ = 12.5
u₁ = (12.5 + 25/12.5)/2 = (12.5 + 2)/2 = 7.25
u₂ = (7.25 + 25/7.25)/2 ≈ 5.39
u₃ ≈ 5.01, u₄ ≈ 5.00 (proche de √25 = 5)
Convergence quadratique (très rapide)
La méthode double approximativement le nombre de décimales correctes à chaque itération
La méthode de Héron converge rapidement vers la racine carrée par itérations successives.
• Convergence : Méthode itérative qui s'approche de la solution
• Critère d'arrêt : Différence suffisamment petite entre itérations
• Prévention : Limite d'itérations pour éviter boucle infinie
La méthode de Héron converge quadratiquement (très efficace)
Chaque itération améliore significativement la précision
Suite de Fibonacci : \(u_0 = 0, u_1 = 1, u_n = u_{n-1} + u_{n-2}\) pour \(n \geq 2\).
Variables n, i, u_prec2, u_prec1, u : entiers
Début
Afficher("Entrez le rang n : ")
Lire(n)
Si n = 0 Alors
u ← 0
Sinon Si n = 1 Alors
u ← 1
Sinon
u_prec2 ← 0 // u₀
u_prec1 ← 1 // u₁
Pour i de 2 à n Faire
u ← u_prec1 + u_prec2 // uₙ = uₙ₋₁ + uₙ₋₂
u_prec2 ← u_prec1 // Décaler les valeurs
u_prec1 ← u
FinPour
FinSi
Afficher("Le terme u_", n, " de la suite de Fibonacci est : ", u)
Fin
u₀ = 0, u₁ = 1 (valeurs initiales)
u_prec2 stocke uₙ₋₂
u_prec1 stocke uₙ₋₁
u stocke uₙ
u ← u_prec1 + u_prec2 (calcul du nouveau terme)
Décaler les variables pour la prochaine itération
i=2: u=1+0=1, u_prec2=0, u_prec1=1
i=3: u=1+1=2, u_prec2=1, u_prec1=2
i=4: u=2+1=3, u_prec2=1, u_prec1=3
i=5: u=3+2=5, u_prec2=2, u_prec1=5
i=6: u=5+3=8, u_prec2=3, u_prec1=8
La suite de Fibonacci apparaît dans de nombreux phénomènes naturels
Le rapport uₙ/uₙ₋₁ tend vers le nombre d'or φ ≈ 1.618
L'algorithme calcule le n-ième terme de la suite de Fibonacci par itérations successives.
• Récurrence : Chaque terme dépend des deux précédents
• Stockage : Garder les deux derniers termes pour le calcul
• Efficacité : Version itérative plus efficace que récursive
La version itérative est beaucoup plus efficace que la version récursive
La suite de Fibonacci illustre bien les calculs itératifs avec dépendance
- Identifier le motif : Reconnaître la relation de récurrence
- Initialiser : Définir les valeurs de départ
- Itérer : Appliquer la relation de proche en proche
- Conserver : Stocker les valeurs nécessaires
- Arrêter : Définir un critère d'arrêt approprié
- Les calculs itératifs répètent une opération avec des valeurs mises à jour
- Les accumulateurs doivent être initialisés correctement (0 pour somme, 1 pour produit)
- Les suites définies par récurrence nécessitent des valeurs initiales
- Les méthodes itératives peuvent converger vers une solution
- Il faut toujours prévoir un critère d'arrêt pour éviter les boucles infinies