Exercices – La boucle for

Comment travailler ces exercices

Dans cette série, la boucle for est au centre de l’apprentissage.

Pour les premiers exercices (niveau 1 à 3), essaie de résoudre chaque problème de deux façons :

1. avec une boucle while
2. avec une boucle for

Pour chacun des exercices, prend le temps d’identifier :

1. Ce que la boucle doit répéter ;
2. Ce qui change à chaque itération ;
3. Ce qui doit être conservé d’une itération à l’autre.

Aide-mémoire : la boucle for

Les trois formes de range()

Forme	Produit	Exemple
range(fin)	0, 1, …, fin-1	range(5) → 0, 1, 2, 3, 4
range(debut, fin)	debut, …, fin-1	range(1, 6) → 1, 2, 3, 4, 5
range(debut, fin, pas)	debut, debut+pas, …	range(0, 20, 5) → 0, 5, 10, 15

La borne de fin est toujours exclue

range(1, 10) produit 1 à 9, pas 1 à 10. Pour aller jusqu’à 10, écris range(1, 11).

Patrons courants: for vs while

Répéter n fois

Boucle for

for i in range(n):
    ...

Boucle while

i = 0
while i < n:
    ...
    i = i + 1

Compter de 1 à n

Boucle for

for i in range(1, n + 1):
    ...

Boucle while

i = 1
while i < n + 1:
    ...
    i = i + 1

Accumuler une somme

Boucle for

total = 0
for i in range(1, n + 1):
    total = total + i

Boucle while

total = 0
i = 1
while i < n + 1:
    total = total + i
    i = i + 1

Boucles imbriquées

Boucle for

for ligne in range(hauteur):
    for colonne in range(largeur):
        ...

Boucle while

ligne = 0
colonne = 0
while ligne < hauteur:
    while colonne < largeur:
        ...
        colonne = colonne + 1
    ligne = ligne + 1

---

Niveau 1 — Découvrir for avec range()

Exercice 1.1 : Nombres pairs

Écris un programme pairs.py qui affiche tous les nombres pairs de 2 à 50.

Résultat attendu :

2 4 6 8 10 12 14 16 18 20 22 24 26 28 30 32 34 36 38 40 42 44 46 48 50

💡 Indice

Utilise le pas de range(). Les nombres pairs commencent à 2 et avancent de 2 en 2.

---

Exercice 1.2 : Table de multiplication

Écris un programme table.py qui demande un nombre et affiche sa table de multiplication de 1 à 12.

Exemple d’exécution :

Table de : 7
7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
...
7 x 12 = 84

---

---

Niveau 2 — Accumulateurs et compteurs

Exercice 2.1 : Somme de 1 à N

Écris un programme somme_n.py qui demande un nombre $n$ et affiche la somme des entiers de 1 à $n$.

Exemple d’exécution :

Valeur de n : 100
La somme de 1 à 100 est : 5050

💡 Indice

Utilise le patron accumulateur : initialise somme = 0 puis ajoute i à chaque tour.

Exercice 2.2 : Prise de présences

Écris un programme presences.py qui prend les présences d’un groupe de 10 étudiants. Pour chaque étudiant, on saisit p (présent) ou a (absent). À la fin, le programme affiche le nombre de présents et d’absents.

Exemple d’exécution :

=== PRISE DE PRÉSENCES ===
Étudiant 1 (p/a) : p
Étudiant 2 (p/a) : p
Étudiant 3 (p/a) : a
Étudiant 4 (p/a) : p
Étudiant 5 (p/a) : a
Étudiant 6 (p/a) : p
Étudiant 7 (p/a) : p
Étudiant 8 (p/a) : p
Étudiant 9 (p/a) : a
Étudiant 10 (p/a) : p

Présents : 7
Absents : 3

💡 Indice

Utilise un compteur absents = 0 et incrémente-le chaque fois que la réponse est "a". Le nombre de présents se déduit : 10 - absents.

---

Exercice 2.3 : Facture multi-items

Écris un programme facture.py qui demande combien d’items le client achète, puis pour chaque item demande son prix. Le programme affiche le sous-total, les taxes (TPS 5 % et TVQ 9,975 %) et le total.

Exemple d’exécution :

=== FACTURE ===
Nombre d'items : 3
Prix de l'item 1 : 12.50
Prix de l'item 2 : 8.99
Prix de l'item 3 : 24.00

Sous-total : 45.49 $
TPS (5%)   : 2.27 $
TVQ (9.975%): 4.54 $
Total      : 52.30 $

💡 Indice

Accumule le sous-total dans une variable, puis calcule les taxes après la boucle.

---

Niveau 3 — Suivre des valeurs pendant la boucle

Exercice 3.1 : Moyenne de notes

Écris un programme moyenne.py qui demande le nombre d’examens, puis la note obtenue à chacun. Le programme affiche la moyenne, la note la plus haute et la plus basse.

Exemple d’exécution :

Nombre d'examens : 4
Note 1 : 85
Note 2 : 72
Note 3 : 91
Note 4 : 68

Moyenne : 79.00
Note la plus haute : 91
Note la plus basse : 68

💡 Indice

Tu as besoin de trois accumulateurs : total pour la somme, plus_haute et plus_basse pour les extrêmes. Initialise plus_haute à 0 et plus_basse à 100 (ou utilise la première note comme référence).

Exercice 3.2 : Dix lancers de dé

Écris un programme lancers.py qui simule 10 lancers d’un dé à 6 faces. Affiche chaque résultat puis la somme et la moyenne des lancers.

Exemple d’exécution :

=== 10 LANCERS DE DÉ ===
Lancer 1 : 4
Lancer 2 : 2
Lancer 3 : 6
Lancer 4 : 1
Lancer 5 : 3
Lancer 6 : 5
Lancer 7 : 2
Lancer 8 : 6
Lancer 9 : 4
Lancer 10 : 3

Somme : 36
Moyenne : 3.60

Exercice 3.3 : Mot aléatoire

Écris un programme mot_aleatoire.py qui génère un « mot » de 10 lettres minuscules aléatoires.

Astuce : les lettres minuscules ont des codes de ord("a") (97) à ord("z") (122). Un chr(random.randint(97, 122)) produit une lettre aléatoire.

Exemple d’exécution :

Mot aléatoire : xkdpqtmwbj

💡 Indice

Accumule les lettres dans une variable mot = "". À chaque tour, ajoute une lettre aléatoire avec mot = mot + chr(random.randint(97, 122)).

---

Exercice 3.4 : Suite de Fibonacci

La suite de Fibonacci commence par 0 et 1. Chaque terme suivant est la somme des deux précédents : $0, 1, 1, 2, 3, 5, 8, 13, 21, 34, \ldots$

Écris un programme fibonacci.py qui affiche les 20 premiers termes de la suite.

Résultat attendu :

=== SUITE DE FIBONACCI (20 termes) ===
0
1
1
2
3
5
8
13
21
34
55
89
144
233
377
610
987
1597
2584
4181

💡 Indice

Tu as besoin de deux variables : a (terme actuel) et b (terme suivant). À chaque itération : affiche a, puis calcule le prochain terme avec a, b = b, a + b.

Niveau 4 — Boucles imbriquées et motifs

Exercice 4.1 : Pyramide

Écris un programme pyramide.py qui demande une hauteur et affiche une pyramide centrée.

Exemple d’exécution :

Hauteur : 5
    *
   ***
  *****
 *******
*********

💡 Indice

À la ligne $i$ (en partant de 1) :

• Il y a hauteur - i espaces
• Il y a 2 * i - 1 étoiles

Utilise " " * nombre pour les espaces et "*" * nombre pour les étoiles.

Bonus : modifie le programme pour que l’utilisateur puisse :

• Choisir le symbole à imprimer (au lieu de *)
• Demander une pyramide inversée (pointe en bas)

Exercice 4.2 : Grille 10 × 10

Écris un programme grille.py qui affiche une grille de 10 lignes par 10 colonnes dans la console.

Résultat attendu :

+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+
|   |   |   |   |   |   |   |   |   |   |
+---+---+---+---+---+---+---+---+---+---+

💡 Indice

Observe le patron :

• Une ligne de séparation : +--- répété 10 fois, terminé par +
• Une ligne de contenu : | répété 10 fois, terminé par |

Chaque ligne de la grille = une ligne de séparation + une ligne de contenu. Termine par une dernière ligne de séparation.

Bonus : ajoute un paramètre scale qui permet d’agrandir ou réduire la taille d’une case.

• Avec scale = 1, une case fait --- de large et 1 ligne de haut.
• Avec scale = 2, une case fait ------ de large et 2 lignes de haut.

Exercice 4.3 : Table de Pythagore

Écris un programme pythagore.py qui affiche une table de multiplication de 1 × 1 à 10 × 10, sous forme de grille formatée.

Résultat attendu :

      1    2    3    4    5    6    7    8    9   10
  1   1    2    3    4    5    6    7    8    9   10
  2   2    4    6    8   10   12   14   16   18   20
  3   3    6    9   12   15   18   21   24   27   30
  4   4    8   12   16   20   24   28   32   36   40
  5   5   10   15   20   25   30   35   40   45   50
  6   6   12   18   24   30   36   42   48   54   60
  7   7   14   21   28   35   42   49   56   63   70
  8   8   16   24   32   40   48   56   64   72   80
  9   9   18   27   36   45   54   63   72   81   90
 10  10   20   30   40   50   60   70   80   90  100

💡 Indice

Utilise format(nombre, "4d") pour formater un entier sur 4 caractères (aligné à droite). Deux boucles imbriquées : la boucle extérieure pour les lignes, l’intérieure pour les colonnes. N’oublie pas la ligne d’en-tête.

---

Niveau 5 — Synthèse

Exercice 5.1 : Génération de coordonnées

Écris un programme coordonnees.py qui génère 10 coordonnées aléatoires $(x, y)$ dans un plan de 0 à 100. Affiche chaque point, puis la distance entre le premier et le dernier point.

La distance entre deux points $(x_1, y_1)$ et $(x_2, y_2)$ est : $d = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$

Exemple d’exécution :

=== 10 COORDONNÉES ALÉATOIRES ===
Point 1 : (23, 87)
Point 2 : (45, 12)
Point 3 : (78, 56)
...
Point 10 : (34, 91)

Distance entre le point 1 et le point 10 : 11.40

💡 Indice

Génère chaque point dans la boucle. Sauvegarde les coordonnées du premier point (quand i == 1) et du dernier point (quand i == 10) dans des variables séparées.

---

Exercice 5.2 : Histogramme horizontal

Écris un programme histogramme.py qui demande 5 valeurs (entre 1 et 30) et affiche un histogramme horizontal avec des barres de #.

Exemple d’exécution :

=== HISTOGRAMME ===
Valeur 1 : 12
Valeur 2 : 8
Valeur 3 : 20
Valeur 4 : 5
Valeur 5 : 15

Barre 1 : ############        (12)
Barre 2 : ########            (8)
Barre 3 : ####################(20)
Barre 4 : #####               (5)
Barre 5 : ###############     (15)

💡 Indice

Pour aligner les barres, pense à compléter avec des espaces. La largeur maximale est 30. Chaque barre a valeur caractères # suivis de 30 - valeur espaces.

Niveau 6 — Défis

Exercice 6.1 : Détecteur de nombres premiers

Écris un programme premiers.py qui affiche tous les nombres premiers entre 2 et 100.

Rappel: Un nombre est premier s’il n’est divisible que par 1 et par lui-même.

Résultat attendu :

Nombres premiers entre 2 et 100 :
2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Total : 25 nombres premiers

💡 Indice

Pour chaque nombre de 2 à 100, vérifie s’il est premier. Un nombre n est premier si aucun entier de 2 à n - 1 ne le divise. Utilise une boucle for imbriquée et un break quand tu trouves un diviseur. Le else sur un for te sera utile ici.

Exercice 6.2 : Jeu du plus ou moins (version limitée)

Écris un programme plus_ou_moins.py qui donne au joueur exactement 7 tentatives pour deviner un nombre aléatoire entre 1 et 100. Si le joueur n’a pas trouvé après 7 essais, il perd.

Exemple d’exécution (victoire) :

*** PLUS OU MOINS ***
Tentative 1/7 : 50
Trop grand !
Tentative 2/7 : 25
Trop petit !
Tentative 3/7 : 37
Trop petit !
Tentative 4/7 : 42
Bravo ! Trouvé en 4 tentatives !

Exemple d’exécution (défaite) :

Tentative 7/7 : 63
Trop petit !

Perdu ! Le nombre était 67.

💡 Indice

Utilise une boucle for de 7 itérations avec un break si le joueur trouve. Le else du for gère le cas où le joueur a épuisé ses tentatives.