Exercices corrigés - suites - Python et Langage C - TD5

Do you want to read our courses in English? please visit our new website cs-teachers.com Click here

Exercices corrigés - suites - Python et Langage C - TD5

Exercice 1

On se propose de calculer une valeur approchée de la constante K de Catalan en utilisant la formule suivante :

Nombre de Catalan

Ecrire une fonction val_app(epsilon) qui permet de retourner une valeur approchée de la constante K en utilisant la formule ci-dessus et en s’arrêtant dès que la valeur absolue de la différence entre deux somme successives devienne inférieure ou égale à une erreur epsilon donnée en paramètre.


Solution :
                                                #include <stdio.h>
                                                #include <math.h>
                                                float val_app(float epsilon)
                                                {
                                                    float elm1, elm2;
                                                    int signe, val;
                                                    elm1 = 1;
                                                    elm2 = elm1 - 1 / (pow(3, 2));
                                                    signe = 1;
                                                    val = 5;
                                                    while (fabsf(elm2 - elm1) > epsilon)
                                                    {
                                                        elm1 = elm2;
                                                        elm2 = elm1 + signe * (1 / (pow(val, 2)));
                                                        val += 2;
                                                        signe *= (-1);
                                                    }
                                                    return elm2;
                                                }
                                                int main(void)
                                                {
                                                    printf("val_app(0.05) = %f \n", val_app(0.05));
                                                    return 0;
                                                }
                                                
                                        
                                            def val_app(epsilon): 
                                                elm1=1
                                                elm2=elm1-1/(3**2)
                                                signe=1
                                                val=5
                                                while abs(elm2-elm1)>epsilon:
                                                   elm1=elm2
                                                   elm2=elm1+signe*(1/(val**2))
                                                   val+=2
                                                   signe*=(-1)
                                                return elm2

                                            # tester la fonction
                                            print(val_app(0.05))
                                        

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

val_app(0.05) = 0.928889

Exercice 2

Soit la formule suivante qui permet de déterminer une valeur approchée de cos(x) :

approximation de cos(x)

Ecrire une fonction Calcul_cos(x)qui permet de :

  •  Saisir un réel x appartenant à l’intervalle [-1, 1],
  •  Calculer et afficher une valeur approchée de cos(x) en utilisant la formule donnée ci-dessus. Le calcul s’arrête lorsque la différence entre deux termes consécutifs devient inférieure à 10-4.

Solution :
                                                #include <stdio.h>
                                                #include <math.h>
                                                float Calcul_cos(float x)
                                                {
                                                    float elm1, elm2;
                                                    int signe, f, puis;
                                                    elm1 = 1;
                                                    elm2 = elm1 - (pow(x, 2) / 2);
                                                    signe = 1;
                                                    puis = 2;
                                                    f = 2;
                                                    while (fabsf(elm2 - elm1) > 0.0001)
                                                    {
                                                        f = f * (puis + 1) * (puis + 2);
                                                        puis += 2;
                                                        elm1 = elm2;
                                                        elm2 = elm1 + signe * (pow(x, puis) / f);
                                                        signe *= (-1);
                                                    }
                                                    return elm2;
                                                }
                                                int main(void)
                                                {
                                                    printf("cos(0.5) = %f \n", Calcul_cos(0.5));
                                                    return 0;
                                                }
                                                
                                        
                                            def Calcul_cos(x):
                                                elm1 = 1
                                                elm2 = elm1-(x**2/2)
                                                signe = 1
                                                puis = 2
                                                f = 2
                                                while abs(elm2-elm1) > 0.0001:
                                                    f = f*(puis+1)*(puis+2)
                                                    puis += 2
                                                    elm1 = elm2
                                                    elm2 = elm1+signe*(x**puis/f)
                                                    signe *= (-1)
                                                return elm2
                                            
                                            
                                            print(Calcul_cos(0.5))
                                        

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

cos(0.5) = 0.877582

Exercice 3

Soit la suite U définie par :

  • U0 est un entier positif pris au hasard (avec 3 < U0<40 )
  • Un=Un-1/2 si Un-1 est pair, sinon Un=3*Un-1+1 (n>0)

Cette suite aboutit au cycle redondant formé par les trois termes 4,2,1 à partir d’un certain rang.

Exemple
  • Pour U0=3
  • U1=10.   U2=5.  U3=16.  U4=8.  U5=4   U6=2.   U7=1.  U8=4.   U9=2    U10=1,

Donc la suite U entre dans le cycle redondant 4,2,1 à partir du 6ème terme(rang=6)
Ecrire une fonction permettant de déterminer le rang à partir du quel la suite U aboutit au cycle redondant 4, 2 et 1


Solution :
                                                #include <stdio.h>
                                                #include <time.h>
                                                int rang()
                                                {
                                                    int u0, pos, Un;
                                                    srand(time(0));                 // Utiliser l'heure actuelle comme source pour le générateur aléatoire
                                                    u0 = rand() % (40 + 1 - 3) + 3; // générer une valeur dans l'intervale 3-40
                                                    pos = 1;
                                                    while (u0 != 4)
                                                    {
                                                        if (u0 % 2 == 0)
                                                            Un = u0 / 2;
                                                        else
                                                            Un = 3 * u0 + 1;
                                                
                                                        u0 = Un;
                                                        pos += 1;
                                                    }
                                                    return pos;
                                                }
                                                int main(void)
                                                {
                                                    printf("Position - %d \n", rang());
                                                    return 0;
                                                }
                                                
                                        
                                                import random

                                                def rang():
                                                    u0 = random.randrange(3, 40)
                                                    pos = 1
                                                    while u0 != 4:
                                                        if u0 % 2 == 0:
                                                            Un = u0//2
                                                        else:
                                                            Un = 3*u0+1
                                                        u0 = Un
                                                        pos += 1
                                                    return pos
                                                
                                                
                                                print(rang())                                                
                                        

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

Position - 8

Exercice 4

Ecrivez un programme permettant de calculer la limite à epsilon près de la suite définie par la relation de récurrence :

  • U0 =2
  • Un+1= Un + 2/Un  , n>0.

On arrête d’itérer quand l’intervalle entre 2 termes consécutifs devient strictement inférieur à epsilon.


Solution :
                                                #include <stdio.h>
                                                #include <math.h>
                                                float limite(float epsilon)
                                                {
                                                    float U0, Un;
                                                    U0 = 2;
                                                    Un = U0 + 2 / U0;
                                                    while (fabsf(Un - U0) > epsilon)
                                                    {
                                                        U0 = Un;
                                                        Un = U0 + 2 / U0;
                                                    }
                                                    return Un;
                                                }
                                                int main(void)
                                                {
                                                    printf("%f \n", limite(0.05));
                                                    return 0;
                                                }
                                                
                                        
                                            def limite(epsilon):
                                                U0 = 2
                                                Un = U0+2/U0
                                                while abs(Un-U0) > epsilon:
                                                    U0 = Un
                                                    Un = U0+2/U0
                                                return Un
                                            
                                            
                                            print(limite(0.05))
                                        

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

40.078770

Exercice 5

Ecrivez un programme Python permettant de calculer la nième terme de la suite définie par :

  • F0=1, F1=2
  • Fn=4 *Fn-1 + 3*Fn-2 (n >=2 )

Solution :
                                                #include <stdio.h>
                                                int suite(int n)
                                                {
                                                    int F0 = 1, F1 = 2, Fn;
                                                    for (int i = 2; i < n; i++)
                                                    {
                                                        Fn = 4 * F1 + 3 * F0;
                                                        F0 = F1;
                                                        F1 = Fn;
                                                    }
                                                
                                                    return F1;
                                                }
                                                int main(void)
                                                {
                                                    printf("%d \n", suite(5));
                                                    return 0;
                                                }
                                        
                                            def suite(int n):
                                                F0, F1 = 1, 2
                                                for i in range(2, n):
                                                    Fn = 4*F1+3*F0
                                                    F0 = F1
                                                    F1 = Fn
                                                return F1
                                            
                                            
                                            print(suite(5))
                                        

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

233

Exercice 6

La suite de Fibonacci est définie comme suit :

Ecrire une fonction récursive calculant Fib(n)


Solution :
                                                #include <stdio.h>
                                                int Fib(int n)
                                                {
                                                    if (n < 2)
                                                        return 1;
                                                    else
                                                        return Fib(n - 1) + Fib(n - 2);
                                                }
                                                int main(void)
                                                {
                                                    printf("%d \n", Fib(7));
                                                    return 0;
                                                }
                                                
                                                
                                        
                                            def Fib(n):
                                                if n < 2:
                                                    return 1
                                                else:
                                                    return Fib(n-1)+Fib(n-2)
                                            
                                            
                                            print(Fib(7))
                                        

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

21

Exercice 7

Soit la suite définie par :

Ecrire une fonction récursive permettant de calculer le nième terme de la suite.


Solution :
                                                #include <stdio.h>
                                                int suite(int n)
                                                {
                                                    if (n < 2)
                                                        return 1;
                                                    else
                                                        return 3 * suite(n - 1) + suite(n - 2);
                                                }
                                                int main(void)
                                                {
                                                    printf("%d \n", suite(5));
                                                    return 0;
                                                }
                                        
                                            def suite(n):
                                                if n < 2:
                                                    return 1
                                                else:
                                                    return 3*suite(n-1) + suite(n-2)
                                            
                                            
                                            print(suite(5))
                                        

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

142

Exercice 8

Soient u et v les deux suites définies par :

Ecrire deux fonctions CalculerU(a,b,n) et CalculerV(a,b,n) pour calculer respectivement les deux termes Un et Vn des deux suites.


Solution :
                                                #include <stdio.h>
                                                #include <math.h>
                                                // déclaration de méthodes
                                                int CalculerV(int, int, int);
                                                int CalculerU(int, int, int);
                                                
                                                // définition de méthodes
                                                int CalculerV(int a, int b, int n)
                                                {
                                                    if (n == 0)
                                                        return b;
                                                    else
                                                        return CalculerV(a, b, n - 1) + 3 * CalculerU(a, b, n - 1);
                                                }
                                                int CalculerU(a, b, n)
                                                {
                                                    if (n == 0)
                                                        return a;
                                                    else
                                                        return pow(CalculerU(a, b, n - 1), 2) + 2 * CalculerV(a, b, n - 1);
                                                }
                                                int main(void)
                                                {
                                                    printf("%d \n", CalculerU(1, 3, 2));
                                                    return 0;
                                                }
                                                
                                        
                                            def CalculerV(int a, int b, int n):
                                                if n == 0:
                                                    return b
                                                else:
                                                    return CalculerV(a, b, n-1) + 3*CalculerU(a, b, n-1)
                                            
                                            
                                            def CalculerU(int a, int b, int n):
                                                if n == 0:
                                                    return a
                                                else:
                                                    return CalculerU(a, b, n-1)**2 + 2*CalculerV(a, b, n-1)
                                            
                                            
                                            print(CalculerU(1, 3, 2))
                                        

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

61

Exercice 9

Considérons la méthode suivante pour calculer Xn :

n/2 représente la division entière de n par 2.

Ecrire une fonction récursive pour calculer Xn


Solution :
                                                #include <stdio.h>
                                                int puissance(int x, int n)
                                                {
                                                    if (n == 1)
                                                        return x;
                                                    if (n % 2 == 0)
                                                        return puissance(x, n / 2) * puissance(x, n / 2);
                                                    else
                                                        return puissance(x, n / 2) * puissance(x, n / 2) * puissance(x, 1);
                                                }
                                                int main(void)
                                                {
                                                    printf("%d \n", puissance(3, 3));
                                                    return 0;
                                                }
                                        
                                            def puissance(x, n):
                                                if n == 1:
                                                    return x
                                                if n % 2 == 0:
                                                    return puissance(x, n//2) * puissance(x, n//2)
                                                else:
                                                    return puissance(x, n//2) * puissance(x, n//2)*puissance(x, 1)
                                            
                                            
                                            print(puissance(3, 3))
                                        

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant

27

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Many people realize their hearts desires late in life. Continue learning, never stop striving and keep your curiosity sharp, and you will never become too old to appreciate life.

0 Commentaire(s)

Pour laisser un commentaire vous devez avoir un compte Inscription, ou Se connecter