5 - Exercices d'approfondissement

Cette série d'exercices est destinée à vous faire travailler sur des algorithmes simples (avec
boucles, tests, etc) et sur la définition de fonctions.
Comme depuis le TP4, tous vos modules devront contenir obligatoirement, dans l'en-tête, un
commentaire indiquant ce que fait le programme, en précisant le numéro de l'exercice correspon­
dant. (ce commentaire est appelé “ documentation ” du module.)
Exercices et programmes à rendre dans le compte-rendu de TP : ex 1 (TP51_1), ex 2 (TP51_2), ex
3 (TP51_3), ex 4 (TP51_4), ex 5 (TP52_5), ex 6 (TP53_6), ex 7 (TP53_7)

5.1 - Exercices d'approfondissement - calculs

Exercice 1 : Calcul d'une valeur approchée du nombre  comme somme “infinie” des
termes d'une suite
Le nombre  est déjà connu dans python, sous forme d'une constante pi du module math.
Donner la valeur exacte de cette constante du module math (l'afficher dans un interpréteur python) :
................................
Nous voulons maintenant écrire notre propre fonction de calcul de , comme somme infinie des
termes d'une suite :
1
Soit (un) n ∈ ℕ* la suite définie pour tout entier strictement positif n par un = 2 .
n
Nous admettons que la somme (infinie) de tous les termes de cette suite est un nombre FINI
qui est égal à :
+∞ +∞
1 π2
S=u1+ u2+ ...+ u 100+ .....+ u 1000+ u1001+ .........= ∑ u k =∑ 2
=
k=1 k=1 k 6
D'après cette égalité, exprimer  en fonction de S : ................................................... (1)
Soit Sn la somme (appelée somme partielle) des termes de la suite entre u 1 et un :
n n
1
S n = ∑ uk = ∑ 2
. On a S= nlim ( Sn )
k=1 k
→+ ∞
k=1

Nous ne sommes pas capables de calculer la valeur précise de S à l'aide d'un ordinateur, mais nous
pouvons calculer des valeurs de la somme partielle S n , pour différentes valeurs de n. Nous en
déduirons ensuite des valeurs approchées de , d'après l'expression de  que nous avons écrite ci-
dessus (1).
Créez un script TP51_1.py (à rendre) avec l'en-tête standard, contenant :
a) Une fonction sommePartielle(p_n) qui prendra en argument un entier p_n, et qui retournera
la valeur de Sn .
b) Une fonction approxPi(p_n) qui prendra en argument un entier p_n.
Cette fonction calculera :
- dans une variable monPi, la valeur approchée de  calculée à partir du résultat résultant d'un
appel à la fonction sommePartielle().

info - TP5 page 45

- dans une variable erreur, l'erreur relative (en pourcentage) entre cette valeur approchée monPi
et la valeur de  fournie par la constante pi du module math.
Cette fonction retournera les deux variables monPi et erreur, sous forme d'une liste composée de
2 éléments : pour cela on écrira return [monPi , erreur]
Dans le programme principal, on écrira un jeu d'essais pour ces fonctions et on affichera à l'écran
les résultats du calcul de la valeur approchée de  pour différentes valeurs de n (par exemple pour
n =10, n=100, n=10000, etc).

Exercice 2 : pgcd (plus grand commun diviseur)

Créez un script TP51_2.py (à rendre) avec l'en-tête standard, contenant une fonction
pgcd(p_x,p_y) qui prendra en arguments deux entiers et qui retournera leur PGCD calculé par
l'algorithme d'Euclide. Utiliser une boucle while. Ne pas oublier le jeu d'essais dans le programme
principal.
Rappels de maths : soient a et b deux nombres entiers naturels non nuls. L’ensemble de leurs divi­
seurs communs admet un plus grand élément appelé PGCD de a et de b (“Plus Grand Commun
Diviseur”).
Il y a deux façons de procéder pour rechercher le PGCD de deux nombres. Exemple pour 2520 et
1188 :
1. par l’utilisation de la décomposition en produits de facteurs premiers :
2520 = 23.32.5.7
1188 = 22.33.11
Le PGCD est obtenu en faisant le produit de tous les facteurs qui figurent à la fois dans les
deux décompositions avec leur exposant le plus bas :
pgcd(2520,1188) = 22.32 = 36
2. Par l’algorithme d’EUCLIDE. Le PGCD est le dernier reste non nul dans cet algorithme :
2520 / 1188 = 2, reste 144
1188 / 144 = 8, reste 36 : c'est le PGCD
144 / 36 = 4, reste 0
On rappelle la propriété suivante : pgcd(x,y).ppcm(x,y)=x.y

Exercice 3 : produit scalaire

Créez un script TP51_3.py (à rendre) avec l'en-tête standard, en reprenant l'algorithme du produit
scalaire de l'exercice 5 du TP3 (script TP3_5.py), et en définissant une fonction pdt_scal(p_u,
p_v) qui prend 2 listes en argument et retournera leur produit scalaire.

Exercice 4 : ppcm (plus petit commun multiple)

Créez un script TP51_4.py (à rendre) avec l'en-tête standard, contenant une fonction ppcm(p_x,
p_y) qui prendra deux entiers comme argument et retournera le PPCM de ces deux entiers. Testez
cette fonction (jeu d'essais).

info - TP5 page 46

5.2 - Travail algorithmique

Exercice 5 : Suite de Syracuse

On appelle suite de Syracuse toute suite d’entiers naturels vérifiant :

{
un
si un est pair
un1= 2
3 un1 si un est impair
Par exemple, la suite de Syracuse partant de u0=11 est :
11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1, 4, 2, 1, 4, 2, 1
En se bornant à 1, on appelle cette suite finie d’entiers le vol10 de 11. On appelle étape un nombre
quelconque de cette suite finie. Par exemple 17 est une étape du vol de 11. On remarque que la suite
atteint une étape maximale, appelée altitude maximale du vol. Par exemple 52 est l’altitude maxi­
male du vol de 11.
Créez un script TP52_5.py (à rendre) avec l'en-tête standard, qui contiendra :
a) Une fonction etapeSuivante(p_terme). Elle reçoit un entier strictement positif, calcule
l’entier suivant dans la suite de Syracuse et le retourne. Par exemple etapeSuivante(5) doit
produire 16 et etapeSuivante(16) doit faire 8, etc.
b) Une fonction vol(p_debut). Elle reçoit un entier initial strictement positif, crée une liste vide
et, en utilisant la fonction etapeSuivante(), calcule et stocke dans cette liste les termes de la
suite de Syracuse de l’entier initial jusqu’à 1 inclus. Cette fonction retourne la nouvelle liste ainsi
créée.
c) Un programme principal qui demande un entier initial à l’utilisateur (pour les tests, utilisez des
valeurs entre 2 et 100) puis qui, en utilisant les fonctions déjà définies, affiche proprement les
termes de la suite de Syracuse correspondante.
Une fois que cela fonctionne, ajoutez une fonction altMaxi(p_debut). Elle reçoit un entier et
retourne la valeur de l’altitude maximale de la suite de Syracuse commençant par u0 = p_debut.
Par exemple, en partant de u0 = 7, la suite de Syracuse est : 7, 22, 11, 34, 17, 52, 26, 13, 40, 20,
10, 5, 16, 8, 4, 2, 1 et par conséquent altMaxi(7) vaut 52.
Enrichissez le programme principal de façon à calculer et afficher l’altitude maximale du vol
correspondant à l'entier initial saisi par l'utilisateur.

5.3 - Exercices de détente

Exercice 6 : palindrome
Créez un script TP53_6.py (à rendre) avec l'en-tête standard, définissant une fonction
palyndrome(p_mot) qui affiche la chaîne inverse à celle donnée en paramètre et qui retourne
une indication si cette chaîne est un palindrome ou non (elle retourne un booléen).
Dans le programme principal, mettre en place une boucle dans laquelle on saisit une chaîne, et on
appelle la fonction définie ci-dessus afin d'avoir la chaîne inversée et de savoir s'il s'agit d'un palin ­
drome. La boucle s'arrêtera lorsqu'on saisit une chaîne vide.
10 On a constaté depuis longtemps que pour tous les entiers de départ testés, la suite atteint après un
nombre de termes plus ou moins grand, la période 4, 2, 1, 4, 2, 1… Hélas ! pour l’instant tous ceux
qui ont essayé de le prouver ont échoué : c’est un « problème ouvert » (une conjecture).

info - TP5 page 47

 Exemple 1 Exemple 2

Chaîne de départ en paramètre "zorglub" "radar"

Chaîne transformée affichée "bulgroz" "radar"

Palindrome? (valeur retournée) Non (False) Oui (True)

Exercice 7 : dessiner avec le module turtle

Note : la documentation du module turtle est disponible (en anglais) à l'URL : http://docs.py­
thon.org/release/3.1.3/library/turtle.html (et bien sûr aussi dans les documentations Python instal­
lées sur les machines dans la salle TP).
Créez un script TP53_7.py (à rendre) avec l'en-tête standard :
a) Écrire les lignes ci-dessous
from turtle import forward, right
def carre(p_cote):
"""Dessine un carré dont le côté est fourni en argument."""
for cpt in range(4):
forward(p_cote)
right(90)
b) Sachant que dans le module turtle, la fonction up() permet de relever le crayon et que la
fonction down() permet de l'abaisser, utilisez la fonction carre() pour dessiner 10 carrés alignés,
séparés par un espace :

Complétez le programme de la façon suivante :

c) Ajoutez un paramètre p_angle et un paramètre p_couleur à la fonction carre(), de manière
à ce que les carrés puissent être tracés dans différentes orientations et de diverses couleurs. La fonc­
tion sera alors : carre(p_cote, p_couleur, p_angle).
Ecrivez une fonction triangle(p_cote, p_couleur, p_angle) capable de dessiner un
triangle équilatéral d’une taille, d’une couleur et d’une orientation bien déterminées.
Dans le programme principal, utilisez ces fonctions pour dessiner la série suivante de carrés rouges
et de triangles bleus :

d) Ecrivez une fonction etoile5() pour dessiner une étoile à 5 branches.

info - TP5 page 48

Dans le programme principal, écrivez une boucle qui dessine la rangée horizontale ci-dessous, de 9
petites étoiles de tailles variées :

e) Ecrivez une fonction etoile6() capable de dessiner une étoile à 6 branches, elle-même consti­
tuée de deux triangles équilatéraux imbriqués. Cette nouvelle fonction devra faire appel à la fonc­
tion triangle() définie précédemment.
Votre programme principal dessinera la série suivante d'étoiles :

ainsi que la série suivante :

info - TP5 page 49