Université Clermont Auvergne Portail Maths Info, LAS Maths-Info, PASS Info

Algorithmique et Programmation en Python - Semestre 1

Algorithmique et Programmation en Python

TD03 : Boucle while

1 Application directe du cours sur les boucles

Exercice 1 : Trouver les bornes

Soit le programme incomplet suivant :

i = <A>
while <B>:
print(i)
i = <C>

Donner les expressions <A>, <B>, <C> pour que :

1. Le programme affiche les entiers allant de 0 à 10 (bornes incluses).

Solution :

1 i =0
2 while i <11:
3 print ( i )
4 i = i +1

2. Le programme affiche les entiers allant de 10 à 0 (bornes incluses).

Solution :

1 i =10
2 while i >=0:
3 print ( i )
4 i =i -1

3. Le programme affiche les multiples de 3 positifs strictement inférieurs à 30 (0 compris).

Solution :

1 i =0
2 while i <30:
3 print ( i )
4 i = i +3

4. Le programme affiche les puissances entières de 3 strictement inférieures à 300 (1 compris).

Solution :

1 i =1
2 while i <300:
3 print ( i )
4 i = i *3

UCA - Licence N1 / LAS / PASS - UE Info. - Python 1

 5. Le programme affiche un entier saisi par l’utilisateur tant que celui-ci est strictement positif.
Solution :

1 i = int ( input ( " Saisir un entier : " ))

2 while i >0:
3 print ( i )
4 i = int ( input ( " Saisir de nouveau un entier : " ))

6. Le programme affiche une lettre saisie par l’utilisateur tant que celle-ci est une voyelle.
Solution :

1 i = input ( " Saisir une lettre ( en minuscule ) : " )

2 while len ( i )==1 and i in " aeiouy " :
3 print ( i )
4 i = input ( " Saisir de nouveau une lettre ( en minuscule ) : " )

Exercice 2 : Lecture de code

Combien de '*' les programmes suivants affichent-ils ? Justifier les réponses.

# (a) # (c) # (e)

i = 0 i=20 i=1
while i <= 15 : while i<100 : while i<=16 :
print('*') if i%2!=0 : print('*')
i = i + 1 print('*') i=i*2
i=i+1
Solution : 16 fois (0, 1, ... 15) Solution : 40 fois (21, 23, .., 99) Solution : 5 fois (1, 2, 4, 8, 16)

# (b) # (d)
i=0 i = 0 # (f)
while i>10 : while i < 100 : i=0
print('*') if i % 2 == 0 : while i<10 :
i=i+1 print('*') print('*')
i = i + 1 i=i-1
Solution : 0 fois Solution : 1 affichée puis boucle
infinie sans affichage Solution : Boucle infinie d’affichage

→ Le(s)quel(s) de ces programmes devrai(en)t être modifié(s), pourquoi, et comment ?

Solution :
Il faut modifier les programmes provoquant une boucle infinie, mais pas les programmes ne rentrant jamais
dans la boucle (ce n’est pas un comportement problématique en soi, il arrive qu’on le fasse volontairement).
Pour modifier le programme (d), il faut désindenter la ligne d’incrémentation i = i+1, pour la mettre
comme dans le programme (c).
Pour le programme (f), les bornes ne sont pas cohérentes avec le pas négatif de compteur de boucle. On
peut repasser à une incrémentation classique i = i+1 par exemple, puisqu’ici il ne semble pas pertinent d’avoir
un compteur de boucle négatif.

Exercice 3 : Jusqu’à

1. Écrire un programme qui demande à l’utilisateur de saisir une lettre et qui continue jusqu’à ce que l’utilisateur
saisisse une voyelle. Une fois qu’une voyelle a été saisie, un message de remerciement s’affiche.
Solution :

1 saisie = " z " # initialisation pour entrer dans la boucle

2 while not ( len ( saisie )==1 and saisie in " aeiouy " ):
3 saisie = input ( " Saisir une voyelle ( en minuscule ) : " )
4 print ( " Merci pour votre voyelle . " )

UCA - Licence N1 / LAS / PASS - UE Info. - Python 2

 2. Écrire un programme qui commence par initialiser une variable prenom avec le prénom du programmeur qui
l’a écrit (initialisation "en dur" dans le code source), puis qui demande à l’utilisateur de deviner ce prénom.
Le programme continue à demander des saisies clavier jusqu’à ce que l’utilisateur trouve le bon prénom ou
bien qu’il ait épuisé 5 chances. Il affichera ensuite "Bravo, tu as trouvé !" ou "Dommage, perdu !".
Solution :

1 prenom = " Aurelie "

2 saisie = " "
3 essai = 0
4 while saisie != prenom and essai < 5:
5 saisie = input ( " Devinez le prenom du programmeur de ce code source : " )
6 essai = essai +1
7 if saisie == prenom :
8 print ( " Bravo , tu as trouve ! " )
9 else :
10 print ( " Dommage , perdu ! " )

3. Écrire un programme qui tire un nombre au hasard entre 0 et 500 jusqu’à obtenir un multiple de 10. Il affiche
alors la "dizaine" ainsi tirée et le nombre de tirages qui ont été nécessaires.
Remarque : Pour tirer un entier au hasard entre 0 et 500, il faut écrire import random comme première
ligne de notre programme, puis l’affectation d’un nombre au hasard dans une variable n se fait grâce à
n=[Link](0, 500). Nous en reparlerons au moment du chapitre sur les fonctions et en particulier
de la section sur les importations de modules.
Solution :

1 import random
2
3 n =1
4 essais =0
5 while n %10 != 0:
6 n = random . randint (0 , 500)
7 essais = essais +1
8 print (n , " ( essais : " , essais , " ) " )

Exercice 4 : Fizz Buzz

Écrire un programme qui affiche tous les entiers entre 1 et 100, mais qui remplace les multiples de 3 par "fizz",
les multiples de 5 par "buzz", et les multiples à la fois de 3 et 5 par "fizzbuzz". Exemple d’exécution (début) :

1
2
fizz
4
buzz
fizz
7
8
fizz
buzz
11
fizz
13
14
fizzbuzz
16
17
...

UCA - Licence N1 / LAS / PASS - UE Info. - Python 3

 Solution :
1 i =1
2 while i <=100:
3 if i %3==0 and i %5==0:
4 print ( " fizzbuzz " )
5 elif i %3==0:
6 print ( " fizz " )
7 elif i %5==0:
8 print ( " buzz " )
9 else :
10 print ( i )
11 i = i +1

Une deuxième version possible :

1 i =1
2 while i <=100:
3 if i %3==0:
4 print ( " fizz " , end = " " )
5
6 if i %5==0:
7 print ( " buzz " , end = " " )
8 elif i %3 != 0 :
9 print (i , end = " " )
10
11 print () # retour a la ligne
12 i = i +1

2 Algorithmique sur les boucles : accumulateurs et drapeaux classiques

Exercice 5 : Accumulateurs et drapeaux

Écrire un programme qui demande à l’utilisateur un entier n par saisie clavier puis qui :
1. Calcule et affiche la somme des n premiers entiers non-nuls
Solution :

1 n = int ( input ( " Donnez un entier n : " ))

2 i =1
3 somme =0
4 while i < n +1:
5 somme = somme + i
6 i = i +1
7 print ( somme )

2. Calcule et affiche la somme des n premiers entiers impairs (6= entiers impairs inférieurs à n)

Solution :

1 n = int ( input ( " Donnez un entier n : " ))

2 compteur =0
3 next =1
4 somme =0
5 while compteur < n :
6 somme = somme + next
7 next = next +2
8 compteur = compteur +1
9 print ( somme )

UCA - Licence N1 / LAS / PASS - UE Info. - Python 4

 3. Calcule et affiche la somme de n entiers saisis au clavier
Solution :

1 n = int ( input ( " Donnez un entier n : " ))

2 i =0
3 somme =0
4 while i < n :
5 saisie = int ( input ( " Saisir un entier : " ))
6 somme = somme + saisie
7 i = i +1
8 print ( somme )

4. Calcule et affiche le produit de n entiers saisis au clavier

Solution :

1 n = int ( input ( " Donnez un entier n : " ))

2 i =0
3 produit =1
4 while i < n :
5 saisie = int ( input ( " Saisir un entier : " ))
6 produit = produit * saisie
7 i = i +1
8 print ( produit )

5. Lit n paires d’entiers, compare les entiers 2 à 2, et affiche à la fin un booléen indiquant si toutes les paires
étaient en ordre croissant au sens large (cf exemple pour n=3).

Paire d'entiers #1
3
7
Paire d'entiers #2
2
12
Paire d'entiers #3
5
9
Toutes les paires sont en ordre croissant
...
Paire d'entiers #3
9
5
Toutes les paires ne sont pas en ordre croissant

Solution :

1 n = int ( input ( " Donnez un entier n : " ))

2 i =1
3 tout esCroiss antes = True
4 while i <= n :
5 print ( " Paire d ' entiers # " , i , sep = " " )
6 a = int ( input ())
7 b = int ( input ())
8 tout esCroiss antes = tou tesCrois santes and (a <= b )
9 i = i +1
10 if toute sCroissa ntes :
11 print ( " Toutes les paires sont en ordre croisssant . " )
12 else :
13 print ( " Toutes les paires ne sont pas en ordre croissant . " )
14 print ( " (= certaines ne le sont pas ) " )

UCA - Licence N1 / LAS / PASS - UE Info. - Python 5

Exercice 6 : Séquence croissante
Écrire un programme qui lit une suite d’entiers au clavier jusqu’à ce que l’utilisateur saisisse un nombre strictement
négatif. Le programme affichera alors ’Croissante’ si la suite d’entiers était croissante (au sens large), ’Décroissante’
si la suite était décroissante (au sens large), ’constante’ si tous les entiers étaient égaux, et ’Ni croissante ni
décroissante’ si la suite n’est ni croissante ni décroissante.
Indice : utiliser des drapeaux.
Solution :

1 croissante = True # vrai jusqu 'a preuve du contraire

2 decroissante = True # idem
3 saisie = int ( input ( " Saisir un entier : " ))
4 saisiePrec = saisie # initialisation juste pour le 1 e tour de boucle
5 while saisie >= 0:
6 # deux facons de faire , j ' illustre l ' une sur le
7 # booleen croissante et l ' autre sur le booleen decroissante
8 # facon drapeau
9 croissante = croissante and ( saisiePrec <= saisie )
10 # facon avec un if lorsqu ' on trouve une contradiction
11 if saisiePrec < saisie :
12 decroissante = False
13 saisiePrec = saisie
14 saisie = int ( input ( " Saisir un entier : " ))
15 if croissante and decroissante :
16 print ( " Constante " )
17 elif croissante :
18 print ( " Croissante " )
19 elif decroissante :
20 print ( " Decroissante " )
21 else :
22 print ( " Ni croissante ni decroissante " )

3 Boucles imbriquées, ASCII Art

Exercice 7 : Escaliers
Écrire un programme qui demande un entier L à l’utilisateur, et qui affiche la forme suivante, constituée de L
lignes :

a. ***** b. * c. * d. ***** e. ***** f. *

***** ** ** **** **** ***
***** *** *** *** *** *****
***** **** **** ** ** *******
***** ***** ***** * * ****o****

Dans la dernière figure, la porte (caractère 'o') est en bonus, pour simplifier vous pouvez afficher une '*' à la
place. Dans cet exercice on s’interdira d’utiliser l’opérateur de multiplication pour créer les chaînes à afficher, on
n’affichera qu’une étoile à la fois.
Solution :
(a)
1 L = int ( input ( " Combien de lignes ? " ))
2 i =0
3 while i < L :
4 j =0
5 while j < L :
6 print ( " * " , end = " " )
7 j = j +1
8 print ()
9 i = i +1

UCA - Licence N1 / LAS / PASS - UE Info. - Python 6

 Solution :
(b)
1 L = int ( input ( " Combien de lignes ? " ))
2 i =1
3 while i <= L :
4 j =0
5 while j < i :
6 print ( " * " , end = " " )
7 j = j +1
8 print ()
9 i = i +1
(c)
1 L = int ( input ( " Combien de lignes ? " ))
2 i =1
3 while i <= L :
4 j =0
5 while j <L - i :
6 print ( " " , end = " " )
7 j = j +1
8 j =0
9 while j < i :
10 print ( " * " , end = " " )
11 j = j +1
12 print ()
13 i = i +1
(d)
1 L = int ( input ( " Combien de lignes ? " ))
2 i=L
3 while i >0 :
4 j =0
5 while j < i :
6 print ( " * " , end = " " )
7 j = j +1
8 print ()
9 i =i -1
(e)
1 L = int ( input ( " Combien de lignes ? " ))
2 i=L
3 while i >0 :
4 j =0
5 while j <L - i :
6 print ( " " , end = " " )
7 j = j +1
8 j =0
9 while j < i :
10 print ( " * " , end = " " )
11 j = j +1
12 print ()
13 i =i -1

UCA - Licence N1 / LAS / PASS - UE Info. - Python 7

 (f)
1 L = int ( input ( " Combien de lignes ? " ))
2 i =0
3 while i < L :
4 j =0
5 while j <L -i -1:
6 print ( " " , end = " " )
7 j = j +1
8 j =1
9 while j <=2* i +1:
10 if i == L -1 and j == L :
11 print ( " o " , end = " " )
12 else :
13 print ( " * " , end = " " )
14 j = j +1
15 print ()
16 i = i +1

Exercice 8 : Triangle d’entiers

Écrire un programme qui demande à l’utilisateur un nombre de lignes, et affiche un triangle d’entiers avec ce
nombre de lignes, sous la forme suivante (dans les exemples avec n=4)

1 1 1 2 3 4 1 2 3 4
1 2 2 3 1 2 3 5 6 7
1 2 3 4 5 6 1 2 8 9
1 2 3 4 7 8 9 10 1 10
a) b) c) d)

10 9 8 7 1 1
6 5 4 1 2 2 3
3 2 1 2 3 4 5 6
1 1 2 3 4 7 8 9 10
e) f) g)

Solution :
(a)
1 i =1 # numero de ligne
2 while i <= n :
3 j =1 # numero de colonne
4 while j <= i :
5 print (j , end = " " )
6 j = j +1
7 print ()
8 i = i +1
(b)
1 p =1 # prochain a afficher
2 i =1 # numero de ligne
3 while i <= n :
4 j =1 # numero de colonne
5 while j <= i :
6 print (p , end = " " )
7 p = p +1
8 j = j +1
9 print ()
10 i = i +1

UCA - Licence N1 / LAS / PASS - UE Info. - Python 8

 Solution :
(c)
1 i = n # numero de ligne ( donne le nb de colonnes )
2 while i >0:
3 j =1 # numero de colonne
4 while j <= i :
5 print (j , end = " " )
6 j = j +1
7 print ()
8 i =i -1

(d)
1 p =1 # prochain a afficher
2 i = n # numero de ligne
3 while i >0:
4 j =1 # numero de colonne
5 while j <= i :
6 print (p , end = " " )
7 p = p +1
8 j = j +1
9 print ()
10 i =i -1

(e)
1 p = n *( n +1)//2 # prochain a afficher
2 i = n # numero de ligne
3 while i >0:
4 j =1 # numero de colonne
5 while j <= i :
6 print (p , end = " " )
7 p =p -1
8 j = j +1
9 print ()
10 i =i -1

(f)
1 i =1 # numero de ligne
2 while i <= n :
3 j =1 # numero de colonne
4 while j <= n - i :
5 print ( " " , end = " " )
6 j = j +1
7 j =1
8 while j <= i :
9 print (j , end = " " )
10 j = j +1
11 print ()
12 i = i +1

UCA - Licence N1 / LAS / PASS - UE Info. - Python 9

 Solution :
(g)
1 i =1 # numero de ligne
2 p =1 # prochain a afficher
3 while i <= n :
4 j =1 # numero de colonne
5 while j <= n - i :
6 print ( " " , end = " " )
7 j = j +1
8 j =1
9 while j <= i :
10 print (p , end = " " )
11 p = p +1
12 j = j +1
13 print ()
14 i = i +1

Exercice 9 : Pyramide ailée

Le but de cet exercice est d’utiliser les boucles, c’est pourquoi on interdira l’utilisation de l’opérateur * sur les
chaînes de caractères. Écrire un programme qui demande un entier n à l’utilisateur et affiche une pyramide ailée
de hauteur n, comme sur la figure suivante avec n = 7 :

^^
^^ ^^
^^^ ^^^
^^^^ ^^^^
^^^^^ ^^^^^
^^^^^^ ^^^^^^
^^^^^^^ ^^^^^^^

Solution :

1 n = int ( input ( " Hauteur n voulue ? " ))

2
3 i =1
4 while i <= n :
5 j =0
6 while j <( n - i ):
7 print ( " " , end = " " ) # deux espaces
8 j = j +1
9 j =0
10 while j < i :
11 print ( " ^ " , end = " " )
12 j = j +1
13 j =0
14 while j <i -1:
15 print ( " " , end = " " )
16 j = j +1
17 j =0
18 while j < i :
19 print ( " ^ " , end = " " )
20 j = j +1
21 print ()
22 i = i +1

Exercice 10 : Moyennes d’étudiants

UCA - Licence N1 / LAS / PASS - UE Info. - Python 10

 (a) Écrire un programme qui demande à l’utilisateur de saisir des nombres réels (float) correspondant à ses
notes d’examen. L’utilisateur donnera une note invalide (non comprise entre 0 et 20) pour indiquer la
fin de la saisie (cette note invalide ne sera pas comptabilisée). Après la fin de la saisie le programme
doit afficher la moyenne des notes (valides) saisies (attention au cas spécial où aucune note valide n’est
saisie).

Solution :

1 note = float ( input ( " Saisir une note : " ))

2 somme =0
3 nb =0
4 while 0 <= note <= 20:
5 nb = nb +1 # Note valide comptabilisee
6 somme = somme + note
7 note = float ( input ( " Saisir une note : " ))
8
9 if nb >0:
10 print ( " Moyenne des notes : " , somme / nb )
11 else :
12 print ( " Aucune note saisie , pas de moyenne a afficher . " )

(b) Compléter ce programme pour afficher aussi la meilleure note et la pire note de l’utilisateur.
1.
Solution :

1 note = float ( input ( " Saisir une note : " ))

2 meilleure = note
3 pire = note
4 somme =0
5 nb =0
6 while 0 <= note <= 20:
7 nb = nb +1 # Note valide comptabilisee
8 somme = somme + note
9 if note > meilleure :
10 meilleure = note
11 if note < pire :
12 pire = note
13 note = float ( input ( " Saisir une note : " ))
14
15 if nb >0:
16 print ( " Moyenne des notes : " , somme / nb )
17 print ( " Meilleur note : " , meilleure , " /20 , pire note : " , pire , " /20 " )
18 else :
19 print ( " Aucune note saisie , aucune donnee a afficher . " )

2. (a) On veut calculer la moyenne d’un groupe de 30 étudiants. Pour ce faire, on veut écrire un programme
qui, pour chaque étudiant du groupe, demande à l’utilisateur de saisir 10 notes. A la fin de la saisie de
ces 10 notes, le programme doit afficher la moyenne de l’étudiant. A la fin du programme, la moyenne
de tout le groupe doit être affichée.
Solution :

1 i =0
2 sommeGroupe =0

UCA - Licence N1 / LAS / PASS - UE Info. - Python 11

 3 nbEtuParGroupe =30
4 nbNotesParEtu =10
5 while i < nbEtuParGroupe :
6 j =0
7 sommeEtu =0
8 print ( " Saisie des notes de l ' etudiant numero " , i )
9 while j < nbNotesParEtu :
10 print ( " Saisie note numero " , j , " de l ' etudiant " , i )
11 note = float ( input ())
12 sommeEtu = sommeEtu + note
13 j = j +1
14 moyenneEtu = sommeEtu / nbNotesParEtu
15 print ( " Moyenne de l ' etudiant " , i , " : " , moyenneEtu )
16 sommeGroupe += moyenneEtu
17 i = i +1
18 print ( " Moyenne du groupe : " , sommeGroupe / nbEtuParGroupe )

(b) Compléter ce programme pour afficher aussi en fin de programme la moyenne et le numéro de l’étudiant
qui a la meilleure moyenne.
Solution :

1 i =0
2 sommeGroupe =0
3 nbEtuParGroupe =30
4 nbNotesParEtu =10
5 numMeilleur =0
6 moyenneMeilleur =0
7 while i < nbEtuParGroupe :
8 j =0
9 sommeEtu =0
10 print ( " Saisie des notes de l ' etudiant numero " , i )
11 while j < nbNotesParEtu :
12 print ( " Saisie note numero " , j , " de l ' etudiant " , i )
13 note = float ( input ())
14 sommeEtu = sommeEtu + note
15 j = j +1
16 moyenneEtu = sommeEtu / nbNotesParEtu
17 if moyenneEtu > moyenneMeilleur :
18 numMeilleur = i
19 moyenneMeilleur = moyenneEtu
20 print ( " Moyenne de l ' etudiant " , i , " : " , moyenneEtu )
21 sommeGroupe += moyenneEtu
22 i = i +1
23 print ( " Moyenne du groupe : " , sommeGroupe / nbEtuParGroupe )
24 print ( " Meilleur etudiant : " )
25 print ( " Numero " , numMeilleur , " moyenne " , moyenneMeilleur , " /20 " )

4 Calculer des suites définies par récurrences

Exercice 11 : Une suite

Soit la suite (un )n∈N définie par récurrence ainsi :


345 si n = 0
un =
3 ∗ un−1 + 72 sinon

UCA - Licence N1 / LAS / PASS - UE Info. - Python 12

 1. Écrire un programme qui demande à l’utilisateur de saisir un entier n puis qui affiche la valeur de un .
Solution :
1 n = int ( input ( " Donnez une valeur pour n : " ))
2 i =0
3 u_i =345
4 while i < n :
5 u_i =3* u_i +72
6 i = i +1
7 print ( " u_ " , n , " vaut " , u_i , sep = " " )

2. Écrire un programme qui demande à l’utilisateur de saisir un entier seuil puis qui affiche la première valeur
de n pour laquelle un est supérieure ou égale à seuil.
Solution :

1 seuil = int ( input ( " Donnez une valeur de seuil : " ))

2 n =0
3 u_n =345
4 while u_n < seuil :
5 u_n =3* u_n +72
6 n = n +1
7 print ( " La plus petite valeur n telle que u_n depasse " , end = " " )
8 print ( " le seuil de " , seuil , " est " , n , " ( avec u_n = " , u_n , " ). " )

Exercice 12 : Suite de Fibonacci

Soit la suite de Fibonacci donnée par

 f0 = 1
f1 = 1
fn = fn−1 + fn−2


1. Écrire un programme qui lit un entier n au clavier, puis calcule et affiche fn

2. On peut estimer le nombre d’or en divisant un terme de la suite par le précédent. Plus n grandit et plus
l’estimation est précise. Compléter ce programme pour afficher l’estimation du nombre d’or fn /fn−1 (on
affiche uniquement la dernière, pas les valeurs intermédiaires).

Solution :

1 n = int ( input ( " Saisir une valeur pour n : " ))

2 if n <0:
3 print ( " Fibo non definie pour n strictement negatif . " )
4 elif n <=1 :
5 print ( " Fibo ( " , n , " )=1 " , sep = " " )
6 else :
7 a va n t _d e rn i er _ t er m e =1
8 dernier_terme =1
9 i =1
10 while i < n :
11 f_n = dernier_terme + a v an t _d e rn i e r_ t er m e
12 a va n t _d e rn i er _ t er m e = dernier_terme
13 dernier_terme = f_n
14 i = i +1
15 print ( " Fibo ( " , n , " )= " , f_n , sep = " " )
16 print ( " Estimation du nombre d ' or : " , dernier_terme / a v a nt _ de r n ie r _t e rm e )

3. Bonus plus difficile : définir une constante nbor = 1, 618033988749895 (approximation du nombre d’or). Mo-
difier ce programme pour qu’il demande à l’utilisateur une précision souhaitée (distance maximale autorisée
avec le nombre d’or, par exemple p = 0.01), puis il calcule les termes de la suite et l’estimation du nombre
d’or estimnbo jusqu’à ce que la précision soit atteinte, c’est-à-dire que la distance entre nbor et estimnbo est

UCA - Licence N1 / LAS / PASS - UE Info. - Python 13

 inférieure ou égale à p.
Solution :

1 nbor = 1. 618 03 39 887 49 89 5

2 p = float ( input ( " Quelle est la precision souhaitee ? " ))
3 a va n t _d e rn i er _ t er m e =1
4 dernier_terme =1
5 premierTour = True # pour forcer l ' entree dans la premiere iteration
6 n =1
7 while premierTour or abs ( estimnbo - nbor ) > p : # abs : valeur absolue
8 premierTour = False
9 f_n = dernier_terme + a v an t _d e rn i e r_ t er m e
10 a va n t _d e rn i er _ t er m e = dernier_terme
11 dernier_terme = f_n
12 estimnbo = dernier_terme / a v an t _ de r ni e r _t e rm e
13 n = n +1
14 print ( " Fibo ( " , n , " )= " , f_n , sep = " " )
15 print ( " Estimation du nombre d ' or : " , dernier_terme / a v a nt _ de r n ie r _t e rm e )
16 print ( " Precision de " , estimnbo - nbor )

Exercice 13 : Suite de Syracuse

Soit la suite récursive donnée par u0 = A et par la relation de récurrence :

un /2 si un est pair
un+1 =
3 ∗ un + 1 si un est impair

NB : une grande question mathématique est de savoir si, pour toute valeur initiale A, cette suite contient l’élément 1.
Les chercheurs en mathématiques n’ayant pas (encore) résolu ce problème, on dit que ce problème est ouvert. On
appelle conjecture de Syracuse l’énoncé non-prouvé suivant : “cette suite passe par 1 quel que soit le point de départ”.

1. Écrire un programme qui demande la saisie d’un entier strictement positif A qui sera utilisé comme u0 et qui
détermine le premier n pour lequel on a : un = 1 (c’est la “durée de vol”)

Solution :

1 A = int ( input ( " Saisir un entier srict . positif de depart : " ))

2 n =0
3 u_n = A
4 while u_n != 1:
5 if u_n %2==0:
6 u_n = u_n //2
7 else :
8 u_n =3* u_n +1
9 n = n +1
10 print ( " u_ " , n , " = " , u_n , sep = " " )

2. Modifier ce programme pour qu’il affiche tous les termes un calculés au fur et à mesure.
Solution :

1 A = int ( input ( " Saisir un entier srict . positif de depart : " ))

2 n =0
3 u_n = A
4 while u_n != 1:
5 if u_n %2==0:
6 u_n = u_n //2
7 else :
8 u_n =3* u_n +1
9 n = n +1
10 print ( " u_ " , n , " = " , u_n , sep = " " )

UCA - Licence N1 / LAS / PASS - UE Info. - Python 14

 3. Modifier ce programme pour qu’il affiche le maximum atteint par la suite (la plus grande valeur d’un terme
un ).

Solution :

1 A = int ( input ( " Saisir un entier srict . positif de depart : " ))

2 n =0
3 u_n = A
4 max = A
5 indiceDuMax =0
6 while u_n != 1:
7 if u_n %2==0:
8 u_n = u_n //2
9 else :
10 u_n =3* u_n +1
11 n = n +1
12 if u_n > max :
13 max = u_n
14 indiceDuMax = n
15 print ( " u_ " , n , " = " , u_n , sep = " " )
16 print ( " Valeur max : " , end = " " )
17 print ( " u_ " , indiceDuMax , " = " , max , sep = " " )

4. Cette suite est donc croissante quand un terme est impair (et le suivant est pair), décroissante tant que les
termes sont pairs. Bonus : modifier ce programme pour qu’il affiche la longueur de la plus longue descente
(suite décroissante), en nombre de termes.

Solution :

1 A = int ( input ( " Saisir un entier srict . positif de depart : " ))

2 n =0
3 u_n = A
4 max = A
5 indiceDuMax =0
6 longu_descente =1
7 while u_n != 1:
8 if u_n %2==0:
9 u_n = u_n //2
10 longu_descente +=1
11 else :
12 u_n =3* u_n +1
13 longu_descente =1
14 n = n +1
15 if u_n > max :
16 max = u_n
17 indiceDuMax = n
18 print ( " u_ " , n , " = " , u_n , sep = " " )
19 print ( " Valeur max : " , end = " " )
20 print ( " u_ " , indiceDuMax , " = " , max , sep = " " )
21 print ( " Plus longue descente : longueur " , longu_descente )

UCA - Licence N1 / LAS / PASS - UE Info. - Python 15