Université Clermont Auvergne Portail Maths Info, LAS Maths-Info, PASS Info
Algorithmique et Programmation en Python - Semestre 1
Algorithmique et Programmation en Python
TD06 : Boucles for
Exercice 1 : Comptons les moutons
1. Écrire un programme qui demande à l’utilisateur un nombre de moutons, et qui ”compte les moutons” :
Combien de moutons ? 3
1 moutons
2 moutons
3 moutons
2. Que se passe-t-il si le nombre de moutons rentré par l’utilisateur est 1 ? Est nul ? Est négatif ?
3. Modifier le programme précédent pour qu’il affiche un seul mouton au singulier (”1 mouton” plutôt que ”1
moutons”).
Exercice 2 : Les classiques sur les listes, le retour
On se propose ici de réécrire encore une fois les classiques sur les listes, cette fois-ci avec une boucle for. Le but est
que vous connaissiez l’algorithme associé, ce qui vous sera utile dans d’autres langages (en C par exemple). On s’in-
terdira donc d’utiliser les fonctions Python prédéfinies suivantes : index, count, min, max, sum, [Link]
1. Affichage d’une liste Écrire une fonction affiche qui prend en argument une liste et un argument optionnel
separateur (valant par défaut un espace) et qui affiche le contenu de la liste, chaque élément étant séparé
du précédent par le séparateur demandé. Pour simplifier, on écrira également ce séparateur après le dernier
élément.
2. Indice d’apparition Écrire une fonction indice qui prend en paramètre une liste de nombres et un nombre,
et qui renvoie l’indice de la dernière position de ce nombre dans cette liste, ou renvoie -1 si le nombre n’y
apparaît pas.
3. Comptage d’élément Écrire une fonction nb_occ qui prend en paramètre une liste de nombres et un
nombre et qui compte combien de fois ce nombre apparaît dans la liste. La fonction renvoie ce compteur.
4. Recherche de minimum Écrire une fonction minimum qui prend en paramètre une liste de nombres et qui
renvoie son élément minimum, ou None si la liste est vide.
5. Recherche de maximum Écrire une fonction maximum qui prend en paramètre une liste de nombres et qui
renvoie l’indice de son plus grand élément, ou None si la liste est vide.
6. Calcul de somme Écrire une fonction somme qui prend en paramètre une liste de nombres et renvoie la
somme de ces nombres.
7. Calcul de moyenne Écrire une fonction moyenne qui prend en paramètre une liste de nombres et renvoie
la moyenne de ces nombres. Vous pouvez faire appel aux fonctions que vous avez définies précédemment.
Exercice 3 : Sommes d’entiers
1. Chacune des trois fonctions demandées ci-dessous prennent en paramètre l’entier n mentionné.
(a) Écrire une fonction somme qui renvoie la somme des n premiers entiers naturels (commençant à 0)
(b) Écrire une fonction sommeImpairs qui renvoie la somme des n premiers entiers impairs
(c) Écrire une fonction sommeCarres qui renvoie la somme des n premiers carrés (commençant à 0)
2. Écrire un programme principal qui lit un entier au clavier, appelle ces fonctions l’une après l’autre, et affiche
leurs résultats (avec un texte clair à chaque fois).
Exercice 4 : Liste de notes
1. Écrire une fonction rabote qui prend en argument une liste l de nombres, et un argument faculatif seuil
dont la valeur par défaut est 20, et qui modifie l de telle sorte que tous les nombres au-dessus du seuil soient
remplacés par seuil. Cette fonction ne renvoie rien mais elle a des effets de bord sur l.
Exemple : si l vaut [10, 6.5, 21, 7.25, 20, 20.5, 17] alors après l’appel rabote(l), l doit valoir [10,
6.5, 20, 7.25, 20, 20, 17]
UCA - Licence N1 / LAS / PASS - UE Info. - Python 1
2. Écrire une fonction indicesMax qui prend en argument une liste non-vide l et qui renvoie une liste contenant
tous les indices i tels que l[i] atteint le maximum de la liste.
Exemple : si l vaut [10, 6.5, 20, 7.25, 20, 20, 17], alors la fonction doit renvoyer [2,4,5] (le maxi-
mum de la liste est 20 et il est atteint en indices 2, 4 et 5).
3. Écrire une fonction notesSousSeuil qui prend en argument une liste l de nombres et un argument optionnel
seuil, valant 10 par défaut, et qui renvoie la liste des notes strictement en-dessous du seuil qui sont contenues
dans l. La liste l ne doit pas être modifiée par l’appel. Par exemple pour l valant [10, 6.5, 20, 7.25,
20, 20, 17], la fonction doit renvoyer [6.5, 7.25].
Exercice 5 : Factorielle et puissance
1. Écrire une fonction qui utilise un for pour calculer et renvoyer la factorielle d’un entier n reçu en paramètre.
2. Écrire une fonction qui reçoit en paramètre deux entiers n et a (a supposé positif ou nul), et qui renvoie la
valeur de na . Attention, on vous demande de ne pas utiliser l’opérateur de puissance ** mais d’utiliser une
boucle for.
Exercice 6 : ASCII Art
Dans cet exercice, on s’interdit d’utiliser la multiplication de chaînes de caractères pour s’exercer sur les boucles.
1. Écrire une fonction regleGraduee qui prend en argument deux entiers n et un intervalle p et qui affiche une
règle graduée de longueur n, comme sur l’exemple ci-dessous : le symbole | est affiché au début, puis tous les
p caractères. De plus si p est inférieur ou égal à 10, alors entre les deux premiers | on affiche les chiffres de 1
à p − 1.
Avec n = 27 et p = 10 : |123456789|––––-|–––-
Avec n = 16 et p = 3 : |12|–|–|–|–|-
Avec n = 42 et p = 20 : |–––––––––-|–––––––––-|–
2. Écrire une fonction trianglePlein qui prend en argument un entier n et affiche un triangle d’étoiles de
hauteur n comme sur les exemples ci-dessous :
n=1 n=2 n=5 n = 10
* * * *
*** *** ***
***** *****
******* *******
********* *********
***********
*************
***************
*****************
*******************
3. Écrire une fonction triangleContour qui prend en argument un entier n et un caractère interieur, et qui
dessine le contour d’un triangle de hauteur n avec les étoiles, et qui remplit l’intérieur du triangle avec le
caractère interieur.
n=1 n=2 n = 5 et interieur="o" n = 10 et interieur="."
* * * *
*** *o* *.*
*ooo* *...*
*ooooo* *.....*
********* *.......*
*.........*
*...........*
*.............*
*...............*
*******************
4. Ré-écrire votre fonction trianglePlein de façon beaucoup plus courte, en appelant triangleContour.
UCA - Licence N1 / LAS / PASS - UE Info. - Python 2
5. Écrire une fonction sapinNoel qui prend en argument un entier n et un entier freq, et qui dessine un sapin
de Noël sous la forme d’un triangle de hauteur n, comprenant des . à l’intérieur, avec remplacement du .
par un o tous les freq caractères.
n = 10 et freq=3 n = 10 et freq=2 n = 15 et freq=5
* * *
*.* *.* *.*
*..o* *.o.* *...*
*..o..* *.o.o.* *....o*
*..o..o.* *.o.o.o.* *....o..*
*..o..o..o* *.o.o.o.o.* *....o....*
*..o..o..o..* *.o.o.o.o.o.* *....o....o.*
*..o..o..o..o.* *.o.o.o.o.o.o.* *....o....o...*
*..o..o..o..o..o* *.o.o.o.o.o.o.o.* *....o....o....o*
******************* ******************* *....o....o....o..*
*....o....o....o....*
*....o....o....o....o.*
*....o....o....o....o...*
*....o....o....o....o....o*
*****************************
Exercice 7 : Zip
Écrire une fonction zip qui reçoit 2 chaînes et renvoie leur ”fermeture éclair”, c’est-à-dire la liste de toutes les
chaînes obtenues en combinant un caractère de la première chaîne suivi d’un caractère de la deuxième chaîne.
>>> zip("abc", "d") == ['ad', 'bd', 'cd']
True
>>> zip("a", "bcd") == ['ab', 'ac', 'ad']
True
>>> zip("ab", "cd") == ['ac', 'ad', 'bc', 'bd']
True
Exercice 8 : Liste de mots
Dans cet exercice, on s’interdira l’utilisation du mot-clé in. On pourra s’aider de fonctions auxiliaires (c’est-
à-dire créer davantage de fonctions que celles explicitement demandées, et ensuite faire appel à nos fonctions
auxiliaires nouvellement créées pour répondre aux questions demandées).
1. Écrire une fonction commencent qui reçoit une liste de mots lm, un caractère c, et qui renvoie une liste des
mots de lm qui commencent par c.
2. Écrire une fonction terminent similaire à la précédente, mais qui renvoie la liste des mots de lm qui finissent
par c
3. Écrire une fonction contiennent avec les mêmes paramètres qui renvoie la liste des mots de lm qui contiennent
la lettre c.
4. Écrire une fonction similaire avec un paramètre optionnel supplémentaire n (valeur par défaut = 1) qui
renvoie la liste des mots de lm contenant au moins n fois la lettre c.
Exercice 9 : Drapeaux
Attention : vous devez maintenant prendre soin de réfléchir, lors du choix d’une boucle, entre une boucle for
et une boucle while.
1. Écrire une fonction tousPositifs qui prend en argument une liste de nombres et qui renvoie un booléen
indiquant si tous les nombres de la liste sont strictement positifs.
2. Écrire une fonction qui reçoit une liste d’entiers et qui renvoie un booléen indiquant si les éléments de cette
liste sont dans l’ordre croissant (non strict), c’est-à-dire si pour tout indice i, l’élément en position i est
inférieur ou égal à l’élément en position i+1.
3. Écrire une fonction qui reçoit en argument un mot, qui détermine si ce mot est un palindrome, et qui renvoie
le résultat (un booléen). Un palindrome est un mot qui se lit de la même manière de la gauche vers la droite
ou de la droite vers la gauche, comme "kayak" ou "elle".
UCA - Licence N1 / LAS / PASS - UE Info. - Python 3
Exercice 10 : Basiques sur for et range
1. Pour les instructions suivantes, indiquer ce qui sera affiché.
for i in range(4) :
print(i)
for j in range(2,5):
print(j)
for k in range(3,12,3):
print(k)
for l in range(12, 3):
print(l)
for m in range(12,3,-2):
print(m)
2. Écrire une boucle for qui affiche les entiers de 1 à 10 (un par ligne)
3. Écrire une boucle for qui affiche les entiers de 1 à 10 en ordre inverse
4. Idem mais en les affichant sur une seule ligne, séparés par une virgule, ligne terminée par un point.
5. Écrire une fonction qui reçoit 3 entiers (deux bornes et un pas) et affiche les entiers entre ces deux bornes
incluses, séparés par ce pas. (Par ex. pour les bornes 1 et 20, et un pas de 3, il doit afficher : 1, 4, 7, 10, 13,
16, 19.)
6. Écrire un programme principal qui demande à l’utilisateur des bornes binf et bsup et un pas step, et appelle
la fonction précédente pour afficher la liste des entiers entre ces bornes séparés par ce pas.
7. Écrire une boucle for qui affiche les multiples de 3 et les multiples de 5 compris entre 1 et 50.
8. Idem mais en n’affichant pas les multiples de 15. Par exemple on veut afficher : 3,5,6,9,10,12,18,20,21,etc
Exercice 11 : Pile ou face, et statistiques
1. Écrire une fonction nb_pile(T) qui reçoit un entier T, simule une partie de T tirages Pile ou Face, et renvoie
le nombre de Pile obtenus.
2. Écrire une fonction liste_nbpile(N,T) qui reçoit un entier N et un entier T, qui simule N parties de T
tirages Pile ou Face, qui construit la liste de N entiers contenant le nombre de Pile obtenus pour chaque
partie, et qui renvoie cette liste.
3. A partir d’une liste d’éléments correspondant au nombre de Pile obtenus dans plusieurs parties de Pile ou
Face, et d’un entier T (le nombre de tirages par partie), on veut construire et afficher un histogramme du
nombre de parties ayant obtenu chaque nombre de Pile possible (entre 0 et T inclus). On va procéder en
plusieurs étapes :
(a) Écrire une fonction compte_parties_xpile(liste_pile,x) qui reçoit la liste de N nombres de tirages
Pile par partie (pour les N parties), et qui compte le nombre d’occurrences d’une valeur x. Cela représente
le nombre de parties qui se sont conclues par x tirages Pile.
(b) Utiliser cette fonction pour écrire une fonction liste_cpt_parties qui construit une liste de compteurs
correspondant au nombre de parties qui se sont conclues par chaque nombre de tirages Pile possible
(T+1 valeurs, entre 0 si on a fait Face à chaque fois, et T si on a fait Pile à chaque fois). La fonction
renvoie cette nouvelle liste.
(c) Combien de fois parcourt-on la liste des résultats des N parties ?
(d) Réécrire cette fonction pour compter le nombre de parties conclues par chaque nombre de tirages Pile
(liste à T+1 éléments) en un seul parcours de la liste de N parties.
(e) Affichage histogramme : écrire une fonction qui reçoit une liste de T+1 entiers et l’affiche sous forme
d’un histogramme horizontal à T+1 lignes, sur chacune desquelles apparaît le numéro i de la ligne (de
0 à T inclus) et un nombre d’étoiles proportionnel à la valeur associée (qui correspond au nombre de
parties ayant obtenu exactement i Pile).
4. Écrire un programme principal qui demande à l’utilisateur un nombre de parties N et un nombre de tirages
par partie T, qui simule les tirages et affiche l’histogramme résultant, en appelant les fonctions précédentes.
N’hésitez pas à reprendre les exercices des fiches de TD précédentes (en particulier celle sur la boucle while et celle
sur les listes) et essayez de les refaire, en s’autorisant cette fois-ci les boucles for.
UCA - Licence N1 / LAS / PASS - UE Info. - Python 4