Mathématiques1ère

Calculs itératifs
Exercices corrigés

Maîtrisez les calculs itératifs : suites numériques, sommes, produits, factorielles, approximations grâce à ces 5 exercices détaillés.

Concepts & Exercices
\(\text{Suite} : u_{n+1} = f(u_n) \xrightarrow[\text{Itérations}]{\text{Calculs}} \text{Résultats}\)
Calculs itératifs
🔢
Suites : Séquences de valeurs calculées itérativement.
Sommes : Accumulation de valeurs au fil des itérations.
✖️
Produits : Multiplication cumulative de termes.
🔄
Itérations : Répétition d'opérations pour convergence.
Exercice 1
Écrire un algorithme qui calcule les 10 premiers termes de la suite définie par u₀ = 1 et uₙ₊₁ = 2uₙ + 3.
Exercice 2
Écrire un algorithme qui calcule la somme des carrés des n premiers entiers naturels.
Exercice 3
Écrire un algorithme qui calcule la factorielle d'un nombre n en utilisant une boucle itérative.
Exercice 4
Écrire un algorithme qui approxime √a en utilisant la méthode de Héron : uₙ₊₁ = (uₙ + a/uₙ)/2.
Exercice 5
Écrire un algorithme qui calcule le terme uₙ de la suite de Fibonacci : u₀ = 0, u₁ = 1, uₙ = uₙ₋₁ + uₙ₋₂.
Corrigé : Exercices 1 à 3
1 Suite arithmético-géométrique
Définition :

Suite arithmético-géométrique : \(u_0 = 1\) et \(u_{n+1} = 2u_n + 3\).

Méthode de calcul :
  1. Initialiser le premier terme
  2. Itérer la relation de récurrence
  3. Calculer chaque terme à partir du précédent
  4. Stocker ou afficher les résultats
Algorithme complet
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
Étape 1 : Calcul des premiers termes

u₀ = 1

u₁ = 2×1 + 3 = 5

u₂ = 2×5 + 3 = 13

u₃ = 2×13 + 3 = 29

u₄ = 2×29 + 3 = 61

Étape 2 : Formule générale

La suite peut être exprimée comme : \(u_n = 2 \times 2^n - 3 = 2^{n+1} - 3\)

Étape 3 : Tableau de valeurs
n uₙ
01
15
213
329
461
5125
Réponse finale :

Les 10 premiers termes sont calculés en itérant la relation de récurrence uₙ₊₁ = 2uₙ + 3.

Règles appliquées :

Itération : Chaque terme est calculé à partir du précédent

Récurrence : Relation entre termes successifs

Initialisation : Valeur de départ indispensable

Point clé 1

La suite croît exponentiellement à cause du facteur 2

Point clé 2

Chaque itération double le terme précédent et ajoute 3

2 Somme des carrés
Définition :

Somme des carrés : \(S_n = \sum_{i=1}^{n} i^2 = 1^2 + 2^2 + 3^2 + ... + n^2\).

Algorithme itératif
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
Étape 1 : Variables et initialisation

Variables : n (entrée), i (compteur), somme (accumulateur)

somme ← 0 (initialisation indispensable pour l'addition)

Étape 2 : Boucle d'itération

Pour i de 1 à n : i prend successivement les valeurs 1, 2, ..., n

somme ← somme + i*i : chaque carré est ajouté à la somme

Étape 3 : Trace de l'exécution (pour n=4)

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

Étape 4 : Formule mathématique

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 ✓

Réponse finale :

L'algorithme calcule la somme des carrés en itérant et accumulant chaque carré.

Règles appliquées :

Accumulation : L'accumulateur doit être initialisé à 0

Itération : Chaque terme est calculé et ajouté

Validation : Comparaison avec la formule mathématique

Point clé 1

L'initialisation de l'accumulateur est cruciale pour le bon fonctionnement

Point clé 2

Chaque itération ajoute un terme supplémentaire à la somme

3 Calcul de factorielle
Définition :

Factorielle : \(n! = 1 \times 2 \times 3 \times ... \times n\), avec \(0! = 1\).

Algorithme itératif
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
Étape 1 : Cas particulier

0! = 1 par convention mathématique

Étape 2 : Initialisation

fact ← 1 (initialisation à 1 pour la multiplication)

Étape 3 : Boucle d'itération

Pour i de 1 à n : i prend les valeurs 1, 2, ..., n

fact ← fact * i : chaque valeur est multipliée à la factorielle

Étape 4 : Trace de l'exécution (pour n=5)

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

Étape 5 : Complexité

La factorielle croît très rapidement : 5!=120, 10!=3,628,800

Réponse finale :

L'algorithme calcule la factorielle en itérant et multipliant chaque entier.

Règles appliquées :

Initialisation : Pour la multiplication, initialiser à 1

Itération : Chaque facteur est multiplié successivement

Cas particulier : Gérer le cas n=0

Point clé 1

Pour les produits, initialiser l'accumulateur à 1 (élément neutre)

Point clé 2

La factorielle croît très rapidement avec n

Corrigé : Exercices 4 à 5
4 Méthode de Héron
Définition :

Méthode de Héron : \(u_{n+1} = \frac{u_n + \frac{a}{u_n}}{2}\) pour approcher \(\sqrt{a}\).

Algorithme d'approximation
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
Étape 1 : Initialisation

u ← a/2 (estimation initiale raisonnable)

max_iter ← 100 (limite pour éviter boucle infinie)

Étape 2 : Itération de Héron

\(u_{n+1} = \frac{u_n + \frac{a}{u_n}}{2}\)

Chaque itération rapproche u de \(\sqrt{a}\)

Étape 3 : Critère d'arrêt

Arrêt quand |u - u_prec| < précision

Ou après un nombre maximal d'itérations

Étape 4 : Exemple de calcul (a=25)

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)

Étape 5 : Propriétés de la méthode

Convergence quadratique (très rapide)

La méthode double approximativement le nombre de décimales correctes à chaque itération

Réponse finale :

La méthode de Héron converge rapidement vers la racine carrée par itérations successives.

Règles appliquées :

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

Point clé 1

La méthode de Héron converge quadratiquement (très efficace)

Point clé 2

Chaque itération améliore significativement la précision

5 Suite de Fibonacci
Définition :

Suite de Fibonacci : \(u_0 = 0, u_1 = 1, u_n = u_{n-1} + u_{n-2}\) pour \(n \geq 2\).

Algorithme itératif
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
Étape 1 : Cas particuliers

u₀ = 0, u₁ = 1 (valeurs initiales)

Étape 2 : Variables de décalage

u_prec2 stocke uₙ₋₂

u_prec1 stocke uₙ₋₁

u stocke uₙ

Étape 3 : Itération

u ← u_prec1 + u_prec2 (calcul du nouveau terme)

Décaler les variables pour la prochaine itération

Étape 4 : Trace de l'exécution (pour n=6)

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

Étape 5 : Propriétés de la suite

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

Réponse finale :

L'algorithme calcule le n-ième terme de la suite de Fibonacci par itérations successives.

Règles appliquées :

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

Point clé 1

La version itérative est beaucoup plus efficace que la version récursive

Point clé 2

La suite de Fibonacci illustre bien les calculs itératifs avec dépendance

Cours bien détaillé
\(\text{u}_{n+1} = f(\text{u}_n) \xrightarrow[\text{Itérations}]{\text{Calculs}} \text{Comportement asymptotique}\)
Calculs itératifs
🔢
Suites : Séquences définies par une relation de récurrence.
Sommes : Accumulation itérative de valeurs.
🔄
Itérations : Répétition d'opérations pour convergence.
Convergence : Propriété de certaines suites itératives.
💡
Conseil : Toujours initialiser les accumulateurs correctement
🔍
Attention : Vérifier la convergence des méthodes itératives
Astuce : Utiliser des variables auxiliaires pour les suites à plusieurs termes
📋
Méthode : Calculer quelques termes à la main pour vérifier
Vérification : Comparer avec des formules connues si disponibles
Méthodologie de calcul itératif :
  1. Identifier le motif : Reconnaître la relation de récurrence
  2. Initialiser : Définir les valeurs de départ
  3. Itérer : Appliquer la relation de proche en proche
  4. Conserver : Stocker les valeurs nécessaires
  5. Arrêter : Définir un critère d'arrêt approprié
Règles fondamentales :
  • 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
\(\text{u}_{n+1} = \text{f}(\text{u}_n, \text{u}_{n-1}, ...) \text{ avec conditions initiales}\)
Relation de récurrence
Calculs itératifs Applications de programmation