Langage Python

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

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

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :