NSI 1ère

Boucles et répétitions
Exercices corrigés

Maîtrisez les boucles et répétitions : for, while, break, continue, imbrication et bonnes pratiques grâce à ces 5 exercices détaillés.

Concepts & Exercices
\(\text{for } i \text{ in range}(n): \text{ action}\)
Boucle for
For
for i in range(5):
Itération
While
while condition:
Répétition
Break
break
Arrêt
🔄
Boucle : Structure qui répète un bloc de code plusieurs fois.
🎯
Contrôle : Mécanismes pour gérer le déroulement des boucles.
⚙️
Itération : Chaque passage dans une boucle.
Exercice 1
Utiliser une boucle for pour répéter une action
Exercice 2
Utiliser une boucle while avec une condition
Exercice 3
Imbriquer des boucles l'une dans l'autre
Exercice 4
Utiliser break et continue dans les boucles
Exercice 5
Calculer des sommes et des produits avec des boucles
Corrigé : Exercices 1 à 3
1 Boucle for simple
Définition :

Boucle for : Structure qui répète un bloc de code un nombre fixe de fois ou pour chaque élément d'une collection.

Méthode d'utilisation :
  1. Utiliser for suivi d'une variable d'itération
  2. Utiliser in suivi d'une séquence
  3. Ajouter : après la déclaration
  4. Indenter le bloc de code à répéter
for i in range(5): print(f"Itération {i}") print(f"Carré de {i} = {i**2}") print("Fin de la boucle")
┌─────────────────┐
│ Début boucle │
│ for i in range(5)│
└─────────┬───────┘
│
┌────▼────┐
│ i = 0? │
├─Oui─┐ ┌─Non─┤
│ │ │ │
┌────▼──┐ │ │ ┌───▼──────────┐
│Afficher│ │ │ │ Fin boucle │
│itération│ │ │ │ et programme│
│et carré │ │ │ └─────────────┘
└─────▲───┘ │ │
│ │ │
┌────▼──┐ │ │
│i = i+1│ │ │
│et │ │ │
│i < 5? │ │ │
└───────▲─┼─┼─┘
│ │ │
┌────▼─▼─▼┐
│Retour │
│boucle │
└────────┘
Itération i Action 1 0 Afficher "Itération 0", "Carré de 0 = 0" 2 1 Afficher "Itération 1", "Carré de 1 = 1" 3 2 Afficher "Itération 2", "Carré de 2 = 4" 4 3 Afficher "Itération 3", "Carré de 3 = 9" 5 4 Afficher "Itération 4", "Carré de 4 = 16"
Étape 1 : Initialisation de la boucle

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

Étape 2 : Première itération

i prend la valeur 0, les instructions sont exécutées

Étape 3 : Incrémentation et répétition

i est incrémenté et la boucle continue jusqu'à i=4

Résultat :

La boucle s'exécute 5 fois avec i allant de 0 à 4

Règles appliquées :

• Nombre fixe : range(n) répète n fois la boucle

• Variable d'itération : La variable reçoit chaque valeur de la séquence

• Indentation : Le bloc répété doit être correctement indenté

2 Boucle while
Définition :

Boucle while : Structure qui répète un bloc de code tant qu'une condition est vraie.

Type de boucle Condition Usage For Nombre fixe d'itérations Quand on connaît le nombre de répétitions While Condition booléenne Quand le nombre de répétitions est inconnu
# Compter à rebours compteur = 10 while compteur > 0: print(f"Compte à rebours : {compteur}") compteur = compteur - 1 # Important : décrémenter le compteur print("Terminé !") # Boucle conditionnelle secret = 42 tentative = 0 while tentative != secret: tentative = int(input("Devinez le nombre : ")) if tentative < secret: print("Trop petit !") elif tentative > secret: print("Trop grand !") print("Bravo !")
┌─────────────┐
│compteur = 10│
└─────────┬───┘
│
┌────▼─────┐
│compteur>0?│
├─Oui─┐ ┌─Non─┤
│ │ │ │
┌────▼──┐ │ │ ┌───▼──────────┐
│Afficher│ │ │ │Afficher │
│compteur│ │ │ │"Terminé !" │
└─────▲─┘ │ │ └─────────────┘
│ │ │
┌────▼───▼─▼┐
│compteur -=1│
└─────────┬──┘
│
┌────▼─────┐
│Retour │
│à la condi│
└─────────┘
Étape 1 : Initialiser la variable de contrôle

compteur = 10 - la variable qui contrôle la boucle

Étape 2 : Tester la condition

compteur > 0 - la boucle continue tant que cette condition est vraie

Étape 3 : Exécuter le bloc et modifier la variable

Exécuter les instructions et décrémenter compteur

Résultat :

La boucle s'exécute 10 fois avec compteur allant de 10 à 1

Règles appliquées :

• Condition : La condition doit pouvoir devenir fausse

• Modification : La variable de contrôle doit être modifiée dans la boucle

• Terminaison : Sans modification, la boucle serait infinie

3 Boucles imbriquées
Définition :

Boucles imbriquées : Structure où une boucle est placée à l'intérieur d'une autre boucle.

# Table de multiplication for i in range(1, 4): # Boucle extérieure print(f"Table de {i}:") for j in range(1, 6): # Boucle intérieure resultat = i * j print(f"{i} × {j} = {resultat}") print("-" * 15) # Ligne de séparation # Parcours d'une grille for ligne in range(3): for colonne in range(3): print(f"Case [{ligne}][{colonne}]", end=" ") print() # Nouvelle ligne après chaque ligne de la grille
Boucle extérieure (i) Boucle intérieure (j) Résultat 1 1, 2, 3, 4, 5 1×1, 1×2, 1×3, 1×4, 1×5 2 1, 2, 3, 4, 5 2×1, 2×2, 2×3, 2×4, 2×5 3 1, 2, 3, 4, 5 3×1, 3×2, 3×3, 3×4, 3×5
Étape 1 : Comprendre la structure

La boucle extérieure contrôle les tables (1 à 3)

Étape 2 : La boucle intérieure

Pour chaque table, la boucle intérieure fait les multiplications (1 à 5)

Étape 3 : Le nombre total d'itérations

3 × 5 = 15 multiplications au total

Résultat :

Tables de multiplication de 1 à 3 avec les résultats de ×1 à ×5

Règles appliquées :

• Indentation : La boucle intérieure est plus indentée que l'extérieure

• Portée : Les variables de chaque boucle sont locales à leur niveau

• Complexité : Le nombre total d'itérations est le produit des itérations

Corrigé : Exercices 4 à 5
4 Break et continue
Définition :

Break : Instruction qui interrompt immédiatement la boucle. Continue : Passe à l'itération suivante sans exécuter le reste du bloc.

Instruction Effet Utilisation break Sortie immédiate de la boucle Arrêter la boucle prématurément continue Sauter au début de la prochaine itération Ignorer le reste du bloc pour cette itération
# Utilisation de break for i in range(20): if i == 10: print("On a atteint 10, arrêt de la boucle") break print(f"Valeur : {i}") print("\n---\n") # Utilisation de continue for i in range(10): if i % 2 == 0: # Si i est pair continue # Passer à l'itération suivante print(f"Nombre impair : {i}") print("\n---\n") # Recherche d'un élément nombres = [3, 7, 1, 9, 4, 6, 2, 8] recherche = 6 trouve = False for num in nombres: if num == recherche: print(f"Trouvé {recherche} à la position {nombres.index(num)}") trouve = True break print(f"Test de {num}...") if not trouve: print("Élément non trouvé")
Étape 1 : Comprendre break

break quitte la boucle immédiatement sans exécuter les itérations restantes

Étape 2 : Comprendre continue

continue saute le reste du bloc courant et passe à la prochaine itération

Étape 3 : Application pratique

break pour sortir d'une boucle de recherche, continue pour filtrer des éléments

Résultats :

break arrête la boucle, continue ignore certaines itérations, permettant un contrôle fin des boucles

Règles appliquées :

• Break : Termine complètement la boucle, même imbriquée

• Continue : Affecte seulement la boucle la plus proche

• Contrôle : Utilisés pour un contrôle plus précis du flux de la boucle

5 Calculs avec boucles
Définition :

Calculs itératifs : Utilisation de boucles pour effectuer des calculs répétitifs comme sommes, produits, ou accumulations.

# Calcul de la somme des nombres de 1 à n n = 100 somme = 0 for i in range(1, n + 1): somme = somme + i print(f"Somme de 1 à {n} = {somme}") # Calcul de la factorielle n = 5 factorielle = 1 for i in range(1, n + 1): factorielle = factorielle * i print(f"{n}! = {factorielle}") # Recherche du maximum dans une liste nombres = [3, 7, 2, 9, 1, 8, 4] maximum = nombres[0] # Initialisation avec le premier élément for nombre in nombres[1:]: # Commencer à partir du deuxième if nombre > maximum: maximum = nombre print(f"Maximum = {maximum}") # Comptage d'éléments liste = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] compteur_pairs = 0 for nombre in liste: if nombre % 2 == 0: compteur_pairs += 1 print(f"Nombre de pairs = {compteur_pairs}")
Calcul Initialisation Mise à jour Résultat Somme somme = 0 somme = somme + i n(n+1)/2 Produit produit = 1 produit = produit * i n! Maximum max = liste[0] if x > max: max = x valeur la plus grande
Étape 1 : Initialiser la variable d'accumulation

somme = 0 pour une somme, produit = 1 pour un produit

Étape 2 : Parcourir les éléments

Utiliser une boucle pour parcourir tous les éléments à traiter

Étape 3 : Mettre à jour l'accumulateur

Appliquer l'opération (addition, multiplication, comparaison) à chaque itération

Résultats :

Somme de 1 à 100 = 5050, 5! = 120, maximum = 9, pairs = 5

Règles appliquées :

• Initialisation : Initialiser correctement la variable d'accumulation

• Mise à jour : Mettre à jour la variable à chaque itération

• Logique : Adapter la logique selon le type de calcul (somme, max, comptage)

Cours bien détaillé
\(\text{Somme} = \sum_{i=1}^{n} i = \frac{n(n+1)}{2}\)
Calcul itératif
🎯
Définition : Une boucle permet de répéter un bloc d'instructions un certain nombre de fois.
📏
Objectif : Éviter la répétition de code et traiter des collections de données.
📐
Types : for (itération sur une séquence) et while (condition booléenne).
📝
Applications : Calculs itératifs, traitement de listes, validations, recherches.
💡
Conseil : Utilisez for pour les répétitions connues, while pour les conditions dynamiques
🔍
Attention : Veillez à modifier la condition dans les boucles while pour éviter les boucles infinies
⚡
Astuce : Utilisez break pour sortir prématurément d'une boucle
📋
Méthode : Tracez l'exécution pas à pas pour comprendre le comportement des boucles
✅
Vérification : Testez vos boucles avec des cas limites (0, 1, vide)
Modèles de boucles :
  • Somme : initialiser à 0, accumuler avec +
  • Produit : initialiser à 1, accumuler avec *
  • Maximum : initialiser avec premier élément, comparer et remplacer
  • Comptage : initialiser à 0, incrémenter selon condition
  • Recherche : utiliser break quand l'élément est trouvé
Règles importantes :
  • La variable de contrôle doit être modifiée dans une boucle while
  • Les boucles imbriquées augmentent la complexité exponentiellement
  • Les instructions break et continue affectent seulement la boucle la plus proche
  • Une boucle for est préférable quand le nombre d'itérations est connu
  • L'indentation est cruciale pour délimiter les blocs de code dans les boucles
Boucles et répétitions Notions de base d’algorithmique