Boucle pour (bornée) | Algorithmique et programmation | 10 Exercices corrigés

Concepts & Exercices

$\text{for } i \text{ in range}(n):$

$\text{for } i \text{ in range}(a, b):$

\(\text{for } i \text{ in range}(a, b, \text{pas}):$

Structure de répétition bornée

Boucle simple

for i in range(5):
action

Répète 5 fois

Bornes inclusives

range(a, b)
i ∈ [a, b-1]

Borne inf incluse, sup exclue

Avec pas

range(a, b, 2)
i = a, a+2, a+4...

Incrément personnalisé

Itération

i change à chaque tour

Valeur courante de la boucle

🎯

Définition : Une boucle bornée répète un bloc d'instructions un nombre fixe de fois.

🔗

range() : Fonction qui génère une séquence de nombres entiers.

✅

Nombre fixe : Le nombre d'itérations est connu à l'avance.

📊

Applications : Calculs itératifs, affichage répété, somme de suites.

💡

Conseil : Visualisez la boucle comme une machine qui effectue une tâche plusieurs fois

🔍

Attention : La borne supérieure de range() est exclue

⚡

Astuce : range(0, n) équivaut à range(n)

📋

Méthode : Tracez la valeur de la variable de boucle à chaque itération

Exercice 1

Qu'affiche la boucle for i in range(3): print(i) ?

Exercice 2

Calculer la somme des entiers de 1 à 5 avec une boucle for

Exercice 3

Qu'affiche for i in range(2, 6): print(i) ?

Exercice 4

Calculer 3^4 en utilisant une boucle for

Exercice 5

Qu'affiche for i in range(0, 10, 2): print(i) ?

Exercice 6

Afficher les carrés des entiers de 1 à 4

Exercice 7

Compter les nombres pairs entre 0 et 10

Exercice 8

Calculer la factorielle de 5 avec une boucle for

Exercice 9

Afficher la table de multiplication de 7

Exercice 10

Calculer la somme des carrés de 1 à 4

Corrigé : Exercices 1 à 5

1 Boucle for i in range(3)

Définition :

Boucle bornée : Répète un bloc un nombre prédéterminé de fois.

Méthode d'évaluation :

Identifier les bornes de la boucle
Calculer le nombre d'itérations
Suivre la variable de boucle à chaque itération

Code Python

                for i in range(3):

                  print(i)

Étape 1 : Analyser la fonction range()

range(3) génère la séquence [0, 1, 2]

Étape 2 : Itération 1

i = 0, affiche 0

Étape 3 : Itération 2

i = 1, affiche 1

Étape 4 : Itération 3

i = 2, affiche 2

Étape 5 : Fin de la boucle

La boucle s'arrête car range(3) ne contient que 0, 1, 2

Réponse finale :

La boucle affiche :
0
1
2

Règles appliquées :

• range(n) : Génère des entiers de 0 à n-1 (n exclus)

• Nombre d'itérations : Exactement n fois

• Variable de boucle : Change à chaque passage

2 Somme des entiers de 1 à 5

Définition :

Somme itérative : Accumulation progressive d'une valeur.

Code Python

                somme = 0

                for i in range(1, 6):

                  somme = somme + i

                print(somme)

Étape 1 : Initialiser la variable d'accumulation

somme = 0 avant la boucle

Étape 2 : Itération 1 (i = 1)

somme = 0 + 1 = 1

Étape 3 : Itération 2 (i = 2)

somme = 1 + 2 = 3

Étape 4 : Itération 3 (i = 3)

somme = 3 + 3 = 6

Étape 5 : Itération 4 (i = 4)

somme = 6 + 4 = 10

Étape 6 : Itération 5 (i = 5)

somme = 10 + 5 = 15

Réponse finale :

La somme des entiers de 1 à 5 est 15

Règles appliquées :

• Accumulation : Variable mise à jour à chaque itération

• range(1, 6) : Génère 1, 2, 3, 4, 5 (borne sup exclue)

• Initialisation : Variable d'accumulation commence à 0

3 Boucle for i in range(2, 6)

Définition :

Bornes personnalisées : Spécifie début et fin de la séquence.

Code Python

                for i in range(2, 6):

                  print(i)

Étape 1 : Analyser la fonction range()

range(2, 6) génère la séquence [2, 3, 4, 5]

Étape 2 : Itération 1

i = 2, affiche 2

Étape 3 : Itération 2

i = 3, affiche 3

Étape 4 : Itération 3

i = 4, affiche 4

Étape 5 : Itération 4

i = 5, affiche 5

Étape 6 : Fin de la boucle

La boucle s'arrête car 6 est exclu de range(2, 6)

Réponse finale :

La boucle affiche :
2
3
4
5

Règles appliquées :

• range(début, fin) : Génère de début à fin-1

• Borne inf incluse : Valeur de départ est incluse

• Borne sup exclue : Valeur de fin est exclue

4 Calcul de 3^4 avec boucle

Définition :

Puissance itérative : Multiplication répétée d'un nombre par lui-même.

Code Python

                resultat = 1

                for i in range(4):

                  resultat = resultat * 3

                print(resultat)

Étape 1 : Initialiser le résultat

resultat = 1 (élément neutre de la multiplication)

Étape 2 : Itération 1 (i = 0)

resultat = 1 * 3 = 3

Étape 3 : Itération 2 (i = 1)

resultat = 3 * 3 = 9

Étape 4 : Itération 3 (i = 2)

resultat = 9 * 3 = 27

Étape 5 : Itération 4 (i = 3)

resultat = 27 * 3 = 81

Étape 6 : Fin de la boucle

Après 4 itérations, resultat = 81

Réponse finale :

Le résultat est 81, donc 3^4 = 81

Règles appliquées :

• Initialisation : Variable commence à 1 pour multiplication

• Nombre d'itérations : Égal à l'exposant

• Opération répétée : Multiplication par la base

5 Boucle for i in range(0, 10, 2)

Définition :

Pas personnalisé : Incrément différent de 1.

Code Python

                for i in range(0, 10, 2):

                  print(i)

Étape 1 : Analyser la fonction range()

range(0, 10, 2) génère la séquence [0, 2, 4, 6, 8]

Étape 2 : Itération 1

i = 0, affiche 0

Étape 3 : Itération 2

i = 2, affiche 2

Étape 4 : Itération 3

i = 4, affiche 4

Étape 5 : Itération 4

i = 6, affiche 6

Étape 6 : Itération 5

i = 8, affiche 8

Étape 7 : Fin de la boucle

La boucle s'arrête car 10 est exclu de range(0, 10, 2)

Réponse finale :

La boucle affiche :
0
2
4
6
8

Règles appliquées :

• range(début, fin, pas) : Génère avec incrément personnalisé

• Borne sup toujours exclue : Même avec pas personnalisé

• Progression arithmétique : Suite de raison égale au pas

Corrigé : Exercices 6 à 10

6 Carrés des entiers de 1 à 4

Définition :

Calcul itératif : Effectuer une opération pour chaque élément.

Code Python

                for i in range(1, 5):

                  carré = i * i

                  print(f"Carré de {i} = {carré}")

Étape 1 : Boucle sur la plage [1, 4]

range(1, 5) génère 1, 2, 3, 4

Étape 2 : Itération 1 (i = 1)

carré = 1 * 1 = 1, affiche "Carré de 1 = 1"

Étape 3 : Itération 2 (i = 2)

carré = 2 * 2 = 4, affiche "Carré de 2 = 4"

Étape 4 : Itération 3 (i = 3)

carré = 3 * 3 = 9, affiche "Carré de 3 = 9"

Étape 5 : Itération 4 (i = 4)

carré = 4 * 4 = 16, affiche "Carré de 4 = 16"

Réponse finale :

La boucle affiche :
Carré de 1 = 1
Carré de 2 = 4
Carré de 3 = 9
Carré de 4 = 16

Règles appliquées :

• Calcul intermédiaire : Variable locale à chaque itération

• Formatage : Utilisation de f-string pour affichage clair

• Itération complète : Traite tous les éléments de la plage

7 Compter les nombres pairs entre 0 et 10

Définition :

Compteur conditionnel : Incrémentation basée sur une condition.

Code Python

                compteur = 0

                for i in range(0, 11):

                  if i % 2 == 0:

                    compteur = compteur + 1

                print(f"Nombre de pairs : {compteur}")

Étape 1 : Initialiser le compteur

compteur = 0 avant la boucle

Étape 2 : Itérations avec condition

range(0, 11) génère 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

Les pairs sont : 0, 2, 4, 6, 8, 10

Étape 3 : Incrémentation du compteur

Pour chaque nombre pair, compteur += 1

Étape 4 : Résultat final

Il y a 6 nombres pairs entre 0 et 10

Réponse finale :

Il y a 6 nombres pairs entre 0 et 10

Règles appliquées :

• Modulo : i % 2 == 0 vérifie si i est pair

• Compteur conditionnel : Incrémenté seulement si condition vraie

• Borne incluse : range(0, 11) inclut 10

8 Factorielle de 5 avec boucle

Définition :

Factorielle : Produit de tous les entiers positifs jusqu'à n.

Code Python

                resultat = 1

                for i in range(1, 6):

                  resultat = resultat * i

                print(f"5! = {resultat}")

Étape 1 : Initialiser le résultat

resultat = 1 (élément neutre de la multiplication)

Étape 2 : Itération 1 (i = 1)

resultat = 1 * 1 = 1

Étape 3 : Itération 2 (i = 2)

resultat = 1 * 2 = 2

Étape 4 : Itération 3 (i = 3)

resultat = 2 * 3 = 6

Étape 5 : Itération 4 (i = 4)

resultat = 6 * 4 = 24

Étape 6 : Itération 5 (i = 5)

resultat = 24 * 5 = 120

Étape 7 : Résultat final

5! = 120

Réponse finale :

La factorielle de 5 est 120

Règles appliquées :

• Accumulation multiplicative : Multiplication progressive

• Plage correcte : range(1, 6) pour inclure 5

• Initialisation : Variable commence à 1 pour multiplication

9 Table de multiplication de 7

Définition :

Table de multiplication : Produits successifs d'un nombre.

Code Python

                for i in range(1, 11):

                  resultat = 7 * i

                  print(f"7 x {i} = {resultat}")

Étape 1 : Boucle sur les multiplicateurs

range(1, 11) génère 1 à 10

Étape 2 : Calculs itératifs

7 x 1 = 7, 7 x 2 = 14, ..., 7 x 10 = 70

Étape 3 : Affichage formaté

Chaque produit est affiché sous forme d'équation

Étape 4 : Résultat complet

La table de 7 de 1 à 10

Réponse finale :

La table de multiplication de 7 est affichée de 7x1 à 7x10

Règles appliquées :

• Calcul répétitif : Multiplication par la variable de boucle

• Formatage clair : Affichage lisible de chaque produit

• Plage standard : Table de 1 à 10

10 Somme des carrés de 1 à 4

Définition :

Somme de carrés : Accumulation des carrés successifs.

Code Python

                somme_carres = 0

                for i in range(1, 5):

                  carré = i * i

                  somme_carres = somme_carres + carré

                print(f"Somme des carrés : {somme_carres}")

Étape 1 : Initialiser la somme

somme_carres = 0 avant la boucle

Étape 2 : Itération 1 (i = 1)

carré = 1² = 1, somme_carres = 0 + 1 = 1

Étape 3 : Itération 2 (i = 2)

carré = 2² = 4, somme_carres = 1 + 4 = 5

Étape 4 : Itération 3 (i = 3)

carré = 3² = 9, somme_carres = 5 + 9 = 14

Étape 5 : Itération 4 (i = 4)

carré = 4² = 16, somme_carres = 14 + 16 = 30

Étape 6 : Résultat final

1² + 2² + 3² + 4² = 1 + 4 + 9 + 16 = 30

Réponse finale :

La somme des carrés de 1 à 4 est 30

Règles appliquées :

• Calcul intermédiaire : Carré calculé à chaque itération

• Accumulation : Ajout du carré à la somme totale

• Double opération : Calcul et accumulation combinés

Boucle pour (bornée)Algorithmique et programmation

Boucle pour (bornée)
Algorithmique et programmation