Structures de contrôle : if, while, for, etc.

Licence pro. GTSBD 2013-2014 Structures de donn´ees, langage Python
S´erie 2 – Premiers programmes
Programmes avec des affectations, des lectures et des ´ecritures
Exo 2.1 – Le probl`eme de la machine qui rend la monnaie
´
Ecrivez un programme qui lit une somme exprim´ee en euros, sans centimes, et affiche le nombre
minimal de billets et de pi`eces de 2 et 1 euros n´ecessaires pour la composer.
Il s’agit pour le moment de r´ealiser un script sans boucles ni instruction conditionnelle. Vous avez
donc le droit de donner des r´eponses maladroites, pourvu qu’elles soient justes. Exemple d’ex´ecution
($est l’invite de ma machine) :
$python monnaie.py
Somme ? 1949
1949=+3x500+2x200+0x100+0x50+2x20+0x10+1x5+2x2+0x1
$
Indications. Si xet ysont des expressions enti`eres (de type int ou long), alors x/yvaut le quotient
entier (on dit aussi quotient «par d´efaut ») et x%yle reste de la division de xpar y.
Programmes avec des instructions conditionnelles if
Exo 2.2 – Jour de la semaine d’une date donn´ee
´
Ecrivez un programme qui calcule le jour de la semaine correspondant `a une date donn´ee, suppos´ee
correcte, exprim´ee sous forme de trois nombres entiers j(jour), m(mois) et a(ann´ee). Exemple
$python joursemaine.py
jour? 24
mois? 9
annee? 2009
le 24/9/2009 est un jeudi
$
Utilisez les formules suivantes :
m1=m−2,si m≥3
m+ 10,sinon ,a1=a, si m≥3 a−1,sinon ,ns= le si`ecle compt´e `a partir de 0 (c’est-`a-dire
tel qu’exprim´e par les deux premiers chiffres de a1), as= l’ann´ee dans le si`ecle (exprim´ee par les deux
derniers chiffres de a1), puis
f=j+as+as
4−2×ns+ns 4+26 ×m1−2 10
Dans ces conditions, le jour de la semaine est donn´e par le reste de la division de fpar 7 (0 ⇒
dimanche, 1 ⇒lundi,. . . 6⇒samedi).
Ci-dessus, les barres de fraction indiquent des divisions enti`eres (c’est-`a-dire des quotients par
d´efaut).
1

Exo 2.3 – R´eapparition de la machine qui rend la monnaie
Am´eliorez la solution pr´ec´edemment donn´ee de ce probl`eme, de mani`ere `a ´eviter les maladresses
que nous avons constat´ees. On doit obtenir maintenant, par exemple :
$ python monnaie.py
Somme ? 1949
1949=3x500+2x200+2x20+1x5+2x2
$
Exo 2.4 – La date du lendemain
´
Ecrivez un programme qui acquiert au clavier une date, exprim´ee sous forme de trois nombres
entiers j(jour), m(mois) et a(ann´ee) et qui affiche la date du lendemain. Exemple :
$python lendemain.py
jour? 30
mois? 9
annee? 2009
aujourd’hui: 30 9 2009
demain: 1 10 2009
$
Vous pouvez supposer que la date saisie est correcte.
Suggestion. Vous aurez fait le plus gros du travail quand vous aurez ´ecrit une expression logique,
portant sur les nombres j,met a, qui traduit exactement la proposition «(j, m, a) est le dernier jour
du mois ».
Rappel. Les ann´ees bissextiles sont les ann´ees multiples de 4 qui ne sont pas multiples de 100, et
les ann´ees multiples de 400.
Programmes avec des boucles while
Exo 2.5 – Moyenne d’une suite de nombres lus successivement
´
Ecrivez un programme qui lit au clavier une suite de nombres positifs ou nuls (tap´es successivement,
`a raison d’un par ligne) et en calcule la moyenne. On ne sait pas `a l’avance combien il y a de nombres,
c’est la frappe d’une valeur n´egative qui indique la fin de la suite. Exemple
$python moyenne.py
?10
?12
?8
?-1
moyenne: 10
$
Indication. Sous son air innocent, cet exercice est tr`es important car il illustre une situation que
vous rencontrerez souvent : traiter une suite de donn´ees dont on ne connaˆıt pas `a l’avance le nombre,
acquises successivement, jusqu’`a la rencontre d’une donn´ee invalide qui indique la fin de la suite.
Attachez-vous `a ´ecrire un programme ob´eissant au sch´ema universel et fiable suivant :
acqu´erir une donn´ee x
tant que x est valide :
traiter x (cela d´epend du probl`eme particulier consid´er´e)
acqu´erir une donn´ee x
2

La plupart des langages actuels disposent d’une instruction d’abandon de boucle, comme break
en Python. Un autre sch´ema universel et fiable est alors celui-ci :
r´ep´eter ind´efiniment :
acqu´erir une donn´ee x
si x est invalide :
abandonner la boucle
traiter x (cela d´epend du probl`eme particulier consid´er´e)
Exo 2.6 – Tester la fonction random
La fonction random() du module random (voyez http://docs.python.org/library/random.
html) renvoie, chaque fois qu’on l’appelle, un nombre flottant xv´erifiant 0 ≤x < 1, la suite des
nombres successivement produits ´etant pseudo-al´eatoire 1.
Pour tester (tr`es succinctement) cette fonction, ´ecrivez un programme qui fait un grand nombre
d’appels de cette fonction et qui calcule la moyenne et l’´ecart-type des valeurs obtenues.
Rappels.´ Etant donn´ee une suite de nnombres (xi)0≤i<n, sa moyenne est d´efinie par x=1
n
n−1
P
i=0
xi
et son ´ecart-type par ρ=s1
n
n−1
P
i=0
x2
i−x2.
Note. Si la fonction random ´etait parfaite et le nombre de tirages infini, la moyenne vaudrait 1
2et
l’´ecart-type 1
√12 = 0,28867513459481292
Exo 2.7 – Facteurs premiers d’un nombre
1. ´ Ecrivez un programme qui lit un nombre entier au clavier et en affiche les facteurs premiers.
Premi`ere version, simple :
$python diviseurs.py
n? 720
720=2*2*2*2*3*3*5
$
On impl´ementera le sch´ema – assez maladroit, mais suffisant – suivant :
acqu´erir le nombre entier n dont on recherche les diviseurs
pour chaque nombre entier d allant de 2 jusqu’`a n :
tant que d divise n :
afficher d
remplacer n par n/d
2. ´ Ecrivez une deuxi`eme version du programme produisant un affichage plus proche de la coutume
math´ematique :
$python diviseurs.py
n? 720
720 = 2^4 * 3^2 * 5^1
$
1. En r´ealit´e on souhaite une suite al´eatoire, c’est-`a-dire faite de nombres choisis au hasard, mais les ordinateurs ne
savent pas faire des choses au hasard. On emploie donc des algorithmes math´ematiques produisant des suites pseudo-
al´eatoires, cens´ees avoir une tr`es grande p´eriode (on peut produire beaucoup de valeurs avant de retomber sur la s´equence
d´ej`a produite) et des propri´et´es statistiques aussi proches que possible de celles d’une suite al´eatoire.
3

Exo 2.8 – Deviner un nombre
´
Ecrivez un programme qui tire au hasard un nombre entier (secret) nv´erifiant 0 ≤n < 100 puis
lit des nombres propos´es par l’utilisateur en r´epondant `a chaque fois trop grand,trop petit ou gagn´e
et en comptant le nombre d’essais n´ecessaires `a l’utilisateur pour deviner le nombre secret. Exemple :
$python jeu.py
?50
trop grand
?25
trop petit
?37
trop petit
?42
trop grand
?40
bravo, vous avez gagn´e en 5 coups!
$
Programmes avec des boucles for
Exo 2.9 – Calcul de la factorielle
´
Ecrivez un programme qui calcule it´erativement (c’est-`a-dire selon un algorithme bas´e sur une
boucle, ici une boucle for) la valeur de la factorielle d’un nombre donn´e. Exemple :
$python factorielle.py
n ? 50
50 ! = 30414093201713378043612608166064768844377641568960512000000000000
$
Rappel. La factorielle d’un nombre nv´erifiant n≥0 est le nombre n! = n×(n−1) ×(n−2) ×
... ×3×2×1
Exo 2.10 – Tabulation d’une fonction
´
Ecrivez un programme qui affiche les valeurs du sinus des angles de 0 `a 90 degr´es par pas de 15
degr´es. On souhaite un affichage respectant strictement la forme suivante :
sin( 0) = 0.000000
sin( 15) = 0.258819
sin( 30) = 0.500000
...
sin( 90) = 1.000000
Exo 2.11 – Encore la machine qui rend la monnaie
R´e´ecrivez une nouvelle version de ce programme en r´eduisant significativement le nombre de ses
lignes par l’utilisation d’une une liste constante repr´esentant les coupures disponibles et une instruction
de boucle for.
Exo 2.12 – Remboursement d’un cr´edit
´
Ecrivez un programme qui ´etant donn´es un capital emprunt´e, un taux d’int´erˆet et un nombre de
mensualit´es, calcule et affiche
4

– d’une part, le montant des mensualit´es de remboursement, en supposant qu’il s’agit d’un emprunt
`a taux fixe et mensualit´es constantes,
– d’autre part, le plan de remboursement, c’est-`a-dire un tableau o`u chaque ligne montre l’int´erˆet
pay´e et le capital restant dˆu chaque mois.
La formule pour calculer la mensualit´e est
M=C×t
1−1
(1+t)n
o`u Mest la mensualit´e, Cle capital emprunt´e, nle nombre de mensualit´es et tle taux mensuel «pour
1», c’est-`a-dire le taux exprim´e «normalement »(en pourcentage annuel) divis´e par 100 et par 12.
Exemple :
$python emprunt.py
capital? 10000
int´er^et (taux annuel)? 12
nombre de mensualit´es? 12
mensualit´e: 888.49
+-----+------------+------------+------------+------------+
| | | | capital | capital |
| | mensualit´e | int´er^ets | rembours´e | restant d^u |
+-----+------------+------------+------------+------------+
| | | | | 10000.00 |
| 1 | 888.49 | 100.00 | 788.49 | 9211.51 |
| 2 | 888.49 | 92.12 | 796.37 | 8415.14 |
| 3 | 888.49 | 84.15 | 804.34 | 7610.80 |
| 4 | 888.49 | 76.11 | 812.38 | 6798.42 |
| 5 | 888.49 | 67.98 | 820.50 | 5977.92 |
| 6 | 888.49 | 59.78 | 828.71 | 5149.21 |
| 7 | 888.49 | 51.49 | 837.00 | 4312.21 |
| 8 | 888.49 | 43.12 | 845.37 | 3466.85 |
| 9 | 888.49 | 34.67 | 853.82 | 2613.03 |
| 10 | 888.49 | 26.13 | 862.36 | 1750.67 |
| 11 | 888.49 | 17.51 | 870.98 | 879.69 |
| 12 | 888.49 | 8.80 | 879.69 | 0.00 |
+-----+------------+------------+------------+------------+
$
Exo 2.13 – Calculette ´el´ementaire
´
Ecrivez un programme qu’on lance avec trois arguments, deux nombres et un op´erateur parmi +,
−,×et /, et qui affiche le r´esultat de l’op´eration indiqu´ee. Exemples :
$python calc.py 2 / 3
2.0 / 3.0 = 0.666666666667
$python calc.py 123000 + 456
123000 + 456 = 123456
$python calc.py 2 % 3
operation inconnue: %
$
Il fait prendre garde au fait qu’en UNIX le caract`ere *dans une ligne de commande est toujours
substitu´e par une liste de fichiers ; pour indiquer l’op´erateur de multiplication il faut donc le taper
sous une des formes ’*’ ou \* :
5