Variables a, b, c : entiers
Début
a ← 5
b ← 3
c ← a + b
a ← c - b
b ← c - a
Afficher(a, b, c)
FinVariables n, i, somme : entiers
Début
n ← 5
somme ← 0
i ← 1
TantQue i <= n Faire
somme ← somme + i*i
i ← i + 1
FinTantQue
Afficher(somme)
FinVariables x, y, z : réels
Début
x ← 10
y ← 5
Si x > y Alors
z ← x - y
Sinon
z ← y - x
FinSi
Afficher(z)
FinVariables tab[5], i, max : entiers
Début
Pour i de 0 à 4 Faire
tab[i] ← (i+1)*2
FinPour
max ← tab[0]
Pour i de 1 à 4 Faire
Si tab[i] > max Alors
max ← tab[i]
FinSi
FinPour
Afficher(max)
FinVariables a, b, temp : entiers
Début
a ← 15
b ← 25
temp ← a
a ← b
b ← temp
Afficher(a, b)
FinSuivi d'exécution : Technique pour comprendre le déroulement d'un algorithme en traçant les valeurs des variables.
- Identifier les variables déclarées
- Créer un tableau de suivi
- Exécuter chaque instruction une par une
- Noter les modifications des variables
- Identifier la sortie finale
Variables : a, b, c (toutes de type entier)
| Instruction | a | b | c |
|---|---|---|---|
| a ← 5 | 5 | - | - |
| b ← 3 | 5 | 3 | - |
| c ← a + b | 5 | 3 | 8 |
| a ← c - b | 5 | 3 | 8 |
| b ← c - a | 5 | 3 | 8 |
c ← a + b = 5 + 3 = 8
a ← c - b = 8 - 3 = 5
b ← c - a = 8 - 5 = 3
a = 5, b = 3, c = 8
Les valeurs affichées sont a = 5, b = 3, c = 8.
• Suivi d'exécution : Technique pour comprendre le déroulement
• Ordre des instructions : L'ordre d'exécution est crucial
• Affectation : La valeur droite est assignée à la variable gauche
Chaque affectation modifie la valeur d'une variable
La valeur utilisée dans une expression est celle avant l'affectation
Boucle TantQue : Structure de répétition contrôlée par une condition.
Variables : n, i, somme
n ← 5, somme ← 0, i ← 1
Condition : i ≤ n (i ≤ 5)
Instructions dans la boucle :
- somme ← somme + i*i
- i ← i + 1
| Itération | i | i*i | somme avant | somme après | Condition |
|---|---|---|---|---|---|
| Initial | 1 | - | 0 | - | 1 ≤ 5 |
| 1 | 1 | 1 | 0 | 1 | 2 ≤ 5 |
| 2 | 2 | 4 | 1 | 5 | 3 ≤ 5 |
| 3 | 3 | 9 | 5 | 14 | 4 ≤ 5 |
| 4 | 4 | 16 | 14 | 30 | 5 ≤ 5 |
| 5 | 5 | 25 | 30 | 55 | 6 ≤ 5 |
La boucle calcule : 1² + 2² + 3² + 4² + 5² = 1 + 4 + 9 + 16 + 25 = 55
La valeur finale de somme est 55, qui est la somme des carrés des 5 premiers entiers.
• Boucle TantQue : Continue tant que la condition est vraie
• Accumulation : La variable somme accumule les valeurs
• Compteur : i est incrémenté pour garantir la terminaison
Le compteur i doit être modifié dans la boucle pour éviter une boucle infinie
Les variables dans la boucle utilisent leurs valeurs avant modification
Structure conditionnelle : Exécution d'instructions selon une condition.
Variables : x, y, z (toutes de type réel)
x ← 10, y ← 5
Condition : x > y
Évaluation : 10 > 5 → VRAI
Puisque la condition est vraie, on exécute :
z ← x - y = 10 - 5 = 5
Si [condition] Alors
[instructions si vraie]
Sinon
[instructions si fausse]
FinSiz = 5, donc Afficher(z) affiche 5
La valeur affichée est 5, qui est la différence positive entre x et y.
• Condition : Évaluée à vrai ou faux
• Exclusivité : Soit le bloc SI, soit le bloc SINON est exécuté
• Flux d'exécution : Continue après la structure conditionnelle
Seul le bloc correspondant à la condition est exécuté
Les structures conditionnelles permettent de prendre des décisions
Boucles imbriquées : Une boucle à l'intérieur d'une autre boucle.
Pour i de 0 à 4 Faire
tab[i] ← (i+1)*2
FinPourCalcul des valeurs :
tab[0] = (0+1)*2 = 2
tab[1] = (1+1)*2 = 4
tab[2] = (2+1)*2 = 6
tab[3] = (3+1)*2 = 8
tab[4] = (4+1)*2 = 10
max ← tab[0] = 2
Pour i de 1 à 4 Faire
Si tab[i] > max Alors
max ← tab[i]
FinSi
FinPour| i | tab[i] | max avant | Condition | max après |
|---|---|---|---|---|
| 1 | 4 | 2 | 4 > 2 | 4 |
| 2 | 6 | 4 | 6 > 4 | 6 |
| 3 | 8 | 6 | 8 > 6 | 8 |
| 4 | 10 | 8 | 10 > 8 | 10 |
max = 10, donc Afficher(max) affiche 10
La valeur affichée est 10, qui est le maximum du tableau [2, 4, 6, 8, 10].
• Boucles imbriquées : Une boucle complète avant l'autre
• Recherche de maximum : Comparaison avec la valeur courante
• Tableau : Accès par indice
La première boucle initialise le tableau, la seconde le traite
Le maximum est mis à jour à chaque fois qu'une valeur plus grande est trouvée
Permutation : Échange des valeurs de deux variables.
Variables : a, b, temp (toutes de type entier)
a ← 15, b ← 25
temp ← a : sauvegarde de la valeur de a
temp = 15
a ← b : copie de la valeur de b dans a
a = 25
b ← temp : copie de la valeur sauvegardée dans b
b = 15
| Instruction | a | b | temp |
|---|---|---|---|
| a ← 15, b ← 25 | 15 | 25 | - |
| temp ← a | 15 | 25 | 15 |
| a ← b | 25 | 25 | 15 |
| b ← temp | 25 | 15 | 15 |
Après permutation : a = 25, b = 15
Donc Afficher(a, b) affiche 25 et 15
La variable temporaire est nécessaire pour éviter de perdre une valeur
Si on faisait a ← b puis b ← a, on aurait a = b et b = b
Les valeurs affichées sont a = 25 et b = 15, les variables ont été permutées.
• Permutation : Nécessite une variable temporaire
• Séquence : L'ordre des affectations est crucial
• Sauvegarde : La valeur originale est préservée dans temp
La permutation nécessite trois affectations pour échanger deux variables
La variable temporaire empêche la perte de données
- Identifier les variables : Repérer toutes les variables déclarées
- Repérer les structures : Distinguer les boucles, conditions, affectations
- Suivre l'exécution : Exécuter chaque instruction pas à pas
- Tracer les valeurs : Suivre l'évolution des variables
- Identifier la sortie : Déterminer ce qui est affiché ou retourné
- Les instructions s'exécutent dans l'ordre d'écriture
- Les variables stockent des valeurs qui peuvent changer
- Les structures conditionnelles exécutent des blocs selon une condition
- Les boucles répètent des instructions tant qu'une condition est vraie
- Les affectations modifient les valeurs des variables
