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 :
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
Exercice 2
Soit la formule suivante qui permet de déterminer une valeur approchée 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
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
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
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
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
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
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
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