Algorithme de calcul et d’affichage des termes d’une suite récurrente

Bac SC 25-09-23

21 0

Plan de tutoriel

1- Principe de l'algorithme

2- Algorithme de calcul et d’affichage des termes d’une suite récurrente

3- Programme Python

Principe de l'algorithme

Cet algorithme permet de calculer et d’afficher les termes d’une suite numérique définie par récurrence. La suite commence par le terme initial (U₀ = 5) et chaque terme suivant est calculé à partir du terme précédent selon la relation : U_n = 2 x U_n-1 + 5

Tout d’abord, la fonction saisie() demande à l’utilisateur de saisir un entier n strictement supérieur à 0. Une boucle de contrôle permet de répéter la saisie tant que la valeur introduite n’est pas valide.

Ensuite, la procédure suite(n) initialise le premier terme à U = 5, correspondant à (U₀), puis l’affiche. Une boucle for permet de calculer successivement les termes (U₁, U₂, U_n). À chaque répétition, la variable U est mise à jour en appliquant la formule :

U_n = 2 x U_n-1 + 5

Enfin, chaque terme calculé est affiché avec son indice. Ainsi, l’algorithme permet d’obtenir tous les termes de la suite jusqu’au rang n.

Algorithme de calcul et d’affichage des termes d’une suite récurrente

Algorithme du programme Principal

L’algorithme principal SUITE permet de gérer l’exécution du programme en faisant appel aux différentes parties nécessaires au calcul de la suite.

Tout d’abord, il appelle la fonction saisie() afin de demander à l’utilisateur un entier n strictement supérieur à 0. La valeur saisie et validée est ensuite affectée à la variable n.

Ensuite, l’algorithme appelle la procédure suite(n) en lui transmettant la valeur de n. Cette procédure calcule et affiche successivement les termes de la suite, depuis U₀ jusqu’à Uₙ, en utilisant la relation de récurrence : U_n = 2 x U_n-1 + 5

Algorithme SUITE
Debut  
     # Appeler la fonction saisie() pour demander
     # et récupérer le premier entier a supérieur à 0.
     n <-- saisie()
     # Appeler la procédure suite(n) pour calculer
     # et afficher les termes de la suite :
     # U0, U1, ..., Un.
     suite(n)
Fin

Algorithme SUITE

Debut

# Appeler la fonction saisie() pour demander

# et récupérer le premier entier a supérieur à 0.

n <-- saisie()

# Appeler la procédure suite(n) pour calculer

# et afficher les termes de la suite :

# U0, U1, ..., Un.

suite(n)

Fin

Déclaration des objets

Objet	Type / Nature
n	entier

La fonction saisie

La fonction saisie() permet de saisir et de contrôler un entier n. Elle oblige l’utilisateur à entrer une valeur strictement supérieure à 1.

Fonction saisie():entier
Début
    # La variable test permet de contrôler
    # la validité de la valeur saisie par l'utilisateur.
    test <-- Faux
    # Répéter la saisie tant que la valeur de n
    # n'est pas supérieure à 1.
    Tant que test = Faux faire
        # Demander à l'utilisateur de saisir un entier n.
        Ecrire("donner n>1 : "))
        Lire(n)
        # Vérifier que la valeur saisie est supérieure à 1.
        Si n > 1 alors
            # La valeur saisie est correcte.
            # On change test à True pour arrêter la boucle.
            test <-- True
        Fin si
    Fin Tant que 
    # Retourner la valeur de n au programme principal.
    Retourner n 
Fin

Fonction saisie():entier

Début

# La variable test permet de contrôler

# la validité de la valeur saisie par l'utilisateur.

test <-- Faux

# Répéter la saisie tant que la valeur de n

# n'est pas supérieure à 1.

Tant que test = Faux faire

# Demander à l'utilisateur de saisir un entier n.

Ecrire("donner n>1 : "))

Lire(n)

# Vérifier que la valeur saisie est supérieure à 1.

Si n > 1 alors

# La valeur saisie est correcte.

# On change test à True pour arrêter la boucle.

test <-- True

Fin si

Fin Tant que

# Retourner la valeur de n au programme principal.

Retourner n

Fin

Déclaration des objets

Objet	Type / Nature
n	entier

La procédure suite

La procédure suite(n) permet de calculer et d’afficher les termes d’une suite numérique définie par récurrence, depuis le premier terme U₀ jusqu’au terme U_n.

Elle commence par initialiser le premier terme avec U₀ = 5, puis l’affiche. Ensuite, une boucle Pour permet de calculer successivement les termes suivants en appliquant la relation de récurrence : U_n = 2 x U_n-1 + 5

À chaque itération, le nouveau terme est calculé à partir du terme précédent, puis affiché avec son indice.

Ainsi, cette procédure a pour rôle de générer et afficher tous les termes de la suite jusqu’au rang n.

Procédure (n:entier)
Début
    # Initialiser le premier terme de la suite.
    # La suite commence par U0 = 5.
    U <-- 5
    # Afficher le premier terme de la suite.
    Ecrire("U0=", U)
    # Calculer successivement les termes U1, U2, ..., Un.
    # La boucle commence à 1 et s'arrête à n inclus.
    Pour i de 1 à n faire
        # Calculer le terme suivant à partir du terme précédent.
        # La relation de récurrence est :
        # Ui = 2 * U(i-1) + 5
        U <-- 2 * U + 5
        # Afficher le terme calculé avec son indice.
        Ecrire("U", i, "=", U)
    Fin pour
Fin

Procédure (n:entier)

Début

# Initialiser le premier terme de la suite.

# La suite commence par U0 = 5.

U <-- 5

# Afficher le premier terme de la suite.

Ecrire("U0=", U)

# Calculer successivement les termes U1, U2, ..., Un.

# La boucle commence à 1 et s'arrête à n inclus.

Pour i de 1 à n faire

# Calculer le terme suivant à partir du terme précédent.

# La relation de récurrence est :

# Ui = 2 * U(i-1) + 5

U <-- 2 * U + 5

# Afficher le terme calculé avec son indice.

Ecrire("U", i, "=", U)

Fin pour

Fin

Déclaration des objets

Objet	Type / Nature
i	entier
u	entier

Programme en Python

# ==========================================================
# Fonction de saisie
# ==========================================================

def saisie():

    # La variable test permet de contrôler
    # la validité de la valeur saisie par l'utilisateur.
    # Au départ, test vaut False car aucune valeur correcte
    # n'a encore été saisie.
    test = False

    # Répéter la saisie tant que la valeur de n
    # n'est pas correcte.
    while test == False:

        # Demander à l'utilisateur de saisir
        # un entier strictement positif.
        n = int(input("donner un entier n>0 : "))

        # Vérifier si l'entier saisi est strictement
        # supérieur à 0.
        if n > 0:

            # La valeur saisie est correcte.
            # On affecte True à test pour arrêter
            # la boucle de contrôle.
            test = True

    # Retourner la valeur correcte de n
    # vers le programme principal.
    return n


# ==========================================================
# Procédure suite
# ==========================================================

def suite(n):

    # Initialiser le premier terme de la suite.
    # La suite commence par U0 = 5.
    U = 5

    # Afficher le premier terme de la suite.
    print("U0=", U)

    # Calculer successivement les termes U1, U2, ..., Un.
    # La boucle commence à 1 et s'arrête à n inclus.
    for i in range(1, n + 1):

        # Calculer le terme suivant à partir du terme précédent.
        # La relation de récurrence est :
        # Ui = 2 * U(i-1) + 5
        U = 2 * U + 5

        # Afficher le terme calculé avec son indice.
        print("U", i, "=", U)


# ==========================================================
# Programme principal
# ==========================================================

# Appeler la fonction saisie() pour demander
# à l'utilisateur un entier n strictement positif.
# La valeur retournée est affectée à la variable n.
n = saisie()

# Appeler la procédure suite(n) pour calculer
# et afficher les termes de la suite :
# U0, U1, ..., Un.
suite(n)