Chapitre 10 – les structures
répétitives – La boucle Pour
Table des matières
I. En algorithme.................................................................................................. 2
II. Les boucles imbriquées............................................................................ 5
III. En Langage Python....................................................................................6
L’instruction Break :....................................................................................... 7
L’instruction Continue :................................................................................7
IV. Exercices d’application............................................................................7
Exercice 1 :.......................................................................................................... 7
Exercice 2 :.......................................................................................................... 8
Exercice 3 :.......................................................................................................... 8
Exercice 4 :.......................................................................................................... 8
Exercice 5............................................................................................................ 9
Exercice 6............................................................................................................ 9
Exercice 7............................................................................................................ 9
Exercice 8......................................................................................................... 10
Exercice 9......................................................................................................... 10
Exercice 10....................................................................................................... 10
Exercice 11....................................................................................................... 10
Exercice 12....................................................................................................... 11
Exercice 13....................................................................................................... 11
I. En algorithme
La syntaxe de la boucle Pour est :
Pour compteur allant de initiale à finale par pas valeur du
pas
Liste des instructions
FinPour
Remarque : le nombre d'itérations dans une boucle Pour est
connu avant le début de la boucle
Compteur est une variable de type entier (ou caractère).
Elle doit être déclarée.
Initiale et finale peuvent être des valeurs, des variables
définies avant le début de la boucle ou des expressions de
même type que compteur.
Pas est un entier qui peut être positif ou négatif. Pas peut
ne pas être mentionné, car par défaut sa valeur est égal à
1. Dans ce cas, le nombre d'itérations est égal à finale -
initiale+ 1.
Déroulement des boucles Pour :
1. La valeur initiale est affectée à la variable compteur
2. On compare la valeur du compteur et la valeur de finale :
a. Si la valeur du compteur est > à la valeur finale dans le
cas d'un pas positif (ou si compteur est < à finale pour
un pas négatif), on sort de la boucle et on continue avec
l'instruction qui suit FinPour
b. Si compteur est <= à finale dans le cas d'un pas positif
(ou si compteur est >= à finale pour un pas négatif),
instructions seront exécutées
i. Ensuite, la valeur de compteur est incrémentée de
la valeur du pas si pas est positif (ou décrémenté
si pas est négatif)
ii. On recommence l'étape 2 : La comparaison entre
compteur et finale est de nouveau effectuée, et
ainsi de suite …
Exemple 1 : Pour avec pas positif
Algorithme exemple_1
Variables
n, i : entier
Debut
Ecrire (" Entrez la valeur de n ")
Lire (n)
Pour i allant de 1 à n
Ecrire ("Bonjour tout le monde")
FinPour
Fin
Exemple 2 : Pour avec pas négatif
Algorithme exemple_1
Variables
n, i : entier
Debut
Ecrire (" Entrez la valeur de n ")
Lire (n)
Pour i allant de n à 1 pas -1
Ecrire ("Bonjour tout le monde")
FinPour
Fin
Liens entre Pour et tant que
La boucle Pour est un cas particulier de Tant Que (cas où le
nombre d'itérations est connu et fixé) . Tout ce qu'on peut écrire
avec Pour peut être remplacé avec TantQue (la réciproque est
fausse)
Pour compteur allant de initiale à finale par pas valeur du pas
instructions
FinPour
peut être remplacé par : (cas d'un pas positif)
compteur ← initiale
TantQue compteur <= finale
instructions
compteur ← compteur+pas
FinTantQue
II. Les boucles imbriquées
Les instructions d'une boucle peuvent être des instructions
itératives. Dans ce cas, on aboutit à des boucles imbriquées.
Pour i allant de 1 à 5
Pour j allant de 1 à i
écrire("O")
FinPour
écrire("X")
FinPou
Exécution du programme :
OX
OOX
OOOX
OOOOX
OOOOOX
III. En Langage Python
La syntaxe de l’utilisation de la boucle Pour en langage Python
est :
Construction sans bloc d'instructions :
for sequence in range(valeur depart, Valeur arrivee, pas) :
Instruction
La fonction range permet de générer des valeurs entières entre la
valeur de départ et la valeur d’arrivée.
Exemple 1 :
print("Exemple d’utilisation de for en python")
print("Affiche les nombres entre 0 et 6")
for i in range(6):
print(i, end=', ')
Le résultat de ce programme est :
Exemple d’utilisation de for en python
Affiche les nombres entre 0 et 6
0, 1, 2, 3, 4, 5,
L’instruction Break :
Sert à interrompre le déroulement de la boucle, en passant à
l'instruction qui suit cette boucle.
Exemple :
for i in range(10):
print("debut iteration", i)
print("bonjour")
if i == 2:
break
print("fin iteration", i)
print("apres la boucle")
L’instruction Continue :
L'instruction continue, quant à elle, permet de passer au tour de
boucle suivant, et donc de ne pas exécuter les instructions situées
après, dans le tour où elle est exécutée.
Exemple :
for i in range(4):
print("debut iteration", i)
print("bonjour")
if i < 2:
continue
print("fin iteration", i)
print("apres la boucle")
IV. Exercices d’application
Exercice 1 :
1. Écrire un algorithme qui demande un nombre de départ, et
qui ensuite écrit la table de multiplication de ce nombre,
présentée comme suit (cas où l'utilisateur entre le nombre 5)
:
Table de 5 :
5x1=5
5 x 2 = 10
5 x 3 = 15
…
5 x 10 = 50
2. Traduire l’algorithme en langage Python.
Algorithme exercice1
Variables
a , i : entier
Debut
Ecrire("Donner un nombre ")
Lire(a)
Pour i allant de 1 a 10
Ecrire(a,"*",i,"=", a*i)
FinPour
Fin
Exercice 2 :
1. Écrire un algorithme qui demande un nombre de départ, et
qui calcule la somme des entiers jusqu’à ce nombre. Par
exemple, si l’on entre 5, le programme doit calculer :
1 + 2 + 3 + 4 + 5 = 15
2. Traduire l’algorithme en langage Python
Algorithme exercice2
Variables
n , i : entier
Debut
Ecrire("Donner un nombre ")
Lire(n)
som 0
Pour i allant de 1 a n
som som + i
FinPour
Ecrire("La somme egale :", som)
Fin
Exercice 3 :
1. Écrire un algorithme qui demande un nombre de départ, et
qui calcule sa factorielle.
NB : la factorielle de 8, notée 8 ! vaut 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8
2. Traduire l’algorithme en langage Python
Algorithme exercice3
Variables
n , i : entier
Debut
Ecrire("Donner un nombre ")
Lire(n)
fact 1
Pour i allant de 1 a n
fact fact * i
FinPour
Ecrire("Le factoriel est :", fact)
Fin
Exercice 4 :
1. Écrire un algorithme qui demande successivement 10
nombres à l’utilisateur, et qui lui dise ensuite quel était le
plus grand parmi ces 10 nombres et sa position :
Entrez le nombre numéro 1 : 12
Entrez le nombre numéro 2 : 14
…
Entrez le nombre numéro 10 : 6
Le plus grand de ces nombres est : 14, sa position : 2
2. Traduire l’algorithme en langage Python
Algorithme exercice4
Variables
a,i,max,pmax : entier
Debut
Pour i allant de 1 a 10
Ecrire("Donner le nombre ",i)
Lire(a)
Si i = 1 OU max < a alors
max a
pmax = i
FinSi
FinPour
Erire("Le maximum est", max, " sa position", pmax)
Fin
Exercice 5
Écrire un algorithme qui demande successivement des nombres à
l’utilisateur, et qui lui dise ensuite quel était le plus grand parmi
ces nombres et quel était sa position. Le nombre des nombres
saisis est donné par l’utilisateur.
Algorithme exercice5
Variables
n,a,i,max,pmax : entier
Debut
Ecrire("Donner le nombre de saisis :")
Lire(n)
Pour i allant de 1 a n
Ecrire("Donner le nombre ",i)
Lire(a)
Si i = 1 OU max < a alors
max a
pmax = i
FinSi
FinPour
Erire("Le maximum est", max, " sa position", pmax)
Fin
Exercice 6
Écrire un algorithme qui demande successivement des nombres à
l’utilisateur, et qui lui dise ensuite quel la moyenne de ces
nombres. Le nombre des nombres saisis est donné par
l’utilisateur.
Exercice 7
1. Écrire un algorithme qui demande successivement des
nombres à l’utilisateur, et qui lui dise ensuite quel le nombre
des paires et impaires saisis. Le nombre des nombres saisis
est donné par l’utilisateur.
2. Traduire l’algorithme en langage Python
Exercice 8
1. Ecrire un algorithme(Algorithme pour chaque somme) qui
permet de calculer la somme des N premiers termes de la
série harmonique :
1 + 1/2 + 1/3 + ... + 1/N
1-1/2+1/4-1/6…..1/N
1+x+x²+…..+xn
1+x+x²/2+…….+xn/n
2. Traduire les algorithmes en langage Python
Exercice 9
Ecrire un algorithme qui vérifie si un nombre entier saisi par
l’utilisateur est un nombre premier ou pas.
Un nombre premier est un nombre qui ne permet la division
que sur 1 et lui-même.
Exemples de nombre premier : 2, 5, 7, 11, 13, 31….
Traduire l’algorithme en langage Python
Exercice 10
Ecrire un algorithme qui affiche tous les diviseurs d’un
nombre saisi par l’utilisateur.
Traduire l’algorithme en langage Python
Exercice 11
Ecrire un algorithme qui vérifie si un nombre entier saisi par
l’utilisateur est un nombre parfait ou pas.
Un nombre parfait et un entier qui est égal à la somme de ses
diviseurs (Exemple : le nombre 6 est parfait car 6=1+2+3).
Traduire l’algorithme en langage Python
Exercice 12
Écrire un algorithme qui calcule le PGCD de deux nombres
saisis par l’utilisateur.
Traduire l’algorithme en langage Python.
Algorithme PGCD_POUR
Variables
x,y,min, pgcd : entier
Debut
Ecrire(" Donner a et b: ")
Lire(x,y)
pgcd 1
min x
Si min > y alors
min y
Finsi
Pour i allant de 2 a min
Si x % i == 0 ET y%i==0 alors
Pgcd = i
Finsi
FinPour
Ecrire(" Le PGCD est ", pgcd)
Fin
Exercice 13
Faire un algorithme permettant de calculer d’afficher la table
des produits pour N variant de 1 à 10 :
X*Y 0 1 2 3 4 5 6 7 8 9 10
--------------------------------------------------
0 0 0 0 0 0 0 0 0 0 0 0
1 0 1 2 3 4 5 6 7 8 9 10
2 0 2 4 6 8 10 12 14 16 18 20
3 0 3 6 9 12 15 18 21 24 27 30
4 0 4 8 12 16 20 24 28 32 36 40
5 0 5 10 15 20 25 30 35 40 45 50
6 0 6 12 18 24 30 36 42 48 54 60
7 0 7 14 21 28 35 42 49 56 63 70
8 0 8 16 24 32 40 48 56 64 72 80
9 0 9 18 27 36 45 54 63 72 81 90
10 0 10 20 30 40 50 60 70 80 90 100
Traduire l’algorithme en langage Python
Exercice 14
Ecrire des programmes pour afficher les formes suivantes :
1. un Carré : Exemple un carré de 5.
*****
*****
*****
*****
*****
2. Un carré vide
*****
* *
* *
* *
*****
3. Triangle 1 : Exemple un triangle de 5
*
**
***
****
*****
4. Triangle 2
*****
****
***
**
*
5. Triangle 3
*
**
***
****
*****
6. Triangle 4
*
**
* *
* *
*****
7. Carre :
*****
** *
* * *
* **
*****
