Variables et boucles simples | Exercices corrigés

Concepts & Exercices

\(\text{Variable} \leftarrow \text{Valeur} \xrightarrow[\text{Boucle}]{\text{Affectation}} \text{Résultat}\)

Affectation et boucles

📦

Variable : Espace mémoire nommé pour stocker une valeur.

🔄

Affectation : Opération qui attribue une valeur à une variable.

🔁

Boucle Pour : Répétition un nombre fixe de fois.

⏳

Boucle TantQue : Répétition tant qu'une condition est vraie.

Exercice 1

Écrire un algorithme qui calcule la somme des n premiers entiers naturels en utilisant une boucle Pour.

Exercice 2

Écrire un algorithme qui calcule la factorielle d'un nombre n en utilisant une boucle TantQue.

Exercice 3

Écrire un algorithme qui détermine si un nombre est premier en utilisant des boucles et variables.

Exercice 4

Écrire un algorithme qui inverse l'ordre des éléments d'un tableau de 5 entiers.

Exercice 5

Écrire un algorithme qui recherche le maximum d'un tableau de 8 nombres et son indice.

Corrigé : Exercices 1 à 3

1 Somme des n premiers entiers

Définition :

Somme des entiers : \(S = 1 + 2 + 3 + ... + n = \frac{n(n+1)}{2}\).

Structure de l'algorithme :

Déclaration des variables
Saisie du nombre n
Initialisation de la variable accumulateur
Boucle Pour pour parcourir les entiers de 1 à n
Affectation cumulative dans la variable somme

Algorithme complet

Variables n, i, somme : entiers
Début
  Afficher("Entrez la valeur de n : ")
  Lire(n)
  
  somme ← 0  // Initialisation de l'accumulateur
  
  Pour i de 1 à n Faire
    somme ← somme + i  // Accumulation
  FinPour
  
  Afficher("La somme des ", n, " premiers entiers est : ", somme)
Fin

Étape 1 : Variables

Variables déclarées : n, i, somme (tous de type entier)

n : nombre dont on veut la somme

i : compteur de la boucle

somme : accumulateur des valeurs

Étape 2 : Initialisation

somme ← 0 (initialisation indispensable pour l'accumulateur)

Étape 3 : Boucle Pour

Pour i de 1 à n : i prend successivement les valeurs 1, 2, ..., n

somme ← somme + i : chaque valeur de i est ajoutée à somme

Étape 4 : Trace de l'exécution (pour n=5)

i=1: somme=0+1=1

i=2: somme=1+2=3

i=3: somme=3+3=6

i=4: somme=6+4=10

i=5: somme=10+5=15

Réponse finale :

L'algorithme utilise une boucle Pour pour accumuler les entiers de 1 à n dans une variable somme.

Règles appliquées :

• Initialisation : L'accumulateur doit être initialisé à 0

• Affectation : somme ← somme + i ajoute i à la valeur actuelle de somme

• Boucle Pour : Itération sur un intervalle fixe

Point clé 1

L'initialisation de l'accumulateur est cruciale pour le bon fonctionnement

Point clé 2

La boucle Pour est idéale pour les itérations sur un nombre fixe de fois

2 Calcul de factorielle

Définition :

Factorielle : \(n! = 1 \times 2 \times 3 \times ... \times n\), avec \(0! = 1\).

Algorithme avec boucle TantQue

Variables n, i, fact : entiers
Début
  Afficher("Entrez la valeur de n : ")
  Lire(n)
  
  fact ← 1  // Initialisation de l'accumulateur multiplicatif
  i ← 1     // Initialisation du compteur
  
  TantQue i <= n Faire
    fact ← fact * i  // Multiplication cumulative
    i ← i + 1        // Incrémentation du compteur
  FinTantQue
  
  Afficher("La factorielle de ", n, " est : ", fact)
Fin

Étape 1 : Variables et initialisation

Variables : n (entrée), i (compteur), fact (accumulateur)

fact ← 1 (initialisation à 1 pour la multiplication)

i ← 1 (initialisation du compteur)

Étape 2 : Boucle TantQue

Condition : i ≤ n (continuer tant que i n'a pas dépassé n)

Instruction : fact ← fact * i (multiplication cumulative)

Incrémentation : i ← i + 1 (avancement du compteur)

Étape 3 : Trace de l'exécution (pour n=4)

i=1: fact=1*1=1, i=2

i=2: fact=1*2=2, i=3

i=3: fact=2*3=6, i=4

i=4: fact=6*4=24, i=5

i=5: condition i≤4 fausse, sortie de la boucle

Étape 4 : Alternative avec boucle Pour

Pour i de 1 à n Faire
  fact ← fact * i
FinPour

Réponse finale :

L'algorithme utilise une boucle TantQue pour multiplier cumulativement les entiers de 1 à n.

Règles appliquées :

• Initialisation : L'accumulateur multiplicatif est initialisé à 1

• Boucle TantQue : Nécessite une condition et une modification de variable

• Invariant : fact contient le produit des entiers de 1 à i-1

Point clé 1

Le compteur doit être incrémenté dans la boucle pour éviter une boucle infinie

Point clé 2

Pour l'accumulation multiplicative, initialiser à 1 (élément neutre)

3 Test de primalité

Définition :

Nombre premier : Nombre supérieur à 1 qui n'est divisible que par 1 et lui-même.

Algorithme de test de primalité

Variables n, i, estPremier : entiers
Début
  Afficher("Entrez un nombre : ")
  Lire(n)
  
  Si n <= 1 Alors
    Afficher(n, " n'est pas premier")
  Sinon
    estPremier ← 1  // Supposé premier
    i ← 2           // Premier diviseur potentiel
    
    TantQue (i <= racine_carree(n)) ET (estPremier = 1) Faire
      Si n MOD i = 0 Alors
        estPremier ← 0  // Trouvé un diviseur
      Sinon
        i ← i + 1
      FinSi
    FinTantQue
    
    Si estPremier = 1 Alors
      Afficher(n, " est premier")
    Sinon
      Afficher(n, " n'est pas premier")
    FinSi
  FinSi
Fin

Étape 1 : Cas particuliers

Si n ≤ 1 : n n'est pas premier

Étape 2 : Initialisation

estPremier ← 1 (variable booléenne simulée)

i ← 2 (premier diviseur à tester)

Étape 3 : Optimisation de la boucle

On teste jusqu'à √n car si n a un diviseur > √n, il en a un < √n

Condition de continuation : (i ≤ √n) ET (estPremier = 1)

Étape 4 : Test de divisibilité

Si n MOD i = 0 : i divise n, donc n n'est pas premier

On met estPremier ← 0 pour sortir de la boucle

Étape 5 : Trace de l'exécution (pour n=17)

i=2: 17 MOD 2 ≠ 0, i=3

i=3: 17 MOD 3 ≠ 0, i=4

i=4: 4 > √17 ≈ 4.12, condition fausse, sortie de boucle

estPremier = 1, donc 17 est premier

Réponse finale :

L'algorithme utilise une boucle TantQue pour tester la divisibilité par des entiers jusqu'à la racine carrée.

Règles appliquées :

• Optimisation : Tester jusqu'à √n suffit pour la primalité

• Booléen simulé : Variable entière pour représenter un état

• Sortie anticipée : Arrêter dès qu'un diviseur est trouvé

Point clé 1

Tester jusqu'à la racine carrée réduit considérablement le nombre d'opérations

Point clé 2

Sortir de la boucle dès qu'un diviseur est trouvé optimise l'algorithme

Corrigé : Exercices 4 à 5

4 Inversion d'un tableau

Définition :

Inversion de tableau : Permuter les éléments pour inverser l'ordre.

Algorithme d'inversion

Variables tab[5], temp : entiers
Variables i, j : entiers
Début
  // Initialisation du tableau
  Pour i de 0 à 4 Faire
    Afficher("Entrez l'élément ", i, " : ")
    Lire(tab[i])
  FinPour
  
  // Affichage avant inversion
  Afficher("Tableau avant inversion : ")
  Pour i de 0 à 4 Faire
    Afficher(tab[i], " ")
  FinPour
  
  // Inversion du tableau
  i ← 0
  j ← 4  // Dernier indice
  
  TantQue i < j Faire
    temp ← tab[i]      // Échange des éléments
    tab[i] ← tab[j]
    tab[j] ← temp
    
    i ← i + 1          // Avancement des indices
    j ← j - 1
  FinTantQue
  
  // Affichage après inversion
  Afficher("Tableau après inversion : ")
  Pour i de 0 à 4 Faire
    Afficher(tab[i], " ")
  FinPour
Fin

Étape 1 : Initialisation du tableau

Boucle Pour pour remplir le tableau de 5 éléments

Étape 2 : Variables de position

i ← 0 (premier indice)

j ← 4 (dernier indice)

Étape 3 : Boucle d'échange

TantQue i < j : continuer tant que les indices ne se sont pas rencontrés

Échange des éléments tab[i] et tab[j] avec variable temporaire

i ← i + 1 et j ← j - 1 pour avancer les positions

Étape 4 : Trace de l'exécution (exemple)

Tableau initial : [2, 5, 8, 1, 9]

i=0, j=4: échange 2↔9 → [9, 5, 8, 1, 2]

i=1, j=3: échange 5↔1 → [9, 1, 8, 5, 2]

i=2, j=2: condition i

Résultat : [9, 1, 8, 5, 2]

Réponse finale :

L'algorithme utilise une boucle TantQue pour échanger les éléments symétriques du tableau.

Règles appliquées :

• Échange : Utilisation d'une variable temporaire pour permuter

• Indices opposés : i croissant, j décroissant

• Condition d'arrêt : i < j empêche les doubles échanges

Point clé 1

La condition i < j évite d'échanger deux fois le même couple

Point clé 2

Un seul passage suffit pour inverser complètement le tableau

5 Recherche du maximum

Définition :

Maximum : Plus grande valeur d'un ensemble de données.

Algorithme de recherche du maximum

Variables tab[8], max, indice_max : entiers
Variables i : entiers
Début
  // Initialisation du tableau
  Pour i de 0 à 7 Faire
    Afficher("Entrez l'élément ", i, " : ")
    Lire(tab[i])
  FinPour
  
  // Initialisation du maximum
  max ← tab[0]        // Premier élément comme référence
  indice_max ← 0      // Indice du maximum
  
  // Recherche du maximum
  Pour i de 1 à 7 Faire  // Commencer à 1
    Si tab[i] > max Alors
      max ← tab[i]       // Mise à jour du maximum
      indice_max ← i     // Mise à jour de l'indice
    FinSi
  FinPour
  
  // Affichage du résultat
  Afficher("Le maximum est : ", max)
  Afficher("Son indice est : ", indice_max)
Fin

Étape 1 : Initialisation

max ← tab[0] (premier élément comme valeur de référence)

indice_max ← 0 (indice de la valeur de référence)

Étape 2 : Parcours du tableau

Boucle Pour de i = 1 à 7 (commencer à 1 car 0 est déjà pris)

Étape 3 : Comparaison

Si tab[i] > max : on a trouvé un nouveau maximum

On met à jour max et indice_max

Étape 4 : Trace de l'exécution (exemple)

Tableau : [3, 7, 2, 9, 1, 5, 8, 4]

i=1: 7>3 → max=7, indice_max=1

i=2: 2<7 → pas de changement

i=3: 9>7 → max=9, indice_max=3

i=4: 1<9 → pas de changement

i=5: 5<9 → pas de changement

i=6: 8<9 → pas de changement

i=7: 4<9 → pas de changement

Résultat : max=9, indice_max=3

Étape 5 : Alternative pour les tableaux vides

// Si la taille est variable
Si taille > 0 Alors
  max ← tab[0]
  Pour i de 1 à taille-1 Faire
    Si tab[i] > max Alors
      max ← tab[i]
    FinSi
  FinPour
Sinon
  Afficher("Tableau vide")
FinSi

Réponse finale :

L'algorithme utilise une boucle Pour pour comparer chaque élément au maximum actuel.

Règles appliquées :

• Initialisation : Prendre le premier élément comme référence

• Comparaison : Mettre à jour les variables quand un élément plus grand est trouvé

• Parcours : Commencer à l'indice 1 après l'initialisation

Point clé 1

Prendre le premier élément comme référence assure que max est toujours dans le tableau

Point clé 2

On parcourt seulement les éléments restants après l'initialisation

Cours bien détaillé

\(\text{Variable} \leftarrow \text{Expression}\)

Affectation

📦

Variable : Nom symbolique pour un espace mémoire.

🔄

Affectation : Attribuer une valeur à une variable.

🔁

Boucle Pour : Répétition sur un intervalle fixe.

⏳

Boucle TantQue : Répétition conditionnelle.

💡

Conseil : Toujours initialiser les variables avant utilisation

🔍

Attention : Vérifier que les boucles ont une condition de sortie

⚡

Astuce : Utiliser des noms de variables explicites

📋

Méthode : Faire une trace d'exécution pour valider l'algorithme

✅

Vérification : Tester l'algorithme avec plusieurs jeux de données

Méthodologie de conception :

Analyse du problème : Identifier les données et le résultat attendu
Choix des variables : Déterminer les variables nécessaires
Choix des structures : Sélectionner les boucles appropriées
Implémentation : Écrire l'algorithme pas à pas
Validation : Vérifier avec des exemples concrets

Règles fondamentales :

Les variables doivent être déclarées avant utilisation
Les accumulateurs doivent être initialisés (0 pour addition, 1 pour multiplication)
Les boucles TantQue doivent avoir une condition qui évolue
Les boucles Pour sont idéales pour les itérations fixes
Les variables de contrôle doivent être modifiées dans les boucles

\(\text{Pour } i \text{ de } a \text{ à } b \text{ Faire instruction FinPour}\)

Boucle Pour

Variables et boucles simplesExercices corrigés

Variables et boucles simples
Exercices corrigés