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
