TD 3 corrigé sur les suites en Scilab

Exercice 1

Calcul de séries numériques

Niveau : Débutant Durée : 30 min

Écrire un programme qui calcule les différentes séries suivantes pour un entier N donné par l'utilisateur :

Détail des séries à calculer :

S1 : Somme des inverses de 1 à N (série harmonique partielle)
S2 : Somme des inverses des entiers pairs de 2 à N
S3 : Somme alternée des inverses des entiers pairs (signe + puis -)
S4 : Somme des puissances de x (1 + x + x² + ... + x^N)

Exemple 1

Entrée

N = 5
x = 2

Sortie

S1 = 2.28333
S2 = 1.5
S3 = 0.5
S4 = 63

Explication : Pour N=5, S1 = 1 + 1/2 + 1/3 + 1/4 + 1/5 ≈ 2.28333
S2 = 1 + 1/2 + 1/4 = 1.75 (correction : 1.5)
S4 = 1 + 2 + 4 + 8 + 16 + 32 = 63

Besoin d'un indice ?

Pour S1, initialisez s1 à 1 et ajoutez 1/i pour i de 2 à N
Pour S2, parcourez i avec un pas de 2 (i=2,4,6...)
Pour S3, utilisez une variable "signe" qui alterne entre +1 et -1
Pour S4, utilisez la fonction puissance ou une multiplication itérative

Solution détaillée

Principe : Chaque série est calculée par une boucle avec des règles spécifiques.

N = input("saisir N ");
x = input("saisir x ");

// S1 : somme des inverses de 1 à N
s1 = 1;
for i = 2:N
    s1 = s1 + (1/i);
end
disp("S1 =", s1);

// S2 : somme des inverses des entiers pairs
s2 = 1;
for i = 2:2:N
    s2 = s2 + (1/i);
end
disp("S2 =", s2);

// S3 : somme alternée des inverses des entiers pairs
s3 = 1;
signe = -1;
for i = 2:2:N
    s3 = s3 + signe * (1/i);
    signe = signe * (-1);
end
disp("S3 =", s3);

// S4 : somme des puissances de x
s4 = 1;
for i = 1:N
    s4 = s4 + (x^i);
end
disp("S4 =", s4);

N = int(input("saisir N : "))
x = float(input("saisir x : "))

# S1 : somme des inverses de 1 à N
s1 = 1
for i in range(2, N+1):
    s1 += 1/i
print(f"S1 = {s1}")

# S2 : somme des inverses des entiers pairs
s2 = 1
for i in range(2, N+1, 2):
    s2 += 1/i
print(f"S2 = {s2}")

# S3 : somme alternée des inverses des entiers pairs
s3 = 1
signe = -1
for i in range(2, N+1, 2):
    s3 += signe * (1/i)
    signe *= -1
print(f"S3 = {s3}")

# S4 : somme des puissances de x
s4 = 1
for i in range(1, N+1):
    s4 += x**i
print(f"S4 = {s4}")

#include <stdio.h>
#include <math.h>

int main() {
    int N, i, signe;
    float x, s1, s2, s3, s4;
    
    printf("saisir N : ");
    scanf("%d", &N);
    printf("saisir x : ");
    scanf("%f", &x);
    
    // S1 : somme des inverses de 1 à N
    s1 = 1;
    for(i = 2; i <= N; i++) {
        s1 += 1.0 / i;
    }
    printf("S1 = %f\n", s1);
    
    // S2 : somme des inverses des entiers pairs
    s2 = 1;
    for(i = 2; i <= N; i += 2) {
        s2 += 1.0 / i;
    }
    printf("S2 = %f\n", s2);
    
    // S3 : somme alternée des inverses des entiers pairs
    s3 = 1;
    signe = -1;
    for(i = 2; i <= N; i += 2) {
        s3 += signe * (1.0 / i);
        signe *= -1;
    }
    printf("S3 = %f\n", s3);
    
    // S4 : somme des puissances de x
    s4 = 1;
    for(i = 1; i <= N; i++) {
        s4 += pow(x, i);
    }
    printf("S4 = %f\n", s4);
    
    return 0;
}

Exercice 2

Suite récurrente avec alternance de signe

Niveau : Débutant Durée : 20 min

Écrire un programme qui détermine le 20^ème terme d'une suite définie par :

S₀ = 2
S₁ = 3
S_n = S_n-1 + (-1)ⁿ × S_n-2 pour n ≥ 2

Objectif : Calculer et afficher la valeur de S₂₀.

Exemple 1

Entrée

s1= 2
s2 = 2

Sortie

Le 20ème terme est : -... (à calculer)

Explication : Les premiers termes : S0=2, S1=3, S2=3+(-1)²×2=5, S3=5+(-1)³×3=2, S4=2+(-1)⁴×5=7, etc.

Besoin d'un indice ?

Vous devez garder en mémoire les deux derniers termes calculés
La puissance (-1)ⁿ vaut 1 si n est pair, -1 si n est impair
Initialisez s1 = 2, s2 = 3, puis itérez de 3 à 20

Solution détaillée

Principe : Suite récurrente d'ordre 2 : chaque terme dépend des deux précédents.

s1 = 2;  // S0
s2 = 3;  // S1

for i = 3:20
    s = s2 + ((-1)^i) * s1
    s1 = s2
    s2 = s
end

disp("Le 20ème terme est :", s2)

s1 = 2  # S0
s2 = 3  # S1

for i in range(3, 21):
    s = s2 + ((-1)**i) * s1
    s1, s2 = s2, s

print(f"Le 20ème terme est : {s2}")

#include <stdio.h>
#include <math.h>

int main() {
    int s1 = 2;  // S0
    int s2 = 3;  // S1
    int s, i;
    
    for(i = 3; i <= 20; i++) {
        s = s2 + (int)pow(-1, i) * s1;
        s1 = s2;
        s2 = s;
    }
    
    printf("Le 20ème terme est : %d\n", s2);
    return 0;
}

Exercice 3

Suite de Collatz (conjecture de Syracuse)

Niveau : Intermédiaire Durée : 30 min

Soit la suite U définie par :

Cette suite aboutit au cycle redondant formé par les trois termes 4, 2, 1 à partir d'un certain rang (conjecture de Collatz).

Exemple 1

Entrée

U0 = 7

Sortie

7 → 22 → 11 → 34 → 17 → 52 → 26 → 13 → 40 → 20 → 10 → 5 → 16 → 8 → 4
Rang = 14

Explication : Pour U0 = 7, il faut 14 itérations pour atteindre 4 (premier élément du cycle). À partir de là, la suite sera 4 → 2 → 1 → 4...

Exemple 2

Entrée

U0 = 6

Sortie

6 → 3 → 10 → 5 → 16 → 8 → 4
Rang = 6

Besoin d'un indice ?

La suite entre dans le cycle quand on atteint la valeur 4 pour la première fois
Il faut compter le nombre d'itérations jusqu'à obtenir U = 4
Attention à ne pas confondre l'indice (rang) et la valeur

Solution détaillée

Principe : On génère aléatoirement la valeur initiale, puis on applique les règles de la suite jusqu'à atteindre la valeur 4. Le nombre d'itérations donne le rang recherché.
Cas particuliers :
- Si U₀ = 1, 2 ou 4, le rang est 0 (déjà dans le cycle)
- La conjecture de Collatz affirme que la suite atteint toujours 1 (donc 4) quel que soit le nombre de départ

// Génération aléatoire de U0 entre 3 et 40
U = grand("uin", 3, 40)
disp("Valeur initiale U0 =", U)

rang = 0

// Tant qu'on n'a pas atteint 4
while U <> 4
    rang = rang + 1
    if modulo(U, 2) == 0 then
        U = U / 2
    else
        U = 3 * U + 1
    end
end

disp("La suite U entre dans le cycle redondant à partir du rang =", rang)

import random

# Génération aléatoire de U0 entre 3 et 40
U = random.randint(3, 40)
print(f"Valeur initiale U0 = {U}")

rang = 0

# Tant qu'on n'a pas atteint 4
while U != 4:
    rang += 1
    if U % 2 == 0:
        U = U // 2
    else:
        U = 3 * U + 1

print(f"La suite U entre dans le cycle redondant à partir du rang = {rang}")

# Pour visualiser la suite
U = random.randint(3, 40)  # Nouvelle valeur
print(f"\nDémonstration avec U0 = {U}:")
valeurs = [U]
rang = 0
while U != 4:
    rang += 1
    if U % 2 == 0:
        U = U // 2
    else:
        U = 3 * U + 1
    valeurs.append(U)
print(" → ".join(str(v) for v in valeurs))
print(f"Rang d'entrée dans le cycle: {rang}")

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main() {
    // Initialisation du générateur aléatoire
    srand(time(NULL));
    
    // Génération aléatoire de U0 entre 3 et 40
    int U = rand() % 38 + 3;  // 38 nombres possibles (3 à 40)
    printf("Valeur initiale U0 = %d\n", U);
    
    int rang = 0;
    int U_original = U;  // Sauvegarde pour l'affichage
    
    // Tant qu'on n'a pas atteint 4
    while (U != 4) {
        rang++;
        if (U % 2 == 0) {
            U = U / 2;
        } else {
            U = 3 * U + 1;
        }
    }
    
    printf("La suite U entre dans le cycle redondant à partir du rang = %d\n", rang);
    
    // Version avec affichage de la suite
    printf("\nDémonstration avec U0 = %d:\n", U_original);
    U = U_original;
    printf("%d", U);
    while (U != 4) {
        if (U % 2 == 0) {
            U = U / 2;
        } else {
            U = 3 * U + 1;
        }
        printf(" → %d", U);
    }
    printf("\n");
    
    return 0;
}

Exercice 4

Suites imbriquées et calcul de sommes

Niveau : Intermédiaire Durée : 45 min

Écrire un programme demandant un entier n à l'utilisateur et affichant la valeur de :

Exemple pour n = 5

Entrée

n = 5

Sortie

Expression 1 = 7.168
Expression 2 = 1152
Expression 3 = 152.847

Détail des calculs :
Expr1: U₁=1, U₂=√2≈1.414, U₃=√(1.414+2)=√3.414≈1.848, U₄=√(1.848+3)=√4.848≈2.202, U₅=√(2.202+4)=√6.202≈2.490
Somme = 1 + 1.414 + 1.848 + 2.202 + 2.490 = 8.954 (valeur approximative, diffère selon les arrondis)
Expr2: U₁=1, U₂=2, U₃=2+1×1=3, U₄=3+2×2=7, U₅=7+3×3=16 → Produit = 1×2×3×7×16 = 672 (et non 1152 - vérifier l'énoncé original)

Besoin d'un indice ?

Expression 1 : Initialisez u = 1, s = 1, puis pour i de 1 à n-1 : u = sqrt(u + i) et s = s + u
Expression 2 : Gardez les deux derniers termes (u1 et u2) et mettez à jour à chaque itération
Expression 3 : Stockez l'ancienne valeur de u dans une variable temporaire avant de la modifier

Solution détaillée

Principe : Chaque expression nécessite une approche différente pour gérer les relations de récurrence.

n = input("saisir n = ");

// Expression 1 : Suite avec racines carrées
u = 1
s1 = 1
for i = 1:n-1
    u = sqrt(u + i)
    s1 = s1 + u
end
disp("Expression 1 (somme) =", s1)

// Expression 2 : Produit de termes
u1 = 1
u2 = 2
p = 2  // produit initial = u1 * u2
for i = 3:n
    u = u2 + (i-2) * u1
    u1 = u2
    u2 = u
    p = p * u
end
disp("Expression 2 (produit) =", p)

// Expression 3 : Suites couplées
u = 1
v = 2
s3 = u * v  // premier terme u1*v1
for i = 2:n
    ancien_u = u  // stocker u(i-1)
    u = 3 * u + sqrt(v)
    v = (1/i) * ancien_u + v
    s3 = s3 + u * v
end
disp("Expression 3 (somme des produits) =", s3)

import math

n = int(input("saisir n = "))

# Expression 1 : Suite avec racines carrées
u = 1
s1 = 1
for i in range(1, n):
    u = math.sqrt(u + i)
    s1 += u
print(f"Expression 1 (somme) = {s1}")

# Expression 2 : Produit de termes
u1, u2 = 1, 2
p = u1 * u2  # produit initial
for i in range(3, n+1):
    u = u2 + (i-2) * u1
    u1, u2 = u2, u
    p *= u
print(f"Expression 2 (produit) = {p}")

# Expression 3 : Suites couplées
u, v = 1, 2
s3 = u * v  # premier terme
for i in range(2, n+1):
    ancien_u = u  # stocker u(i-1)
    u = 3 * u + math.sqrt(v)
    v = (1/i) * ancien_u + v
    s3 += u * v
print(f"Expression 3 (somme des produits) = {s3}")

#include <stdio.h>
#include <math.h>

int main() {
    int n, i;
    float u, u1, u2, p, s1, s3, v, ancien_u;
    
    printf("saisir n = ");
    scanf("%d", &n);
    
    // Expression 1 : Suite avec racines carrées
    u = 1;
    s1 = 1;
    for(i = 1; i < n; i++) {
        u = sqrt(u + i);
        s1 += u;
    }
    printf("Expression 1 (somme) = %f\n", s1);
    
    // Expression 2 : Produit de termes
    u1 = 1;
    u2 = 2;
    p = u1 * u2;  // produit initial
    for(i = 3; i <= n; i++) {
        u = u2 + (i-2) * u1;
        u1 = u2;
        u2 = u;
        p *= u;
    }
    printf("Expression 2 (produit) = %f\n", p);
    
    // Expression 3 : Suites couplées
    u = 1;
    v = 2;
    s3 = u * v;  // premier terme
    for(i = 2; i <= n; i++) {
        ancien_u = u;  // stocker u(i-1)
        u = 3 * u + sqrt(v);
        v = (1.0/i) * ancien_u + v;
        s3 += u * v;
    }
    printf("Expression 3 (somme des produits) = %f\n", s3);
    
    return 0;
}

Exercice 5

Approximation du nombre e par la série de Taylor

Niveau : Intermédiaire Durée : 25 min

On veut obtenir une bonne approximation du nombre e (base des logarithmes naturels, environ 2.71828...). Pour cela, on construit une suite de nombres réels de la façon suivante :

U₀ = 1 et pour chaque entier n > 0, Uₙ = Uₙ₋₁ + 1/n!

avec n! = 1 × 2 × 3 × ... × n

Cette suite converge vers le nombre e quand n tend vers l'infini.

Phénomène numérique : Le terme 1/n! tend rapidement vers zéro. À partir d'un certain rang, à cause des imprécisions de la représentation des nombres réels en machine, on aura Uₙ = Uₙ₋₁ (la valeur n'évolue plus).

Objectif : Écrire un programme qui calcule et affiche la valeur de e ≈ Uₙ ainsi que le premier rang n qui vérifie Uₙ = Uₙ₋₁ (c'est-à-dire quand l'ajout du terme suivant ne change plus la valeur en raison de la précision machine).

Exemple d'exécution

Sortie typique

Valeur approximative de e = 2.718281828459045
Rang n = 18
Dernier terme ajouté = 1/18! = 1.216e-16

Explication : La série converge vers e ≈ 2.718281828459045. En double précision, le dernier terme significatif est 1/18! ≈ 1.2×10⁻¹⁶, en dessous de la précision machine.

Besoin d'un indice ?

Calculez la factorielle progressivement pour éviter les dépassements
Comparez Uₙ et Uₙ₋₁ avec un seuil de tolérance ou directement avec l'opérateur d'égalité
La convergence est très rapide : n ne dépassera pas 20 en pratique

Solution détaillée

Principe : On utilise le développement en série de Taylor de eˣ en x=1 : e = ∑(1/n!) de n=0 à ∞.
Précision machine : En simple précision (float), la convergence s'arrête vers n=8-10. En double précision (double), vers n=15-20.

U1 = 1        // U0
U2 = U1 + 1   // U1 = 2
n = 2
f = 1         // factorielle (1! = 1)

while U1 <> U2
    f = f * n        // mise à jour de la factorielle : n!
    n = n + 1
    U1 = U2
    U2 = U1 + (1/f)
end

disp("Valeur approximative de e =", U2)
disp("Rang n où la convergence est atteinte =", n-1)
disp("Dernier terme ajouté 1/n! =", 1/f)

# Version simple
U_prev = 1.0  # U0
U_curr = U_prev + 1.0  # U1
n = 2
fact = 1.0  # 1!

while U_prev != U_curr:
    fact *= n  # mise à jour de la factorielle
    n += 1
    U_prev, U_curr = U_curr, U_curr + 1.0/fact

print(f"Valeur approximative de e = {U_curr}")
print(f"Rang n = {n-1}")
print(f"Dernier terme ajouté = 1/{n-1}! = {1/fact}")

# Version avec affichage de la progression
print("\nProgression de la série :")
U = 1.0
fact = 1.0
print(f"n=0: U = {U}")
for i in range(1, 20):
    fact *= i
    U += 1.0/fact
    print(f"n={i}: U = {U} (ajout 1/{i}! = {1/fact:.10f})")

#include <stdio.h>

int main() {
    double U_prev = 1.0;  // U0
    double U_curr = U_prev + 1.0;  // U1
    int n = 2;
    double fact = 1.0;  // 1!
    
    while (U_prev != U_curr) {
        fact *= n;  // mise à jour de la factorielle
        n++;
        U_prev = U_curr;
        U_curr = U_prev + 1.0 / fact;
    }
    
    printf("Valeur approximative de e = %.15f\n", U_curr);
    printf("Rang n = %d\n", n-1);
    printf("Dernier terme ajouté = 1/%d! = %.15f\n", n-1, 1.0/fact);
    
    // Version avec affichage détaillé
    printf("\nProgression détaillée:\n");
    U_prev = 1.0;
    fact = 1.0;
    printf("n=0: U = %.15f\n", U_prev);
    for(int i = 1; i <= 20; i++) {
        fact *= i;
        U_prev += 1.0/fact;
        printf("n=%d: U = %.15f (ajout 1/%d! = %.15f)\n", 
               i, U_prev, i, 1.0/fact);
    }
    
    return 0;
}

Sortie

// La sortie apparaîtra ici…

Prêt · Ctrl+Entrée pour exécuter

Précédent TD 2 corrigé sur les boucles en Scilab

Calcul de séries numériques

Suite récurrente avec alternance de signe

Suite de Collatz (conjecture de Syracuse)

Suites imbriquées et calcul de sommes

Approximation du nombre e par la série de Taylor

Discussion (0)

Laisser un commentaire

Structures de données

Algorithmes

Programmation

Bases de données

CPGE

Modules informatique

TD 3 corrigé sur les suites en Scilab

Calcul de séries numériques

Suite récurrente avec alternance de signe

Suite de Collatz (conjecture de Syracuse)

Suites imbriquées et calcul de sommes

Approximation du nombre e par la série de Taylor

Discussion (0)

Laisser un commentaire