Compteur – accumulateur | Algorithmique et programmation | 10 Exercices corrigés

Concepts & Exercices

\(\text{Compteur: } c = c + 1\)

\(\text{Accumulateur: } s = s + x\)

Variables de boucles fondamentales

Compteur

c = 0
for ...:
c += 1

Incrémentation unitaire

Accumulateur

s = 0
for x in ...:
s += x

Addition progressive

Initialisation

c = 0 (compteur)
s = 0 (somme)

Avant la boucle

Mise à jour

c += 1
s += valeur

À chaque itération

🎯

Définition : Un compteur compte le nombre d'itérations ou occurrences, un accumulateur accumule des valeurs.

🔗

Initialisation : Compteur à 0, accumulateur à 0 (ou valeur initiale).

✅

Mise à jour : À chaque itération, incrémenter le compteur ou ajouter à l'accumulateur.

📊

Applications : Sommes, moyennes, dénombrements, produits.

💡

Conseil : Initialisez toujours vos compteurs et accumulateurs avant la boucle

🔍

Attention : N'oubliez pas de mettre à jour la variable dans la boucle

⚡

Astuce : Utilisez des noms de variables clairs comme 'total', 'nombre', 'somme'

📋

Méthode : Tracez les valeurs de la variable à chaque itération

Exercice 1

Compter combien de fois la boucle for i in range(5) s'exécute

Exercice 2

Calculer la somme des entiers de 1 à 10 avec accumulateur

Exercice 3

Compter les nombres pairs entre 1 et 20

Exercice 4

Calculer le produit des entiers de 1 à 5

Exercice 5

Compter les nombres supérieurs à 10 dans une liste

Exercice 6

Calculer la moyenne d'une série de notes

Exercice 7

Compter les occurrences d'une valeur dans une liste

Exercice 8

Calculer la somme des carrés de 1 à 6

Exercice 9

Compter les lettres dans une chaîne de caractères

Exercice 10

Calculer la factorielle de 7 avec accumulateur

Corrigé : Exercices 1 à 5

1 Compter les itérations de range(5)

Définition :

Compteur : Variable qui incrémente de 1 à chaque itération.

Méthode d'évaluation :

Initialiser le compteur à 0
Augmenter de 1 à chaque itération
Retourner la valeur finale

Code Python

                compteur = 0

                for i in range(5):

                  compteur = compteur + 1

                print(compteur)

Étape 1 : Initialiser le compteur

compteur = 0 avant la boucle

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

compteur = 0 + 1 = 1

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

compteur = 1 + 1 = 2

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

compteur = 2 + 1 = 3

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

compteur = 3 + 1 = 4

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

compteur = 4 + 1 = 5

Étape 7 : Résultat final

La boucle s'exécute 5 fois

Réponse finale :

Le compteur vaut 5, la boucle s'exécute 5 fois

Règles appliquées :

• Initialisation : Compteur commence à 0

• Incrémentation : +1 à chaque itération

• Vérification : range(5) contient 5 éléments

2 Somme des entiers de 1 à 10

Définition :

Accumulateur : Variable qui accumule des valeurs à chaque itération.

Code Python

                somme = 0

                for i in range(1, 11):

                  somme = somme + i

                print(somme)

Étape 1 : Initialiser l'accumulateur

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érations suivantes...

somme = 10 + 5 = 15

somme = 15 + 6 = 21

somme = 21 + 7 = 28

somme = 28 + 8 = 36

somme = 36 + 9 = 45

somme = 45 + 10 = 55

Réponse finale :

La somme des entiers de 1 à 10 est 55

Règles appliquées :

• Initialisation : Accumulateur commence à 0

• Ajout progressif : Chaque valeur est ajoutée à l'accumulateur

• Vérification : 1+2+3+4+5+6+7+8+9+10 = 55

3 Compter les nombres pairs entre 1 et 20

Définition :

Compteur conditionnel : Incrémente seulement si une condition est remplie.

Code Python

                compteur_pairs = 0

                for i in range(1, 21):

                  if i % 2 == 0:

                    compteur_pairs = compteur_pairs + 1

                print(compteur_pairs)

Étape 1 : Initialiser le compteur

compteur_pairs = 0 avant la boucle

Étape 2 : Analyse des itérations

Les nombres pairs entre 1 et 20 sont : 2, 4, 6, 8, 10, 12, 14, 16, 18, 20

Soit 10 nombres pairs

Étape 3 : Itérations avec condition

Pour chaque nombre pair trouvé, le compteur est incrémenté

Étape 4 : Résultat final

Le compteur atteint la valeur 10

Réponse finale :

Il y a 10 nombres pairs entre 1 et 20

Règles appliquées :

• Condition : i % 2 == 0 teste si i est pair

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

• Vérification : 20/2 = 10 nombres pairs dans [1,20]

4 Produit des entiers de 1 à 5

Définition :

Accumulateur multiplicatif : Variable qui accumule des produits.

Code Python

                produit = 1

                for i in range(1, 6):

                  produit = produit * i

                print(produit)

Étape 1 : Initialiser l'accumulateur

produit = 1 avant la boucle (élément neutre de la multiplication)

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

produit = 1 * 1 = 1

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

produit = 1 * 2 = 2

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

produit = 2 * 3 = 6

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

produit = 6 * 4 = 24

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

produit = 24 * 5 = 120

Étape 7 : Résultat final

Le produit est 120

Réponse finale :

Le produit des entiers de 1 à 5 est 120

Règles appliquées :

• Initialisation : Produit commence à 1 (élément neutre)

• Ajout multiplicatif : Chaque valeur multiplie l'accumulateur

• Vérification : 1×2×3×4×5 = 120 (factorielle de 5)

5 Compter les nombres > 10 dans [5, 12, 8, 15, 3, 20, 7, 18]

Définition :

Compteur conditionnel : Sur une liste avec critère spécifique.

Code Python

                liste = [5, 12, 8, 15, 3, 20, 7, 18]

                compteur = 0

                for element in liste:

                  if element > 10:

                    compteur = compteur + 1

                print(compteur)

Étape 1 : Initialiser le compteur

compteur = 0 avant la boucle

Étape 2 : Analyse de la liste

Liste : [5, 12, 8, 15, 3, 20, 7, 18]

Nombres > 10 : 12, 15, 20, 18 (soit 4 nombres)

Étape 3 : Itérations avec condition

element = 5: 5 > 10 ? Non → compteur = 0

element = 12: 12 > 10 ? Oui → compteur = 1

element = 8: 8 > 10 ? Non → compteur = 1

element = 15: 15 > 10 ? Oui → compteur = 2

element = 3: 3 > 10 ? Non → compteur = 2

element = 20: 20 > 10 ? Oui → compteur = 3

element = 7: 7 > 10 ? Non → compteur = 3

element = 18: 18 > 10 ? Oui → compteur = 4

Réponse finale :

Il y a 4 nombres supérieurs à 10 dans la liste

Règles appliquées :

• Parcours de liste : Boucle for sur les éléments

• Condition : Teste chaque élément contre le critère

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

Corrigé : Exercices 6 à 10

6 Moyenne d'une série de notes

Définition :

Moyenne : Somme des valeurs divisée par leur nombre.

Code Python

                notes = [12, 15, 10, 18, 14, 9, 16, 13]

                somme = 0

                nombre_notes = 0

                for note in notes:

                  somme = somme + note

                  nombre_notes = nombre_notes + 1

                moyenne = somme / nombre_notes

                print(moyenne)

Étape 1 : Initialiser les variables

somme = 0, nombre_notes = 0 avant la boucle

Étape 2 : Calcul de la somme

Notes: 12, 15, 10, 18, 14, 9, 16, 13

Somme: 12+15+10+18+14+9+16+13 = 107

Étape 3 : Comptage des notes

Nombre de notes: 8 (compteur incrémenté 8 fois)

Étape 4 : Calcul de la moyenne

moyenne = 107 / 8 = 13.375

Réponse finale :

La moyenne des notes est 13.375

Règles appliquées :

• Deux variables : Un accumulateur pour la somme et un compteur pour le nombre

• Calcul de moyenne : Division de la somme par le nombre d'éléments

• Vérification : Moyenne = Somme / Nombre

7 Compter les occurrences de 'a' dans 'algorithmique'

Définition :

Compteur d'occurrences : Compte les apparitions d'un caractère.

Code Python

                chaine = "algorithmique"

                compteur = 0

                for caractere in chaine:

                  if caractere == 'a':

                    compteur = compteur + 1

                print(compteur)

Étape 1 : Initialiser le compteur

compteur = 0 avant la boucle

Étape 2 : Analyse de la chaîne

Chaîne : 'a-l-g-o-r-i-t-h-m-i-q-u-e'

Occurrences de 'a' : position 0 (1 occurrence)

Étape 3 : Itérations avec condition

caractere = 'a': 'a' == 'a' ? Oui → compteur = 1

caractere = 'l': 'l' == 'a' ? Non → compteur = 1

caractere = 'g': 'g' == 'a' ? Non → compteur = 1

...continuer pour chaque lettre

Seule la première lettre 'a' correspond

Réponse finale :

La lettre 'a' apparaît 1 fois dans 'algorithmique'

Règles appliquées :

• Parcours de chaîne : Boucle for sur les caractères

• Comparaison : Teste chaque caractère contre le modèle

• Compteur conditionnel : Incrémenté pour chaque correspondance

8 Somme des carrés de 1 à 6

Définition :

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

Code Python

                somme_carres = 0

                for i in range(1, 7):

                  carré = i * i

                  somme_carres = somme_carres + carré

                print(somme_carres)

Étape 1 : Initialiser l'accumulateur

somme_carres = 0 avant la boucle

Étape 2 : Calculs itératifs

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

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

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

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

i = 5: carré = 5² = 25, somme_carres = 30 + 25 = 55

i = 6: carré = 6² = 36, somme_carres = 55 + 36 = 91

Étape 3 : Résultat final

1² + 2² + 3² + 4² + 5² + 6² = 1 + 4 + 9 + 16 + 25 + 36 = 91

Réponse finale :

La somme des carrés de 1 à 6 est 91

Règles appliquées :

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

• Accumulation : Chaque carré est ajouté à la somme totale

• Vérification : Formule : Σ(k²) pour k de 1 à n

9 Compter les lettres dans "programmation"

Définition :

Compteur de caractères : Compte les lettres dans une chaîne.

Code Python

                chaine = "programmation"

                compteur = 0

                for caractere in chaine:

                  compteur = compteur + 1

                print(compteur)

Étape 1 : Initialiser le compteur

compteur = 0 avant la boucle

Étape 2 : Analyse de la chaîne

Chaîne : 'p-r-o-g-r-a-m-m-a-t-i-o-n'

Position : 0-1-2-3-4-5-6-7-8-9-10-11-12

Étape 3 : Itérations

Chaque caractère incrémente le compteur

13 caractères → 13 incrémentations

Étape 4 : Résultat final

Le compteur atteint 13

Réponse finale :

La chaîne "programmation" contient 13 lettres

Règles appliquées :

• Parcours de chaîne : Boucle for sur chaque caractère

• Compteur simple : Incrémenté à chaque caractère

• Vérification : Compte total des caractères

10 Factorielle de 7 avec accumulateur

Définition :

Factorielle : Produit de tous les entiers de 1 à n.

Code Python

                n = 7

                factorielle = 1

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

                  factorielle = factorielle * i

                print(factorielle)

Étape 1 : Initialiser l'accumulateur

factorielle = 1 avant la boucle (élément neutre)

Étape 2 : Calculs itératifs

i = 1: factorielle = 1 × 1 = 1

i = 2: factorielle = 1 × 2 = 2

i = 3: factorielle = 2 × 3 = 6

i = 4: factorielle = 6 × 4 = 24

i = 5: factorielle = 24 × 5 = 120

i = 6: factorielle = 120 × 6 = 720

i = 7: factorielle = 720 × 7 = 5040

Étape 3 : Résultat final

7! = 5040

Réponse finale :

La factorielle de 7 est 5040

Règles appliquées :

• Accumulateur multiplicatif : Multiplication progressive

• Initialisation : 1 pour multiplication

• Vérification : 7! = 1×2×3×4×5×6×7 = 5040

Compteur – accumulateurAlgorithmique et programmation

Compteur – accumulateur
Algorithmique et programmation