LICENCE 1 INFORMATIQUE

Algorithmique et
Structures de Données
Cours complet avec exercices et corrections

Année universitaire 2025-2026

Programme de Licence 1 - Semestre 1 & 2

12 chapitres progressifs - 144+ exercices corrigés

Document généré pour l'étude personnelle - Progression validée chapitre par chapitre
Table des Matières

Chapitre 1 : Introduction à l'algorithmique

Chapitre 2 : Variables et constantes

Chapitre 3 : Types de données

Chapitre 4 : Entrées et sorties

Chapitre 5 : Opérateurs arithmétiques

Chapitre 6 : Conditions (SI, SINON, SINON SI)

Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Chapitre 8 : Fonctions et procédures

Chapitre 9 : Tableaux à une dimension

Chapitre 10 : Chaînes de caractères

Chapitre 11 : Recherche séquentielle

Chapitre 12 : Introduction aux structures de données

Chapitre 1 : Introduction à l'algorithmique

Chapitre 1 : Introduction à l'algorithmique

CHAPITRE 1

Introduction à l'algorithmique

1.1 Définition simple et intuitive

DÉFINITION

Un algorithme est une suite finie d'instructions claires et non ambiguës qui,
lorsqu'on les exécute dans l'ordre, permet de résoudre un problème donné ou
d'accomplir une tâche spécifique. On peut voir un algorithme comme une recette
de cuisine : une liste d'étapes à suivre dans un ordre précis pour obtenir un
résultat souhaité.

L'algorithmique est l'art de concevoir ces algorithmes. C'est la fondation de toute la

programmation informatique. Avant d'écrire un programme dans un langage comme
Python, Java ou C++, il est essentiel de savoir structurer sa pensée logique sous forme
d'algorithme. Un bon algorithme doit être correct (il résout le bon problème), efficace (il le
fait rapidement et sans gaspiller de ressources) et compréhensible (quelqu'un d'autre peut
le lire et le comprendre).

L'histoire de l'algorithmique remonte à l'Antiquité. Le mot "algorithme" vient du nom du

mathématicien perse Al-Khwarizmi (IXe siècle), considéré comme l'un des pères de
l'algèbre. Cependant, la notion d'algorithme sous sa forme moderne a été formalisée au XXe
siècle par des mathématiciens comme Alan Turing et Alonzo Church, qui ont posé les bases
théoriques de l'informatique.

3
Chapitre 1 : Introduction à l'algorithmique

1.2 Objectif de la notion

OBJECTIFS PÉDAGOGIQUES

À la fin de ce chapitre, vous serez capable de :

Comprendre ce qu'est un algorithme et à quoi il sert

Distinguer les caractéristiques essentielles d'un bon algorithme

Lire et interpréter un algorithme écrit en pseudo-code

Connaître les étapes de conception d'un algorithme

Comprendre la différence entre algorithme et programme

1.3 Exemple concret de la vie courante

4
Chapitre 1 : Introduction à l'algorithmique

EXEMPLE CONCRET : LA RECETTE DES CRÊPES

Imaginons que vous vouliez expliquer à quelqu'un comment faire des crêpes.
Voici un algorithme de préparation des crêpes :

1. DÉBUT

2. Prendre un saladier

3. Casser 3 oeufs dans le saladier

4. Ajouter 250g de farine

5. Ajouter 50cl de lait

6. Ajouter une pincée de sel

7. Mélanger énergiquement jusqu'à obtenir une pâte lisse

8. Chauffer une poêle à feu moyen

9. Beurrer légèrement la poêle

10. Verser une louche de pâte dans la poêle

11. Attendre 2 minutes

12. Retourner la crêpe

13. Attendre encore 1 minute

14. Retirer la crêpe et la poser sur une assiette

15. S'il reste de la pâte, retourner à l'étape 10

16. FIN

Cette recette est un algorithme ! Elle possède toutes les caractéristiques : un début,
une fin, des étapes claires dans un ordre précis, des conditions (étape 15) et un
résultat (des crêpes prêtes).

1.4 Explication détaillée avec schémas ASCII

1.4.1 Les caractéristiques d'un algorithme

5
Chapitre 1 : Introduction à l'algorithmique

Qu'est-ce qui fait qu'une suite d'instructions est un algorithme ? Voici les cinq critères
fondamentaux :

Tableau 1.1 : Les cinq critères d'un algorithme

Critère Description Exemple concret

Entrées Données nécessaires au départ Farine, oeufs, lait pour les crêpes

Sortie Résultat produit à la fin Crêpes prêtes à manger

Définitude Chaque étape est claire et non ambiguë "Ajouter 250g de farine" (précis)

Finitude L'algorithme se termine en un temps fini La recette ne boucle pas indéfiniment

Effectivité Chaque étape est réalisable "Casser un oeuf" est faisable

1.4.2 Schéma général d'un algorithme

+----------------+ +------------------+ +----------------+

| ENTRÉES | ===> | TRAITEMENT | ===> | SORTIES |
| (données | | (instructions | | (résultats |
| de départ) | | de l'algo) | | obtenus) |
+----------------+ +------------------+ +----------------+

Exemple : Calcul du prix TTC

+--------------------+ +---------------------+ +--------------+
| Prix HT = 100 EUR | ===> | Multiplier par 1.20 | ===> | Prix TTC |
| Taux TVA = 20% | | (ajouter la TVA) | | = 120 EUR |
+--------------------+ +---------------------+ +--------------+

1.4.3 Différence entre algorithme et programme

Tableau 1.2 : Algorithme vs Programme

Algorithme Programme

Écrit en pseudo-code (langage naturel Écrit dans un langage de programmation (Python,

structuré) C, Java...)

Compréhensible par les humains Compréhensible par la machine (après compilation)

Indépendant de tout langage Dépend du langage choisi

On se concentre sur la logique On se concentre sur la syntaxe et la logique

6
Chapitre 1 : Introduction à l'algorithmique

Comme un plan d'architecte Comme la maison construite

1.5 Pseudo-code commenté ligne par ligne

1.5.1 Structure générale d'un algorithme

ALGORITHME 1.1 : MODÈLE GÉNÉRAL

ALGORITHME Nom_De_L_Algorithme
// Ceci est un commentaire : il explique mais n'est pas exécuté
// DÉCLARATION DES VARIABLES
VARIABLES
nom_variable : Type // On déclare ce dont on a besoin

DÉBUT
// Corps de l'algorithme : les instructions à exécuter
Instruction_1 // Chaque instruction se termine
normalement
Instruction_2 // Les instructions s'exécutent de haut
en bas
...
FIN

1.5.2 Exemple : Algorithme de calcul de moyenne

7
Chapitre 1 : Introduction à l'algorithmique

ALGORITHME 1.2 : CALCUL DE MOYENNE DE DEUX NOMBRES

ALGORITHME Calcul_Moyenne
// ============================================================
// But : Calculer la moyenne arithmétique de deux nombres
// Entrées : Deux nombres réels
// Sortie : La moyenne de ces deux nombres
// ============================================================

VARIABLES
nombre1 : REEL // Premier nombre à saisir
nombre2 : REEL // Deuxième nombre à saisir
moyenne : REEL // Résultat du calcul

DÉBUT
// ÉTAPE 1 : Demander les valeurs à l'utilisateur
AFFICHER "Entrez le premier nombre : "
LIRE nombre1 // On stocke la saisie dans nombre1

AFFICHER "Entrez le deuxième nombre : "

LIRE nombre2 // On stocke la saisie dans nombre2

// ÉTAPE 2 : Calculer la moyenne

moyenne <- (nombre1 + nombre2) / 2
// La flèche <- signifie "prend la valeur de"
// On additionne les deux nombres et on divise par 2

// ÉTAPE 3 : Afficher le résultat

AFFICHER "La moyenne est : ", moyenne

FIN

1.5.3 Convention de pseudo-code utilisée dans ce cours

Tableau 1.3 : Conventions de pseudo-code

Mot-clé Signification Usage

ALGORITHME Début de l'algorithme Suivi du nom

VARIABLES Zone de déclaration Avant le DÉBUT

8
Chapitre 1 : Introduction à l'algorithmique

DÉBUT ... FIN Bloc d'instructions Contient les étapes

<- Affectation Variable <- Valeur

AFFICHER Afficher à l'écran Sortie de données

LIRE Lire depuis le clavier Entrée de données

// Commentaire Explication non exécutée

SI ... ALORS ... FIN SI Condition Chapitre 6

POUR ... FAIRE ... FIN POUR Boucle bornée Chapitre 7

TANT QUE ... FAIRE ... FIN TANT QUE Boucle non bornée Chapitre 7

1.6 Exemple d'exécution pas à pas

Exécutons l'Algorithme 1.2 pas à pas avec les valeurs nombre1 = 10 et nombre2 = 20 :

Tableau 1.4 : Exécution pas à pas du calcul de moyenne

Étape Instruction Variables après exécution Affichage

nombre1 = ?, nombre2 = ?,
1 Déclaration des variables (rien)
moyenne = ?

AFFICHER "Entrez le premier Entrez le premier

2 (inchangé)
nombre : " nombre :

LIRE nombre1 (l'utilisateur nombre1 = 10, nombre2 = ?,

3 (rien)
tape 10) moyenne = ?

AFFICHER "Entrez le Entrez le deuxième

4 (inchangé)
deuxième nombre : " nombre :

LIRE nombre2 (l'utilisateur nombre1 = 10, nombre2 = 20,

5 (rien)
tape 20) moyenne = ?

moyenne <- (nombre1 + nombre1 = 10, nombre2 = 20,

6 (rien)
nombre2) / 2 moyenne = 15.0

AFFICHER "La moyenne est : La moyenne est :

7 (inchangé)
", moyenne 15.0

9
Chapitre 1 : Introduction à l'algorithmique

1.7 Erreurs fréquentes des débutants

ERREURS À ÉVITER ABSOLUMENT

Oublier de déclarer les variables : En pseudo-code formel, toute variable

doit être déclarée avant usage. Cela aide à structurer la pensée.

Confondre = et <- : Le signe = est une comparaison (est-égal-à), tandis que

<- est une affectation (prend-la-valeur-de). On écrit moyenne <- 15 , pas
moyenne = 15 dans un algorithme.

Ne pas commenter son algorithme : Les commentaires expliquent le

"pourquoi", pas le "quoi". Ils sont essentiels pour la relecture.

Écrire des étapes trop vagues : "Traiter les données" n'est pas un
algorithme. Il faut détailler chaque opération.

Oublier que l'ordre compte : Dans un algorithme, les instructions

s'exécutent de haut en bas. Changer l'ordre change le résultat.

Confondre algorithme et programme : L'algorithme est la logique (le

plan), le programme est l'implémentation (la construction).

1.8 Résumé des points essentiels

10
Chapitre 1 : Introduction à l'algorithmique

POINTS CLÉS À RETENIR

Un algorithme est une suite finie d'instructions claires pour résoudre un

problème.

Un algorithme possède cinq caractéristiques : entrées, sortie, définitude,

finitude, effectivité.

On écrit les algorithmes en pseudo-code, un langage intermédiaire entre le

langage naturel et le code informatique.

La structure de base est : ALGORITHME → VARIABLES → DÉBUT ... FIN .

L'affectation se note avec la flèche <- (ex : x <- 5 ).

AFFICHER sert à sortir des informations, LIRE sert à recevoir des données.

L'algorithme est le plan, le programme est la construction réelle.

Exercices du Chapitre 1

Pour valider ce chapitre, résolvez au moins 8 exercices sur 12. Les exercices 11 et 12 sont des
mini-projets de validation.

11
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.1 (Très facile)

Question de cours : Donnez la définition d'un algorithme en utilisant vos propres

mots, puis citez les cinq caractéristiques fondamentales qu'un algorithme doit
respecter.

Correction

Un algorithme est une suite finie et ordonnée d'instructions claires permettant

de résoudre un problème donné. Les cinq caractéristiques sont :

1. Entrées : les données nécessaires au départ

2. Sortie : le résultat produit

3. Définitude : chaque étape est précise et non ambiguë

4. Finitude : l'algorithme se termine après un nombre fini d'étapes

5. Effectivité : chaque opération est réalisable

12
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.2 (Très facile)

Vrai ou Faux : Indiquez si les affirmations suivantes sont vraies ou fausses, et

justifiez.

1. Un algorithme peut boucler indéfiniment.

2. Un algorithme est écrit dans un langage de programmation comme Python.

3. Un algorithme doit toujours produire le même résultat pour les mêmes

entrées.

4. Le pseudo-code est un langage compris par l'ordinateur.

5. Un algorithme peut avoir zéro entrée.

Correction

1. Faux : Un algorithme doit être fini par définition. S'il boucle

indéfiniment, ce n'est pas un algorithme valide.

2. Faux : Un algorithme est écrit en pseudo-code (langage humain

structuré). Un programme est écrit dans un langage de programmation.

3. Vrai : C'est la propriété de déterminisme. Mêmes entrées → même suite

d'opérations → même résultat.

4. Faux : Le pseudo-code est compris par les humains. Seul le programme

(code source) est compris par la machine après compilation.

5. Vrai : Un algorithme peut n'avoir aucune entrée (ex : afficher "Bonjour").

13
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.3 (Facile)

Identifier les composantes : Pour l'algorithme de la recette des crêpes (section 1.3),
identifiez : les entrées, la sortie, et au moins deux conditions de finitude.

Correction

Entrées : 3 oeufs, 250g de farine, 50cl de lait, une pincée de sel, du

beurre.

Sortie : Des crêpes cuites et prêtes sur une assiette.

Conditions de finitude :

La pâte est finie (étape 15 : "S'il reste de la pâte") → quand il n'y a

plus de pâte, on arrête.

Nombre fini d'ingrédients → on ne peut pas faire un nombre

infini de crêpes.

14
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.4 (Facile)

Algorithme du matin : Écrivez en pseudo-code l'algorithme de votre routine

matinale (réveil, toilette, petit-déjeuner, préparation) depuis le réveil jusqu'à sortir
de chez vous.

Correction

ALGORITHME Routine_Matinale
DÉBUT
// Phase 1 : Réveil
Se_réveiller
Éteindre_le_réveil

// Phase 2 : Toilette
Se_lever_du_lit
Aller_dans_la_salle_de_bain
Se_laver_le_visage
Se_brosser_les_dents

// Phase 3 : Habillage
Choisir_des_vêtements
S'habiller

// Phase 4 : Petit-déjeuner
Aller_dans_la_cuisine
Préparer_le_petit_déjeuner
Manger

// Phase 5 : Départ
Vérifier_les_affaires_nécessaires
Mettre_les_chaussures
Sortir_de_la_maison
Fermer_la_porte_à_clé
FIN

Méthode : Décomposer la tâche en phases logiques, puis détailler chaque

phase par des actions concrètes et ordonnées.

15
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.5 (Facile)

Tracer d'exécution : On considère l'algorithme suivant. Faites le tableau

d'exécution pas à pas avec a = 4 et b = 6 .

ALGORITHME Mystere
VARIABLES
a, b, c : ENTIER
DÉBUT
LIRE a
LIRE b
c <- a + b
a <- c - a
b <- c - b
AFFICHER a
AFFICHER b
FIN

Correction

Étape Instruction a b c

1 Déclaration ? ? ?

2 LIRE a (4) 4 ? ?

3 LIRE b (6) 4 6 ?

4 c <- a + b 4 6 10

5 a <- c - a (10-4) 6 6 10

6 b <- c - b (10-6) 6 4 10

Affichage final : a = 6, b = 4. Cet algorithme échange les valeurs de a et b !

Méthode : Créer une colonne par variable et suivre chaque affectation ligne
par ligne sans anticiper.

16
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.6 (Moyen)

Comprendre l'échange : Dans l'exercice 1.5, l'algorithme échange les valeurs de a

et b. Pourquoi ne peut-on pas simplement écrire a <- b puis b <- a ? Montrez
avec un exemple numérique ce qui se passerait.

Correction

Si on écrit naivement :

a <- b // a prend la valeur de b (on perd l'ancienne valeur de a

!)
b <- a // b prend la nouvelle valeur de a (qui est égale à b !)

Exemple avec a=4, b=6 :

Instruction a b

(initial) 4 6

a <- b 6 6

b <- a 6 6

Résultat : les deux valent 6 ! La valeur 4 est perdue. D'où la nécessité d'une
variable temporaire (ici c ) pour stocker la valeur intermédiaire.

17
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.7 (Moyen)

Comptage de monnaie : Écrivez un algorithme qui calcule le nombre total de

pièces et le montant total dans une tirelire contenant : x pièces de 2 EUR, y pièces de
1 EUR, z pièces de 50 centimes, w pièces de 20 centimes, et v pièces de 10 centimes.

Correction

ALGORITHME Comptage_Monnaie
VARIABLES
x, y, z, w, v : ENTIER // Nombre de chaque type de
pièce
total_pieces : ENTIER // Nombre total de pièces
montant_total : REEL // Montant total en EUR
DÉBUT
// Saisie des quantités
AFFICHER "Nombre de pièces de 2 EUR : "
LIRE x
AFFICHER "Nombre de pièces de 1 EUR : "
LIRE y
AFFICHER "Nombre de pièces de 50 centimes : "
LIRE z
AFFICHER "Nombre de pièces de 20 centimes : "
LIRE w
AFFICHER "Nombre de pièces de 10 centimes : "
LIRE v

// Calcul du nombre total de pièces

total_pieces <- x + y + z + w + v

// Calcul du montant total (en euros)

montant_total <- x*2 + y*1 + z*0.5 + w*0.2 + v*0.1

// Affichage des résultats

AFFICHER "Nombre total de pièces : ", total_pieces
AFFICHER "Montant total : ", montant_total, " EUR"
FIN

Méthode : Identifier les entrées (5 types de pièces), les traitements (deux

calculs distincts), et les sorties (total pièces + montant).

18
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.8 (Moyen)

Conversion temps : Écrivez un algorithme qui convertit une durée donnée en

secondes en heures, minutes et secondes. Par exemple, 3665 secondes = 1 heure, 1
minute, 5 secondes.

Correction

ALGORITHME Conversion_Temps
VARIABLES
duree_totale : ENTIER // Durée en secondes (entrée)
heures : ENTIER // Résultat en heures
minutes : ENTIER // Résultat en minutes
secondes : ENTIER // Résultat en secondes
reste : ENTIER // Variable intermédiaire
DÉBUT
AFFICHER "Entrez la durée en secondes : "
LIRE duree_totale

// 1 heure = 3600 secondes

heures <- duree_totale DIV 3600 // Division entière
reste <- duree_totale MOD 3600 // Reste après les
heures

// 1 minute = 60 secondes
minutes <- reste DIV 60
secondes <- reste MOD 60

AFFICHER duree_totale, " secondes = "

AFFICHER heures, " heure(s), "
AFFICHER minutes, " minute(s), "
AFFICHER secondes, " seconde(s)"
FIN

Version Python :

19
Chapitre 1 : Introduction à l'algorithmique

# Conversion temps
duree_totale = int(input("Entrez la duree en secondes : "))

heures = duree_totale // 3600 # Division entiere

reste = duree_totale % 3600 # Modulo (reste)
minutes = reste // 60
secondes = reste % 60

print(f"{duree_totale} secondes = {heures}h {minutes}min

{secondes}s")

Méthode : Utiliser la division entière (DIV ou //) pour obtenir le quotient et le

modulo (MOD ou %) pour obtenir le reste. Traiter par ordre décroissant
(heures → minutes → secondes).

20
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.9 (Moyen)

Analyser un algorithme existant : Quel est le résultat de l'algorithme suivant avec

n = 5 ? Tracez l'exécution pas à pas.

ALGORITHME Calcul
VARIABLES
n, resultat : ENTIER
DÉBUT
LIRE n
resultat <- n * n
resultat <- resultat + n
resultat <- resultat DIV 2
AFFICHER resultat
FIN

Correction

Avec n = 5 :

Instruction n resultat

Initial 5 ?

resultat <- n*n 5 25

resultat <- resultat+n 5 30

resultat <- resultat DIV 2 5 15

Résultat affiché : 15
n×(n+1)
Observation mathématique : Cet algorithme calcule 2 ​ , c'est-à-dire la
somme des entiers de 1 à n. C'est la célèbre formule de Gauss !

21
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.10 (Difficile)

Permutation circulaire : Écrivez un algorithme qui effectue une permutation

circulaire de trois variables a, b, c : la valeur de a va dans b, celle de b va dans c,
celle de c va dans a. Utilisez une seule variable temporaire.

Correction

ALGORITHME Permutation_Circulaire
VARIABLES
a, b, c : ENTIER
temp : ENTIER // Variable temporaire unique
DÉBUT
// Saisie
AFFICHER "Entrez a : " ; LIRE a
AFFICHER "Entrez b : " ; LIRE b
AFFICHER "Entrez c : " ; LIRE c

// Permutation circulaire : a->b, b->c, c->a

// Stratégie : sauver a, décaler, restaurer
temp <- a // On sauvegarde a dans temp
a <- c // a prend l'ancienne valeur de c
c <- b // c prend l'ancienne valeur de b
b <- temp // b prend l'ancienne valeur de a (sauvée)

AFFICHER "Après permutation : a=", a, " b=", b, " c=", c

FIN

Trace avec a=1, b=2, c=3 :

Étape a b c temp

Initial 1 2 3 ?

temp <- a 1 2 3 1

a <- c 3 2 3 1

c <- b 3 2 2 1

22
Chapitre 1 : Introduction à l'algorithmique

b <- temp 3 1 2 1

Résultat : a=3, b=1, c=2. Les valeurs ont tourné dans le sens inverse des
aiguilles d'une montre.

Méthode : La clé est de sauvegarder une valeur avant de l'écraser. On ne peut

pas faire a<-c puis c<-b car c aurait déjà été modifié. L'ordre des affectations est
crucial.

23
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.11 (Mini-projet)

Caisse automatique : Écrivez un algorithme complet pour une caisse automatique.

Le client donne un montant (billet de 20, 50 ou 100 EUR) pour payer un article.
L'algorithme doit :

1. Lire le prix de l'article (maximum 100 EUR)

2. Lire le billet donné par le client

3. Vérifier que le billet est suffisant

4. Calculer la monnaie à rendre

5. Indiquer combien de billets de 10, 5 et pièces de 1, 50c, 20c, 10c sont à rendre
(rendre le minimum de pièces/billets)

Correction complète

24
Chapitre 1 : Introduction à l'algorithmique

ALGORITHME Caisse_Automatique
VARIABLES
prix : REEL // Prix de l'article
billet : ENTIER // Billet donné (20, 50 ou 100)
monnaie : REEL // Monnaie à rendre

// Compteurs de monnaie à rendre

nb_10 : ENTIER
nb_5 : ENTIER
nb_1 : ENTIER
nb_50c : ENTIER
nb_20c : ENTIER
nb_10c : ENTIER

reste : ENTIER // Reste en centimes pour calcul

DÉBUT
// ÉTAPE 1 : Saisie
AFFICHER "=== CAISSE AUTOMATIQUE ==="
AFFICHER "Prix de l'article (max 100 EUR) : "
LIRE prix
AFFICHER "Billet donné (20, 50, 100) : "
LIRE billet

// ÉTAPE 2 : Vérification
SI billet < prix ALORS
AFFICHER "ERREUR : Le billet est insuffisant !"
SINON
// ÉTAPE 3 : Calcul de la monnaie
monnaie <- billet - prix
AFFICHER "Monnaie à rendre : ", monnaie, " EUR"

// Conversion en centimes pour éviter les problèmes de

flottants
reste <- monnaie * 100 // ex: 37.50 EUR -> 3750
centimes

// ÉTAPE 4 : Décomposition optimale (algorithme

glouton)
nb_10 <- reste DIV 1000 // Billets de 10 EUR (1000
centimes)
reste <- reste MOD 1000

nb_5 <- reste DIV 500 // Billets de 5 EUR

reste <- reste MOD 500

nb_1 <- reste DIV 100 // Pièces de 1 EUR

reste <- reste MOD 100

25
Chapitre 1 : Introduction à l'algorithmique

nb_50c <- reste DIV 50 // Pièces de 50 centimes

reste <- reste MOD 50

nb_20c <- reste DIV 20

reste <- reste MOD 20

nb_10c <- reste DIV 10

// ÉTAPE 5 : Affichage du résultat

AFFICHER "--- Monnaie à rendre ---"
AFFICHER "Billets 10 EUR : ", nb_10
AFFICHER "Billets 5 EUR : ", nb_5
AFFICHER "Pièces 1 EUR : ", nb_1
AFFICHER "Pièces 50c : ", nb_50c
AFFICHER "Pièces 20c : ", nb_20c
AFFICHER "Pièces 10c : ", nb_10c
FIN SI
FIN

Méthode de résolution :

1. Analyse du problème : Identifier entrées (prix, billet), traitements

(vérification, calcul, décomposition), sorties (monnaie détaillée).

2. Conception : Utiliser l'algorithme glouton - toujours prendre la plus

grande coupure possible d'abord.

3. Astuce technique : Travailler en centimes (entiers) plutôt qu'en euros

(décimaux) pour éviter les imprécisions des nombres flottants.

Version Python :

26
Chapitre 1 : Introduction à l'algorithmique

prix = float(input("Prix (max 100 EUR): "))

billet = int(input("Billet (20/50/100): "))

if billet < prix:

print("Billet insuffisant!")
else:
monnaie = billet - prix
print(f"Monnaie: {monnaie:.2f} EUR")

reste = int(monnaie * 100) # En centimes

nb_10 = reste // 1000; reste %= 1000

nb_5 = reste // 500; reste %= 500
nb_1 = reste // 100; reste %= 100
nb_50c = reste // 50; reste %= 50
nb_20c = reste // 20; reste %= 20
nb_10c = reste // 10

print(f"10 EUR: {nb_10}, 5 EUR: {nb_5}, 1 EUR: {nb_1}")

print(f"50c: {nb_50c}, 20c: {nb_20c}, 10c: {nb_10c}")

27
Chapitre 1 : Introduction à l'algorithmique

Exercice 1.12 (Mini-projet - Difficile)

Calculateur de moyenne pondérée universitaire : En Licence 1, les matières ont

des coefficients différents. Écrivez un algorithme qui :

1. Lit les notes de 5 matières (chaque note sur 20)

2. Lit le coefficient de chaque matière

∑(note ×coefi )
3. Calcule la moyenne pondérée : ∑ coef i
​ ​

i ​

4. Affiche la moyenne sur 20

5. Affiche la mention : Très Bien (>=16), Bien (>=14), Assez Bien (>=12), Passable
(>=10), Insuffisant (<10)

Correction

28
Chapitre 1 : Introduction à l'algorithmique

ALGORITHME Moyenne_Ponderee
VARIABLES
// Notes (sur 20)
note1, note2, note3, note4, note5 : REEL
// Coefficients
coef1, coef2, coef3, coef4, coef5 : ENTIER
// Calculs
somme_ponderee : REEL // Somme de (note * coef)
somme_coefs : ENTIER // Somme des coefficients
moyenne : REEL // Résultat final
DÉBUT
AFFICHER "=== CALCUL DE MOYENNE PONDEREE ==="

// Saisie des 5 matières (note + coefficient)

AFFICHER "Matière 1 - Note : " ; LIRE note1
AFFICHER "Matière 1 - Coef : " ; LIRE coef1

AFFICHER "Matière 2 - Note : " ; LIRE note2

AFFICHER "Matière 2 - Coef : " ; LIRE coef2

AFFICHER "Matière 3 - Note : " ; LIRE note3

AFFICHER "Matière 3 - Coef : " ; LIRE coef3

AFFICHER "Matière 4 - Note : " ; LIRE note4

AFFICHER "Matière 4 - Coef : " ; LIRE coef4

AFFICHER "Matière 5 - Note : " ; LIRE note5

AFFICHER "Matière 5 - Coef : " ; LIRE coef5

// Calcul de la moyenne pondérée

somme_ponderee <- note1*coef1 + note2*coef2 + note3*coef3
+ note4*coef4 + note5*coef5
somme_coefs <- coef1 + coef2 + coef3 + coef4 + coef5
moyenne <- somme_ponderee / somme_coefs

// Affichage de la moyenne
AFFICHER "Votre moyenne est : ", moyenne, "/20"

// Détermination de la mention
SI moyenne >= 16 ALORS
AFFICHER "Mention : TRES BIEN"
SINON SI moyenne >= 14 ALORS
AFFICHER "Mention : BIEN"
SINON SI moyenne >= 12 ALORS
AFFICHER "Mention : ASSEZ BIEN"
SINON SI moyenne >= 10 ALORS
AFFICHER "Mention : PASSABLE"

29
Chapitre 1 : Introduction à l'algorithmique

FIN SI
FIN

Version Python :

print("=== MOYENNE PONDEREE ===")

notes = []
coefs = []

for i in range(1, 6):

n = float(input(f"Matiere {i} - Note : "))
c = int(input(f"Matiere {i} - Coef : "))
[Link](n)
[Link](c)

somme_ponderee = sum(n * c for n, c in zip(notes, coefs))

somme_coefs = sum(coefs)
moyenne = somme_ponderee / somme_coefs

print(f"\nMoyenne : {moyenne:.2f}/20")

if moyenne >= 16: print("Mention : TRES BIEN")

elif moyenne >= 14: print("Mention : BIEN")
elif moyenne >= 12: print("Mention : ASSEZ BIEN")
elif moyenne >= 10: print("Mention : PASSABLE")
else: print("Mention : INSUFFISANT")

Méthode : La moyenne pondérée n'est pas une simple moyenne. Chaque note
est "importée" selon son coefficient. On calcule d'abord toutes les contributions
(note x coef), on les additionne, puis on divise par la somme des coefficients.
Les conditions imbriquées pour les mentions utilisent la structure SI/SINON SI
que nous verrons en détail au Chapitre 6.

30
Chapitre 1 : Introduction à l'algorithmique

Validation du Chapitre 1

Félicitations ! Vous avez terminé le premier chapitre. Avant de passer au Chapitre

2, assurez-vous de maîtriser :

La définition et les 5 caractéristiques d'un algorithme

La structure générale ALGORITHME / VARIABLES / DÉBUT / FIN

La différence entre algorithme et programme

L'affectation avec la flèche <-

Le traçage pas à pas d'un algorithme

Lorsque vous êtes prêt, écrivez "Chapitre suivant" pour passer au Chapitre 2.

31
Chapitre 2 : Variables et constantes

Chapitre 2 : Variables et constantes

CHAPITRE 2

Variables et constantes

2.1 Définition simple et intuitive

DÉFINITIONS

Une variable est un espace de stockage nommé dans la mémoire de l'ordinateur,

capable de contenir une valeur qui peut changer au cours de l'exécution de
l'algorithme. C'est comme une boîte étiquetée : vous pouvez y mettre quelque
chose, le consulter, et le remplacer par autre chose quand vous voulez.

Une constante est également un espace de stockage nommé, mais dont la valeur
est fixée une fois pour toutes et ne peut jamais être modifiée. C'est comme le
nombre pi (π ≈ 3.14159) : c'est une valeur qui ne change jamais.

2.2 Objectif de la notion

32
Chapitre 2 : Variables et constantes

OBJECTIFS PÉDAGOGIQUES

Comprendre le rôle des variables et des constantes dans un algorithme

Savoir déclarer correctement une variable (nom, type, valeur initiale)

Maîtriser l'opération d'affectation

Distinguer les bonnes pratiques de nommage

Comprendre la différence entre variable et constante

2.3 Exemple concret de la vie courante

EXEMPLE CONCRET : LA BOÎTE À OUTILS ET LES RÈGLES FIXES

Imaginez un ébéniste qui travaille dans son atelier :

Variables (boîtes changeantes) : Il a une boîte marquée "vis en cours

d'utilisation". Aujourd'hui elle contient 50 vis, demain 30, après-demain 0.
Le contenu change, mais le nom de la boîte reste le même.

Constantes (règles fixes) : Sur le mur de l'atelier est affichée la règle "1
pouce = 2.54 centimètres". Cette valeur ne change jamais, quelle que soit la
situation. On peut la consulter autant de fois que nécessaire, mais on ne la
modifie pas.

Dans un algorithme, les variables stockent des données qui évoluent (résultats
intermédiaires, compteurs, saisies utilisateur), tandis que les constantes stockent
des valeurs immuables (taux de TVA, conversions d'unités, messages fixes).

2.4 Explication détaillée avec schémas ASCII

2.4.1 Représentation mémoire d'une variable

33
Chapitre 2 : Variables et constantes

Quand vous déclarez une variable, l'ordinateur réserve un emplacement en mémoire RAM
et lui associe un nom.

MÉMOIRE DE L'ORDINATEUR (simplifiée)

+----------------------------------------------------+
| Adresse | Nom variable | Valeur | Type |
+----------------------------------------------------+
| 0x1000 | age | 20 | ENTIER |
| 0x1004 | prix | 29.99 | REEL |
| 0x1008 | nom | "Alice" | CHAINE |
| 0x1016 | estValide | VRAI | BOOLEEN |
+----------------------------------------------------+

Déclaration : VARIABLE age : ENTIER

Affectation : age <- 20

+-------+ +-------+
| age | -----> | 20 |
+-------+ +-------+
(nom de la (contenu dans
variable) la mémoire)

2.4.2 L'affectation en détail

L'affectation est l'opération fondamentale qui modifie la valeur d'une variable. Elle se note
<- (flèche vers la gauche).

Opération : x <- 10

AVANT l'affectation : APRÈS l'affectation :

+-------+ +-------+ +-------+ +-------+
| x |-->| ??? | | x |-->| 10 |
+-------+ +-------+ +-------+ +-------+
(indéfini) (initialisé)

Opération : x <- x + 5 (x vaut déjà 10)

Étape 1 : Évaluer la partie droite (x + 5 = 10 + 5 = 15)

Étape 2 : Stocker le résultat dans x

+-------+ +-------+ +-------+ +-------+

| x |-->| 10 | ===> | x |-->| 15 |
+-------+ +-------+ +-------+ +-------+

2.4.3 Règles de nommage des variables

34
Chapitre 2 : Variables et constantes

Tableau 2.1 : Règles de nommage

Exemple Exemple
Règle Explication
valide invalide

Commencer par une Ne peut pas commencer par un

age , note1 1ereNote
lettre chiffre

Utiliser le CamelCase ou
Pas d'espaces prixTotal prix total
underscore

Pas de caractères tva_francai tva#française

Seuls lettres, chiffres, underscore
spéciaux se !

Pas de mot réservé sinonValeur SINON , ALORS On évite les mots-clés du langage

prixHorsTax
Nom significatif pht , x Le nom doit décrire le contenu
e

(les deux Majuscules et minuscules sont

Casse sensible Age et age
diffèrent) différentes

2.5 Pseudo-code commenté ligne par ligne

2.5.1 Déclaration et utilisation de variables

35
Chapitre 2 : Variables et constantes

ALGORITHME 2.1 : DÉCLARATION ET INITIALISATION

36
Chapitre 2 : Variables et constantes

ALGORITHME Exemple_Variables
// ============================================================
// But : Montrer la déclaration, l'initialisation et
// la modification de variables
// ============================================================

VARIABLES
// --- Déclarations simples ---
age : ENTIER // Variable entière (pas de décimale)
taille : REEL // Variable réelle (avec décimale)
prenom : CHAINE // Variable texte
estMajeur : BOOLEEN // Variable logique (VRAI ou FAUX)

// --- Déclarations avec initialisation ---

compteur : ENTIER <- 0 // Déclarée ET initialisée à 0

// --- Constantes ---

CONST AGE_MAJORITE : ENTIER <- 18
CONST TAUX_TVA : REEL <- 0.20
CONST PI : REEL <- 3.14159

DÉBUT
// --- Affectation de valeurs ---
age <- 20 // La variable 'age' contient
maintenant 20
taille <- 1.75 // La variable 'taille' contient 1.75
prenom <- "Alice" // La variable 'prenom' contient
"Alice"
estMajeure <- (age >= AGE_MAJORITE) // VRAI car 20 >= 18

// --- Modification d'une variable ---

compteur <- compteur + 1 // compteur passe de 0 à 1
compteur <- compteur + 1 // compteur passe de 1 à 2

// --- Utilisation des constantes ---

AFFICHER "L'âge de majorité est : ", AGE_MAJORITE
AFFICHER "Le taux de TVA est : ", TAUX_TVA * 100, "%"

// --- Affichage des variables ---

AFFICHER prenom, " a ", age, " ans."
AFFICHER "Majeur ? ", estMajeur
AFFICHER "Compteur final : ", compteur
FIN

37
Chapitre 2 : Variables et constantes

2.5.2 Différence variable / constante

ALGORITHME 2.2 : VARIABLES VS CONSTANTES

ALGORITHME Variable_Vs_Constante
VARIABLES
prix : REEL <- 100.0 // Variable : peut changer
CONST TAUX : REEL <- 0.20 // Constante : ne change JAMAIS
prixTTC : REEL

DÉBUT
// On peut modifier une variable
prix <- 150.0 // CORRECT : prix est une variable

// On ne peut PAS modifier une constante

// TAUX <- 0.25 // ERREUR ! Interdit !

// On utilise la constante dans un calcul

prixTTC <- prix * (1 + TAUX)
AFFICHER "Prix TTC : ", prixTTC

// On peut changer prix autant de fois que voulu

prix <- 200.0
prixTTC <- prix * (1 + TAUX)
AFFICHER "Nouveau prix TTC : ", prixTTC
// TAUX reste toujours à 0.20 (20%)
FIN

2.6 Exemple d'exécution pas à pas

Exécutons l'Algorithme 2.1 pas à pas :

Tableau 2.2 : Trace d'exécution détaillée

Étape Instruction age taille prenom estMajeur compteur Affichage

1 Déclaration ? ? ? ? 0 -

2 age <- 20 20 ? ? ? 0 -

38
Chapitre 2 : Variables et constantes

3 taille <- 1.75 20 1.75 ? ? 0 -

4 prenom <- "Alice" 20 1.75 "Alice" ? 0 -

5 estMajeur <- (age >= 18) 20 1.75 "Alice" VRAI 0 -

6 compteur <- compteur + 1 20 1.75 "Alice" VRAI 1 -

7 compteur <- compteur + 1 20 1.75 "Alice" VRAI 2 -

8 AFFICHER AGE_MAJORITE 20 1.75 "Alice" VRAI 2 "L'âge de majorité est : 18"

9 AFFICHER TAUX_TVA 20 1.75 "Alice" VRAI 2 "Le taux de TVA est : 20%"

10 AFFICHER prenom, age 20 1.75 "Alice" VRAI 2 "Alice a 20 ans."

11 AFFICHER estMajeur 20 1.75 "Alice" VRAI 2 "Majeur ? VRAI"

2.7 Erreurs fréquentes des débutants

ERREURS À ÉVITER

Utiliser une variable non initialisée : Si vous déclarez x : ENTIER puis

faites y <- x + 1 sans avoir jamais donné de valeur à x, le résultat est
imprévisible. Toujours initialiser ses variables !

Confondre déclaration et affectation : VARIABLES x : ENTIER réserve

l'espace. x <- 5 y met une valeur. Ce sont deux opérations distinctes.

Affecter une valeur d'un type incompatible : Si age : ENTIER , on ne peut

pas faire age <- "vingt" . Le type doit correspondre.

Essayer de modifier une constante : Après CONST PI <- 3.14 , tenter PI

<- 3.14159 provoque une erreur. C'est le propre d'une constante.

Noms de variables peu clairs : x , y , z n'ont aucun sens sémantique.

Préférez prixUnitaire , quantiteCommandee .

Oublier que l'affectation écrase l'ancienne valeur : Après x <- 5 puis x

<- 10 , la valeur 5 est perdue à jamais. Il n'y a pas d'"historique".

Confondre = (comparaison) et <- (affectation) : Dans un algorithme, =

signifie "est-égal-à" (test), et <- signifie "devient" ou "reçoit la valeur de".

39
Chapitre 2 : Variables et constantes

2.8 Résumé des points essentiels

POINTS CLÉS À RETENIR

Une variable est un espace mémoire nommé dont le contenu peut changer.
Une constante a une valeur fixe définitive.

Chaque variable a un nom, un type et une valeur.

L'affectation se note <- et se lit "reçoit" ou "prend la valeur de".

On déclare les variables dans la section VARIABLES , avant le DÉBUT .

Les constantes se déclarent avec le mot-clé CONST et s'écrivent en

MAJUSCULES par convention.

Toujours initialiser ses variables avant de les utiliser.

Choisir des noms significatifs : le nom doit décrire le contenu.

L'affectation écrase la valeur précédente sans possibilité de récupération.

Exercices du Chapitre 2

40
Chapitre 2 : Variables et constantes

Exercice 2.1 (Très facile)

Questions de cours : Définissez "variable" et "constante". Citez deux exemples de

chaque dans la vie courante, puis donnez trois rèles à respecter pour nommer une
variable.

Correction

Variable : Espace mémoire nommé pouvant changer de valeur. Exemples : le

solde bancaire, la température extérieure, le nombre de likes sur une photo.

Constante : Espace mémoire nommé avec une valeur fixe. Exemples : le

nombre Pi, la vitesse de la lumière, le taux de TVA (pour une année donnée).

Règles de nommage : (1) Commencer par une lettre, (2) Pas d'espaces, (3)
Utiliser des noms significatifs.

41
Chapitre 2 : Variables et constantes

Exercice 2.2 (Très facile)

Identifiez les erreurs : Trouvez toutes les erreurs dans les déclarations suivantes.

1. VARIABLES 1erNombre : ENTIER

2. CONST PI <- 3.14 puis plus loin : PI <- 3.14159

3. VARIABLES nom de famille : CHAINE

4. VARIABLES ALORS : BOOLEEN

5. AGE <- 20 sans déclaration préalable

Correction

1. Erreur : commence par un chiffre. Correction : premierNombre ou

nombre1 .

2. Erreur : on ne peut pas modifier une constante. Une constante est

immuable.

3. Erreur : espace dans le nom. Correction : nomDeFamille ou nom_famille .

4. Erreur : ALORS est un mot réservé. Correction : reponseAlors ou

conditionValidee .

5. Erreur : variable utilisée sans déclaration. Il faut d'abord déclarer AGE :

ENTIER .

42
Chapitre 2 : Variables et constantes

Exercice 2.3 (Facile)

Trace d'exécution : Faites la trace complète de l'algorithme suivant. Quelles sont

les valeurs finales de a, b et c ?

ALGORITHME Trace
VARIABLES a, b, c : ENTIER
DÉBUT
a <- 5
b <- a + 3
c <- a + b
a <- c - a
b <- a * 2
FIN

Correction

Instruction a b c

Début ? ? ?

a <- 5 5 ? ?

b <- a + 3 (= 5 + 3) 5 8 ?

c <- a + b (= 5 + 8) 5 8 13

a <- c - a (= 13 - 5) 8 8 13

b <- a * 2 (= 8 * 2) 8 16 13

Valeurs finales : a = 8, b = 16, c = 13.

43
Chapitre 2 : Variables et constantes

Exercice 2.4 (Facile)

Déclarations correctes : Écrivez les déclarations de variables adaptées pour

stocker : le nom d'un étudiant, son année de naissance, sa moyenne générale (sur
20), et s'il a validé son semestre (oui/non). Écrivez aussi une constante pour le
nombre de matières (6).

Correction

ALGORITHME Declaration_Etudiant
VARIABLES
nomEtudiant : CHAINE
anneeNaissance : ENTIER
moyenneGenerale : REEL // Peut avoir des décimales
(ex: 13.5)
semestreValide : BOOLEEN // VRAI ou FAUX

CONST NB_MATIERES : ENTIER <- 6

DÉBUT
// Les variables sont prêtes à être utilisées
FIN

Choix des types : Nom → CHAINE (texte), Année → ENTIER (nombre entier),
Moyenne → REEL (peut être 13.5), Validation → BOOLEEN (VRAI/Faux).

44
Chapitre 2 : Variables et constantes

Exercice 2.5 (Facile)

Initialisation multiple : On souhaite initialiser trois variables a , b , c à 0.

Pourquoi l'instruction a <- b <- c <- 0 est-elle problématique en pseudo-code
standard ? Quelle est la méthode correcte ?

Correction

L'instruction chaînée a <- b <- c <- 0 n'est pas standard car elle mêle
affectations et expressions de manière ambiguë. Chaque affectation doit être
une instruction distincte :

a <- 0
b <- 0
c <- 0

Alternative avec initialisation à la déclaration :

VARIABLES
a : ENTIER <- 0
b : ENTIER <- 0
c : ENTIER <- 0

45
Chapitre 2 : Variables et constantes

Exercice 2.6 (Moyen)

Compteur de passages : Écrivez un algorithme qui simule un compteur de

passages dans un magasin. Le compteur commence à 0. Trois clients entrent
(incrémentation de 3), puis deux sortent (décrémentation de 2), puis cinq entrent.
Affichez le compteur final.

Correction

ALGORITHME Compteur_Passages
VARIABLES
compteur : ENTIER <- 0
DÉBUT
// 3 clients entrent
compteur <- compteur + 3 // compteur = 3

// 2 clients sortent
compteur <- compteur - 2 // compteur = 1

// 5 clients entrent
compteur <- compteur + 5 // compteur = 6

AFFICHER "Nombre de personnes dans le magasin : ", compteur

FIN

Python :

compteur = 0
compteur += 3 # équivalent à compteur = compteur + 3
compteur -= 2 # équivalent à compteur = compteur - 2
compteur += 5
print(f"Personnes dans le magasin : {compteur}") # Affiche 6

46
Chapitre 2 : Variables et constantes

Exercice 2.7 (Moyen)

Calculateur d'IMC : Écrivez un algorithme qui calcule l'Indice de Masse Corporelle

(IMC = poids en kg / taille en mètres au carré). Utilisez des constantes pour les
catégories : maigreur (<18.5), normal (18.5-25), surpoids (25-30), obésité (>30).
L'algorithme affiche l'IMC et la catégorie.

Correction

ALGORITHME Calculateur_IMC
VARIABLES
poids : REEL // en kilogrammes
taille : REEL // en mètres
imc : REEL

CONST SEUIL_MAIGREUR : REEL <- 18.5

CONST SEUIL_SURPOIDS : REEL <- 25.0
CONST SEUIL_OBESITE : REEL <- 30.0
DÉBUT
AFFICHER "Poids (kg) : "
LIRE poids
AFFICHER "Taille (m) : "
LIRE taille

// Calcul de l'IMC
imc <- poids / (taille * taille)

AFFICHER "Votre IMC est : ", imc

// Détermination de la catégorie
SI imc < SEUIL_MAIGREUR ALORS
AFFICHER "Catégorie : Maigreur"
SINON SI imc < SEUIL_SURPOIDS ALORS
AFFICHER "Catégorie : Poids normal"
SINON SI imc < SEUIL_OBESITE ALORS
AFFICHER "Catégorie : Surpoids"
SINON
AFFICHER "Catégorie : Obésité"
FIN SI
FIN

47
Chapitre 2 : Variables et constantes

Python :

poids = float(input("Poids (kg) : "))

taille = float(input("Taille (m) : "))
imc = poids / (taille ** 2)
print(f"IMC : {imc:.2f}")

SEUIL_MAIGREUR = 18.5
SEUIL_SURPOIDS = 25.0
SEUIL_OBESITE = 30.0

if imc < SEUIL_MAIGREUR: print("Maigreur")

elif imc < SEUIL_SURPOIDS: print("Normal")
elif imc < SEUIL_OBESITE: print("Surpoids")
else: print("Obésité")

48
Chapitre 2 : Variables et constantes

Exercice 2.8 (Moyen)

Compteur de caractères : On définit une chaîne phrase <- "Bonjour le monde" .

Écrivez un algorithme qui compte le nombre de caractères (on suppose disposer
d'une fonction LONGUEUR(ch) qui retourne la taille) et qui calcule le nombre de mots
(en comptant les espaces + 1).

Correction

ALGORITHME Compteur_Caracteres
VARIABLES
phrase : CHAINE <- "Bonjour le monde"
nbCaracteres : ENTIER
nbEspaces : ENTIER
nbMots : ENTIER
i : ENTIER // Indice pour parcourir la chaîne
car : CARACTERE // Caractère courant
DÉBUT
// Nombre de caractères total
nbCaracteres <- LONGUEUR(phrase)

// Comptage des espaces (boucle POUR vue au Chapitre 7)

nbEspaces <- 0
POUR i DE 1 A LONGUEUR(phrase) FAIRE
car <- CARACTERE_A(phrase, i)
SI car = ' ' ALORS
nbEspaces <- nbEspaces + 1
FIN SI
FIN POUR

// Nombre de mots = espaces + 1

nbMots <- nbEspaces + 1

AFFICHER "Phrase : \"", phrase, "\""

AFFICHER "Caractères : ", nbCaracteres
AFFICHER "Mots : ", nbMots
FIN

49
Chapitre 2 : Variables et constantes

Exercice 2.9 (Moyen)

Évolution de variables : Qu'affiche l'algorithme suivant ? Dressez le tableau de

trace complet.

ALGORITHME Evolution
VARIABLES x, y, z : ENTIER
DÉBUT
x <- 2
y <- x * 3 // y = ?
z <- x + y // z = ?
x <- z - y // x = ?
y <- y + x // y = ?
z <- x * y * z // z = ?
AFFICHER x, y, z
FIN

Correction

Instruction x y z

Début ? ? ?

x <- 2 2 ? ?

y <- x * 3 (= 2*3) 2 6 ?

z <- x + y (= 2+6) 2 6 8

x <- z - y (= 8-6) 2 6 8

y <- y + x (= 6+2) 2 8 8

z <- x * y * z (= 2*8*8) 2 8 128

Affichage final : x = 2, y = 8, z = 128.

50
Chapitre 2 : Variables et constantes

Exercice 2.10 (Difficile)

Échange sans variable temporaire : On veut échanger les valeurs de deux

variables a et b sans utiliser de variable intermédiaire. Utilisez uniquement les
opérations + et - pour y parvenir. Prouvez que votre méthode fonctionne avec a=7,
b=4.

Correction

ALGORITHME Echange_Sans_Temp
VARIABLES a, b : ENTIER
DÉBUT
AFFICHER "Entrez a : " ; LIRE a
AFFICHER "Entrez b : " ; LIRE b

// Méthode par additions et soustractions

a <- a + b // a contient maintenant la somme (a+b)
b <- a - b // b = (a+b) - b = ancien a
a <- a - b // a = (a+b) - (ancien a) = ancien b

AFFICHER "a = ", a, " b = ", b

FIN

Preuve avec a=7, b=4 :

Instruction a b

Initial 7 4

a <- a + b (= 7+4) 11 4

b <- a - b (= 11-4) 11 7

a <- a - b (= 11-7) 4 7

Résultat : a = 4, b = 7. L'échange est réussi sans variable temporaire !

Limitation : Cette méthode ne fonctionne que pour des nombres et risque le

dépassement si a+b est très grand.

51
Chapitre 2 : Variables et constantes

Exercice 2.11 (Mini-projet)

Gestionnaire de budget mensuel : Écrivez un algorithme complet qui :

1. Définit des constantes pour les postes de dépenses fixes (loyer, internet,
assurance)

2. Lit les dépenses variables (nourriture, transport, loisirs)

3. Lit le revenu du mois

4. Calcule le total des dépenses et l'épargne possible

5. Affiche un bilan détaillé avec pourcentage de chaque poste

Correction

52
Chapitre 2 : Variables et constantes

ALGORITHME Gestionnaire_Budget
// --- CONSTANTES (dépenses fixes) ---
CONST LOYER : REEL <- 650.00
CONST INTERNET : REEL <- 29.99
CONST ASSURANCE : REEL <- 45.00
CONST NB_POSTES : ENTIER <- 6

VARIABLES
nourriture : REEL
transport : REEL
loisirs : REEL
revenu : REEL
totalFixes : REEL
totalVariables : REEL
totalDepenses : REEL
epargne : REEL
pourcentageEpargne : REEL
DÉBUT
// Saisie des variables
AFFICHER "=== GESTIONNAIRE DE BUDGET ==="
AFFICHER ""
AFFICHER "--- Dépenses variables ---"
AFFICHER "Nourriture (EUR) : " ; LIRE nourriture
AFFICHER "Transport (EUR) : " ; LIRE transport
AFFICHER "Loisirs (EUR) : " ; LIRE loisirs
AFFICHER ""
AFFICHER "--- Revenus ---"
AFFICHER "Revenu du mois (EUR) : " ; LIRE revenu

// Calculs
totalFixes <- LOYER + INTERNET + ASSURANCE
totalVariables <- nourriture + transport + loisirs
totalDepenses <- totalFixes + totalVariables
epargne <- revenu - totalDepenses
pourcentageEpargne <- (epargne / revenu) * 100

// Affichage du bilan
AFFICHER ""
AFFICHER "========== BILAN MENSUEL =========="
AFFICHER "--- Dépenses fixes ---"
AFFICHER "Loyer : ", LOYER, " EUR"
AFFICHER "Internet : ", INTERNET, " EUR"
AFFICHER "Assurance : ", ASSURANCE, " EUR"
AFFICHER "Sous-total fixes : ", totalFixes, " EUR"
AFFICHER ""
AFFICHER "--- Dépenses variables ---"
AFFICHER "Nourriture : ", nourriture, " EUR"

53
Chapitre 2 : Variables et constantes

AFFICHER "Sous-total variables : ", totalVariables, " EUR"

AFFICHER ""
AFFICHER "--- Total ---"
AFFICHER "TOTAL DÉPENSES : ", totalDepenses, " EUR"
AFFICHER "REVENU : ", revenu, " EUR"
AFFICHER "ÉPARGNE : ", epargne, " EUR (",
pourcentageEpargne, "%)"

// Message d'alerte si déficit

SI epargne < 0 ALORS
AFFICHER "ALERTE : Vous dépassez votre budget de ", -
epargne, " EUR !"
FIN SI
FIN

Méthode : Séparer clairement les données fixes (CONST) des données

variables. Calculer par étapes : sous-totaux puis total global. Toujours vérifier
les cas limites (déficit ici).

54
Chapitre 2 : Variables et constantes

Exercice 2.12 (Mini-projet - Difficile)

Simulateur d'intérêts composés : Écrivez un algorithme qui simule un placement

avec intérêts composés. L'utilisateur entre : le capital initial, le taux d'intérêt annuel
(en %), et la durée en années. L'algorithme calcule et affiche le capital final selon la
taux annˊees
formule : Capitalf inal = Capitalinitial × (1 +
​ ​

100 ) . Affichez aussi le gain

total.

Correction

55
Chapitre 2 : Variables et constantes

ALGORITHME Interets_Composes
// Formule : Cf = Ci * (1 + t/100)^n
// On suppose disposer de la fonction PUISSANCE(x, n)

VARIABLES
capitalInitial : REEL
tauxAnnuel : REEL // En pourcentage (ex: 3.5 pour
3.5%)
dureeAnnees : ENTIER
capitalFinal : REEL
gain : REEL
facteur : REEL // (1 + taux/100)
DÉBUT
AFFICHER "=== SIMULATEUR D'INTÉRÊTS COMPOSÉS ==="
AFFICHER "Capital initial (EUR) : " ; LIRE capitalInitial
AFFICHER "Taux annuel (%) : " ; LIRE tauxAnnuel
AFFICHER "Durée (années) : " ; LIRE dureeAnnees

// Calcul
facteur <- 1 + (tauxAnnuel / 100)
capitalFinal <- capitalInitial * PUISSANCE(facteur,
dureeAnnees)
gain <- capitalFinal - capitalInitial

// Résultats
AFFICHER ""
AFFICHER "--- RÉSULTAT ---"
AFFICHER "Capital initial : ", capitalInitial, " EUR"
AFFICHER "Taux : ", tauxAnnuel, "% sur ", dureeAnnees, "
ans"
AFFICHER "Capital final : ", ARRONDIR(capitalFinal, 2), "
EUR"
AFFICHER "Gain total : ", ARRONDIR(gain, 2), " EUR"
AFFICHER "Rendement : ",
ARRONDIR((gain/capitalInitial)*100, 2), "%"
FIN

Version Python :

56
Chapitre 2 : Variables et constantes

capital = float(input("Capital initial (EUR): "))

taux = float(input("Taux annuel (%): "))
annees = int(input("Duree (annees): "))

# Le ** est l'operateur de puissance en Python

capital_final = capital * (1 + taux/100) ** annees
gain = capital_final - capital

print(f"\nCapital final : {capital_final:.2f} EUR")

print(f"Gain total : {gain:.2f} EUR")
print(f"Rendement : {(gain/capital)*100:.2f}%")

Méthode : La formule des intérêts composés est fondamentale en

mathématiques financières. Le taux doit être converti de pourcentage (3.5) en
décimal (0.035). La puissance s'obtient via la fonction PUISSANCE ou
l'opérateur ** en Python. L'arrondi à 2 décimales est essentiel pour les
montants en euros.

Validation du Chapitre 2

Bravo ! Vous maîtrisez maintenant les variables et constantes. Vérifiez vos acquis :

Différence variable (changeable) vs constante (fixe)

Déclaration correcte avec type approprié

Affectation <- et son fonctionnement

Règles de nommage

Initialisation obligatoire avant usage

Traçage pas à pas des évolutions de variables

Écrivez "Chapitre suivant" pour valider et passer au Chapitre 3.

57
Chapitre 3 : Types de données

Chapitre 3 : Types de données

CHAPITRE 3

Types de données

3.1 Définition simple et intuitive

DÉFINITION

Un type de donnée définit la nature des valeurs qu'une variable peut contenir,
ainsi que les opérations que l'on peut effectuer sur ces valeurs. C'est comme les
catégories de rangement dans une armoire : on ne range pas les chaussettes de la
même façon que les vestes. Chaque type a ses propres règles et ses propres
opérations valides.

3.2 Objectif de la notion

58
Chapitre 3 : Types de données

OBJECTIFS PÉDAGOGIQUES

Connaître les types de base : entier, réel, caractère, chaîne, booléen

Savoir choisir le type adapté à une donnée donnée

Comprendre les conversions de types (cast)

Maîtriser les opérations permises par type

Identifier les erreurs de type courantes

3.3 Exemple concret de la vie courante

EXEMPLE CONCRET : LES TYPES DANS UN FORMULAIRE

D'INSCRIPTION

Quand vous remplissez un formulaire d'inscription à la fac, chaque champ a un

type implicite :

ENTIER : "Année de naissance" (1985, 2002...) → nombre sans décimale

RÉEL : "Moyenne au bac" (14.5, 12.75...) → nombre avec décimale

CHAÎNE : "Nom de famille" ("Dupont") → texte

CARACTÈRE : "Première lettre du nom" ('D') → un seul caractère

BOOLÉEN : "Cochez si boursier" (oui/non) → VRAI ou FAUX

Si vous écrivez votre nom dans le champ "Année de naissance", le système refuse :
c'est une erreur de type !

3.4 Explication détaillée avec schémas ASCII

3.4.1 Les types de base

59
Chapitre 3 : Types de données

ET, OU, NON

Tableau 3.1 : Les types de données fondamentaux

Type Description Exemples Opérations possibles

Nombre sans décimale (positif ou

ENTIER 42, -7, 0, 1000000 +, -, *, DIV, MOD
négatif)

RÉEL Nombre à virgule (flottant) 3.14, -0.5, 2.0 +, -, *, /

CARACTÈR Comparaison,
Un seul caractère alphanumérique 'A', 'z', '7', '@'
E concaténation

"Bonjour", "L1 Concaténation,

CHAÎNE Séquence de caractères (texte)
Info" extraction

BOOLÉEN Valeur logique binaire VRAI, FAUX

3.4.2 Représentation en mémoire

+------------------------------------------------+
| REPRÉSENTATION EN MÉMOIRE |
+------------------------------------------------+

ENTIER (4 octets = 32 bits)

+----+----+----+----+----+----+----+----+
| 0 | 0 | 0 | 0 | 1 | 0 | 1 | 0 | = 42
+----+----+----+----+----+----+----+----+
31 30 29 28 27 26 25 24
(bit de signe à gauche : 0 = positif, 1 = négatif)

RÉEL (8 octets = 64 bits - norme IEEE 754)

+-+----------+-----------------------------+
|S| Exposant | Mantisse |
+-+----------+-----------------------------+
1 11 bits 52 bits
S=signe, stocké en notation scientifique

CHAÎNE : tableau de caractères en mémoire

Adresse 0x1000: 'B' 'o' 'n' 'j' 'o' 'u' 'r' '\0'
+----+----+----+----+----+----+----+----+
| 66 | 111| 110| 106| 111| 117| 114| 0 |
+----+----+----+----+----+----+----+----+
(codes ASCII) (fin de chaîne)

3.4.3 Conversion de types (cast)

60
Chapitre 3 : Types de données

Tableau 3.2 : Conversions de types possibles

Conversion Exemple Résultat Risque

ENTIER → RÉEL 5 devient 5.0 5.0 Aucun

RÉEL → ENTIER 3.94 devient 3 3 (troncature) Perte de la partie décimale

ENTIER → CHAÎNE 42 devient "42" "42" Aucun

"123" devient Erreur si la chaîne n'est pas

CHAÎNE → ENTIER 123
123 numérique

CARACTÈRE → 65 (code
'A' devient 65 Aucun
ENTIER ASCII)

3.5 Pseudo-code commenté ligne par ligne

61
Chapitre 3 : Types de données

ALGORITHME 3.1 : MANIPULATION DES TYPES

ALGORITHME Types_Donnees
VARIABLES
// --- Déclarations avec types explicites ---
age : ENTIER <- 20
prix : REEL <- 19.99
initiale : CARACTERE <- 'A'
nom : CHAINE <- "Alice"
estActif : BOOLEEN <- VRAI

// --- Variables pour conversions ---

prixEntier : ENTIER
ageChaine : CHAINE
codeAscii : ENTIER

DÉBUT
// Conversion RÉEL → ENTIER (troncature)
prixEntier <- CONVERTIR_ENTIER(prix) // 19.99 devient 19
AFFICHER "Prix entier : ", prixEntier // Affiche 19

// Conversion ENTIER → CHAÎNE

ageChaine <- CONVERTIR_CHAINE(age) // 20 devient "20"
AFFICHER "Age en texte : ", ageChaine // Affiche "20"

// Conversion CARACTÈRE → ENTIER (code ASCII)

codeAscii <- CONVERTIR_ENTIER(initiale) // 'A' (ASCII 65)
AFFICHER "Code ASCII de A : ", codeAscii // Affiche 65

// Concaténation de chaînes
nom <- nom + " Dupont" // "Alice" + " Dupont"
AFFICHER "Nom complet : ", nom // Affiche "Alice
Dupont"

// Longueur d'une chaîne

AFFICHER "Longueur : ", LONGUEUR(nom) // Affiche 12
FIN

3.6 Exemple d'exécution pas à pas

62
Chapitre 3 : Types de données

Tableau 3.3 : Exécution pas à pas

Étape Instruction État des variables Affichage

age=20, prix=19.99, initiale='A',

1 Déclarations -
nom="Alice", estActif=VRAI

prixEntier <-
2 prixEntier=19 -
CONVERTIR_ENTIER(prix)

"Prix entier :
3 AFFICHER prixEntier (inchangé)
19"

ageChaine <-
4 ageChaine="20" -
CONVERTIR_CHAINE(age)

codeAscii <-
5 codeAscii=65 -
CONVERTIR_ENTIER('A')

6 nom <- nom + " Dupont" nom="Alice Dupont" -

"Longueur :
7 AFFICHER LONGUEUR(nom) (inchangé)
12"

3.7 Erreurs fréquentes des débutants

63
Chapitre 3 : Types de données

ERREURS À ÉVITER

Confondre ENTIER et RÉEL : Faire x : ENTIER <- 3.5 provoque une

erreur. Un entier ne peut pas stocker de décimales.

Oublier les guillemets pour les chaînes : nom <- Alice cherche une
variable nommée Alice. Il faut nom <- "Alice" .

Confondre caractère et chaîne : 'A' (CARACTÈRE, apostrophes simples)

vs "A" (CHAÎNE, guillemets doubles). Ce sont des types différents.

Division entière inattendue : 5 DIV 2 = 2 (entier), mais 5.0 / 2.0 = 2.5

(réel). Le type change le résultat.

Convertir une chaîne non numérique en nombre :

CONVERTIR_ENTIER("abc") provoque une erreur d'exécution.

Concaténer nombre et chaîne sans conversion : "Age : " + 20 est

invalide. Il faut d'abord convertir : "Age : " + CONVERTIR_CHAINE(20) .

3.8 Résumé des points essentiels

POINTS CLÉS À RETENIR

ENTIER : nombres sans virgule. RÉEL : nombres à virgule.

CARACTÈRE : un seul symbole entre apostrophes. CHAÎNE : texte entre

guillemets.

BOOLEEN : VRAI ou FAUX uniquement.

Chaque variable doit avoir un type déclaré et ce type ne change pas.

Les conversions doivent être explicites : CONVERTIR_ENTIER() ,

CONVERTIR_CHAINE() , etc.

La conversion RÉEL → ENTIER tronque (3.99 devient 3, pas 4).

64
Chapitre 3 : Types de données

Exercices du Chapitre 3

Exercice 3.1 (Très facile)

Type approprié : Pour chaque donnée, indiquez le type le plus adapté (ENTIER,
RÉEL, CARACTÈRE, CHAÎNE, BOOLÉEN) : le numéro de téléphone, la température
corporelle, la civilité (M./Mme), si un étudiant est présent, le nombre de pages d'un
livre.

Correction

Numéro de téléphone : CHAÎNE (commence souvent par 0, pas de calcul)

Température corporelle : RÉEL (37.5°C)

Civilité : CHAÎNE ("M.", "Mme", "Mlle")

Étudiant présent : BOOLÉEN (VRAI/FAUX)

Nombre de pages : ENTIER (325 pages)

65
Chapitre 3 : Types de données

Exercice 3.2 (Très facile)

Vrai ou Faux : (1) Un ENTIER peut stocker 3.14. (2) Un CARACTÈRE peut être un
chiffre. (3) Une CHAÎNE vide "" a une longueur de 0. (4) Un BOOLÉEN peut valoir 0
ou 1. (5) CONVERTIR_ENTIER(3.9) donne 4.

Correction

1. Faux : ENTIER = pas de décimale.

2. Vrai : '7' est un CARACTÈRE (apostrophes !).

3. Vrai : Chaîne vide = 0 caractère.

4. Faux : Un BOOLÉEN vaut VRAI ou FAUX, pas 0 ou 1 (ce sont des entiers).

5. Faux : La troncature donne 3, pas 4. Pour arrondir, il faut une fonction

spécifique.

Exercice 3.3 (Facile)

Déclarations : Écrivez les déclarations correctes pour : le numéro INE d'un étudiant
(11 caractères), son année de naissance, sa mention au bac (chaîne), et s'il a
redoublé (oui/non).

VARIABLES
numeroINE : CHAINE // Ex: "09876543210"
anneeNaissance : ENTIER // Ex: 2005
mentionBac : CHAINE // Ex: "Bien", "Tres Bien"
aRedouble : BOOLEEN // VRAI ou FAUX

66
Chapitre 3 : Types de données

Exercice 3.4 (Facile)

Conversion : On a x : REEL <- 7.8 et y : ENTIER <- 3 . Donnez le type et la

valeur de : (a) CONVERTIR_ENTIER(x), (b) y + 2, (c) CONVERTIR_REEL(y), (d)
CONVERTIR_CHAINE(x) + " euros".

Correction

(a) ENTIER, valeur 7 (troncature de 7.8)

(b) ENTIER, valeur 5 (3 + 2)

(c) RÉEL, valeur 3.0

(d) CHAÎNE, valeur "7.8 euros"

Exercice 3.5 (Facile)

Chaîne vs Caractère : Expliquez pourquoi 'A' + "BC" peut poser problème, et

comment le résoudre pour obtenir "ABC".

Correction

'A' est un CARACTÈRE (type différent) et "BC" est une CHAÎNE. La

concaténation directe peut échouer car les types diffèrent. Solution : convertir
le caractère en chaîne d'abord.

resultat <- CONVERTIR_CHAINE('A') + "BC" // "A" + "BC" = "ABC"

Ou directement : resultat <- "A" + "BC" si on écrit 'A' comme chaîne "A".

67
Chapitre 3 : Types de données

Exercice 3.6 (Moyen)

Durée en secondes : Écrivez un algorithme qui lit une durée en secondes (ENTIER)
et la convertit en heures, minutes, secondes. Utilisez uniquement des opérations
ENTIÈRES (DIV et MOD).

Correction

ALGORITHME Convertir_Duree
VARIABLES
dureeSec : ENTIER
heures : ENTIER
minutes : ENTIER
secondes : ENTIER
reste : ENTIER
DÉBUT
AFFICHER "Durée en secondes : " ; LIRE dureeSec

heures <- dureeSec DIV 3600

reste <- dureeSec MOD 3600
minutes <- reste DIV 60
secondes <- reste MOD 60

AFFICHER heures, "h ", minutes, "min ", secondes, "s"

FIN

Python :

duree = int(input("Secondes : "))

h = duree // 3600
reste = duree % 3600
m = reste // 60
s = reste % 60
print(f"{h}h {m}min {s}s")

68
Chapitre 3 : Types de données

Exercice 3.7 (Moyen)

Code de vérification : Un code à 4 chiffres est stocké sous forme d'ENTIER (ex:
4729). Écrivez un algorithme qui extrait chaque chiffre (unités, dizaines, centaines,
milliers) en utilisant DIV et MOD.

Correction

ALGORITHME Extraire_Chiffres
VARIABLES
code : ENTIER // Ex: 4729
u, d, c, m : ENTIER // unités, dizaines, centaines,
milliers
DÉBUT
AFFICHER "Code à 4 chiffres : " ; LIRE code

u <- code MOD 10 // 4729 MOD 10 = 9

d <- (code DIV 10) MOD 10 // 472 DIV 10 = 2
c <- (code DIV 100) MOD 10 // 47 MOD 10 = 7
m <- code DIV 1000 // 4

AFFICHER "Milliers : ", m

AFFICHER "Centaines : ", c
AFFICHER "Dizaines : ", d
AFFICHER "Unités : ", u
FIN

Méthode : MOD 10 isole le dernier chiffre. DIV 10 enlève le dernier chiffre. En

combinant, on extrait chaque position.

69
Chapitre 3 : Types de données

Exercice 3.8 (Moyen)

Type résultat : Donnez le type et la valeur résultat de chaque expression : (1) 5 +

3.0, (2) 10 DIV 4, (3) 10 / 4, (4) CONVERTIR_REEL(5) + 3, (5) LONGUEUR("ABC"), (6)
"42" + "3".

Correction

Expression Type Valeur

5 + 3.0 RÉEL (promotion) 8.0

10 DIV 4 ENTIER 2

10 / 4 RÉEL 2.5

CONVERTIR_REEL(5) + 3 RÉEL 8.0

LONGUEUR("ABC") ENTIER 3

"42" + "3" CHAÎNE "423"

70
Chapitre 3 : Types de données

Exercice 3.9 (Moyen)

Conversion de température : Écrivez un algorithme qui convertit une température

9
de Celsius en Fahrenheit (F =C× 5 ​ + 32) et en Kelvin (K = C + 273.15). Le
résultat doit être un RÉEL arrondi à 2 décimales.

Correction

ALGORITHME Conversion_Temperature
VARIABLES
celsius : REEL
fahrenheit : REEL
kelvin : REEL
DÉBUT
AFFICHER "Température en °C : " ; LIRE celsius
fahrenheit <- celsius * (9.0/5.0) + 32.0
kelvin <- celsius + 273.15
AFFICHER celsius, "°C = ", ARRONDIR(fahrenheit, 2), "°F"
AFFICHER celsius, "°C = ", ARRONDIR(kelvin, 2), "K"
FIN

Python :

c = float(input("Temperature en °C : "))
f = c * 9/5 + 32
k = c + 273.15
print(f"{c}°C = {f:.2f}°F = {k:.2f}K")

71
Chapitre 3 : Types de données

Exercice 3.10 (Difficile)

Inverser un nombre à 3 chiffres : Écrivez un algorithme qui lit un nombre ENTIER

à 3 chiffres (ex: 527) et affiche son inverse (725). Utilisez DIV et MOD uniquement,
sans convertir en chaîne.

Correction

ALGORITHME Inverser_Nombre
VARIABLES
n : ENTIER // Nombre initial (ex: 527)
inverse : ENTIER // Résultat (ex: 725)
u, d, c : ENTIER // Chiffres
DÉBUT
AFFICHER "Nombre à 3 chiffres : " ; LIRE n

// Extraction des chiffres

u <- n MOD 10 // 7 (unités)
d <- (n DIV 10) MOD 10 // 2 (dizaines)
c <- n DIV 100 // 5 (centaines)

// Reconstruction inversée : u d c au lieu de c d u

inverse <- u * 100 + d * 10 + c // 7*100 + 2*10 + 5 = 725

AFFICHER "Inverse : ", inverse

FIN

Python :

n = int(input("Nombre a 3 chiffres : "))

u = n % 10
d = (n // 10) % 10
c = n // 100
inverse = u * 100 + d * 10 + c
print(f"Inverse : {inverse}")

72
Chapitre 3 : Types de données

Exercice 3.11 (Mini-projet)

Convertisseur d'unités complet : Écrivez un algorithme qui lit une longueur en

mètres (RÉEL) et la convertit en : kilomètres, centimètres, millimètres, pouces (1
pouce = 2.54 cm), pieds (1 pied = 30.48 cm), yards (1 yard = 91.44 cm). Utilisez des
constantes pour les facteurs de conversion.

Correction

ALGORITHME Convertisseur_Unites
CONST POUCE_CM : REEL <- 2.54
CONST PIED_CM : REEL <- 30.48
CONST YARD_CM : REEL <- 91.44

VARIABLES
metres : REEL
cm : REEL
DÉBUT
AFFICHER "Longueur en mètres : " ; LIRE metres
cm <- metres * 100.0

AFFICHER "--- RÉSULTATS ---"

AFFICHER "Kilomètres : ", metres / 1000.0
AFFICHER "Centimètres : ", cm
AFFICHER "Millimètres : ", cm * 10.0
AFFICHER "Pouces : ", ARRONDIR(cm / POUCE_CM, 2)
AFFICHER "Pieds : ", ARRONDIR(cm / PIED_CM, 2)
AFFICHER "Yards : ", ARRONDIR(cm / YARD_CM, 2)
FIN

73
Chapitre 3 : Types de données

Exercice 3.12 (Mini-projet - Difficile)

Calculateur de date de naissance : On dispose du numéro de sécurité sociale

français (15 chiffres stockés en CHAÎNE) : 1 85 12 76 451 089 (1=homme, 85=année
1985, 12=mois décembre, 76=département). Écrivez un algorithme qui extrait : le
sexe (1=M, 2=F), l'année, le mois, le département, et affiche une description
complète.

Correction

74
Chapitre 3 : Types de données

ALGORITHME Decoder_Securite_Sociale
VARIABLES
num : CHAINE // 15 chiffres
sexeCode : CHAINE // "1" ou "2"
anneeCode : CHAINE // "85"
moisCode : CHAINE // "12"
deptCode : CHAINE // "76"
sexe : CHAINE
annee : ENTIER
mois : ENTIER
dept : ENTIER
DÉBUT
AFFICHER "Numéro SS (15 chiffres) : " ; LIRE num

// Extraction par sous-chaînes

sexeCode <- SOUS_CHAINE(num, 1, 1) // Position 1,
longueur 1
anneeCode <- SOUS_CHAINE(num, 2, 2) // Positions 2-3
moisCode <- SOUS_CHAINE(num, 4, 2) // Positions 4-5
deptCode <- SOUS_CHAINE(num, 6, 2) // Positions 6-7

// Conversions et interprétation
SI sexeCode = "1" ALORS sexe <- "Homme"
SINON sexe <- "Femme" FIN SI

annee <- CONVERTIR_ENTIER(anneeCode)

annee <- 1900 + annee // 85 -> 1985
mois <- CONVERTIR_ENTIER(moisCode)
dept <- CONVERTIR_ENTIER(deptCode)

AFFICHER "Sexe : ", sexe

AFFICHER "Année de naissance : ", annee
AFFICHER "Mois : ", mois
AFFICHER "Département : ", dept
FIN

Python :

75
Chapitre 3 : Types de données

num = input("Numero SS : ")

sexe = "Homme" if num[0] == "1" else "Femme"
annee = 1900 + int(num[1:3])
mois = int(num[3:5])
dept = int(num[5:7])
print(f"{sexe}, ne(e) en {annee}, mois {mois}, dept {dept}")

Méthode : La fonction SOUS_CHAINE(chaine, debut, longueur) extrait une

portion. En Python, on utilise le slicing num[1:3] . La clé est de bien respecter
les positions exactes du numéro SS.

Validation du Chapitre 3

Excellent travail ! Vous connaissez maintenant les types fondamentaux.

Maîtrisez-vous bien :

Les 5 types de base et leur usage

Le choix du type adapté à la situation

Les conversions entre types

La différence DIV/MOD vs division réelle

L'extraction de chiffres avec DIV/MOD

Écrivez "Chapitre suivant" pour valider et passer au Chapitre 4.

76
Chapitre 4 : Entrées et sorties

Chapitre 4 : Entrées et sorties

CHAPITRE 4

Entrées et sorties

4.1 Définition simple et intuitive

DÉFINITIONS

Les entrées (LIRE) sont les moyens par lesquels un algorithme reçoit des données
de l'extérieur, typiquement via le clavier. C'est comme quand on vous pose une
question et que vous répondez : l'algorithme "demande" et l'utilisateur "répond".

Les sorties (AFFICHER) sont les moyens par lesquels un algorithme communique
ses résultats à l'utilisateur, typiquement via l'écran. C'est comme quand on vous
donne un résultat ou une information.

4.2 Objectif de la notion

77
Chapitre 4 : Entrées et sorties

OBJECTIFS PÉDAGOGIQUES

Maîtriser les instructions LIRE et AFFICHER

Savoir formater les messages de sortie

Comprendre le flux d'exécution entrées-traitements-sorties

Gérer les messages d'invite (prompts) clairs

Comprendre la notion de flux (stdin/stdout)

4.3 Exemple concret de la vie courante

EXEMPLE CONCRET : LE DISTRIBUTEUR AUTOMATIQUE

Un distributeur automatique de boissons illustre parfaitement les entrées et

sorties :

Entrées : Vous appuyez sur le bouton "Café" (donnée en entrée), vous

insérez une pièce de 1 EUR (donnée en entrée).

Traitement : La machine vérifie le prix, chauffe l'eau, moud le café, verse.

Sorties : La machine affiche "Café en préparation" (sortie écran), puis

distribue le gobelet (sortie physique), et affiche "Bon café !" (sortie écran).

4.4 Explication détaillée avec schémas ASCII

4.4.1 Schéma du flux d'entrées-sorties

78
Chapitre 4 : Entrées et sorties

+------------+ LIRE +------------------+ AFFICHER +------------+

| UTILISATEUR| ===============> | | ===============> | UTILISATEUR|
| (clavier) | Données en | ALGORITHME | Résultats | (écran) |
| | entrée | | affichés | |
+------------+ +------------------+ +------------+

Exemple concret :
+------------+ +------------------+ +------------+
| Taper: 20 | ==> LIRE age ==> | age <- 20 | ==> AFFICHER ==> | "Vous avez"|
| | | calcul... | "Age: 20" | "20 ans" |
+------------+ +------------------+ +------------+

4.4.2 Structure générale d'un programme interactif

+-------+ +---------+ +-----------+ +----------+ +--------+

| DÉBUT | --> | LIRE | --> | TRAITEMENT| --> | AFFICHER | --> | FIN |
+-------+ | données | | | |résultats | +--------+
+---------+ +-----------+ +----------+

Avec message d'invite :

+-------+ +----------------------+ +-----------+ +----------------------+
| DÉBUT | --> | AFFICHER "Nom?" | --> | | --> | AFFICHER "Bonjour" |
+-------+ | LIRE nom | |Traitement | | AFFICHER nom |
| (invite claire) | | | | (sortie formatée) |
+----------------------+ +-----------+ +----------------------+

4.5 Pseudo-code commenté ligne par ligne

79
Chapitre 4 : Entrées et sorties

ALGORITHME 4.1 : DIALOGUE COMPLET AVEC L'UTILISATEUR

ALGORITHME Dialogue_Utilisateur
VARIABLES
prenom : CHAINE
age : ENTIER
taille : REEL
DÉBUT
// --- ENTRÉES avec messages d'invite clairs ---

// Invite + lecture du prénom

AFFICHER "Bonjour ! Quel est votre prénom ? "
LIRE prenom

// Invite + lecture de l'âge

AFFICHER "Enchanté ", prenom, ". Quel âge avez-vous ? "
LIRE age

// Invite + lecture de la taille

AFFICHER "Quelle est votre taille en mètres ? "
LIRE taille

// --- TRAITEMENT ---

// On pourrait calculer des choses ici (pas dans cet exemple)

// --- SORTIES formatées ---

AFFICHER ""
AFFICHER "========== RÉCAPITULATIF =========="
AFFICHER "Nom : ", prenom
AFFICHER "Age : ", age, " ans"
AFFICHER "Taille : ", taille, " m"
AFFICHER "===================================="
FIN

4.5.1 Bonnes pratiques pour les entrées

Tableau 4.1 : Bonnes pratiques d'entrée-sortie

Bonne pratique Exemple correct Exemple incorrect

80
Chapitre 4 : Entrées et sorties

Toujours afficher un message AFFICHER "Age?" puis

LIRE age (sans invite)
avant LIRE LIRE age

"Taille?" (ambigu : cm ?
Indiquer l'unité attendue "Taille en mètres :"
m ?)

AFFICHER r (sans
Formater les sorties clairement "Résultat : " + r
contexte)

Sauter une ligne entre sections AFFICHER "" (ligne vide) Tout collé sans séparation

4.6 Exemple d'exécution pas à pas

Exécution de l'Algorithme 4.1 avec l'utilisateur qui tape "Alice", "20", "1.65" :

Tableau 4.2 : Exécution interactive pas à pas

Étape Instruction Écran affiché Action utilisateur

Bonjour ! Quel est votre

1 AFFICHER "Bonjour..." (attend)
prénom ?

Tape "Alice" puis

2 LIRE prenom (curseur clignote)
Entrée

3 AFFICHER "Enchanté..." Enchanté Alice. Quel âge ? (attend)

4 LIRE age (curseur) Tape "20" puis Entrée

AFFICHER "Quelle
5 Taille en mètres ? (attend)
taille..."

Tape "1.65" puis

6 LIRE taille (curseur)
Entrée

7-11 AFFICHER (récap) Le récapitulatif formaté (lit)

4.7 Erreurs fréquentes des débutants

81
Chapitre 4 : Entrées et sorties

ERREURS À ÉVITER

Oublier le message d'invite : Un LIRE age sans AFFICHER avant laisse

l'écran vide. L'utilisateur ne sait pas quoi faire.

Lire dans le mauvais type : Si age : ENTIER mais l'utilisateur tape "vingt",
l'algorithme plante.

Afficher sans contexte : AFFICHER resultat affiche juste un nombre.

Préférer AFFICHER "La moyenne est : ", resultat .

Melanger LIRE et AFFICHER dans le même instruction : AFFICHER LIRE

x n'existe pas. Ce sont deux instructions séparées.

Oublier que LIRE attend une action utilisateur : L'exécution s'arrête à

LIRE jusqu'à ce que l'utilisateur tape quelque chose et appuie sur Entrée.

4.8 Résumé des points essentiels

POINTS CLÉS À RETENIR

LIRE variable : lit une valeur au clavier et la stocke. L'exécution s'arrête en

attendant l'utilisateur.

AFFICHER expression : affiche à l'écran. Peut afficher du texte, des

variables, ou les deux.

Toujours afficher un message avant LIRE pour guider l'utilisateur.

Indiquer les unités dans les messages (mètres, kilogrammes, etc.).

Formater les sorties avec du contexte : "Résultat : " + valeur .

La structure type est : Entrées → Traitements → Sorties.

Exercices du Chapitre 4

82
Chapitre 4 : Entrées et sorties

Exercice 4.1 (Très facile)

Question de cours : Expliquez la différence entre LIRE et AFFICHER. Donnez un

exemple concret de chacun.

Correction

LIRE : instruction d'entrée. L'algorithme reçoit une donnée de l'utilisateur via

le clavier. Exemple : AFFICHER "Nom?" puis LIRE nom .

AFFICHER : instruction de sortie. L'algorithme affiche un résultat à l'écran.

Exemple : AFFICHER "Bonjour ", nom .

83
Chapitre 4 : Entrées et sorties

Exercice 4.2 (Très facile)

Invite correcte : Corrigez cet algorithme qui a des problèmes d'entrées-sorties :

VARIABLES nom : CHAINE

DÉBUT
LIRE nom
AFFICHER nom
FIN

Correction

VARIABLES nom : CHAINE

DÉBUT
AFFICHER "Entrez votre nom : " // Message d'invite
indispensable
LIRE nom
AFFICHER "Bonjour ", nom, " !" // Message de sortie
contextualisé
FIN

84
Chapitre 4 : Entrées et sorties

Exercice 4.3 (Facile)

Questionnaire : Écrivez un algorithme qui pose 3 questions à l'utilisateur (nom,

ville préférée, plat préféré) et affiche un résumé personnalisé du type "Alice aime
Rome et les pâtes".

Correction

ALGORITHME Questionnaire
VARIABLES nom, ville, plat : CHAINE
DÉBUT
AFFICHER "Votre nom : " ; LIRE nom
AFFICHER "Votre ville préférée : " ; LIRE ville
AFFICHER "Votre plat préféré : " ; LIRE plat
AFFICHER nom, " aime ", ville, " et les ", plat, "."
FIN

85
Chapitre 4 : Entrées et sorties

Exercice 4.4 (Facile)

Conversion d'unités interactive : Écrivez un algorithme qui lit une distance en

kilomètres et affiche la conversion en miles (1 mile = 1.60934 km). L'invite doit
préciser l'unité.

Correction

ALGORITHME Km_Vers_Miles
CONST MILE_EN_KM : REEL <- 1.60934
VARIABLES km, miles : REEL
DÉBUT
AFFICHER "Distance en kilomètres : "
LIRE km
miles <- km / MILE_EN_KM
AFFICHER km, " km = ", ARRONDIR(miles, 2), " miles"
FIN

Python :

km = float(input("Distance en kilometres : "))

miles = km / 1.60934
print(f"{km} km = {miles:.2f} miles")

86
Chapitre 4 : Entrées et sorties

Exercice 4.5 (Facile)

Bulletin de notes simplifié : Lire le nom d'un étudiant et ses 3 notes sur 20.
Afficher ses notes et leur moyenne avec le format : "Alice : 12, 15, 8 | Moyenne :
11.67/20".

Correction

ALGORITHME Bulletin
VARIABLES nom : CHAINE
n1, n2, n3, moy : REEL
DÉBUT
AFFICHER "Nom : " ; LIRE nom
AFFICHER "Note 1/20 : " ; LIRE n1
AFFICHER "Note 2/20 : " ; LIRE n2
AFFICHER "Note 3/20 : " ; LIRE n3
moy <- (n1 + n2 + n3) / 3
AFFICHER nom, " : ", n1, ", ", n2, ", ", n3,
" | Moyenne : ", ARRONDIR(moy, 2), "/20"
FIN

87
Chapitre 4 : Entrées et sorties

Exercice 4.6 (Moyen)

Facture de restaurant : Écrivez un algorithme qui calcule une facture de

restaurant. Entrées : prix de l'entrée, du plat, du dessert, du café, et nombre de
convives. Sortie : total HT, TVA (10% pour la restauration), total TTC, et montant par
personne.

Correction

ALGORITHME Facture_Restaurant
CONST TVA_RESTO : REEL <- 0.10
VARIABLES
prixEntree, prixPlat, prixDessert, prixCafe : REEL
nbConvives : ENTIER
totalHT, totalTTC, montantTVA, parPersonne : REEL
DÉBUT
AFFICHER "=== FACTURE RESTAURANT ==="
AFFICHER "Prix entrée (EUR) : " ; LIRE prixEntree
AFFICHER "Prix plat (EUR) : " ; LIRE prixPlat
AFFICHER "Prix dessert (EUR) : " ; LIRE prixDessert
AFFICHER "Prix café (EUR) : " ; LIRE prixCafe
AFFICHER "Nombre de convives : " ; LIRE nbConvives

totalHT <- prixEntree + prixPlat + prixDessert + prixCafe

montantTVA <- totalHT * TVA_RESTO
totalTTC <- totalHT + montantTVA
parPersonne <- totalTTC / nbConvives

AFFICHER ""
AFFICHER "--- DÉTAIL ---"
AFFICHER "Total HT : ", ARRONDIR(totalHT, 2), " EUR"
AFFICHER "TVA (10%) : ", ARRONDIR(montantTVA, 2), " EUR"
AFFICHER "Total TTC : ", ARRONDIR(totalTTC, 2), " EUR"
AFFICHER "Par personne : ", ARRONDIR(parPersonne, 2), "
EUR"
FIN

88
Chapitre 4 : Entrées et sorties

Exercice 4.7 (Moyen)

Saisie contrôlée : Expliquez pourquoi il est important d'indiquer le type attendu et

les contraintes dans le message d'invite. Donnez un exemple où une mauvaise
invite mène à une erreur.

Correction

Mauvaise invite : AFFICHER "Age?" puis LIRE age . L'utilisateur peut répondre
"15 ans" ou "quinze" au lieu de "15", provoquant une erreur de type.

Bonne invite : AFFICHER "Age en années (nombre entier) : " . L'utilisateur

comprend qu'il doit entrer un nombre entier.

Invite encore meilleure : AFFICHER "Age (entier entre 0 et 120) : " . Les
contraintes sont claires.

89
Chapitre 4 : Entrées et sorties

Exercice 4.8 (Moyen)

Affichage formaté : On a produit = "Livre" , quantite = 3 , prixUnitaire =

12.50 . Écrivez les instructions AFFICHER pour produire exactement :
+-----------+----------+-------------+----------+
| Produit | Quantité | Prix unit. | Total |
+-----------+----------+-------------+----------+

Correction

ALGORITHME Tableau_Formate
VARIABLES
produit : CHAINE <- "Livre"
quantite : ENTIER <- 3
prixUnitaire : REEL <- 12.50
total : REEL
DÉBUT
total <- quantite * prixUnitaire

// Lignes de séparation
AFFICHER "+-----------+----------+-------------+----------
+"
AFFICHER "| Produit | Quantité | Prix unit. | Total
|"
AFFICHER "+-----------+----------+-------------+----------
+"
AFFICHER "| ", produit, " | ", quantite,
" | ", prixUnitaire,
" | ", total, " |"
AFFICHER "+-----------+----------+-------------+----------
+"
FIN

Python (plus élégant) :

90
Chapitre 4 : Entrées et sorties

print(f"{'Produit':<11} {'Qte':<8} {'Prix':<10} {'Total':<10}")

print(f"{produit:<11} {quantite:<8} {prixUnitaire:<10.2f} {total:
<10.2f}")

Exercice 4.9 (Moyen)

Calculateur de pourboire : Lire le montant d'une addition et le pourcentage de

pourboire souhaité. Afficher le montant du pourboire et le total à payer. Gérez
l'affichage pour que les montants aient toujours 2 décimales.

Correction

ALGORITHME Pourboire
VARIABLES
addition, pourcentage, pourboire, total : REEL
DÉBUT
AFFICHER "Montant de l'addition (EUR) : " ; LIRE addition
AFFICHER "Pourcentage de pourboire (%) : " ; LIRE
pourcentage

pourboire <- addition * (pourcentage / 100)

total <- addition + pourboire

AFFICHER ""
AFFICHER "Addition : ", ARRONDIR(addition, 2), " EUR"
AFFICHER "Pourboire (", pourcentage, "%) : ",
ARRONDIR(pourboire, 2), " EUR"
AFFICHER "TOTAL : ", ARRONDIR(total, 2), " EUR"
FIN

91
Chapitre 4 : Entrées et sorties

Exercice 4.10 (Difficile)

Simulateur de remise : Un magasin fait une promotion : 5% de remise dès 100 EUR
d'achat, 10% dès 200 EUR, 15% dès 500 EUR. Écrivez un algorithme qui lit le
montant des achats et affiche : montant initial, taux de remise appliqué, montant de
la remise, et prix final à payer.

Correction

ALGORITHME Simulateur_Remise
VARIABLES
montant, remise, prixFinal : REEL
tauxRemise : REEL
DÉBUT
AFFICHER "Montant des achats (EUR) : " ; LIRE montant

// Détermination du taux de remise

SI montant >= 500 ALORS
tauxRemise <- 0.15
SINON SI montant >= 200 ALORS
tauxRemise <- 0.10
SINON SI montant >= 100 ALORS
tauxRemise <- 0.05
SINON
tauxRemise <- 0.0
FIN SI

remise <- montant * tauxRemise

prixFinal <- montant - remise

AFFICHER ""
AFFICHER "Montant initial : ", ARRONDIR(montant, 2), " EUR"
AFFICHER "Taux remise : ", tauxRemise * 100, "%"
AFFICHER "Remise : ", ARRONDIR(remise, 2), " EUR"
AFFICHER "PRIX FINAL : ", ARRONDIR(prixFinal, 2), " EUR"
FIN

92
Chapitre 4 : Entrées et sorties

Exercice 4.11 (Mini-projet)

Fiche de paie simplifiée : Écrivez un algorithme complet qui simule une fiche de
paie. Entrées : nom, salaire brut horaire, nombre d'heures travaillées. Calculs :
salaire brut = horaire x heures, cotisations sociales = 23% du brut, salaire net = brut
- cotisations. Affichez une fiche complète et formatée.

Correction

ALGORITHME Fiche_Paie
CONST TAUX_COTISATIONS : REEL <- 0.23
VARIABLES
nom : CHAINE
horaire : REEL
heures : REEL
brut, cotisations, net : REEL
DÉBUT
AFFICHER "=== FICHE DE PAIE ==="
AFFICHER "Nom : " ; LIRE nom
AFFICHER "Salaire brut horaire (EUR) : " ; LIRE horaire
AFFICHER "Heures travaillées : " ; LIRE heures

brut <- horaire * heures

cotisations <- brut * TAUX_COTISATIONS
net <- brut - cotisations

AFFICHER ""
AFFICHER "========================================"
AFFICHER " FICHE DE PAIE - ", nom
AFFICHER "========================================"
AFFICHER " Salaire brut : ", ARRONDIR(brut, 2), " EUR"
AFFICHER " Cotisations (23%): ", ARRONDIR(cotisations, 2),
" EUR"
AFFICHER " --------------------------------------"
AFFICHER " SALAIRE NET : ", ARRONDIR(net, 2), " EUR"
AFFICHER "========================================"
FIN

93
Chapitre 4 : Entrées et sorties

Exercice 4.12 (Mini-projet - Difficile)

Calculateur de prêt immobilier : Lire le capital emprunté (EUR), le taux d'intérêt

annuel (%), et la durée en années. Calculer la mensualité selon la formule : M=
C× r12
où C=capital, r=taux annuel, n=durée en années. Afficher un tableau
​

1−(1+ r12 )−12n

​

d'amortissement simplifié (mois 1 à 12 : capital restant, intérêts, capital remboursé).

Correction

94
Chapitre 4 : Entrées et sorties

ALGORITHME Calculateur_Pret
// Formule de mensualité standard
VARIABLES
capital, tauxAnnuel, dureeAnnees : REEL
tauxMensuel, mensualite : REEL
capitalRestant, interets, capitalRembourse : REEL
mois : ENTIER
nbMoisTotal : ENTIER
DÉBUT
AFFICHER "=== CALCULATEUR DE PRÊT ==="
AFFICHER "Capital (EUR) : " ; LIRE capital
AFFICHER "Taux annuel (%) : " ; LIRE tauxAnnuel
AFFICHER "Durée (années) : " ; LIRE dureeAnnees

// Conversion du taux en décimal et mensuel

tauxMensuel <- (tauxAnnuel / 100) / 12
nbMoisTotal <- CONVERTIR_ENTIER(dureeAnnees * 12)

// Calcul de la mensualité (formule standard)

SI tauxAnnuel > 0 ALORS
mensualite <- (capital * tauxMensuel)
/ (1 - PUISSANCE(1 + tauxMensuel, -
nbMoisTotal))
SINON
mensualite <- capital / nbMoisTotal
FIN SI

AFFICHER ""
AFFICHER "Mensualité : ", ARRONDIR(mensualite, 2), " EUR"
AFFICHER ""

// Tableau d'amortissement (année 1 uniquement)

AFFICHER "--- AMORTISSEMENT (Année 1) ---"
AFFICHER "Mois | Capital dû | Intérêts | Capital remb."

capitalRestant <- capital

POUR mois DE 1 A 12 FAIRE // Afficher les 12 premiers
mois
interets <- capitalRestant * tauxMensuel
capitalRembourse <- mensualite - interets
capitalRestant <- capitalRestant - capitalRembourse

AFFICHER mois, " | ",

ARRONDIR(capitalRestant + capitalRembourse,
2),
" | ", ARRONDIR(interets, 2),
" | ", ARRONDIR(capitalRembourse, 2)
FIN POUR

95
Chapitre 4 : Entrées et sorties

AFFICHER ""
AFFICHER "Coût total du crédit : ",
ARRONDIR(mensualite * nbMoisTotal - capital, 2), "
EUR"
FIN

Python :

capital = float(input("Capital : "))

taux = float(input("Taux annuel (%) : ")) / 100
annees = int(input("Duree (annees) : "))

taux_m = taux / 12
n = annees * 12

if taux > 0:
mensualite = (capital * taux_m) / (1 - (1 + taux_m)**(-n))
else:
mensualite = capital / n

print(f"Mensualite : {mensualite:.2f} EUR")

# Tableau annee 1
cr = capital
print("\nAmortissement (Annee 1):")
print("Mois | Capital du | Interets | Cap. remb.")
for mois in range(1, 13):
interets = cr * taux_m
cap_remb = mensualite - interets
cr -= cap_remb
print(f"{mois:4} | {cr+cap_remb:10.2f} | {interets:8.2f} |
{cap_remb:10.2f}")

print(f"\nCout total : {mensualite*n - capital:.2f} EUR")

Méthode : La formule de mensualité est standard en finance. On la décompose

: d'abord convertir le taux annuel en mensuel, puis appliquer la formule. Pour
l'amortissement, on calcule mois par mois : les intérêts diminuent à chaque
fois car ils sont calculés sur le capital restant.

96
Chapitre 4 : Entrées et sorties

Validation du Chapitre 4

Super progrès ! Vous savez maintenant gérer les interactions utilisateur. Vérifiez :

LIRE et AFFICHER correctement utilisés

Messages d'invite clairs et complets

Formatage des sorties avec contexte

Structure Entrées-Traitements-Sorties respectée

Écrivez "Chapitre suivant" pour valider et passer au Chapitre 5.

97
Chapitre 5 : Opérateurs arithmétiques

Chapitre 5 : Opérateurs arithmétiques

CHAPITRE 5

Opérateurs arithmétiques

5.1 Définition simple et intuitive

DÉFINITION

Les opérateurs arithmétiques sont les symboles qui permettent d'effectuer des
calculs mathématiques de base sur des nombres. Ce sont les fondements de tout
traitement numérique en informatique : addition, soustraction, multiplication,
division, ainsi que le reste de division (modulo) et la division entière.

5.2 Objectif de la notion

OBJECTIFS PÉDAGOGIQUES

Connaître tous les opérateurs arithmétiques et leur symbole

Maîtriser la priorité des opérations

Comprendre la différence entre division entière et division réelle

Utiliser le modulo (MOD) et la division entière (DIV)

Écrire des expressions arithmétiques correctes

98
Chapitre 5 : Opérateurs arithmétiques

5.3 Exemple concret de la vie courante

EXEMPLE CONCRET : LE PARTAGE DE PIZZAS

Vous organisez une soirée avec 17 amis (soit 18 personnes au total) et vous
commandez 5 pizzas. Chaque pizza est coupée en 8 parts.

Multiplication (×) : 5 pizzas × 8 parts = 40 parts au total

Division entière (DIV) : 40 parts DIV 18 personnes = 2 parts chacun

Modulo (MOD) : 40 MOD 18 = 4 parts restantes pour les plus gourmands

Division réelle (/) : 40 / 18 = 2.22 parts en moyenne par personne

Chaque opérateur répond à une question différente : combien au total ? Combien

par personne (entier) ? Quel est le reste ? Quel est le partage exact ?

5.4 Explication détaillée avec schémas ASCII

5.4.1 Les opérateurs arithmétiques

Tableau 5.1 : Opérateurs arithmétiques fondamentaux

Opérateur Symbole Exemple Résultat Type résultat

Addition + 5 + 3 8 ENTIER ou RÉEL

Soustraction - 5 - 3 2 ENTIER ou RÉEL

Multiplication * 5 * 3 15 ENTIER ou RÉEL

Division réelle / 5 / 2 2.5 RÉEL

Division entière DIV 5 DIV 2 2 ENTIER

Modulo (reste) MOD 5 MOD 2 1 ENTIER

Puissance ^ ou PUISSANCE 2^3 8 RÉEL

99
Chapitre 5 : Opérateurs arithmétiques

5.4.2 Priorité des opérations

+----------------------------------------------------------+
| ORDRE DE PRIORITÉ DES OPÉRATIONS |
+----------------------------------------------------------+
| |
| 1. Parenthèses (les plus internes d'abord) |
| (a + b) * c ==> a+b d'abord, puis *c |
| |
| 2. Puissances |
| 2 + 3^2 ==> 3^2=9, puis 2+9=11 |
| |
| 3. Multiplications, Divisions, MOD, DIV (gauche-droite)|
| 10 / 2 * 3 ==> (10/2)=5, puis 5*3=15 |
| |
| 4. Additions, Soustractions (gauche-droite) |
| 10 - 3 + 2 ==> (10-3)=7, puis 7+2=9 |
| |
+----------------------------------------------------------+

Exemple complet : 2 + 3 * 4 - 10 DIV 3

Étape 1 : 3 * 4 = 12 ==> 2 + 12 - 10 DIV 3

Étape 2 : 10 DIV 3 = 3 ==> 2 + 12 - 3
Étape 3 : 2 + 12 = 14 ==> 14 - 3
Étape 4 : 14 - 3 = 11

Avec parenthèses : (2 + 3) * (4 - 10) DIV 3

Étape 1 : (2 + 3) = 5
Étape 2 : (4 - 10) = -6
Étape 3 : 5 * (-6) = -30
Étape 4 : -30 DIV 3 = -10

5.4.3 DIV et MOD en détail

La division entière (DIV) et le modulo (MOD) sont deux opérations complémentaires issues
de la division euclidienne. Pour tout couple d'entiers (a, b) avec b > 0 :

a = b × (a DIV b) + (a MOD b)

100
Chapitre 5 : Opérateurs arithmétiques

Division de 17 par 5 :

17 | 5
-15 +----
--- | 3 <--- 17 DIV 5 = 3 (quotient)
2 <--- 17 MOD 5 = 2 (reste)

Vérification : 17 = 5 * 3 + 2 = 15 + 2 = 17 CORRECT !

Applications courantes de MOD :

- Parité : n MOD 2 = 0 ==> n est pair
- Parité : n MOD 2 = 1 ==> n est impair
- Dernier chiffre : n MOD 10 = dernier chiffre
- Cycle horloge : 14 MOD 12 = 2 (14h = 2h PM)

5.5 Pseudo-code commenté ligne par ligne

101
Chapitre 5 : Opérateurs arithmétiques

ALGORITHME 5.1 : DÉMONSTRATION DES OPÉRATEURS

ALGORITHME Operateurs_Arithmetiques
VARIABLES
a, b : ENTIER <- 17, 5
quotient, reste : ENTIER
divisionReelle : REEL
DÉBUT
// Division entière (quotient)
quotient <- a DIV b // 17 DIV 5 = 3
AFFICHER a, " DIV ", b, " = ", quotient

// Modulo (reste de la division)

reste <- a MOD b // 17 MOD 5 = 2
AFFICHER a, " MOD ", b, " = ", reste

// Division réelle
divisionReelle <- CONVERTIR_REEL(a) / CONVERTIR_REEL(b)
// 17.0 / 5.0 = 3.4
AFFICHER a, " / ", b, " = ", divisionReelle

// Vérification : a = b * quotient + reste

AFFICHER "Vérification : ", b, " * ", quotient,
" + ", reste, " = ", b * quotient + reste
// Doit afficher : 5 * 3 + 2 = 17
FIN

5.6 Exemple d'exécution pas à pas

Exécution avec a = 17, b = 5 :

Tableau 5.2 : Trace d'exécution

Instruction quotient reste divisionReelle Affichage

a,b = 17,5 ? ? ? -

quotient <- a DIV b 3 ? ? "17 DIV 5 = 3"

reste <- a MOD b 3 2 ? "17 MOD 5 = 2"

102
Chapitre 5 : Opérateurs arithmétiques

divisionReelle <- 17.0/5.0 3 2 3.4 "17 / 5 = 3.4"

Vérification 3 2 3.4 "5 * 3 + 2 = 17"

5.7 Erreurs fréquentes des débutants

ERREURS À ÉVITER

Division par zéro : x / 0 ou x DIV 0 provoquent une erreur fatale.

Toujours vérifier que le diviseur n'est pas zéro.

Confondre / et DIV : 5 / 2 = 2.5 (RÉEL) mais 5 DIV 2 = 2 (ENTIER). Le

contexte détermine lequel choisir.

Oublier la priorité : 2 + 3 * 4 = 14 , pas 20. La multiplication est

prioritaire sur l'addition.

Parenthèses oubliées : Pour forcer l'ordre, utiliser des parenthèses : (2 +

3) * 4 = 20 .

Dépassement de capacité : Un ENTIER a une limite. 999999999 *

999999999 peut dépasser cette limite.

Problèmes de précision flottante : 0.1 + 0.2 ne donne pas exactement

0.3 en machine. Attention aux comparaisons de réels.

5.8 Résumé des points essentiels

103
Chapitre 5 : Opérateurs arithmétiques

POINTS CLÉS À RETENIR

+ - * : opérations classiques (attention au type : ENTIER + RÉEL = RÉEL)

/ : division réelle, résultat toujours RÉEL

DIV : division entière (quotient), résultat ENTIER

MOD : reste de la division entière, résultat ENTIER

a = b * (a DIV b) + (a MOD b) : relation fondamentale

Priorité : Parenthèses > Puissances > * / DIV MOD > + -

Ne jamais diviser par zéro

Exercices du Chapitre 5

Exercice 5.1 (Très facile)

Calcul mental : Donnez le résultat de : (1) 25 DIV 4, (2) 25 MOD 4, (3) 25 / 4, (4) 100
DIV 10, (5) 7 MOD 2, (6) 7 DIV 2.

Correction

1. 25 DIV 4 = 6 (car 4 x 6 = 24)

2. 25 MOD 4 = 1 (reste : 25 - 24 = 1)

3. 25 / 4 = 6.25 (division réelle)

4. 100 DIV 10 = 10

5. 7 MOD 2 = 1 (7 est impair)

6. 7 DIV 2 = 3

104
Chapitre 5 : Opérateurs arithmétiques

Exercice 5.2 (Très facile)

Priorités : Calculez à la main : (1) 3 + 4 * 2, (2) (3 + 4) * 2, (3) 10 - 6 DIV 2, (4) 20 DIV 3

+ 20 MOD 3, (5) 2^3 + 3^2.

Correction

1. 3 + (4 * 2) = 3 + 8 = 11

2. 7 * 2 = 14

3. 10 - (6 DIV 2) = 10 - 3 = 7

4. (20 DIV 3) + (20 MOD 3) = 6 + 2 = 8

5. 8 + 9 = 17

105
Chapitre 5 : Opérateurs arithmétiques

Exercice 5.3 (Facile)

Pair ou impair : Écrivez un algorithme qui lit un entier et détermine s'il est pair ou
impair en utilisant MOD.

Correction

ALGORITHME Pair_Impair
VARIABLES n : ENTIER
DÉBUT
AFFICHER "Entrez un entier : " ; LIRE n
SI n MOD 2 = 0 ALORS
AFFICHER n, " est pair."
SINON
AFFICHER n, " est impair."
FIN SI
FIN

Python :

n = int(input("Entier : "))
if n % 2 == 0: print(f"{n} est pair")
else: print(f"{n} est impair")

106
Chapitre 5 : Opérateurs arithmétiques

Exercice 5.4 (Facile)

Conversion euros-centimes : Lire un montant en centimes (ENTIER). Calculer et

afficher le nombre de pièces de 2 EUR, 1 EUR, 50c, 20c, 10c, 5c, 2c, 1c nécessaires
pour former ce montant (algorithme glouton : prendre le plus gros d'abord).

Correction

ALGORITHME Decomposer_Monnaie
VARIABLES
centimes, reste : ENTIER
nb2e, nb1e, nb50c, nb20c, nb10c, nb5c, nb2c, nb1c : ENTIER
DÉBUT
AFFICHER "Montant en centimes : " ; LIRE centimes
reste <- centimes

nb2e <- reste DIV 200; reste <- reste MOD 200
nb1e <- reste DIV 100; reste <- reste MOD 100
nb50c <- reste DIV 50; reste <- reste MOD 50
nb20c <- reste DIV 20; reste <- reste MOD 20
nb10c <- reste DIV 10; reste <- reste MOD 10
nb5c <- reste DIV 5; reste <- reste MOD 5
nb2c <- reste DIV 2; reste <- reste MOD 2
nb1c <- reste

AFFICHER "2 EUR : ", nb2e

AFFICHER "1 EUR : ", nb1e
AFFICHER "50c : ", nb50c
AFFICHER "20c : ", nb20c
AFFICHER "10c : ", nb10c
AFFICHER "5c : ", nb5c
AFFICHER "2c : ", nb2c
AFFICHER "1c : ", nb1c
FIN

107
Chapitre 5 : Opérateurs arithmétiques

Exercice 5.5 (Facile)

Moyenne pondérée : Lire trois notes (REEL) et leurs coefficients (ENTIER). Calculer
et afficher la moyenne pondérée avec 2 décimales.

Correction

ALGORITHME Moyenne_Ponderee
VARIABLES
n1, n2, n3 : REEL
c1, c2, c3 : ENTIER
moyenne : REEL
DÉBUT
AFFICHER "Note 1 : " ; LIRE n1
AFFICHER "Coef 1 : " ; LIRE c1
AFFICHER "Note 2 : " ; LIRE n2
AFFICHER "Coef 2 : " ; LIRE c2
AFFICHER "Note 3 : " ; LIRE n3
AFFICHER "Coef 3 : " ; LIRE c3
moyenne <- (n1*c1 + n2*c2 + n3*c3) / (c1 + c2 + c3)
AFFICHER "Moyenne pondérée : ", ARRONDIR(moyenne, 2), "/20"
FIN

108
Chapitre 5 : Opérateurs arithmétiques

Exercice 5.6 (Moyen)

Nombre à 3 chiffres inversé : Lire un nombre ENTIER à 3 chiffres (ex: 472).

Extraire chaque chiffre avec DIV et MOD, puis reconstruire le nombre inversé (274).
Sans convertir en chaîne.

Correction

ALGORITHME Inverser_Nombre
VARIABLES n, c, d, u, inverse : ENTIER
DÉBUT
AFFICHER "Nombre à 3 chiffres : " ; LIRE n
c <- n DIV 100 // centaines (4)
d <- (n DIV 10) MOD 10 // dizaines (7)
u <- n MOD 10 // unités (2)
inverse <- u * 100 + d * 10 + c // 2*100 + 7*10 + 4 = 274
AFFICHER "Inversé : ", inverse
FIN

Méthode : DIV 100 isole les centaines, DIV 10 puis MOD 10 isole les dizaines,
MOD 10 isole les unités. On reconstruit en inversant l'ordre.

109
Chapitre 5 : Opérateurs arithmétiques

Exercice 5.7 (Moyen)

Heures et minutes : Lire un nombre de minutes (ENTIER, ex: 145). Convertir en

heures et minutes avec DIV et MOD (ex: 145 = 2h25min). Vérifier que le résultat est
correct.

Correction

ALGORITHME Minutes_Vers_Heures
VARIABLES minutes, h, m : ENTIER
DÉBUT
AFFICHER "Minutes : " ; LIRE minutes
h <- minutes DIV 60
m <- minutes MOD 60
AFFICHER minutes, " min = ", h, "h", m, "min"
// Vérification
AFFICHER "Vérif : ", h * 60 + m, " min"
FIN

110
Chapitre 5 : Opérateurs arithmétiques

Exercice 5.8 (Moyen)

Périmètre et aire : Lire la longueur et la largeur d'un rectangle. Calculer et afficher

son périmètre (P = 2 × (L + l)) et son aire (A = L × l). Si c'est un carré (L = l),
l'indiquer.

Correction

ALGORITHME Rectangle
VARIABLES L, l, perimetre, aire : REEL
DÉBUT
AFFICHER "Longueur : " ; LIRE L
AFFICHER "Largeur : " ; LIRE l
perimetre <- 2 * (L + l)
aire <- L * l
AFFICHER "Périmètre : ", perimetre
AFFICHER "Aire : ", aire
SI L = l ALORS
AFFICHER "C'est un carré !"
FIN SI
FIN

111
Chapitre 5 : Opérateurs arithmétiques

Exercice 5.9 (Moyen)

Convertisseur de secondes : Lire une durée en secondes (ENTIER). Afficher en

format HH:MM:SS. Utiliser uniquement DIV et MOD.

Correction

ALGORITHME Format_Heure
VARIABLES sec, h, m, s : ENTIER
DÉBUT
AFFICHER "Secondes : " ; LIRE sec
h <- sec DIV 3600
m <- (sec MOD 3600) DIV 60
s <- sec MOD 60
AFFICHER h, ":", m, ":", s
FIN

Python :

sec = int(input("Secondes : "))

h = sec // 3600
m = (sec % 3600) // 60
s = sec % 60
print(f"{h:02d}:{m:02d}:{s:02d}")

112
Chapitre 5 : Opérateurs arithmétiques

Exercice 5.10 (Difficile)

Somme des chiffres : Lire un nombre ENTIER à 4 chiffres (ex: 4729). Calculer la
somme de ses chiffres (4+7+2+9 = 22) en utilisant uniquement DIV et MOD.

Correction

ALGORITHME Somme_Chiffres
VARIABLES n, somme, chiffre : ENTIER
DÉBUT
AFFICHER "Nombre à 4 chiffres : " ; LIRE n
somme <- 0

// Extrait chaque chiffre un par un

chiffre <- n DIV 1000; somme <- somme + chiffre; n <- n MOD
1000
chiffre <- n DIV 100; somme <- somme + chiffre; n <- n MOD
100
chiffre <- n DIV 10; somme <- somme + chiffre; n <- n MOD
10
somme <- somme + n // dernier chiffre

AFFICHER "Somme des chiffres : ", somme

FIN

113
Chapitre 5 : Opérateurs arithmétiques

Exercice 5.11 (Mini-projet)

Convertisseur d'unités complet : Lire une température et son unité ('C', 'F', ou 'K').
Convertir dans les deux autres unités. Formules : F = C × 9/5 + 32, K = C +
273.15, C = (F − 32) × 5/9, C = K − 273.15.

Correction

ALGORITHME Convertisseur_Temperature
VARIABLES
temp, celsius, fahrenheit, kelvin : REEL
unite : CARACTERE
DÉBUT
AFFICHER "Température : " ; LIRE temp
AFFICHER "Unité (C/F/K) : " ; LIRE unite

// Convertir d'abord en Celsius

SI unite = 'C' ALORS
celsius <- temp
SINON SI unite = 'F' ALORS
celsius <- (temp - 32) * 5 / 9
SINON SI unite = 'K' ALORS
celsius <- temp - 273.15
FIN SI

// Puis convertir depuis Celsius

fahrenheit <- celsius * 9 / 5 + 32
kelvin <- celsius + 273.15

AFFICHER "Celsius : ", ARRONDIR(celsius, 2), "°C"

AFFICHER "Fahrenheit : ", ARRONDIR(fahrenheit, 2), "°F"
AFFICHER "Kelvin : ", ARRONDIR(kelvin, 2), "K"
FIN

114
Chapitre 5 : Opérateurs arithmétiques

Exercice 5.12 (Mini-projet - Difficile)

Calculateur de date de pâques (algorithme de Meeus) : Pour une année donnée,

a=
calculez la date de Pâques (jour et mois) avec l'algorithme simplifié :
anneeMOD19, b = anneeDIV 100, c = anneeMOD100, d = bDIV 4, e =
bMOD4, f = (b + 8)DIV 25, g = (b − f + 1)DIV 3, h = (19 × a + b − d −
g + 15)MOD30, i = cDIV 4, k = cMOD4, l = (32 + 2 × e + 2 × i − h −
k)MOD7, m = (a + 11 × h + 22 × l)DIV 451, mois = (h + l − 7 × m +
114)DIV 31, jour = ((h + l − 7 × m + 114)MOD31) + 1.

Correction

ALGORITHME Date_Paques
VARIABLES
annee, a, b, c, d, e, f, g, h, i, k, l, m : ENTIER
mois, jour : ENTIER
DÉBUT
AFFICHER "Année : " ; LIRE annee

a <- annee MOD 19

b <- annee DIV 100
c <- annee MOD 100
d <- b DIV 4
e <- b MOD 4
f <- (b + 8) DIV 25
g <- (b - f + 1) DIV 3
h <- (19*a + b - d - g + 15) MOD 30
i <- c DIV 4
k <- c MOD 4
l <- (32 + 2*e + 2*i - h - k) MOD 7
m <- (a + 11*h + 22*l) DIV 451
mois <- (h + l - 7*m + 114) DIV 31
jour <- ((h + l - 7*m + 114) MOD 31) + 1

AFFICHER "Pâques en ", annee, " : ", jour, "/", mois

FIN

Python :

115
Chapitre 5 : Opérateurs arithmétiques

annee = int(input("Annee : "))

a = annee % 19; b = annee // 100; c = annee % 100
d = b // 4; e = b % 4; f = (b + 8) // 25
g = (b - f + 1) // 3
h = (19*a + b - d - g + 15) % 30
i = c // 4; k = c % 4
l = (32 + 2*e + 2*i - h - k) % 7
m = (a + 11*h + 22*l) // 451
mois = (h + l - 7*m + 114) // 31
jour = (h + l - 7*m + 114) % 31 + 1
print(f"Paques {annee} : {jour}/{mois}")

Méthode : Cet algorithme, publié par l'astronome Jean Meeus, calcule la date
de Pâques gr&e226;ce à une série de divisions euclidiennes. Il illustre
parfaitement l'usage intensif de DIV et MOD. Chaque variable intermédiaire
sert à isoler un aspect du calendrier lunaire.

Validation du Chapitre 5

Excellent ! Vous maîtrisez les calculs. Vérifiez :

Les 7 opérateurs arithmétiques

La différence / DIV / MOD

La priorité des opérations

L'antériorité des parenthèses

Les applications pratiques (extract. de chiffres, conversion temps)

Écrivez "Chapitre suivant" pour valider et passer au Chapitre 6.

116
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Chapitre 6 : Conditions (SI, SINON, SINON

SI)

CHAPITRE 6

Structures conditionnelles

6.1 Définition simple et intuitive

DÉFINITION

Une structure conditionnelle permet à un algorithme de prendre des décisions et

d'exécuter des instructions différentes selon qu'une condition est vraie ou fausse.
C'est comme un carrefour : selon la réponse à une question ("Est-ce que j'ai assez
d'argent ?"), on prend un chemin différent.

6.2 Objectif de la notion

117
Chapitre 6 : Conditions (SI, SINON, SINON SI)

OBJECTIFS

Maîtriser les structures SI ALORS, SI ALORS SINON, SI ALORS SINON SI

Comprendre les opérateurs de comparaison et logiques

Savoir imbriquer des conditions

Savoir choisir entre conditions imbriquées et SINON SI

6.3 Exemple concret

LE DISTRIBUTEUR DE BILLETS

Vous demandez 200 EUR à un distributeur :

SI votre solde >= 200 ALORS le distributeur vous donne les billets

SINON SI votre solde > 0 ALORS il vous propose de retirer ce montant

SINON il affiche "Solde insuffisant"

6.4 Explication détaillée

6.4.1 Les opérateurs de comparaison

Tableau 6.1 : Opérateurs de comparaison

Opérateur Signification Exemple Résultat (x=5, y=10)

= Égal à x = 5 VRAI

<> ou != Différent de x <> y VRAI

< Inférieur à x < y VRAI

> Supérieur à x > y FAUX

118
Chapitre 6 : Conditions (SI, SINON, SINON SI)

<= Inférieur ou égal x <= 5 VRAI

>= Supérieur ou égal x >= 10 FAUX

6.4.2 Les opérateurs logiques

Tableau 6.2 : Opérateurs logiques

Opérateur Nom Usage Vrai si...

ET Conjonction A ET B Les deux conditions sont vraies

OU Disjonction A OU B Au moins une est vraie

NON Négation NON A A est fausse

6.4.3 Tables de vérité

Table de vérité de ET :
+-------+-------+----------+
| A | B | A ET B |
+-------+-------+----------+
| VRAI | VRAI | VRAI |
| VRAI | FAUX | FAUX |
| FAUX | VRAI | FAUX |
| FAUX | FAUX | FAUX |
+-------+-------+----------+

Table de vérité de OU :
+-------+-------+----------+
| A | B | A OU B |
+-------+-------+----------+
| VRAI | VRAI | VRAI |
| VRAI | FAUX | VRAI |
| FAUX | VRAI | VRAI |
| FAUX | FAUX | FAUX |
+-------+-------+----------+

NON inverse : NON VRAI = FAUX, NON FAUX = VRAI

6.4.4 Schémas des structures conditionnelles

119
Chapitre 6 : Conditions (SI, SINON, SINON SI)

SI ALORS SINON (binaire) :

+------------------+
| CONDITION ? |
+------------------+
VRAI / \ FAUX
/ \
+------+ +------+
| Bloc | | Bloc |
| Vrai | | Faux |
+------+ +------+
\ /
+------+
| Suite|
+------+

SINON SI (multiple) :

+--------+ Non +--------+ Non +--------+ Non

| Cond1? | ------> | Cond2? | ------> | Cond3? | ------> Sinon
| Vrai | | Vrai | | Vrai |
| | |
Bloc1 Bloc2 Bloc3

6.5 Pseudo-code

120
Chapitre 6 : Conditions (SI, SINON, SINON SI)

ALGORITHME 6.1 : LES TROIS FORMES DE CONDITIONS

ALGORITHME Conditions
VARIABLES age, revenus : ENTIER
DÉBUT
AFFICHER "Age : " ; LIRE age
AFFICHER "Revenus mensuels : " ; LIRE revenus

// --- Forme 1 : SI ALORS (simple) ---

SI age >= 18 ALORS
AFFICHER "Vous êtes majeur."
FIN SI

// --- Forme 2 : SI ALORS SINON (alternative) ---

SI revenus > 3000 ALORS
AFFICHER "Revenus élevés"
SINON
AFFICHER "Revenus modestes"
FIN SI

// --- Forme 3 : SINON SI (multiple) ---

SI age < 13 ALORS
AFFICHER "Enfant"
SINON SI age < 20 ALORS
AFFICHER "Adolescent"
SINON SI age < 65 ALORS
AFFICHER "Adulte"
SINON
AFFICHER "Senior"
FIN SI

// --- Avec opérateurs logiques ---

SI (age >= 18) ET (revenus >= 1500) ALORS
AFFICHER "Éligible au prêt."
SINON
AFFICHER "Non éligible."
FIN SI
FIN

6.6 Exécution pas à pas

121
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Avec age=25, revenus=3500 :

Condition Évaluation Action

age >= 18 25 >= 18 = VRAI "Vous êtes majeur."

revenus > 3000 3500 > 3000 = VRAI "Revenus élevés"

age < 13 Faux (25 > 13) On passe à la suivante

age < 20 Faux (25 > 20) On passe à la suivante

age < 65 VRAI "Adulte" (et on s'arrête)

(age>=18) ET (revenus>=1500) VRAI ET VRAI = VRAI "Éligible au prêt."

6.7 Erreurs fréquentes

ERREURS À ÉVITER

Oublier FIN SI : Chaque SI doit se terminer par FIN SI.

Conditions contradictoires : SI x > 5 puis SINON SI x > 10 → la 2e

condition est morte car si x > 10 alors x > 5 aussi.

= au lieu de <- : Dans un algorithme, = est une comparaison, pas une

affectation.

Comparer des réels avec = : x = 0.1 peut être faux à cause des
imprécisions flottantes.

Parenthèses oubliées : age >= 18 ET revenus >= 1500 peut être ambigu.
Préférer (age >= 18) ET (revenus >= 1500) .

6.8 Résumé

122
Chapitre 6 : Conditions (SI, SINON, SINON SI)

POINTS CLÉS

SI ... ALORS ... FIN SI : exécute si condition vraie

SI ... ALORS ... SINON ... FIN SI : choix entre deux blocs

SI ... ALORS ... SINON SI ... SINON ... FIN SI : choix multiple

Opérateurs : =, <>, <, >, <=, >=

Opérateurs logiques : ET, OU, NON

SINON SI teste dans l'ordre et s'arrête à la première condition vraie

Exercices du Chapitre 6

Exercice 6.1 (Très facile)

Maximum de deux nombres : Lire deux nombres et afficher le plus grand.

ALGORITHME Max2
VARIABLES a, b : REEL
DÉBUT
AFFICHER "a : " ; LIRE a
AFFICHER "b : " ; LIRE b
SI a > b ALORS AFFICHER "Max : ", a
SINON AFFICHER "Max : ", b FIN SI
FIN

123
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Exercice 6.2 (Très facile)

Signe d'un nombre : Lire un nombre. Afficher s'il est positif, négatif ou nul.

ALGORITHME Signe
VARIABLES x : REEL
DÉBUT
AFFICHER "x : " ; LIRE x
SI x > 0 ALORS AFFICHER "Positif"
SINON SI x < 0 ALORS AFFICHER "Négatif"
SINON AFFICHER "Nul" FIN SI
FIN

Exercice 6.3 (Facile)

Mention au bac : Lire une moyenne sur 20. Afficher la mention : Très Bien (>=16),
Bien (>=14), Assez Bien (>=12), Passable (>=10), Refus (<10).

ALGORITHME Mention_Bac
VARIABLES moy : REEL
DÉBUT
AFFICHER "Moyenne /20 : " ; LIRE moy
SI moy >= 16 ALORS AFFICHER "Très Bien"
SINON SI moy >= 14 ALORS AFFICHER "Bien"
SINON SI moy >= 12 ALORS AFFICHER "Assez Bien"
SINON SI moy >= 10 ALORS AFFICHER "Passable"
SINON AFFICHER "Refus" FIN SI
FIN

124
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Exercice 6.4 (Facile)

Année bissextile : Une année est bissextile si divisible par 4, sauf si divisible par
100 mais pas par 400. Tester avec 2024, 1900, 2000.

ALGORITHME Bissextile
VARIABLES annee : ENTIER
DÉBUT
AFFICHER "Année : " ; LIRE annee
SI (annee MOD 400 = 0) OU ((annee MOD 4 = 0) ET (annee MOD
100 <> 0)) ALORS
AFFICHER annee, " est bissextile."
SINON
AFFICHER annee, " n'est pas bissextile."
FIN SI
FIN

Python :

annee = int(input("Annee : "))

if (annee % 400 == 0) or ((annee % 4 == 0) and (annee % 100 != 0)):
print(f"{annee} est bissextile")
else:
print(f"{annee} n'est pas bissextile")

125
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Exercice 6.5 (Facile)

Maximum de trois nombres : Lire trois nombres et afficher le plus grand sans
utiliser de fonction max.

ALGORITHME Max3
VARIABLES a, b, c, max : REEL
DÉBUT
AFFICHER "a b c : " ; LIRE a ; LIRE b ; LIRE c
max <- a
SI b > max ALORS max <- b FIN SI
SI c > max ALORS max <- c FIN SI
AFFICHER "Maximum : ", max
FIN

Méthode : On suppose que a est le max, puis on compare avec b et c. On met à

jour si on trouve plus grand.

126
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Exercice 6.6 (Moyen)

Calculateur d'impôt simplifié : Les tranches d'imposition sont : jusqu'à 11294 EUR
= 0%, 11295-28797 = 11%, 28798-82341 = 30%, 82342-177106 = 41%, au-delà = 45%.
Calculer l'impôt dû sur le revenu entré.

ALGORITHME Impot
VARIABLES revenu, impot : REEL
DÉBUT
AFFICHER "Revenu annuel : " ; LIRE revenu
SI revenu <= 11294 ALORS
impot <- 0
SINON SI revenu <= 28797 ALORS
impot <- (revenu - 11294) * 0.11
SINON SI revenu <= 82341 ALORS
impot <- (28797-11294)*0.11 + (revenu-28797)*0.30
SINON SI revenu <= 177106 ALORS
impot <- (28797-11294)*0.11 + (82341-28797)*0.30 +
(revenu-82341)*0.41
SINON
impot <- (28797-11294)*0.11 + (82341-28797)*0.30 +
(177106-82341)*0.41 + (revenu-177106)*0.45
FIN SI
AFFICHER "Impôt : ", ARRONDIR(impot, 2), " EUR"
FIN

Python :

127
Chapitre 6 : Conditions (SI, SINON, SINON SI)

revenu = float(input("Revenu : "))

if revenu <= 11294: impot = 0
elif revenu <= 28797: impot = (revenu - 11294) * 0.11
elif revenu <= 82341:
impot = (28797-11294)*0.11 + (revenu-28797)*0.30
elif revenu <= 177106:
impot = 1757.33 + 16033.2 + (revenu-82341)*0.41
else:
impot = 1757.33 + 16033.2 + 38853.65 + (revenu-177106)*0.45
print(f"Impot : {impot:.2f} EUR")

Exercice 6.7 (Moyen)

Jeu : deviner un nombre : Le nombre à deviner est 42. Lire un essai. Afficher "Trop
grand", "Trop petit" ou "Gagné !".

ALGORITHME Deviner
CONST CIBLE : ENTIER <- 42
VARIABLES essai : ENTIER
DÉBUT
AFFICHER "Devinez le nombre : " ; LIRE essai
SI essai = CIBLE ALORS
AFFICHER "Gagné !"
SINON SI essai > CIBLE ALORS
AFFICHER "Trop grand !"
SINON
AFFICHER "Trop petit !"
FIN SI
FIN

128
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Exercice 6.8 (Moyen)

Valider une date : Lire un jour, un mois, une année. Vérifier que c'est une date
valide (tenir compte des années bissextiles pour février).

ALGORITHME Valider_Date
VARIABLES j, m, a, maxJours : ENTIER
estBissextile : BOOLEEN
valide : BOOLEEN <- VRAI
DÉBUT
AFFICHER "Jour Mois Annee : " ; LIRE j ; LIRE m ; LIRE a

SI (m < 1) OU (m > 12) OU (j < 1) ALORS valide <- FAUX

SINON
// Déterminer maxJours selon le mois
SI m = 2 ALORS
estBissextile <- (a MOD 400=0) OU ((a MOD 4=0) ET
(a MOD 100 <>0))
SI estBissextile ALORS maxJours <- 29 SINON
maxJours <- 28 FIN SI
SINON SI (m=4) OU (m=6) OU (m=9) OU (m=11) ALORS
maxJours <- 30
SINON
maxJours <- 31
FIN SI
SI j > maxJours ALORS valide <- FAUX FIN SI
FIN SI

SI valide ALORS AFFICHER "Date valide" SINON AFFICHER "Date

invalide" FIN SI
FIN

129
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Exercice 6.9 (Moyen)

Résolution équation ax + b = 0 : Lire a et b (REEL). Afficher la solution selon les cas

(unique, infinie, impossible).

ALGORITHME Equation_Premier_Degre
VARIABLES a, b : REEL
DÉBUT
AFFICHER "a : " ; LIRE a
AFFICHER "b : " ; LIRE b
SI a <> 0 ALORS
AFFICHER "Solution : x = ", -b / a
SINON SI b = 0 ALORS
AFFICHER "Infinité de solutions"
SINON
AFFICHER "Pas de solution"
FIN SI
FIN

130
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Exercice 6.10 (Difficile)

Tri de trois nombres : Lire trois nombres et les afficher dans l'ordre croissant sans
utiliser de tableau.

ALGORITHME Tri3
VARIABLES a, b, c, temp : REEL
DÉBUT
AFFICHER "a b c : " ; LIRE a ; LIRE b ; LIRE c
SI a > b ALORS temp <- a; a <- b; b <- temp FIN SI
SI b > c ALORS temp <- b; b <- c; c <- temp FIN SI
SI a > b ALORS temp <- a; a <- b; b <- temp FIN SI
AFFICHER "Ordre : ", a, " <= ", b, " <= ", c
FIN

Méthode : Algorithme de tri à bulles sur 3 éléments. On compare et on échange

si nécessaire. Maximum 3 comparaisons.

131
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Exercice 6.11 (Mini-projet)

Machine à calculer : Lire deux nombres et un opérateur (+, -, *, /, DIV, MOD).

Effectuer l'opération demandée avec vérification (division par zéro, opérateur
invalide).

ALGORITHME Machine_Calculer
VARIABLES a, b, resultat : REEL
op : CARACTERE
DÉBUT
AFFICHER "Nombre 1 : " ; LIRE a
AFFICHER "Opérateur (+,-,*,/,D,M) : " ; LIRE op
AFFICHER "Nombre 2 : " ; LIRE b

SI op = '+' ALORS resultat <- a + b

SINON SI op = '-' ALORS resultat <- a - b
SINON SI op = '*' ALORS resultat <- a * b
SINON SI op = '/' ALORS
SI b = 0 ALORS
AFFICHER "ERREUR : Division par zéro !"
resultat <- 0 // valeur par défaut
SINON resultat <- a / b FIN SI
SINON SI op = 'D' ALORS
SI b = 0 ALORS AFFICHER "ERREUR"
SINON resultat <- CONVERTIR_ENTIER(a) DIV
CONVERTIR_ENTIER(b) FIN SI
SINON SI op = 'M' ALORS
resultat <- CONVERTIR_ENTIER(a) MOD CONVERTIR_ENTIER(b)
SINON
AFFICHER "Opérateur invalide"
FIN SI

AFFICHER "Résultat : ", resultat

FIN

132
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Exercice 6.12 (Mini-projet - Difficile)

Résolution équation ax² + bx + c = 0 : Lire a, b, c (REEL). Calculer le discriminant

Δ = b2 − 4ac. Selon le signe de Δ, afficher les solutions réelles (distinctes, double)
ou complexes.

ALGORITHME Equation_Second_Degre
VARIABLES a, b, c, delta, x1, x2 : REEL
DÉBUT
AFFICHER "a : " ; LIRE a
AFFICHER "b : " ; LIRE b
AFFICHER "c : " ; LIRE c

SI a = 0 ALORS
AFFICHER "Ce n'est pas une équation du second degré."
SINON
delta <- b*b - 4*a*c
AFFICHER "Delta = ", delta

SI delta > 0 ALORS

x1 <- (-b - RACINE(delta)) / (2*a)
x2 <- (-b + RACINE(delta)) / (2*a)
AFFICHER "Deux solutions : x1 = ", x1, ", x2 = ",
x2
SINON SI delta = 0 ALORS
x1 <- -b / (2*a)
AFFICHER "Solution double : x = ", x1
SINON
AFFICHER "Pas de solution réelle (delta < 0)"
AFFICHER "Solutions complexes :"
AFFICHER "x1 = ", -b/(2*a), " - ", RACINE(-
delta)/(2*a), "i"
AFFICHER "x2 = ", -b/(2*a), " + ", RACINE(-
delta)/(2*a), "i"
FIN SI
FIN SI
FIN

Python :

133
Chapitre 6 : Conditions (SI, SINON, SINON SI)

import math
a = float(input("a : "))
b = float(input("b : "))
c = float(input("c : "))

if a == 0:
print("Ce n'est pas un polynome du 2nd degre")
else:
delta = b**2 - 4*a*c
print(f"Delta = {delta}")
if delta > 0:
x1 = (-b - [Link](delta)) / (2*a)
x2 = (-b + [Link](delta)) / (2*a)
print(f"x1 = {x1:.4f}, x2 = {x2:.4f}")
elif delta == 0:
x = -b / (2*a)
print(f"Solution double : x = {x:.4f}")
else:
print("Solutions complexes")
print(f"x1 = {-b/(2*a):.4f} - {[Link](-
delta)/(2*a):.4f}i")
print(f"x2 = {-b/(2*a):.4f} + {[Link](-
delta)/(2*a):.4f}i")

134
Chapitre 6 : Conditions (SI, SINON, SINON SI)

Validation du Chapitre 6

Félicitations ! Vous maîtrisez les conditions ! Vérifiez :

SI ALORS / SI ALORS SINON / SINON SI

Opérateurs de comparaison : =, <>, <, >, <=, >=

Opérateurs logiques : ET, OU, NON

Conditions imbriquées

Ordre des conditions dans SINON SI

Écrivez "Chapitre suivant" pour valider et passer au Chapitre 7.

135
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Chapitre 7 : Boucles (POUR, TANT QUE,

RÉPÉTER)

CHAPITRE 7

Structures itératives

7.1 Définition simple et intuitive

DÉFINITION

Une boucle est une structure qui permet de répéter un bloc d'instructions
plusieurs fois. Au lieu d'écrire 100 fois la même instruction, on écrit une boucle
qui s'exécute 100 fois. C'est le concept le plus puissant de l'algorithmique :
résoudre des problèmes de taille arbitraire avec un code de taille fixe.

7.2 Objectif

136
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

OBJECTIFS

Maîtriser les trois types de boucles : POUR, TANT QUE, RÉPÉTER

Savoir choisir la bonne boucle selon le contexte

Comprendre les risques de boucle infinie

Maîtriser les compteurs et accumulateurs

Savoir utiliser les boucles imbriquées

7.3 Exemple concret

LES ÉTAGES D'UN IMMEUBLE

Vous distribuez du courrier dans un immeuble de 10 étages :

POUR : "Pour chaque étage de 1 à 10, déposez un prospectus" → on connaît

le nombre d'itérations d'avance

TANT QUE : "Tant qu'il reste des prospectus, continuez à monter" → on ne

sait pas combien d'étages, condition testée avant

RÉPÉTER : "Montez un étage et déposez un prospectus, jusqu'à ce que vous

soyez au sommet" → on exécute au moins une fois

7.4 Explication détaillée

7.4.1 Les trois boucles comparées

137
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

+-----------+ +------------+ +-------------+

| POUR | | TANT QUE | | REPETER |
+-----------+ +------------+ +-------------+
| | | | | |
| for init | | CONDITION?| | BLOC |
| | | | | | | | |
| v | | VRAI| | | v |
| BLOC | | BLOC | | CONDITION? |
| | | | | | | FAUX-> |
| v | | v | | recommence|
| increment | | retourne | | VRAI -> fin |
| | | | en haut | | |
| fin? | | | | (toujours |
| non->bloc | | (peut ne | | au moins |
| oui->fin | | pas s' | | 1 tour) |
| | | executer) | | |
+-----------+ +------------+ +-------------+

Schéma TANT QUE (test avant) :

+-----------------+
| CONDITION ? |
+-----------------+
VRAI | | FAUX (sortie)
v |
+-------------+
| BLOC |
+-------------+
|
+----> (retour au test)

Schéma REPETER (test après) :

+-------------+
| BLOC | <--- exécuté au moins une fois
+-------------+
|
v
+-----------------+
| CONDITION ? | (de sortie)
+-----------------+
FAUX | | VRAI (sortie)
+----+
(retour au bloc)

Tableau 7.1 : Comparaison des trois boucles

Critère POUR TANT QUE RÉPÉTER

Nombre d'itérations connu ? Oui Non Non

Test de la condition Implicite Avant Après

Peut ne pas s'exécuter Oui Oui Non (au moins 1x)

138
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Variable de boucle Oui (compteur) Non Non

Cas d'usage typique Parcours, comptage Validation saisie Menu, confirmation

7.4.2 Syntaxe en pseudo-code

SYNTAXE DES TROIS BOUCLES

// ========== BOUCLE POUR ==========

// Quand on sait combien de fois répéter
POUR compteur DE valeur_debut A valeur_fin [PAS increment] FAIRE
// bloc d'instructions
FIN POUR

// Exemple : afficher 1 à 5
POUR i DE 1 A 5 FAIRE
AFFICHER i // Affiche 1, 2, 3, 4, 5
FIN POUR

// ========== BOUCLE TANT QUE ==========

// Quand on ne sait pas, test AVANT
TANT QUE condition FAIRE
// bloc d'instructions
FIN TANT QUE

// Exemple : lire jusqu'à obtenir un nombre positif

TANT QUE nombre <= 0 FAIRE
AFFICHER "Entrez un nombre positif : "
LIRE nombre
FIN TANT QUE

// ========== BOUCLE REPETER ==========

// Quand on veut exécuter au moins une fois, test APRES
REPETER
// bloc d'instructions
JUSQU'A condition_de_sortie

// Exemple : confirmation
REPETER
AFFICHER "Voulez-vous continuer (O/N) ? "
LIRE reponse
JUSQU'A (reponse = 'O') OU (reponse = 'N')

139
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

7.5 Pseudo-code complet

140
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

ALGORITHME 7.1 : LES TROIS BOUCLES EN ACTION

ALGORITHME Boucles_Demo
VARIABLES
i, somme, n, factorielle : ENTIER
saisie : REEL
DÉBUT
// --- POUR : Somme de 1 à 100 ---
somme <- 0
POUR i DE 1 A 100 FAIRE
somme <- somme + i // Accumulateur
FIN POUR
AFFICHER "Somme 1..100 = ", somme // 5050

// --- POUR : Factorielle ---

AFFICHER "n : " ; LIRE n
factorielle <- 1
POUR i DE 1 A n FAIRE
factorielle <- factorielle * i
FIN POUR
AFFICHER n, "! = ", factorielle

// --- TANT QUE : Validation de saisie ---

saisie <- -1 // Initialiser pour entrer dans la boucle
TANT QUE (saisie < 0) OU (saisie > 20) FAIRE
AFFICHER "Note /20 (0-20) : "
LIRE saisie
SI (saisie < 0) OU (saisie > 20) ALORS
AFFICHER "ERREUR : note invalide."
FIN SI
FIN TANT QUE

// --- REPETER : Menu ---

REPETER
AFFICHER "=== MENU ==="
AFFICHER "1. Option 1"
AFFICHER "2. Option 2"
AFFICHER "3. Quitter"
AFFICHER "Choix : "
LIRE choix
JUSQU'A (choix >= 1) ET (choix <= 3)
FIN

141
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

7.6 Exécution pas à pas (somme 1 à 5)

Tableau 7.2 : Trace de POUR i DE 1 A 5

Tour i somme (avant) somme (après)

Initial - - 0

1 1 0 0+1=1

2 2 1 1+2=3

3 3 3 3+3=6

4 4 6 6+4=10

5 5 10 10+5=15

7.7 Erreurs fréquentes

ERREURS À ÉVITER

Boucle infinie : La condition de sortie ne devient jamais fausse. Ex : TANT

QUE i > 0 FAIRE ... sans décrémenter i.

Oublier d'initialiser le compteur/accumulateur : somme <- 0 avant la

boucle est indispensable.

Modifier la variable de boucle POUR dans le bloc : C'est dangereux et

imprévisible.

Condition toujours fausse dès le départ (TANT QUE) : Le bloc ne

s'exécute jamais. Vérifier l'initialisation.

Confondre <= et < : DE 1 A 5 fait 5 tours, < 5 en ferait 4.

7.8 Résumé

142
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

POINTS CLÉS

POUR : nombre d'itérations connu. Compteur automatique.

TANT QUE : test avant. Peut ne pas s'exécuter. Risque de boucle infinie si la
condition ne change jamais.

RÉPÉTER : test après. S'exéute au moins une fois.

Accumulateur : variable qui cumule (somme <- somme + x). Initialiser à 0.

Compteur : variable qui compte (cpt <- cpt + 1). Initialiser à 0.

Boucle infinie : la condition reste toujours vraie. À éviter absolument !

Exercices du Chapitre 7

Exercice 7.1 (Très facile)

Table de multiplication : Lire un nombre n. Afficher sa table de multiplication de 1

à 10 avec POUR.

ALGORITHME Table_Multiplication
VARIABLES n, i : ENTIER
DÉBUT
AFFICHER "n : " ; LIRE n
POUR i DE 1 A 10 FAIRE
AFFICHER n, " x ", i, " = ", n * i
FIN POUR
FIN

143
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Exercice 7.2 (Très facile)

Compteur pair : Afficher tous les nombres pairs de 2 à 20 avec POUR PAS 2.

ALGORITHME Compteur_Pair
VARIABLES i : ENTIER
DÉBUT
POUR i DE 2 A 20 PAS 2 FAIRE
AFFICHER i
FIN POUR
FIN

Exercice 7.3 (Facile)

Saisie contrôlée : Lire un nombre entre 1 et 100. Re-demander tant que la valeur
est invalide (TANT QUE).

ALGORITHME Saisie_Controlee
VARIABLES n : ENTIER
DÉBUT
n <- -1
TANT QUE (n < 1) OU (n > 100) FAIRE
AFFICHER "Nombre (1-100) : " ; LIRE n
FIN TANT QUE
AFFICHER "Vous avez saisi : ", n
FIN

144
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Exercice 7.4 (Facile)

Somme des entiers jusqu'à n : Lire n. Calculer 1 + 2 + ... + n avec POUR. Vérifier
avec la formule n(n+1)/2.

ALGORITHME Somme_JusquaN
VARIABLES n, i, somme : ENTIER
DÉBUT
AFFICHER "n : " ; LIRE n
somme <- 0
POUR i DE 1 A n FAIRE
somme <- somme + i
FIN POUR
AFFICHER "Somme boucle : ", somme
AFFICHER "Formule : ", n * (n + 1) DIV 2
FIN

145
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Exercice 7.5 (Facile)

Nombre de chiffres : Lire un entier positif. Compter et afficher son nombre de

chiffres (TANT QUE en divisant par 10).

ALGORITHME Nombre_Chiffres
VARIABLES n, compteur : ENTIER
DÉBUT
AFFICHER "n : " ; LIRE n
compteur <- 0
TANT QUE n > 0 FAIRE
n <- n DIV 10
compteur <- compteur + 1
FIN TANT QUE
AFFICHER "Nombre de chiffres : ", compteur
FIN

146
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Exercice 7.6 (Moyen)

Jeu deviner avec compteur : Le nombre à deviner est 42. Lire des essais jusqu'à
trouver. Afficher "Gagné en X essais !". Comptez les essais.

ALGORITHME Deviner_Compteur
CONST CIBLE : ENTIER <- 42
VARIABLES essai, nbEssais : ENTIER
DÉBUT
nbEssais <- 0
REPETER
AFFICHER "Votre essai : " ; LIRE essai
nbEssais <- nbEssais + 1
SI essai > CIBLE ALORS AFFICHER "Trop grand"
SINON SI essai < CIBLE ALORS AFFICHER "Trop petit" FIN
SI
JUSQU'A essai = CIBLE
AFFICHER "Gagné en ", nbEssais, " essais !"
FIN

147
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Exercice 7.7 (Moyen)

Nombre premier : Lire n. Déterminer si n est premier (divisible uniquement par 1

et lui-même). Tester les diviseurs de 2 à RACINE(n).

ALGORITHME Premier
VARIABLES n, i : ENTIER
estPremier : BOOLEEN <- VRAI
DÉBUT
AFFICHER "n : " ; LIRE n
SI n <= 1 ALORS estPremier <- FAUX
SINON
POUR i DE 2 A RACINE(n) FAIRE
SI n MOD i = 0 ALORS
estPremier <- FAUX
i <- RACINE(n) // Sortie anticipée
FIN SI
FIN POUR
FIN SI
SI estPremier ALORS AFFICHER n, " est premier"
SINON AFFICHER n, " n'est pas premier" FIN SI
FIN

Python :

import math
n = int(input("n : "))
est_premier = n > 1
for i in range(2, int([Link](n)) + 1):
if n % i == 0:
est_premier = False
break
print(f"{n} est premier : {est_premier}")

148
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Exercice 7.8 (Moyen)

Factorielle avec validation : Lire n. Si n < 0, redemander. Calculer n! avec POUR.

ALGORITHME Factorielle_Validee
VARIABLES n, i, fact : ENTIER
DÉBUT
REPETER
AFFICHER "n (>=0) : " ; LIRE n
JUSQU'A n >= 0
fact <- 1
POUR i DE 1 A n FAIRE
fact <- fact * i
FIN POUR
AFFICHER n, "! = ", fact
FIN

149
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Exercice 7.9 (Moyen)

Suites : Calculer les 20 premiers termes de la suite de Fibonacci : F0 = 0, F1 =

​ ​

1, Fn = Fn−1 + Fn−2 .
​ ​ ​

ALGORITHME Fibonacci
VARIABLES f0, f1, f2, i : ENTIER
DÉBUT
f0 <- 0; f1 <- 1
AFFICHER f0, " ", f1, " "
POUR i DE 2 A 19 FAIRE
f2 <- f0 + f1
AFFICHER f2, " "
f0 <- f1
f1 <- f2
FIN POUR
FIN

Python :

f0, f1 = 0, 1
print(f0, f1, end=" ")
for i in range(2, 20):
f2 = f0 + f1
print(f2, end=" ")
f0, f1 = f1, f2

150
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Exercice 7.10 (Difficile)

Calcul de xn : Lire x (REEL) et n (ENTIER, peut être négatif). Calculer xn sans

utiliser de fonction puissance. Gérer n < 0.

ALGORITHME Puissance
VARIABLES x, resultat : REEL
n, i, exp : ENTIER
DÉBUT
AFFICHER "x : " ; LIRE x
AFFICHER "n : " ; LIRE n

SI n >= 0 ALORS exp <- n SINON exp <- -n FIN SI

resultat <- 1
POUR i DE 1 A exp FAIRE
resultat <- resultat * x
FIN POUR

SI n < 0 ALORS resultat <- 1 / resultat FIN SI

AFFICHER x, "^", n, " = ", resultat

FIN

151
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Exercice 7.11 (Mini-projet)

Calculatrice avec menu : Afficher un menu (+, -, *, /, quitter). Lire le choix. Si

opération, lire deux nombres et afficher le résultat. Reafficher le menu jusqu'à ce
que l'utilisateur choisisse quitter (RÉPÉTER).

ALGORITHME Calculatrice_Menu
VARIABLES a, b, resultat : REEL
choix : ENTIER
DÉBUT
REPETER
AFFICHER "\n=== CALCULATRICE ==="
AFFICHER "1. Addition"
AFFICHER "2. Soustraction"
AFFICHER "3. Multiplication"
AFFICHER "4. Division"
AFFICHER "5. Quitter"
AFFICHER "Choix : " ; LIRE choix

SI choix >= 1 ET choix <= 4 ALORS

AFFICHER "a : " ; LIRE a
AFFICHER "b : " ; LIRE b
FIN SI

choix vaut
1: resultat <- a + b
2: resultat <- a - b
3: resultat <- a * b
4: SI b <> 0 ALORS resultat <- a / b
SINON AFFICHER "Div par 0 !" FIN SI
5: AFFICHER "Au revoir !"
SINON: AFFICHER "Choix invalide"

SI choix >= 1 ET choix <= 4 ALORS

AFFICHER "Résultat : ", resultat
FIN SI
JUSQU'A choix = 5
FIN

152
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Exercice 7.12 (Mini-projet - Difficile)

Dessin de formes avec boucles imbriquées : Lire un entier n. Dessiner un triangle

rectangle de * avec n lignes, puis un carré de côté n, puis un triangle isocèle centré.

153
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

ALGORITHME Dessin_Formes
VARIABLES n, i, j : ENTIER
DÉBUT
AFFICHER "n : " ; LIRE n

// Triangle rectangle
AFFICHER "--- Triangle rectangle ---"
POUR i DE 1 A n FAIRE
POUR j DE 1 A i FAIRE
AFFICHER_SANS_RETOUR "* "
FIN POUR
AFFICHER "" // Saut de ligne
FIN POUR

// Carré
AFFICHER "--- Carré ---"
POUR i DE 1 A n FAIRE
POUR j DE 1 A n FAIRE
AFFICHER_SANS_RETOUR "* "
FIN POUR
AFFICHER ""
FIN POUR

// Triangle isocèle
AFFICHER "--- Triangle isocèle ---"
POUR i DE 1 A n FAIRE
// Espaces
POUR j DE 1 A (n - i) FAIRE
AFFICHER_SANS_RETOUR " "
FIN POUR
// Étoiles
POUR j DE 1 A (2*i - 1) FAIRE
AFFICHER_SANS_RETOUR "* "
FIN POUR
AFFICHER ""
FIN POUR
FIN

Python :

154
Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

n = int(input("n : "))

# Triangle rectangle
for i in range(1, n+1):
print("* " * i)

# Carre
for i in range(n):
print("* " * n)

# Triangle isocele
for i in range(1, n+1):
print(" " * (n-i) + "* " * (2*i-1))

Méthode : Les boucles imbriquées servent pour les dimensions. La boucle

extérieure parcourt les lignes, l'intérieure les colonnes. Pour le triangle isocèle,
on combine espaces décroissants et étoiles croissantes.

Validation du Chapitre 7

Bravo ! Les boucles sont maîtrisées ! Vérifiez :

POUR : compteur, nombre connu d'itérations

TANT QUE : condition avant, risque boucle infinie

RÉPÉTER : condition après, au moins 1 exécution

Accumulateurs et compteurs : initialiser !

Boucles imbriquées

Écrivez "Chapitre suivant" pour valider et passer au Chapitre 8.

155
Chapitre 8 : Fonctions et procédures

Chapitre 8 : Fonctions et procédures

CHAPITRE 8

Fonctions et procédures

8.1 Définition simple et intuitive

DÉFINITIONS

Une fonction est un bloc d'instructions nommé qui effectue une tâche et retourne
une valeur. C'est comme une machine : on lui donne des ingrédients (paramètres),
elle travaille et nous rend un résultat. Exemple : la fonction "maximum" prend
deux nombres et retourne le plus grand.

Une procédure est un bloc d'instructions nommé qui effectue une tâche mais ne
retourne rien. C'est comme une instruction : on l'appelle et elle fait son travail.
Exemple : une procédure "afficherMenu" affiche un menu à l'écran sans retourner
de valeur.

8.2 Objectif

156
Chapitre 8 : Fonctions et procédures

OBJECTIFS

Savoir définir et appeler une fonction

Savoir définir et appeler une procédure

Comprendre les paramètres et la valeur de retour

Maîtriser la portée des variables (locales vs globales)

Savoir décomposer un problème en sous-programmes

8.3 Exemple concret

LA PIZZERIA

Dans une pizzeria, il y a des tâches spécialisées :

Fonction "calculerPrix" : reçoit (base, garnitures, taille), retourne le prix

(15.50 EUR). Elle retourne une valeur.

Procédure "cuirePizza" : reçoit (pizza), ne retourne rien mais réalise

l'action de cuisson. Elle fait quelque chose.

Procédure "afficherTicket" : reçoit (commande), affiche le ticket client.

Elle affiche quelque chose.

Le chef d'orchestre (algorithme principal) appelle ces sous-programmes sans se

soucier de leurs détails internes.

8.4 Explication détaillée

8.4.1 Schéma : algorithme principal et sous-programmes

157
Chapitre 8 : Fonctions et procédures

+----------------------------------+
| ALGORITHME PRINCIPAL |
| |
| r <- maximum(10, 20) ------->+---------+ +---------+
| afficherResultat(r) ------> | Fonction| |Procedure|
| afficherMenu() ------> | maximum | |afficherR|
| | a, b | | val |
+----------------------------------+---------+ +---------+
| Appels | | |
| | v v
| retourne Affichage
v max(a,b) à l'écran
+----------------------------------+
| Fonction maximum(a, b) |
| SI a > b ALORS retourne a |
| SINON retourne b |
+----------------------------------+

Portée des variables :

+-------------------------------------+
| Algo principal |
| VARIABLES globale : x |
| |
| +---------------------------+ |
| | Fonction f(a) | |
| | VARIABLE locale : y | |
| | a est visible ici | |
| | x est visible ici | |
| | y n'existe que ici | |
| +---------------------------+ |
| y n'existe PAS ici |
+-------------------------------------+

8.4.2 Passage de paramètres

Tableau 8.1 : Paramètres et retour

Élément Rôle Exemple

Paramètre formel Variable déclarée dans la fonction a, b dans maximum(a, b)

Paramètre effectif Valeur passée lors de l'appel maximum(10, 20) → a=10, b=20

RETOURNE Renvoie la valeur au point d'appel retourne a

8.5 Pseudo-code

158
Chapitre 8 : Fonctions et procédures

ALGORITHME 8.1 : FONCTIONS ET PROCÉDURES

159
Chapitre 8 : Fonctions et procédures

// ========== FONCTION : retourne une valeur ==========

FONCTION maximum(a : REEL, b : REEL) : REEL
// Retourne le plus grand des deux nombres
SI a > b ALORS
RETOURNE a
SINON
RETOURNE b
FIN SI
FIN FONCTION

// ========== FONCTION avec calcul ==========

FONCTION factorielle(n : ENTIER) : ENTIER
VARIABLES i, resultat : ENTIER
resultat <- 1
POUR i DE 1 A n FAIRE
resultat <- resultat * i
FIN POUR
RETOURNE resultat
FIN FONCTION

// ========== PROCEDURE : ne retourne rien ==========

PROCEDURE afficherLigne(taille : ENTIER, car : CARACTERE)
VARIABLES i : ENTIER
POUR i DE 1 A taille FAIRE
AFFICHER_SANS_RETOUR car
FIN POUR
AFFICHER "" // Saut de ligne
FIN PROCEDURE

// ========== ALGORITHME PRINCIPAL ==========

ALGORITHME Principal
VARIABLES x, y, z : REEL
DÉBUT
x <- 15
y <- 22

// Appel de fonction : on récupère le résultat

z <- maximum(x, y) // z = 22
AFFICHER "Max : ", z

// Appel de fonction direct dans AFFICHER

AFFICHER "Factorielle 5 = ", factorielle(5) // 120

// Appel de procédure : pas de valeur de retour

160
Chapitre 8 : Fonctions et procédures

8.6 Exécution pas à pas

Appel de maximum(15, 22) :

Étape Action a b Résultat

1 Appel maximum(15, 22) 15 22 -

2 Test a > b : 15 > 22 15 22 FAUX

3 RETOURNE b 15 22 22

4 Retour au principal, z <- 22 - - z=22

8.7 Erreurs fréquentes

ERREURS À ÉVITER

Oublier RETOURNE : Une fonction doit toujours retourner une valeur.

Appeler une fonction sans récupérer le résultat : maximum(3, 4) seul ne

sert à rien. Il faut x <- maximum(3, 4) .

Confondre fonction et procédure : On ne peut pas faire x <-

afficherMenu() car une procédure ne retourne rien.

Variables locales vs globales : Une variable déclarée dans une fonction

n'existe que dans cette fonction.

Mauvais nombre de paramètres : maximum(3) alors que la fonction en

attend 2.

8.8 Résumé

161
Chapitre 8 : Fonctions et procédures

POINTS CLÉS

Fonction = sous-programme qui retourne une valeur

Procédure = sous-programme qui fait quelque chose sans retourner

FONCTION nom(param) : type_retour ... RETOURNE valeur ... FIN FONCTION

PROCEDURE nom(param) ... FIN PROCEDURE

Les variables déclarées dans un sous-programme sont locales

La décomposition en sous-programmes rend le code plus lisible et

réutilisable

Exercices du Chapitre 8

Exercice 8.1 (Très facile)

Fonction carré : Écrivez une fonction carre(x : REEL) : REEL qui retourne x2 .
Appelez-la pour calculer le carré de 5 et de 3.14.

FONCTION carre(x : REEL) : REEL

RETOURNE x * x
FIN FONCTION

// Appel
ALGORITHME Test
AFFICHER "Carré de 5 : ", carre(5) // 25
AFFICHER "Carré de 3.14 : ", carre(3.14) // 9.8596
FIN

162
Chapitre 8 : Fonctions et procédures

Exercice 8.2 (Très facile)

Procédure de séparation : Écrivez une procédure ligne(taille : ENTIER) qui

affiche une ligne de tirets. Utilisez-la pour encadrer un titre.

PROCEDURE ligne(taille : ENTIER)

VARIABLES i : ENTIER
POUR i DE 1 A taille FAIRE
AFFICHER_SANS_RETOUR "-"
FIN POUR
AFFICHER ""
FIN PROCEDURE

ALGORITHME Test
ligne(30)
AFFICHER " TITRE CENTRE"
ligne(30)
FIN

Exercice 8.3 (Facile)

Fonction estPair : Écrivez une fonction booléenne qui retourne VRAI si un entier
est pair.

FONCTION estPair(n : ENTIER) : BOOLEEN

RETOURNE (n MOD 2 = 0)
FIN FONCTION

// Appels
AFFICHER estPair(4) // VRAI
AFFICHER estPair(7) // FAUX

163
Chapitre 8 : Fonctions et procédures

Exercice 8.4 (Facile)

Fonction PGCD (Euclide) : Écrivez une fonction qui calcule le PGCD de deux entiers
par l'algorithme d'Euclide.

FONCTION pgcd(a : ENTIER, b : ENTIER) : ENTIER

VARIABLES temp : ENTIER
TANT QUE b <> 0 FAIRE
temp <- b
b <- a MOD b
a <- temp
FIN TANT QUE
RETOURNE a
FIN FONCTION

// Appel : pgcd(48, 18) = 6

Python :

def pgcd(a, b):

while b != 0:
a, b = b, a % b
return a

164
Chapitre 8 : Fonctions et procédures

Exercice 8.5 (Facile)

Fonction factorielle : Écrivez une fonction récursive et itérative pour la factorielle.

// Version itérative
FONCTION fact(n : ENTIER) : ENTIER
VARIABLES i, resultat : ENTIER
resultat <- 1
POUR i DE 1 A n FAIRE
resultat <- resultat * i
FIN POUR
RETOURNE resultat
FIN FONCTION

// Version récursive
FONCTION factRec(n : ENTIER) : ENTIER
SI n <= 1 ALORS
RETOURNE 1
SINON
RETOURNE n * factRec(n - 1)
FIN SI
FIN FONCTION

165
Chapitre 8 : Fonctions et procédures

Exercice 8.6 (Moyen)

Fonction estPremier : Écrivez une fonction booléenne qui teste si un nombre est
premier. Optimisez avec RACINE(n).

FONCTION estPremier(n : ENTIER) : BOOLEEN

VARIABLES i : ENTIER
SI n <= 1 ALORS RETOURNE FAUX FIN SI
SI n <= 3 ALORS RETOURNE VRAI FIN SI
SI (n MOD 2 = 0) OU (n MOD 3 = 0) ALORS RETOURNE FAUX FIN SI
i <- 5
TANT QUE i * i <= n FAIRE
SI (n MOD i = 0) OU (n MOD (i+2) = 0) ALORS
RETOURNE FAUX
FIN SI
i <- i + 6
FIN TANT QUE
RETOURNE VRAI
FIN FONCTION

166
Chapitre 8 : Fonctions et procédures

Exercice 8.7 (Moyen)

Fonction puissance rapide : Écrivez une fonction récursive qui calcule xn par
exponentiation rapide.

FONCTION puissance(x : REEL, n : ENTIER) : REEL

// Exponentiation rapide : O(log n)
SI n = 0 ALORS RETOURNE 1 FIN SI
SI n < 0 ALORS RETOURNE 1 / puissance(x, -n) FIN SI
SI n MOD 2 = 0 ALORS
RETOURNE puissance(x * x, n DIV 2)
SINON
RETOURNE x * puissance(x * x, n DIV 2)
FIN SI
FIN FONCTION

Python :

def puissance(x, n):

if n == 0: return 1
if n < 0: return 1 / puissance(x, -n)
if n % 2 == 0:
return puissance(x * x, n // 2)
return x * puissance(x * x, n // 2)

167
Chapitre 8 : Fonctions et procédures

Exercice 8.8 (Moyen)

Procédure dessiner rectangle : Écrivez une procédure qui dessine un rectangle de

L x l avec un caractère donné.

PROCEDURE rectangle(long : ENTIER, larg : ENTIER, car : CARACTERE)

VARIABLES i, j : ENTIER
POUR i DE 1 A larg FAIRE
POUR j DE 1 A long FAIRE
AFFICHER_SANS_RETOUR car
FIN POUR
AFFICHER ""
FIN POUR
FIN PROCEDURE

Exercice 8.9 (Moyen)

Fonction nombre de chiffres : Écrivez une fonction qui retourne le nombre de

chiffres d'un entier positif.

FONCTION nbChiffres(n : ENTIER) : ENTIER

VARIABLES compteur : ENTIER
compteur <- 0
TANT QUE n > 0 FAIRE
n <- n DIV 10
compteur <- compteur + 1
FIN TANT QUE
RETOURNE compteur
FIN FONCTION

168
Chapitre 8 : Fonctions et procédures

Exercice 8.10 (Difficile)

Fonction conversion base : Écrivez une fonction qui convertit un entier en chaîne
représentant sa forme dans une base (2 à 16).

FONCTION convertirBase(n : ENTIER, base : ENTIER) : CHAINE

CONST CHIFFRES : CHAINE <- "0123456789ABCDEF"
VARIABLES resultat : CHAINE <- ""
TANT QUE n > 0 FAIRE
resultat <- CARACTERE_A(CHIFFRES, n MOD base + 1) +
resultat
n <- n DIV base
FIN TANT QUE
SI resultat = "" ALORS resultat <- "0" FIN SI
RETOURNE resultat
FIN FONCTION

// convertirBase(255, 16) = "FF"

// convertirBase(13, 2) = "1101"

Python :

def convertir_base(n, base):

chiffres = "0123456789ABCDEF"
resultat = ""
while n > 0:
resultat = chiffres[n % base] + resultat
n //= base
return resultat if resultat else "0"

169
Chapitre 8 : Fonctions et procédures

Exercice 8.11 (Mini-projet)

Bibliothèque mathématique : Créez un ensemble de fonctions : somme(a, b),

difference(a, b), produit(a, b), quotient(a, b) avec vérification division par zéro,
puissance(x, n), factorielle(n), estPremier(n). Puis un algorithme principal avec
menu qui les utilise toutes.

170
Chapitre 8 : Fonctions et procédures

// === FONCTIONS ===

FONCTION somme(a : REEL, b : REEL) : REEL
RETOURNE a + b
FIN FONCTION

FONCTION difference(a : REEL, b : REEL) : REEL

RETOURNE a - b
FIN FONCTION

FONCTION produit(a : REEL, b : REEL) : REEL

RETOURNE a * b
FIN FONCTION

FONCTION quotient(a : REEL, b : REEL) : REEL

SI b = 0 ALORS
AFFICHER "ERREUR : Division par zéro !"
RETOURNE 0
SINON
RETOURNE a / b
FIN SI
FIN FONCTION

// === ALGORITHME PRINCIPAL ===

ALGORITHME Calculatrice_Avancee
VARIABLES a, b, resultat : REEL
choix : ENTIER
DÉBUT
REPETER
AFFICHER "\n=== CALCULATRICE ==="
AFFICHER "1. Somme 2. Différence"
AFFICHER "3. Produit 4. Quotient"
AFFICHER "5. Puissance 6. Factorielle"
AFFICHER "7. Premier ? 8. Quitter"
AFFICHER "Choix : " ; LIRE choix

choix vaut
1: LIRE a, b; AFFICHER somme(a, b)
2: LIRE a, b; AFFICHER difference(a, b)
3: LIRE a, b; AFFICHER produit(a, b)
4: LIRE a, b; AFFICHER quotient(a, b)
5: LIRE a, b; AFFICHER puissance(a, b)
6: LIRE a; AFFICHER factorielle(a)
7: LIRE a; AFFICHER estPremier(a)
8: AFFICHER "Au revoir !"
SINON: AFFICHER "Choix invalide"

171
Chapitre 8 : Fonctions et procédures

Exercice 8.12 (Mini-projet - Difficile)

Tours de Hanoï récursif : Écrivez une procédure récursive qui résout les tours de
Hanoï (déplacer n disques de la tour A à la tour C en utilisant B comme
intermédiaire). Afficher chaque mouvement.

PROCEDURE hanoi(n : ENTIER, depart : CHAINE, arrivee : CHAINE,

inter : CHAINE)
// n = nombre de disques
// départ = tour de départ, arrivée = tour d'arrivée, inter =
tour intermédiaire
SI n = 1 ALORS
AFFICHER "Déplacer disque 1 de ", depart, " vers ", arrivee
SINON
hanoi(n - 1, depart, inter, arrivee)
AFFICHER "Déplacer disque ", n, " de ", depart, " vers ",
arrivee
hanoi(n - 1, inter, arrivee, depart)
FIN SI
FIN PROCEDURE

// Appel : hanoi(3, "A", "C", "B")

Python :

def hanoi(n, depart="A", arrivee="C", inter="B"):

if n == 1:
print(f"Deplacer disque 1 de {depart} vers {arrivee}")
else:
hanoi(n-1, depart, inter, arrivee)
print(f"Deplacer disque {n} de {depart} vers {arrivee}")
hanoi(n-1, inter, arrivee, depart)

hanoi(3)

172
Chapitre 8 : Fonctions et procédures

Méthode : La récursivité est naturelle ici. Pour déplacer n disques de A vers C :

(1) déplacer n-1 disques de A vers B, (2) déplacer le disque n de A vers C, (3)
déplacer n-1 disques de B vers C. Complexité : 2n − 1 mouvements.

Validation du Chapitre 8

Excellent ! Vous maîtrisez la modularisation ! Vérifiez :

Différence fonction (retourne) vs procédure (action)

Définition avec paramètres et type de retour

Appel correct : récupération du retour pour une fonction

Portée des variables (locales)

Récursivité de base

Écrivez "Chapitre suivant" pour valider et passer au Chapitre 9.

173
Chapitre 9 : Tableaux à une dimension

Chapitre 9 : Tableaux à une dimension

CHAPITRE 9

Tableaux à une dimension

9.1 Définition simple et intuitive

DÉFINITION

Un tableau (ou array en anglais) est une structure de données qui permet de
stocker plusieurs valeurs du même type sous un seul nom, en les organisant de
manière séquentielle. C'est comme une armoire avec des cases numérotées :
chaque case contient une valeur, et on accède à une valeur grâce à son numéro de
case (indice).

9.2 Objectif

174
Chapitre 9 : Tableaux à une dimension

OBJECTIFS

Déclarer et initialiser un tableau à une dimension

Accéder à un élément par son indice

Parcourir un tableau (boucle POUR)

Rechercher un élément, calculer une moyenne, trouver un extremum

Modifier le contenu d'un tableau

9.3 Exemple concret

LES CASIERS D'UNE SALLE DE SPORT

Imaginez une rangée de 20 casiers numérotés de 0 à 19 (ou 1 à 20) :

Nom du tableau : casiers

Indice : le numéro du casier (0, 1, 2, ..., 19)

Valeur : le nom du propriétaire ("Alice", "Bob", "", "Charlie", ...)

Accès : casier[3] = "Charlie" signifie "dans le casier n°3, il y a Charlie"

9.4 Explication détaillée

9.4.1 Représentation en mémoire

175
Chapitre 9 : Tableaux à une dimension

Déclaration : notes : TABLEAU[5] DE REEL (indices de 0 à 4)

Indice : 0 1 2 3 4
+------+------+------+------+------+
| 12.5 | 15.0 | 8.5 | 14.0 | 11.0 |
+------+------+------+------+------+
notes[0] = 12.5
notes[1] = 15.0
notes[2] = 8.5
notes[3] = 14.0
notes[4] = 11.0

Accès : notes[2] = 8.5 (3ème élément)

notes[0] = 12.5 (1er élément)
notes[4] = 11.0 (dernier élément)

TAILLE(notes) = 5

Modification : notes[2] <- 10.0

+------+------+------+------+------+
| 12.5 | 15.0 | 10.0 | 14.0 | 11.0 |
+------+------+------+------+------+
ancien 8.5 écrasé par 10.0

9.4.2 Déclaration et initialisation

Tableau 9.1 : Déclaration de tableaux

Opération Syntaxe Exemple

Déclaration nom : TABLEAU[taille] DE type notes : TABLEAU[10] DE REEL

Accès lecture nom[indice] x <- notes[3]

Accès écriture nom[indice] <- valeur notes[0] <- 15.5

Taille TAILLE(nom) n <- TAILLE(notes) (n=10)

9.5 Pseudo-code

176
Chapitre 9 : Tableaux à une dimension

ALGORITHME 9.1 : MANIPULATION DE TABLEAUX

ALGORITHME Tableaux_Demo
// Déclaration
notes : TABLEAU[5] DE REEL
i : ENTIER
somme, moyenne : REEL
max, indiceMax : ENTIER

DÉBUT
// --- REMPLISSAGE (saisie) ---
AFFICHER "=== Saisie des 5 notes ==="
POUR i DE 0 A 4 FAIRE // Indices de 0 à 4
AFFICHER "Note ", i+1, " : "
LIRE notes[i]
FIN POUR

// --- AFFICHAGE ---

AFFICHER "\n=== Notes saisies ==="
POUR i DE 0 A 4 FAIRE
AFFICHER "notes[", i, "] = ", notes[i]
FIN POUR

// --- SOMME ET MOYENNE ---

somme <- 0
POUR i DE 0 A 4 FAIRE
somme <- somme + notes[i]
FIN POUR
moyenne <- somme / TAILLE(notes)
AFFICHER "\nMoyenne : ", moyenne

// --- MAXIMUM ---

max <- notes[0] // On suppose le 1er max
indiceMax <- 0
POUR i DE 1 A 4 FAIRE // On compare avec les autres
SI notes[i] > max ALORS
max <- notes[i]
indiceMax <- i
FIN SI
FIN POUR
AFFICHER "Max : ", max, " (indice ", indiceMax, ")"
FIN

177
Chapitre 9 : Tableaux à une dimension

9.6 Exécution pas à pas

Avec notes = [12, 15, 8, 14, 11] :

Étape i notes[i] somme max indiceMax

Initial - [12,15,8,14,11] 0 12 0

Calcul somme 0 12 12 - -

Calcul somme 1 15 27 15 1

Calcul somme 2 8 35 - -

Calcul somme 3 14 49 - -

Calcul somme 4 11 60 - -

Résultat - Moy = 60/5 = 12 60 15 1

9.7 Erreurs fréquentes

ERREURS À ÉVITER

Débordement d'indice : Avec un tableau de 5 éléments (indices 0..4),

accéder à notes[5] provoque une erreur. Le dernier indice est toujours
TAILLE - 1 .

Confondre indice et valeur : notes[i] est la valeur, i est l'indice.

Oublier d'initialiser : Un tableau non initialisé contient des valeurs

aléatoires.

Boucle hors limites : POUR i DE 0 A TAILLE(tab) est faux, c'est DE 0 A

TAILLE(tab)-1 .

9.8 Résumé

178
Chapitre 9 : Tableaux à une dimension

POINTS CLÉS

Tableau = collection ordonnée de valeurs du même type

Accès par indice : tab[i] (i commence généralement à 0)

Taille : TAILLE(tab) , dernier indice : TAILLE(tab) - 1

Parcours standard : POUR i DE 0 A TAILLE(tab)-1

Opérations classiques : remplissage, affichage, somme, moyenne, maximum,

recherche

Exercices du Chapitre 9

Exercice 9.1 (Très facile)

Remplissage et affichage : Déclarer un tableau de 5 entiers, le remplir par saisie,

puis l'afficher.

ALGORITHME Remplir_Afficher
tab : TABLEAU[5] DE ENTIER
i : ENTIER
DÉBUT
POUR i DE 0 A 4 FAIRE
AFFICHER "valeur ", i, " : " ; LIRE tab[i]
FIN POUR
POUR i DE 0 A 4 FAIRE
AFFICHER tab[i]
FIN POUR
FIN

179
Chapitre 9 : Tableaux à une dimension

Exercice 9.2 (Très facile)

Somme et moyenne : Calculer la somme et la moyenne d'un tableau de 10 réels.

ALGORITHME Somme_Moyenne
tab : TABLEAU[10] DE REEL
i : ENTIER; somme, moy : REEL
DÉBUT
// saisie
POUR i DE 0 A 9 FAIRE LIRE tab[i] FIN POUR
// calcul
somme <- 0
POUR i DE 0 A 9 FAIRE somme <- somme + tab[i] FIN POUR
moy <- somme / 10
AFFICHER "Somme=", somme, " Moy=", moy
FIN

180
Chapitre 9 : Tableaux à une dimension

Exercice 9.3 (Facile)

Maximum et minimum : Trouver et afficher le maximum et le minimum d'un

tableau de 8 entiers, avec leurs indices.

ALGORITHME Max_Min
tab : TABLEAU[8] DE ENTIER
i, max, min, iMax, iMin : ENTIER
DÉBUT
POUR i DE 0 A 7 FAIRE LIRE tab[i] FIN POUR
max <- tab[0]; min <- tab[0]; iMax <- 0; iMin <- 0
POUR i DE 1 A 7 FAIRE
SI tab[i] > max ALORS max <- tab[i]; iMax <- i FIN SI
SI tab[i] < min ALORS min <- tab[i]; iMin <- i FIN SI
FIN POUR
AFFICHER "Max=", max, " (", iMax, ") Min=", min, " (",
iMin, ")"
FIN

181
Chapitre 9 : Tableaux à une dimension

Exercice 9.4 (Facile)

Comptage : Compter combien d'éléments sont supérieurs à la moyenne dans un

tableau de 10 réels.

ALGORITHME Comptage_Superieur_Moyenne
tab : TABLEAU[10] DE REEL
i, compteur : ENTIER; somme, moy : REEL
DÉBUT
POUR i DE 0 A 9 FAIRE LIRE tab[i]; somme <- somme + tab[i]
FIN POUR
moy <- somme / 10
compteur <- 0
POUR i DE 0 A 9 FAIRE
SI tab[i] > moy ALORS compteur <- compteur + 1 FIN SI
FIN POUR
AFFICHER compteur, " éléments > ", moy
FIN

182
Chapitre 9 : Tableaux à une dimension

Exercice 9.5 (Facile)

Recherche d'un élément : Lire un tableau de 6 entiers, puis lire une valeur à
chercher. Afficher si elle est présente et à quel(s) indice(s).

ALGORITHME Recherche
tab : TABLEAU[6] DE ENTIER
i, val : ENTIER; trouve : BOOLEEN
DÉBUT
POUR i DE 0 A 5 FAIRE LIRE tab[i] FIN POUR
AFFICHER "Valeur à chercher : " ; LIRE val
trouve <- FAUX
POUR i DE 0 A 5 FAIRE
SI tab[i] = val ALORS
AFFICHER "Trouvé à l'indice ", i
trouve <- VRAI
FIN SI
FIN POUR
SI NON trouve ALORS AFFICHER "Non trouvé" FIN SI
FIN

183
Chapitre 9 : Tableaux à une dimension

Exercice 9.6 (Moyen)

Inversion : Inverser un tableau en place (le premier devient dernier, etc.). Afficher
avant et après.

ALGORITHME Inverser
tab : TABLEAU[6] DE ENTIER
i, temp, milieu : ENTIER
DÉBUT
POUR i DE 0 A 5 FAIRE LIRE tab[i] FIN POUR
milieu <- TAILLE(tab) DIV 2
POUR i DE 0 A milieu - 1 FAIRE
temp <- tab[i]
tab[i] <- tab[TAILLE(tab) - 1 - i]
tab[TAILLE(tab) - 1 - i] <- temp
FIN POUR
POUR i DE 0 A 5 FAIRE AFFICHER tab[i] FIN POUR
FIN

Méthode : On échange tab[0] avec tab[N-1], tab[1] avec tab[N-2], etc. jusqu'au
milieu du tableau.

184
Chapitre 9 : Tableaux à une dimension

Exercice 9.7 (Moyen)

Palindrome : Vérifier si un tableau de caractères forme un palindrome (lu

identiquement dans les deux sens, ex: [R, A, D, A, R]).

ALGORITHME Palindrome
tab : TABLEAU[5] DE CARACTERE
i : ENTIER; estPalindrome : BOOLEEN
DÉBUT
POUR i DE 0 A 4 FAIRE LIRE tab[i] FIN POUR
estPalindrome <- VRAI
POUR i DE 0 A 2 FAIRE
SI tab[i] <> tab[4 - i] ALORS
estPalindrome <- FAUX
FIN SI
FIN POUR
AFFICHER "Palindrome : ", estPalindrome
FIN

185
Chapitre 9 : Tableaux à une dimension

Exercice 9.8 (Moyen)

Décalage circulaire : Effectuer un décalage circulaire à droite d'un tableau (le

dernier élément passe en première position).

ALGORITHME Decalage_Circulaire
tab : TABLEAU[6] DE ENTIER
i, dernier : ENTIER
DÉBUT
POUR i DE 0 A 5 FAIRE LIRE tab[i] FIN POUR
dernier <- tab[TAILLE(tab) - 1]
POUR i DE TAILLE(tab) - 1 A 1 (PAS -1) FAIRE
tab[i] <- tab[i - 1]
FIN POUR
tab[0] <- dernier
POUR i DE 0 A 5 FAIRE AFFICHER tab[i] FIN POUR
FIN

186
Chapitre 9 : Tableaux à une dimension

Exercice 9.9 (Moyen)

Fusion de deux tableaux triés : Deux tableaux triés A et B de tailles différentes.

Créer un tableau C fusionné et trié.

ALGORITHME Fusion
A : TABLEAU[4] DE ENTIER <- [1, 3, 5, 7]
B : TABLEAU[3] DE ENTIER <- [2, 4, 6]
C : TABLEAU[7] DE ENTIER
i, j, k : ENTIER
DÉBUT
i <- 0; j <- 0; k <- 0
TANT QUE i < TAILLE(A) ET j < TAILLE(B) FAIRE
SI A[i] < B[j] ALORS
C[k] <- A[i]; i <- i + 1
SINON
C[k] <- B[j]; j <- j + 1
FIN SI
k <- k + 1
FIN TANT QUE
// Copier le reste
TANT QUE i < TAILLE(A) FAIRE C[k] <- A[i]; i <- i+1; k <-
k+1 FIN TANT QUE
TANT QUE j < TAILLE(B) FAIRE C[k] <- B[j]; j <- j+1; k <-
k+1 FIN TANT QUE
POUR k DE 0 A 6 FAIRE AFFICHER C[k] FIN POUR
FIN

187
Chapitre 9 : Tableaux à une dimension

Exercice 9.10 (Difficile)

Tri par sélection : Trier un tableau par ordre croissant par la méthode du tri par
sélection (chercher le min, le placer au début, recommencer).

ALGORITHME Tri_Selection
tab : TABLEAU[6] DE ENTIER
i, j, minIndex, temp : ENTIER
DÉBUT
POUR i DE 0 A 5 FAIRE LIRE tab[i] FIN POUR

POUR i DE 0 A TAILLE(tab) - 2 FAIRE

minIndex <- i
POUR j DE i + 1 A TAILLE(tab) - 1 FAIRE
SI tab[j] < tab[minIndex] ALORS minIndex <- j FIN
SI
FIN POUR
// Échanger
temp <- tab[i]
tab[i] <- tab[minIndex]
tab[minIndex] <- temp
FIN POUR

POUR i DE 0 A 5 FAIRE AFFICHER tab[i] FIN POUR

FIN

Python :

tab = [int(input()) for _ in range(6)]

for i in range(len(tab)-1):
min_idx = i
for j in range(i+1, len(tab)):
if tab[j] < tab[min_idx]:
min_idx = j
tab[i], tab[min_idx] = tab[min_idx], tab[i]
print(tab)

188
Chapitre 9 : Tableaux à une dimension

Exercice 9.11 (Mini-projet)

Gestion des notes d'une classe : Tableau de 20 notes. Menu : 1=Saisir, 2=Afficher,
3=Moyenne, 4=Max/Min, 5=Nombre au-dessus de 10, 6=Trier, 7=Quitter.

ALGORITHME Gestion_Notes
notes : TABLEAU[20] DE REEL
choix, i, compteur : ENTIER
somme, moy : REEL
DÉBUT
REPETER
AFFICHER "\[Link] [Link] [Link] [Link] 5>10
[Link] [Link]"
AFFICHER "Choix : " ; LIRE choix

choix vaut
1: POUR i DE 0 A 19 FAIRE
AFFICHER "Note ", i+1, " : " ; LIRE notes[i]
FIN POUR
2: POUR i DE 0 A 19 FAIRE AFFICHER notes[i], " "
FIN POUR
3: somme <- 0
POUR i DE 0 A 19 FAIRE somme <- somme + notes[i]
FIN POUR
AFFICHER "Moy : ", somme/20
4: // Max et Min avec leurs indices
// (code similaire à l'exercice 9.3)
5: compteur <- 0
POUR i DE 0 A 19 FAIRE
SI notes[i] >= 10 ALORS compteur <- compteur
+ 1 FIN SI
FIN POUR
AFFICHER compteur, " élèves ont la moyenne"
6: // Tri par sélection
// (code similaire à l'exercice 9.10)
7: AFFICHER "Au revoir"
SINON: AFFICHER "Choix invalide"
JUSQU'A choix = 7
FIN

189
Chapitre 9 : Tableaux à une dimension

Exercice 9.12 (Mini-projet - Difficile)

Analyse statistique complète : Tableau de N températures. Calculer : moyenne,

∑(xi −ˉx)2
médiane (après tri), écart-type (σ = ), température min, max, et
​

N ​ ​

histogramme simplifié (étoiles par tranche de 5 degrés).

190
Chapitre 9 : Tableaux à une dimension

ALGORITHME Statistiques_Temperatures
tab : TABLEAU[20] DE REEL
i, j, minIdx : ENTIER
somme, moy, variance, ecartType : REEL
temp : REEL
DÉBUT
// Saisie
POUR i DE 0 A 19 FAIRE
AFFICHER "Temp ", i+1, " : " ; LIRE tab[i]
FIN POUR
N <- TAILLE(tab)

// Moyenne
somme <- 0
POUR i DE 0 A N-1 FAIRE somme <- somme + tab[i] FIN POUR
moy <- somme / N

// Tri pour médiane

POUR i DE 0 A N-2 FAIRE
minIdx <- i
POUR j DE i+1 A N-1 FAIRE
SI tab[j] < tab[minIdx] ALORS minIdx <- j FIN SI
FIN POUR
temp <- tab[i]; tab[i] <- tab[minIdx]; tab[minIdx] <-
temp
FIN POUR

// Médiane
med <- (tab[N DIV 2 - 1] + tab[N DIV 2]) / 2 // pour N
pair

// Ecart-type
variance <- 0
POUR i DE 0 A N-1 FAIRE
variance <- variance + (tab[i] - moy) * (tab[i] - moy)
FIN POUR
variance <- variance / N
ecartType <- RACINE(variance)

AFFICHER "Moy : ", moy

AFFICHER "Med : ", med
AFFICHER "Ecart-type : ", ecartType
AFFICHER "Min : ", tab[0], " Max : ", tab[N-1]
FIN

191
Chapitre 9 : Tableaux à une dimension

Python :

import math

temps = [float(input(f"Temp {i+1}: ")) for i in range(20)]

moy = sum(temps) / len(temps)
variance = sum((t - moy)**2 for t in temps) / len(temps)
ecart = [Link](variance)
[Link]()
med = (temps[9] + temps[10]) / 2

print(f"Moy={moy:.2f} Med={med:.2f} Ecart={ecart:.2f}")

print(f"Min={temps[0]} Max={temps[-1]}")

# Histogramme par tranches de 5

for base in range(0, 36, 5):
compte = sum(1 for t in temps if base <= t < base+5)
print(f"{base:2d}-{base+4:2d}: {'*' * compte}")

Validation du Chapitre 9

Super ! Les tableaux sont maîtrisés ! Vérifiez :

Déclaration, accès par indice

Boucle de parcours : POUR i DE 0 A TAILLE-1

Remplissage, affichage, somme, moyenne

Recherche, maximum, minimum

Inversion, tri par sélection

Écrivez "Chapitre suivant" pour valider et passer au Chapitre 10.

192
Chapitre 10 : Chaînes de caractères

Chapitre 10 : Chaînes de caractères

CHAPITRE 10

Chaînes de caractères

10.1 Définition simple et intuitive

DÉFINITION

Une chaîne de caractères est une séquence ordonnée de caractères. C'est le

type informatique qui représente du texte : un mot, une phrase, un paragraphe.
Chaque caractère a une position (indice) dans la chaîne, comme dans un tableau à
une dimension de caractères.

10.2 Objectif

OBJECTIFS

Manipuler les chaînes : concaténation, extraction, longueur

Parcourir une chaîne caractère par caractère

Rechercher un caractère ou une sous-chaîne

Comparer des chaînes

Transformer des chaînes (majuscules/minuscules, inversion)

193
Chapitre 10 : Chaînes de caractères

10.3 Exemple concret

L'IMMATRICULATION D'UNE VOITURE

Une plaque d'immatriculation comme "AB-123-CD" est une chaîne :

Longueur : 9 caractères (AB-123-CD)

Extraction : les lettres (AB, CD) et les chiffres (123)

Concaténation : "AB" + "-" + "123" + "-" + "CD" = "AB-123-CD"

Comparaison : "AB-123-CD" est différent de "AB-124-CD"

10.4 Explication détaillée

10.4.1 Représentation d'une chaîne

Chaîne : message <- "Bonjour"

Indice : 0 1 2 3 4 5 6
+------+------+------+------+------+------+------+
| 'B' | 'o' | 'n' | 'j' | 'o' | 'u' | 'r' |
+------+------+------+------+------+------+------+

LONGUEUR(message) = 7
CARACTERE_A(message, 0) = 'B'
CARACTERE_A(message, 3) = 'j'
SOUS_CHAINE(message, 0, 3) = "Bon" (indice 0, longueur 3)
SOUS_CHAINE(message, 3, 4) = "jour" (indice 3, longueur 4)

10.4.2 Opérations sur les chaînes

Tableau 10.1 : Opérations sur chaînes

Opération Syntaxe Exemple Résultat

Longueur LONGUEUR(ch) LONGUEUR("Bonjour") 7

194
Chapitre 10 : Chaînes de caractères

Accès caractère CARACTERE_A(ch, i) CARACTERE_A("Bonjour", 0) 'B'

Sous-chaîne SOUS_CHAINE(ch, d, l) SOUS_CHAINE("Bonjour", 1, 2) "on"

Concaténation ch1 + ch2 "Bon" + "jour" "Bonjour"

Recherche POSITION(ch, sous) POSITION("Bonjour", "jo") 3

10.5 Pseudo-code

195
Chapitre 10 : Chaînes de caractères

ALGORITHME 10.1 : MANIPULATION DE CHAÎNES

ALGORITHME Chaines_Demo
VARIABLES
prenom, nom, complet : CHAINE
i, nbVoyelles : ENTIER
c : CARACTERE
inverse : CHAINE
DÉBUT
// Concaténation
prenom <- "Alice"
nom <- "DUPONT"
complet <- prenom + " " + nom // "Alice DUPONT"
AFFICHER complet

// Longueur
AFFICHER "Longueur : ", LONGUEUR(complet)

// Parcours et comptage
nbVoyelles <- 0
POUR i DE 0 A LONGUEUR(complet) - 1 FAIRE
c <- CARACTERE_A(complet, i)
SI c = 'a' OU c = 'e' OU c = 'i' OU c = 'o' OU c = 'u' OU
c = 'A' OU c = 'E' OU c = 'I' OU c = 'O' OU c = 'U'
ALORS
nbVoyelles <- nbVoyelles + 1
FIN SI
FIN POUR
AFFICHER "Voyelles : ", nbVoyelles

// Inversion
inverse <- ""
POUR i DE LONGUEUR(complet) - 1 A 0 (PAS -1) FAIRE
inverse <- inverse + CARACTERE_A(complet, i)
FIN POUR
AFFICHER "Inversé : ", inverse // "TNOPUD ecilA"
FIN

10.6 Exécution pas à pas (comptage de voyelles)

196
Chapitre 10 : Chaînes de caractères

Chaîne = "Alice" :

i c Voyelle ? nbVoyelles

0 'A' OUI 1

1 'l' non 1

2 'i' OUI 2

3 'c' non 2

4 'e' OUI 3

10.7 Erreurs fréquentes

ERREURS À ÉVITER

Débordement d'indice : Dernier caractère = indice LONGUEUR - 1 , pas

LONGUEUR .

Confondre CARACTERE et CHAINE : 'A' (caractère, apostrophe) vs "A"

(chaîne, guillemets).

Modification d'une chaîne caractère par caractère : En pseudo-code

classique, les chaînes sont immuables. Il faut reconstruire.

Comparaison avec = : "abc" = "ABC" est FAUX car la casse compte.

10.8 Résumé

197
Chapitre 10 : Chaînes de caractères

POINTS CLÉS

Une chaîne est une séquence de caractères indexée de 0 à LONGUEUR-1

LONGUEUR(ch) , CARACTERE_A(ch, i) , SOUS_CHAINE(ch, debut, longueur)

Concaténation : +

Parcours avec POUR pour analyser chaque caractère

Pour modifier : reconstruire une nouvelle chaîne

Exercices du Chapitre 10

Exercice 10.1 (Très facile)

Longueur et concaténation : Lire prénom et nom. Afficher le nom complet et sa

longueur.

ALGORITHME NomComplet
prenom, nom : CHAINE
DÉBUT
AFFICHER "Prénom : " ; LIRE prenom
AFFICHER "Nom : " ; LIRE nom
AFFICHER "Complet : ", prenom + " " + nom
AFFICHER "Longueur : ", LONGUEUR(prenom + " " + nom)
FIN

198
Chapitre 10 : Chaînes de caractères

Exercice 10.2 (Très facile)

Initialles : Lire prénom et nom. Afficher les initiales.

ALGORITHME Initialles
prenom, nom : CHAINE
DÉBUT
LIRE prenom ; LIRE nom
AFFICHER CARACTERE_A(prenom, 0), CARACTERE_A(nom, 0)
FIN

Exercice 10.3 (Facile)

Comptage de voyelles : Lire une chaîne. Compter et afficher le nombre de voyelles.

ALGORITHME CompterVoyelles
ch : CHAINE; i, compteur : ENTIER; c : CARACTERE
DÉBUT
AFFICHER "Texte : " ; LIRE ch
compteur <- 0
POUR i DE 0 A LONGUEUR(ch) - 1 FAIRE
c <- CARACTERE_A(ch, i)
SI c DANS "aeiouAEIOU" ALORS compteur <- compteur + 1
FIN SI
FIN POUR
AFFICHER "Voyelles : ", compteur
FIN

199
Chapitre 10 : Chaînes de caractères

Exercice 10.4 (Facile)

Inverser une chaîne : Lire une chaîne et l'afficher à l'envers.

ALGORITHME InverserChaine
ch, inv : CHAINE; i : ENTIER
DÉBUT
AFFICHER "Texte : " ; LIRE ch
inv <- ""
POUR i DE LONGUEUR(ch) - 1 A 0 (PAS -1) FAIRE
inv <- inv + CARACTERE_A(ch, i)
FIN POUR
AFFICHER "Inversé : ", inv
FIN

Python : print(input("Texte : ")[::-1])

200
Chapitre 10 : Chaînes de caractères

Exercice 10.5 (Facile)

Vérifier palindrome : Lire un mot. Déterminer s'il se lit identiquement dans les
deux sens (radar, kayak).

ALGORITHME Palindrome
ch : CHAINE; i : ENTIER; estPal : BOOLEEN
DÉBUT
AFFICHER "Mot : " ; LIRE ch
estPal <- VRAI
POUR i DE 0 A LONGUEUR(ch) DIV 2 - 1 FAIRE
SI CARACTERE_A(ch, i) <> CARACTERE_A(ch,
LONGUEUR(ch)-1-i) ALORS
estPal <- FAUX
FIN SI
FIN POUR
AFFICHER "Palindrome : ", estPal
FIN

201
Chapitre 10 : Chaînes de caractères

Exercice 10.6 (Moyen)

Remplacer un caractère : Lire une chaîne, un caractère à remplacer et un

caractère de remplacement. Construire la nouvelle chaîne.

ALGORITHME Remplacer
ch, resultat : CHAINE; ancien, nouveau : CARACTERE
i : ENTIER; c : CARACTERE
DÉBUT
AFFICHER "Chaîne : " ; LIRE ch
AFFICHER "Ancien : " ; LIRE ancien
AFFICHER "Nouveau : " ; LIRE nouveau
resultat <- ""
POUR i DE 0 A LONGUEUR(ch) - 1 FAIRE
c <- CARACTERE_A(ch, i)
SI c = ancien ALORS
resultat <- resultat + nouveau
SINON
resultat <- resultat + c
FIN SI
FIN POUR
AFFICHER "Résultat : ", resultat
FIN

202
Chapitre 10 : Chaînes de caractères

Exercice 10.7 (Moyen)

Compter les mots : Lire une phrase. Compter le nombre de mots (séparés par des
espaces).

ALGORITHME CompterMots
phrase : CHAINE; i, compteur : ENTIER
DÉBUT
AFFICHER "Phrase : " ; LIRE phrase
compteur <- 1
POUR i DE 0 A LONGUEUR(phrase) - 1 FAIRE
SI CARACTERE_A(phrase, i) = ' ' ALORS
compteur <- compteur + 1
FIN SI
FIN POUR
AFFICHER "Mots : ", compteur
FIN

Astuce : On suppose qu'il n'y a pas d'espaces consécutifs ni aux extrémités.

Pour être robuste, il faudrait gérer ces cas.

203
Chapitre 10 : Chaînes de caractères

Exercice 10.8 (Moyen)

Extraire les chiffres : Lire une chaîne alphanumérique. Extraire et afficher

uniquement les chiffres qu'elle contient.

ALGORITHME ExtraireChiffres
ch, resultat : CHAINE; i : ENTIER; c : CARACTERE
DÉBUT
AFFICHER "Texte : " ; LIRE ch
resultat <- ""
POUR i DE 0 A LONGUEUR(ch) - 1 FAIRE
c <- CARACTERE_A(ch, i)
SI c >= '0' ET c <= '9' ALORS
resultat <- resultat + c
FIN SI
FIN POUR
AFFICHER "Chiffres : ", resultat
FIN

204
Chapitre 10 : Chaînes de caractères

Exercice 10.9 (Moyen)

Formatage de nom : Lire un nom complet en minuscules (ex: "jean dupont"). Le

transformer en format titre : "Jean Dupont" (première lettre de chaque mot en
majuscule).

ALGORITHME FormaterNom
ch, resultat : CHAINE; i : ENTIER; c : CARACTERE
majusculeSuivante : BOOLEEN
DÉBUT
AFFICHER "Nom : " ; LIRE ch
resultat <- ""
majusculeSuivante <- VRAI
POUR i DE 0 A LONGUEUR(ch) - 1 FAIRE
c <- CARACTERE_A(ch, i)
SI majusculeSuivante ET c >= 'a' ET c <= 'z' ALORS
// Convertir en majuscule (ASCII)
c <- CARACTERE_A("ABCDEFGHIJKLMNOPQRSTUVWXYZ",
CONVERTIR_ENTIER(c) -
CONVERTIR_ENTIER('a'))
majusculeSuivante <- FAUX
SINON SI c = ' ' ALORS
majusculeSuivante <- VRAI
FIN SI
resultat <- resultat + c
FIN POUR
AFFICHER "Formaté : ", resultat
FIN

Python : print(input("Nom : ").title())

205
Chapitre 10 : Chaînes de caractères

Exercice 10.10 (Difficile)

Valider un email simple : Vérifier qu'une chaîne contient exactement un @ et au

moins un point après le @.

ALGORITHME ValiderEmail
email : CHAINE; i, arobase, pointApres : ENTIER
valide : BOOLEEN
DÉBUT
AFFICHER "Email : " ; LIRE email
arobase <- 0; pointApres <- 0
POUR i DE 0 A LONGUEUR(email) - 1 FAURE
SI CARACTERE_A(email, i) = '@' ALORS
arobase <- arobase + 1
SINON SI arobase = 1 ET CARACTERE_A(email, i) = '.'
ALORS
pointApres <- pointApres + 1
FIN SI
FIN POUR
valide <- (arobase = 1) ET (pointApres >= 1)
AFFICHER "Valide : ", valide
FIN

206
Chapitre 10 : Chaînes de caractères

Exercice 10.11 (Mini-projet)

Codage de César : Lire un texte et un décalage. Chiffrer le texte en décalant chaque

lettre (A+3=D, Z+3=C). Ne chiffrer que les lettres.

ALGORITHME CodeCesar
texte, chiffre : CHAINE; decalage, i, pos : ENTIER
c : CARACTERE
DÉBUT
AFFICHER "Texte : " ; LIRE texte
AFFICHER "Décalage : " ; LIRE decalage
chiffre <- ""
POUR i DE 0 A LONGUEUR(texte) - 1 FAIRE
c <- CARACTERE_A(texte, i)
SI c >= 'a' ET c <= 'z' ALORS
pos <- (CONVERTIR_ENTIER(c) - CONVERTIR_ENTIER('a')
+ decalage) MOD 26
c <- CARACTERE_A("abcdefghijklmnopqrstuvwxyz", pos
+ 1)
SINON SI c >= 'A' ET c <= 'Z' ALORS
pos <- (CONVERTIR_ENTIER(c) - CONVERTIR_ENTIER('A')
+ decalage) MOD 26
c <- CARACTERE_A("ABCDEFGHIJKLMNOPQRSTUVWXYZ", pos
+ 1)
FIN SI
chiffre <- chiffre + c
FIN POUR
AFFICHER "Chiffré : ", chiffre
FIN

Python :

207
Chapitre 10 : Chaînes de caractères

def cesar(texte, decalage):

resultat = ""
for c in texte:
if 'a' <= c <= 'z':
resultat += chr((ord(c) - ord('a') + decalage) % 26 +
ord('a'))
elif 'A' <= c <= 'Z':
resultat += chr((ord(c) - ord('A') + decalage) % 26 +
ord('A'))
else:
resultat += c
return resultat

print(cesar(input("Texte : "), int(input("Decalage : "))))

208
Chapitre 10 : Chaînes de caractères

Exercice 10.12 (Mini-projet - Difficile)

Analyse fréquentielle : Lire un texte. Compter la fréquence de chaque lettre de

l'alphabet (tableau de compteurs). Afficher les résultats sous forme d'histogramme
horizontal (étoiles proportionnelles aux fréquences relatives).

209
Chapitre 10 : Chaînes de caractères

ALGORITHME FrequenceLettres
texte : CHAINE
frequences : TABLEAU[26] DE ENTIER // a=0, b=1, ..., z=25
i, total, maxFreq, echelle : ENTIER
c : CARACTERE; ligne : CHAINE
DÉBUT
AFFICHER "Texte : " ; LIRE texte

// Initialiser à 0
POUR i DE 0 A 25 FAIRE frequences[i] <- 0 FIN POUR

// Compter
total <- 0
POUR i DE 0 A LONGUEUR(texte) - 1 FAIRE
c <- CARACTERE_A(texte, i)
SI c >= 'a' ET c <= 'z' ALORS
frequences[CONVERTIR_ENTIER(c) -
CONVERTIR_ENTIER('a')] <-
frequences[CONVERTIR_ENTIER(c) -
CONVERTIR_ENTIER('a')] + 1
total <- total + 1
SINON SI c >= 'A' ET c <= 'Z' ALORS
frequences[CONVERTIR_ENTIER(c) -
CONVERTIR_ENTIER('A')] <-
frequences[CONVERTIR_ENTIER(c) -
CONVERTIR_ENTIER('A')] + 1
total <- total + 1
FIN SI
FIN POUR

// Afficher histogramme
AFFICHER "\n=== FRÉQUENCES === (total lettres : ", total,
")"
POUR i DE 0 A 25 FAIRE
c <- CARACTERE_A("abcdefghijklmnopqrstuvwxyz", i + 1)
AFFICHER c, " : ", frequences[i], " "
POUR j DE 1 A frequences[i] FAIRE
AFFICHER_SANS_RETOUR "*"
FIN POUR
AFFICHER ""
FIN POUR
FIN

210
Chapitre 10 : Chaînes de caractères

Python :

texte = input("Texte : ").lower()

freq = [0] * 26
total = 0
for c in texte:
if 'a' <= c <= 'z':
freq[ord(c) - ord('a')] += 1
total += 1

print(f"\nFrequences (total : {total}):")

for i in range(26):
lettre = chr(ord('a') + i)
print(f"{lettre} : {freq[i]:4d} {'*' * freq[i]}")

Méthode : Un tableau de 26 cases sert de compteur pour chaque lettre. On

calcule l'indice par code_ASCII(lettre) - code_ASCII('a') . L'histogramme
utilise une boucle interne pour les étoiles.

Validation du Chapitre 10

Génial ! Les chaînes sont maîtrisées ! Vérifiez :

Accès par indice, longueur, sous-chaîne

Parcours caractère par caractère

Concaténation et construction

Comparaison et recherche

Algorithmes : palindrome, César, fréquences

Écrivez "Chapitre suivant" pour valider et passer au Chapitre 11.

211
Chapitre 11 : Recherche séquentielle

Chapitre 11 : Recherche séquentielle

CHAPITRE 11

Recherche séquentielle

11.1 Définition simple et intuitive

DÉFINITION

La recherche séquentielle (ou recherche linéaire) est l'algorithme le plus simple

pour trouver un élément dans un tableau : on examine chaque élément un par
un, du premier au dernier, jusqu'à trouver l'élément cherché ou arriver à la fin du
tableau. C'est comme chercher un mot dans un dictionnaire en feuilletant page par
page depuis le début.

11.2 Objectif

212
Chapitre 11 : Recherche séquentielle

OBJECTIFS

Comprendre le principe de la recherche séquentielle

Implémenter la recherche dans un tableau

Analyser la complexité (nombre d'opérations)

Distinguer recherche dans tableau trié et non trié

Comprendre les notions de cas optimal, moyen et pire cas

11.3 Exemple concret

CHERCHER UN LIVRE SUR UNE ÉTAGÈRE

Vous cherchez le livre "Algorithmique" sur une étagère de 50 livres non classés :

Vous prenez le 1er livre : ce n'est pas le bon → vous passez au suivant

Vous prenez le 2e livre : ce n'est pas le bon → vous passez au suivant

... et ainsi de suite jusqu'à trouver "Algorithmique" ou à avoir tout vérifié

Dans le meilleur cas, le livre est en 1re position (1 comparaison). Dans le pire cas,
il est en dernière position ou absent (50 comparaisons). En moyenne, il faut
environ 25 comparaisons.

11.4 Explication détaillée

11.4.1 Principe de l'algorithme

213
Chapitre 11 : Recherche séquentielle

RECHERCHE SÉQUENTIELLE DE x DANS tab[0..N-1]

Étape 0 : x=42, tab=[12, 7, 42, 5, 19], N=5

i=0 i=1 i=2 i=3 i=4

+-----+ +-----+ +-----+ +-----+ +-----+
| 12 | | 7 | | 42 | | 5 | | 19 |
+-----+ +-----+ +-----+ +-----+ +-----+
|
tab[0]=12 <> 42 --> avancer
|
tab[1]=7 <> 42 --> avancer
|
tab[2]=42 = 42 --> TROUVÉ !

Résultat : trouvé à l'indice 2, 3 comparaisons effectuées.

11.4.2 Algorithme et complexité

Tableau 11.1 : Complexité de la recherche séquentielle

Cas Nombre de comparaisons Exemple

Meilleur cas 1 L'élément est en première position

Cas moyen N/2 L'élément est au milieu (en moyenne)

Pire cas N L'élément est en dernière position ou absent

11.5 Pseudo-code

214
Chapitre 11 : Recherche séquentielle

ALGORITHME 11.1 : RECHERCHE SÉQUENTIELLE

215
Chapitre 11 : Recherche séquentielle

// Version 1 : retourne l'indice ou -1

FONCTION rechercheSequentielle(tab : TABLEAU[] DE ENTIER,
x : ENTIER) : ENTIER
VARIABLES i : ENTIER
POUR i DE 0 A TAILLE(tab) - 1 FAIRE
SI tab[i] = x ALORS
RETOURNE i // Trouvé ! On retourne l'indice
FIN SI
FIN POUR
RETOURNE -1 // Non trouvé
FIN FONCTION

// Version 2 : retourne un booléen

FONCTION contient(tab : TABLEAU[] DE ENTIER,
x : ENTIER) : BOOLEEN
VARIABLES i : ENTIER
POUR i DE 0 A TAILLE(tab) - 1 FAIRE
SI tab[i] = x ALORS RETOURNE VRAI FIN SI
FIN POUR
RETOURNE FAUX
FIN FONCTION

// Version 3 : compte les occurrences

FONCTION compterOccurrences(tab : TABLEAU[] DE ENTIER,
x : ENTIER) : ENTIER
VARIABLES i, compteur : ENTIER
compteur <- 0
POUR i DE 0 A TAILLE(tab) - 1 FAIRE
SI tab[i] = x ALORS compteur <- compteur + 1 FIN SI
FIN POUR
RETOURNE compteur
FIN FONCTION

// Version 4 : dans un tableau trié (optimisation)

FONCTION rechercheTriee(tab : TABLEAU[] DE ENTIER,
x : ENTIER) : ENTIER
VARIABLES i : ENTIER
POUR i DE 0 A TAILLE(tab) - 1 FAIRE
SI tab[i] = x ALORS RETOURNE i
SINON SI tab[i] > x ALORS RETOURNE -1 // Optimisation !
FIN SI
FIN POUR
RETOURNE -1
FIN FONCTION

216
Chapitre 11 : Recherche séquentielle

11.6 Exécution pas à pas

Recherche de x=7 dans tab=[3, 7, 1, 9, 7] :

Étape i tab[i] tab[i] = x ? Action

1 0 3 FAUX Continuer

2 1 7 VRAI Retourner 1

11.7 Erreurs fréquentes

ERREURS À ÉVITER

Oublier de traiter le cas "non trouvé" : Toujours retourner une valeur

spéciale (-1) si l'élément n'est pas dans le tableau.

Boucle qui dépasse les bornes : POUR i DE 0 A TAILLE(tab) est faux

(débordement).

Retourner l'élément au lieu de l'indice : La fonction retourne la position,

pas la valeur.

Continuer après avoir trouvé : Utiliser RETOURNE ou break pour sortir dès
qu'on trouve.

11.8 Résumé

217
Chapitre 11 : Recherche séquentielle

POINTS CLÉS

Recherche séquentielle = examiner chaque élément dans l'ordre

Fonctionne sur tableau trié ou non trié

Complexité : O(N) dans le pire cas, O(1) dans le meilleur cas

Optimisation sur tableau trié : arrêter si tab[i] > x

Variantes : recherche booléenne, comptage d'occurrences

Exercices du Chapitre 11

Exercice 11.1 (Très facile)

Recherche basique : Écrivez une fonction qui recherche un entier x dans un

tableau et retourne son indice ou -1.

FONCTION recherche(tab : TABLEAU[] DE ENTIER, x : ENTIER) : ENTIER

i : ENTIER
POUR i DE 0 A TAILLE(tab) - 1 FAIRE
SI tab[i] = x ALORS RETOURNE i FIN SI
FIN POUR
RETOURNE -1
FIN FONCTION

218
Chapitre 11 : Recherche séquentielle

Exercice 11.2 (Très facile)

Présence : Écrivez une fonction booléenne qui dit si un élément est présent.

FONCTION contient(tab : TABLEAU[] DE ENTIER, x : ENTIER) : BOOLEEN

i : ENTIER
POUR i DE 0 A TAILLE(tab) - 1 FAIRE
SI tab[i] = x ALORS RETOURNE VRAI FIN SI
FIN POUR
RETOURNE FAUX
FIN FONCTION

Exercice 11.3 (Facile)

Occurrences : Compter combien de fois x apparaît dans le tableau.

FONCTION compter(tab : TABLEAU[] DE ENTIER, x : ENTIER) : ENTIER

i, cpt : ENTIER; cpt <- 0
POUR i DE 0 A TAILLE(tab) - 1 FAIRE
SI tab[i] = x ALORS cpt <- cpt + 1 FIN SI
FIN POUR
RETOURNE cpt
FIN FONCTION

219
Chapitre 11 : Recherche séquentielle

Exercice 11.4 (Facile)

Dernier indice : Retourner le dernier indice où x apparaît, ou -1.

FONCTION dernierIndice(tab : TABLEAU[] DE ENTIER, x : ENTIER) :

ENTIER
i, resultat : ENTIER; resultat <- -1
POUR i DE 0 A TAILLE(tab) - 1 FAIRE
SI tab[i] = x ALORS resultat <- i FIN SI
FIN POUR
RETOURNE resultat
FIN FONCTION

Exercice 11.5 (Facile)

Tous les indices : Afficher tous les indices où x apparaît.

PROCEDURE tousLesIndices(tab : TABLEAU[] DE ENTIER, x : ENTIER)

i : ENTIER
AFFICHER "Indices : "
POUR i DE 0 A TAILLE(tab) - 1 FAIRE
SI tab[i] = x ALORS AFFICHER i, " " FIN SI
FIN POUR
FIN PROCEDURE

220
Chapitre 11 : Recherche séquentielle

Exercice 11.6 (Moyen)

Recherche dans tableau trié : Améliorer la recherche en s'arrêtant dès que tab[i] >
x.

FONCTION rechercheTriee(tab : TABLEAU[] DE ENTIER, x : ENTIER) :

ENTIER
i : ENTIER
POUR i DE 0 A TAILLE(tab) - 1 FAIRE
SI tab[i] = x ALORS RETOURNE i
SINON SI tab[i] > x ALORS RETOURNE -1
FIN SI
FIN POUR
RETOURNE -1
FIN FONCTION

Avantage : Dans un tableau trié, on peut s'arrêter précocement si on dépasse la

valeur cherchée.

221
Chapitre 11 : Recherche séquentielle

Exercice 11.7 (Moyen)

Minimum et sa position : Trouver la valeur minimum et tous ses indices

d'apparition.

ALGORITHME MinEtPositions
tab : TABLEAU[8] DE ENTIER; i, minVal : ENTIER
DÉBUT
POUR i DE 0 A 7 FAIRE LIRE tab[i] FIN POUR
minVal <- tab[0]
POUR i DE 1 A 7 FAIRE
SI tab[i] < minVal ALORS minVal <- tab[i] FIN SI
FIN POUR
AFFICHER "Min : ", minVal, " aux indices : "
POUR i DE 0 A 7 FAIRE
SI tab[i] = minVal ALORS AFFICHER i, " " FIN SI
FIN POUR
FIN

Exercice 11.8 (Moyen)

Analyse de complexité : Sur un tableau de 1000 éléments, combien de

comparaisons en moyenne pour la recherche séquentielle ? Et si le tableau est trié
et l'élément absent mais proche du début ?

Correction

Non trié, élément présent : en moyenne N/2 = 500 comparaisons

Non trié, élément absent : N = 1000 comparaisons (pire cas)

Trié, élément absent mais petit : peu de comparaisons grâce à

l'optimisation (arrêt dès tab[i] > x). Par exemple si x est plus petit que
tab[0], une seule comparaison suffit.

222
Chapitre 11 : Recherche séquentielle

Exercice 11.9 (Moyen)

Supprimer toutes les occurrences : Construire un nouveau tableau sans les

occurrences de x.

ALGORITHME SupprimerOccurrences
tab : TABLEAU[10] DE ENTIER
resultat : TABLEAU[10] DE ENTIER
x, i, j : ENTIER
DÉBUT
POUR i DE 0 A 9 FAIRE LIRE tab[i] FIN POUR
AFFICHER "x à supprimer : " ; LIRE x
j <- 0
POUR i DE 0 A 9 FAIRE
SI tab[i] <> x ALORS
resultat[j] <- tab[i]
j <- j + 1
FIN SI
FIN POUR
AFFICHER "Résultat (", j, " éléments) : "
POUR i DE 0 A j - 1 FAIRE AFFICHER resultat[i], " " FIN
POUR
FIN

223
Chapitre 11 : Recherche séquentielle

Exercice 11.10 (Difficile)

Recherche avec sentinelle : Optimiser la recherche en ajoutant x à la fin du

tableau (sentinelle) pour éviter le test de fin de boucle.

FONCTION rechercheSentinelle(tab : TABLEAU[] DE ENTIER,

x : ENTIER) : ENTIER
// Précondition : tab a une case supplémentaire pour la
sentinelle
i, dernier : ENTIER
dernier <- tab[TAILLE(tab) - 2] // Sauver dernier élément réel
tab[TAILLE(tab) - 2] <- x // Placer la sentinelle
i <- 0
TANT QUE tab[i] <> x FAIRE
i <- i + 1
FIN TANT QUE
tab[TAILLE(tab) - 2] <- dernier // Restaurer
SI i < TAILLE(tab) - 2 ALORS RETOURNE i SINON RETOURNE -1 FIN
SI
FIN FONCTION

Principe : La sentinelle garantit que la boucle s'arrête. On économise le test i

< TAILLE à chaque itération.

224
Chapitre 11 : Recherche séquentielle

Exercice 11.11 (Mini-projet)

Comparaison empirique : Créer un tableau de 10000 entiers aléatoires. Mesurer

(en nombre de comparaisons) la recherche séquentielle standard vs avec sentinelle
vs sur tableau trié. Tester avec élément présent au début, au milieu, à la fin, et
absent.

ALGORITHME Comparaison
tab : TABLEAU[10000] DE ENTIER
i, cpt1, cpt2, cpt3 : ENTIER
DÉBUT
// Remplissage aléatoire
POUR i DE 0 A 9999 FAIRE
tab[i] <- ALÉATOIRE(0, 100000)
FIN POUR

// Recherche standard de 42
cpt1 <- 0
POUR i DE 0 A 9999 FAIRE
cpt1 <- cpt1 + 1
SI tab[i] = 42 ALORS i <- 99999 FIN SI // sortie
FIN POUR

// Recherche avec sentinelle

// (code similaire)

// Trier puis recherche optimisée

TRIER(tab)
cpt3 <- 0
POUR i DE 0 A 9999 FAIRE
cpt3 <- cpt3 + 1
SI tab[i] = 42 ALORS i <- 99999
SINON SI tab[i] > 42 ALORS i <- 99999 FIN SI
FIN POUR

AFFICHER "Standard : ", cpt1, " comparaisons"

AFFICHER "Optimisée triée : ", cpt3, " comparaisons"
FIN

225
Chapitre 11 : Recherche séquentielle

Exercice 11.12 (Mini-projet - Difficile)

Carnet d'adresses simplifié : Deux tableaux parallèles : noms et téléphones. Menu

: 1=Ajouter, 2=Chercher par nom, 3=Chercher par téléphone, 4=Afficher tout,
5=Supprimer, 6=Quitter. Utiliser la recherche séquentielle pour toutes les
recherches.

226
Chapitre 11 : Recherche séquentielle

ALGORITHME CarnetAdresses
noms : TABLEAU[50] DE CHAINE
telephones : TABLEAU[50] DE CHAINE
nbContacts, choix, i, indice : ENTIER
nom, tel, recherche : CHAINE
trouve : BOOLEEN
DÉBUT
nbContacts <- 0
REPETER
AFFICHER "\[Link] [Link] [Link]
[Link] [Link] [Link]"
AFFICHER "Choix : " ; LIRE choix

choix vaut
1: SI nbContacts < 50 ALORS
AFFICHER "Nom : " ; LIRE noms[nbContacts]
AFFICHER "Tel : " ; LIRE
telephones[nbContacts]
nbContacts <- nbContacts + 1
SINON AFFICHER "Carnet plein !" FIN SI

2: AFFICHER "Nom à chercher : " ; LIRE recherche

trouve <- FAUX
POUR i DE 0 A nbContacts - 1 FAIRE
SI noms[i] = recherche ALORS
AFFICHER teléphones[i]
trouve <- VRAI
FIN SI
FIN POUR
SI NON trouve ALORS AFFICHER "Non trouvé" FIN SI

3: AFFICHER "Tel à chercher : " ; LIRE recherche

trouve <- FAUX
POUR i DE 0 A nbContacts - 1 FAIRE
SI telephones[i] = recherche ALORS
AFFICHER noms[i]
trouve <- VRAI
FIN SI
FIN POUR
SI NON trouve ALORS AFFICHER "Non trouvé" FIN SI

4: POUR i DE 0 A nbContacts - 1 FAIRE

AFFICHER noms[i], " : ", telephones[i]
FIN POUR

5: AFFICHER "Nom à supprimer : " ; LIRE recherche

227
Chapitre 11 : Recherche séquentielle

POUR i DE 0 A nbContacts - 1 FAIRE

SI noms[i] = recherche ALORS indice <- i FIN
SI
FIN POUR
SI indice >= 0 ALORS
POUR i DE indice A nbContacts - 2 FAIRE
noms[i] <- noms[i+1]
telephones[i] <- telephones[i+1]
FIN POUR
nbContacts <- nbContacts - 1
AFFICHER "Supprimé"
SINON AFFICHER "Non trouvé" FIN SI

6: AFFICHER "Au revoir"

SINON: AFFICHER "Choix invalide"
JUSQU'A choix = 6
FIN

Python :

228
Chapitre 11 : Recherche séquentielle

noms = [""] * 50
tels = [""] * 50
nb = 0

while True:
choix = input("\[Link] [Link] [Link] [Link] [Link] [Link]
: ")
if choix == "1" and nb < 50:
noms[nb] = input("Nom : ")
tels[nb] = input("Tel : ")
nb += 1
elif choix == "2":
r = input("Nom : ")
for i in range(nb):
if noms[i] == r: print(tels[i])
elif choix == "3":
r = input("Tel : ")
for i in range(nb):
if tels[i] == r: print(noms[i])
elif choix == "4":
for i in range(nb): print(f"{noms[i]} : {tels[i]}")
elif choix == "5":
r = input("Nom à supprimer : ")
idx = -1
for i in range(nb):
if noms[i] == r: idx = i; break
if idx >= 0:
for i in range(idx, nb-1):
noms[i] = noms[i+1]; tels[i] = tels[i+1]
nb -= 1
elif choix == "6": break

229
Chapitre 11 : Recherche séquentielle

Validation du Chapitre 11

Excellent ! La recherche séquentielle est maîtrisée ! Vérifiez :

Parcours linéaire du tableau

Retour de l'indice ou de -1

Variantes : booléen, comptage, tous les indices

Optimisation sur tableau trié

Complexité O(N)

Écrivez "Chapitre suivant" pour valider et passer au dernier Chapitre 12 !

230
Chapitre 12 : Introduction aux structures de données

Chapitre 12 : Introduction aux structures

de données

CHAPITRE 12

Introduction aux structures de données

12.1 Définition simple et intuitive

DÉFINITION

Une structure de données est une façon d'organiser et de stocker des données
pour faciliter leur accès et leur modification. C'est comme choisir un type de
rangement : une étagère (accès direct), une pile d'assiettes (dernier arrivé premier
servi), ou une file d'attente (premier arrivé premier servi). Le choix de la structure
impacte l'efficacité des opérations.

12.2 Objectif

231
Chapitre 12 : Introduction aux structures de données

OBJECTIFS

Découvrir la notion de structure de données et son importance

Comprendre la structure Pile (LIFO)

Comprendre la structure File (FIFO)

Comprendre la structure Liste chaînée (conceptuel)

Savoir implémenter ces structures avec des tableaux

Choisir la bonne structure selon le problème

12.3 Exemple concret

LA VIE QUOTIDIENNE

Pile (LIFO = Last In First Out) : Une pile d'assiettes. On dépose par le dessus, on
prend par le dessus. La dernière posée est la première prise. Comme le bouton
"Annuler" d'un logiciel.

File (FIFO = First In First Out) : Une file d'attente au supermarché. Le premier
arrivé est le premier servi. Comme une liste d'impression.

Liste chaînée : Une chasse au trésor avec des indices. Chaque indice mène au
suivant. On peut insérer un nouvel indice n'importe où sans déplacer les autres.

12.4 Explication détaillée

12.4.1 La Pile (LIFO)

232
Chapitre 12 : Introduction aux structures de données

OPÉRATIONS SUR UNE PILE

EMPILER (PUSH) 10 :
+-----+
| 10 | <--- sommet
+-----+

EMPILER 20 :
+-----+
| 20 | <--- sommet
+-----+
| 10 |
+-----+

EMPILER 30 :
+-----+
| 30 | <--- sommet
+-----+
| 20 |
+-----+
| 10 |
+-----+

DÉPILER (POP) : retourne 30 (sommet)

+-----+
| 20 | <--- sommet
+-----+
| 10 |
+----+

Accès uniquement par le SOMMET !

Tableau 12.1 : Opérations sur une Pile

Opération Description Exemple (pile ci-dessus)

empiler(x) Ajoute x au sommet empiler(40) → [10, 20, 40]

depiler() Retire et retourne le sommet depiler() → 20, pile = [10]

sommet() Retourne le sommet sans retirer sommet() → 20

estVide() VRAI si la pile est vide FAUX (2 éléments)

taille() Nombre d'éléments 2

12.4.2 La File (FIFO)

233
Chapitre 12 : Introduction aux structures de données

OPÉRATIONS SUR UNE FILE

ENFILER (ENQUEUE) 10 :
Tête Queue
+-----+
| 10 |
+-----+

ENFILER 20 :
Tête Queue
+-----+ +-----+
| 10 |--> | 20 |
+-----+ +----+

ENFILER 30 :
Tête Queue
+-----+ +-----+ +-----+
| 10 |--> | 20 |--> | 30 |
+-----+ +-----+ +-----+

DÉFILER (DEQUEUE) : retourne 10 (tête)

Tête Queue
+-----+ +-----+
| 20 |--> | 30 |
+-----+ +----+

On ajoute en QUEUE, on retire en TÊTE.

12.4.3 Implémentation avec tableau

234
Chapitre 12 : Introduction aux structures de données

ALGORITHME 12.1 : PILE AVEC TABLEAU

// Pile implémentée avec un tableau et un sommet

ALGORITHME Pile
CONST CAPACITE : ENTIER <- 100
pile : TABLEAU[CAPACITE] DE ENTIER
sommet : ENTIER <- -1 // -1 = pile vide

// Empiler
PROCEDURE empiler(x : ENTIER)
SI sommet < CAPACITE - 1 ALORS
sommet <- sommet + 1
pile[sommet] <- x
SINON
AFFICHER "Pile pleine !"
FIN SI
FIN PROCEDURE

// Dépiler
FONCTION depiler() : ENTIER
SI sommet >= 0 ALORS
sommet <- sommet - 1
RETOURNE pile[sommet + 1]
SINON
AFFICHER "Pile vide !"
RETOURNE -1
FIN SI
FIN FONCTION

// Est vide
FONCTION estVide() : BOOLEEN
RETOURNE sommet = -1
FIN FONCTION

DÉBUT
empiler(10); empiler(20); empiler(30)
AFFICHER depiler() // 30
AFFICHER depiler() // 20
AFFICHER sommet() // 10
FIN

235
Chapitre 12 : Introduction aux structures de données

ALGORITHME 12.2 : FILE AVEC TABLEAU CIRCULAIRE

ALGORITHME File
CONST CAPACITE : ENTIER <- 100
file : TABLEAU[CAPACITE] DE ENTIER
tete, queue, nbElements : ENTIER

// Initialisation
tete <- 0; queue <- 0; nbElements <- 0

// Enfiler
PROCEDURE enfiler(x : ENTIER)
SI nbElements < CAPACITE ALORS
file[queue] <- x
queue <- (queue + 1) MOD CAPACITE
nbElements <- nbElements + 1
SINON
AFFICHER "File pleine !"
FIN SI
FIN PROCEDURE

// Défiler
FONCTION defiler() : ENTIER
VARIABLES resultat : ENTIER
SI nbElements > 0 ALORS
resultat <- file[tete]
tete <- (tete + 1) MOD CAPACITE
nbElements <- nbElements - 1
RETOURNE resultat
SINON
AFFICHER "File vide !"
RETOURNE -1
FIN SI
FIN FONCTION

DÉBUT
enfiler(10); enfiler(20); enfiler(30)
AFFICHER defiler() // 10
AFFICHER defiler() // 20
enfiler(40)
AFFICHER defiler() // 30
AFFICHER defiler() // 40
FIN

236
Chapitre 12 : Introduction aux structures de données

12.4.4 Liste chaînée (conceptuelle)

LISTE CHAÎNÉE :

Chaque élément contient : [ donnée | pointeur vers suivant ]

+------+---+ +------+---+ +------+---+ +------+----+

| 10 | --|--> | 20 | --|--> | 30 | --|--> | 40 |NULL|
+------+---+ +------+---+ +------+---+ +------+----+
^
|
tête

Insertion de 25 entre 20 et 30 :
1. Créer nouvel élément : [ 25 | pointeur ]
2. Faire pointer 20 vers 25
3. Faire pointer 25 vers 30

+------+---+ +------+---+ +------+---+ +------+---+ +------+----+

| 10 | --|--> | 20 | --|--> | 25 | --|--> | 30 | --|--> | 40 |NULL|
+------+---+ +------+---+ +------+---+ +------+---+ +------+----+

Avantage : insertion en O(1) si on a le pointeur précédent

Inconvénient : pas d'accès direct par indice

12.4.5 Comparaison des structures

Tableau 12.2 : Comparaison des structures de données

Structure Accès Ajout Suppression Cas d'usage

O(1) par O(1) fin, O(N)

Tableau O(1) fin, O(N) début Accès aléatoire
indice début

Annuler,
Pile Sommet seul O(1) au sommet O(1) au sommet
expressions

File Tête seule O(1) en queue O(1) en tête File d'attente, BFS

Liste Séquentiel O(1) si position O(1) si position Insertions

chaînée O(N) connue connue fréquentes

12.5 Pseudo-code complet : Vérificateur d'équilibrement

de parenthèses

237
Chapitre 12 : Introduction aux structures de données

ALGORITHME 12.3 : PARENTHÈSES ÉQUILIBRÉES (APPLICATION DE

LA PILE)

238
Chapitre 12 : Introduction aux structures de données

ALGORITHME ParenthesesEquilibrees
expression : CHAINE
i : ENTIER; c : CARACTERE
// Pile pour les parenthèses ouvrantes
CONST MAX : ENTIER <- 100
pile : TABLEAU[MAX] DE CARACTERE
sommet : ENTIER <- -1
equilibre : BOOLEEN <- VRAI

PROCEDURE empilerChar(car : CARACTERE)

sommet <- sommet + 1
pile[sommet] <- car
FIN PROCEDURE

FONCTION depilerChar() : CARACTERE

sommet <- sommet - 1
RETOURNE pile[sommet + 1]
FIN FONCTION

DÉBUT
AFFICHER "Expression : " ; LIRE expression

POUR i DE 0 A LONGUEUR(expression) - 1 FAIRE

c <- CARACTERE_A(expression, i)

SI c = '(' OU c = '[' OU c = '{' ALORS

empilerChar(c)
SINON SI c = ')' ALORS
SI sommet < 0 OU depilerChar() <> '(' ALORS
equilibre <- FAUX
FIN SI
SINON SI c = ']' ALORS
SI sommet < 0 OU depilerChar() <> '[' ALORS
equilibre <- FAUX
FIN SI
SINON SI c = '}' ALORS
SI sommet < 0 OU depilerChar() <> '{' ALORS
equilibre <- FAUX
FIN SI
FIN SI
FIN POUR

SI sommet >= 0 ALORS equilibre <- FAUX FIN SI

SI equilibre ALORS AFFICHER "Expression valide !"

239
Chapitre 12 : Introduction aux structures de données

12.6 Exécution pas à pas

Expression : "(a + [b * c])" :

Étape c Action Pile équilibre

1 '(' empiler '(' ['('] VRAI

2-6 'a','+',' ' ignorer ['('] VRAI

7 '[' empiler '[' ['(', '['] VRAI

8-12 'b','*','c' ignorer ['(', '['] VRAI

13 ']' depiler, vérifie '[' ['('] VRAI

14 ')' depiler, vérifie '(' [] VRAI

12.7 Erreurs fréquentes

ERREURS À ÉVITER

Dépiler une pile vide : Toujours vérifier estVide() avant de dépiler.

Empiler dans une pile pleine : Vérifier la capacité maximale.

Confondre pile et file : Pile = LIFO (dernier entré sort en 1er), File = FIFO
(premier entré sort en 1er).

Oublier le caractère de fin de chaîne dans les implémentations bas

niveau.

12.8 Résumé

240
Chapitre 12 : Introduction aux structures de données

POINTS CLÉS

Structure de données = organisation des données pour un accès efficace

Pile (LIFO) : empiler au sommet, dépiler au sommet. Applications : undo,

évaluations d'expressions, parcours en profondeur.

File (FIFO) : enfiler en queue, défiler en tête. Applications : file d'attente,

parcours en largeur (BFS), buffer.

Liste chaînée : éléments reliés par des pointeurs. Insertions/suppressions

efficaces.

Le choix de la structure dépend des opérations à privilégier

Exercices du Chapitre 12

241
Chapitre 12 : Introduction aux structures de données

Exercice 12.1 (Très facile)

Simulation de pile : Simulez manuellement une pile avec les opérations :

empiler(5), empiler(3), empiler(8), depiler(), empiler(2), depiler(), depiler(). Quel est
le sommet final ? Quels éléments restent ?

Correction

Opération Pile (sommet à droite)

empiler(5) [5]

empiler(3) [5, 3]

empiler(8) [5, 3, 8]

depiler() [5, 3] (retourne 8)

empiler(2) [5, 3, 2]

depiler() [5, 3] (retourne 2)

depiler() [5] (retourne 3)

Reste : [5], sommet = 5.

242
Chapitre 12 : Introduction aux structures de données

Exercice 12.2 (Très facile)

Simulation de file : Simulez une file : enfiler(A), enfiler(B), enfiler(C), defiler(),

enfiler(D), defiler(), defiler(). Quels éléments restent ?

Opération File (tête à gauche)

enfiler(A) [A]

enfiler(B) [A, B]

enfiler(C) [A, B, C]

defiler() [B, C] (retourne A)

enfiler(D) [B, C, D]

defiler() [C, D] (retourne B)

defiler() [D] (retourne C)

Reste : [D]

243
Chapitre 12 : Introduction aux structures de données

Exercice 12.3 (Facile)

Implémenter une pile complète : Écrivez toutes les opérations (empiler, depiler,
sommet, estVide, taille) avec un tableau et un sommet.

244
Chapitre 12 : Introduction aux structures de données

ALGORITHME PileComplete
CONST CAPA : ENTIER <- 50
pile : TABLEAU[CAPA] DE ENTIER
sommet : ENTIER <- -1

PROCEDURE empiler(x : ENTIER)

SI sommet < CAPA - 1 ALORS
sommet <- sommet + 1; pile[sommet] <- x
SINON AFFICHER "Plein" FIN SI
FIN PROCEDURE

FONCTION depiler() : ENTIER

SI sommet >= 0 ALORS
sommet <- sommet - 1; RETOURNE pile[sommet + 1]
SINON AFFICHER "Vide"; RETOURNE -1 FIN SI
FIN FONCTION

FONCTION sommetVal() : ENTIER

RETOURNE pile[sommet]
FIN FONCTION

FONCTION estVide() : BOOLEEN

RETOURNE sommet = -1
FIN FONCTION

FONCTION taille() : ENTIER

RETOURNE sommet + 1
FIN FONCTION

DÉBUT
empiler(10); empiler(20); empiler(30)
AFFICHER taille() // 3
AFFICHER depiler() // 30
AFFICHER sommetVal() // 20
AFFICHER estVide() // FAUX
FIN

245
Chapitre 12 : Introduction aux structures de données

Exercice 12.4 (Facile)

Inverser avec une pile : Lire 5 nombres, les empiler, puis les dépiler pour les
afficher dans l'ordre inverse.

ALGORITHME InverserPile
// Utilise la pile définie ci-dessus
i, x : ENTIER
DÉBUT
POUR i DE 1 A 5 FAIRE
AFFICHER "Nombre : " ; LIRE x
empiler(x)
FIN POUR
AFFICHER "Ordre inverse : "
TANT QUE NON estVide() FAIRE
AFFICHER depiler(), " "
FIN TANT QUE
FIN

246
Chapitre 12 : Introduction aux structures de données

Exercice 12.5 (Facile)

Vérification de palindrome avec pile : Lire un mot. Utiliser une pile pour vérifier
s'il est un palindrome.

ALGORITHME PalindromePile
mot : CHAINE; i, milieu : ENTIER
c : CARACTERE; estPal : BOOLEEN
DÉBUT
AFFICHER "Mot : " ; LIRE mot
// Empiler la première moitié
milieu <- LONGUEUR(mot) DIV 2
POUR i DE 0 A milieu - 1 FAIRE
empilerChar(CARACTERE_A(mot, i))
FIN POUR
// Si longueur impaire, sauter le milieu
SI LONGUEUR(mot) MOD 2 = 1 ALORS milieu <- milieu + 1 FIN
SI
// Comparer avec la deuxième moitié
estPal <- VRAI
POUR i DE milieu A LONGUEUR(mot) - 1 FAIRE
SI depilerChar() <> CARACTERE_A(mot, i) ALORS
estPal <- FAUX
FIN SI
FIN POUR
AFFICHER "Palindrome : ", estPal
FIN

247
Chapitre 12 : Introduction aux structures de données

Exercice 12.6 (Moyen)

Conversion décimal vers binaire avec pile : Lire un entier positif. Le convertir en
binaire en empilant les restes de divisions par 2, puis les dépiler pour afficher.

ALGORITHME DecimalVersBinaire
n : ENTIER
DÉBUT
AFFICHER "n : " ; LIRE n
SI n = 0 ALORS AFFICHER "0" SINON
TANT QUE n > 0 FAIRE
empiler(n MOD 2)
n <- n DIV 2
FIN TANT QUE
TANT QUE NON estVide() FAIRE
AFFICHER_SANS_RETOUR depiler()
FIN TANT QUE
AFFICHER ""
FIN SI
FIN

Explication : Les restes sont générés du poids faible au poids fort. La pile les
inverse naturellement.

248
Chapitre 12 : Introduction aux structures de données

Exercice 12.7 (Moyen)

Implémenter une file complète : Écrivez toutes les opérations (enfiler, defiler, tete,
estVide, taille) avec un tableau circulaire.

249
Chapitre 12 : Introduction aux structures de données

ALGORITHME FileComplete
CONST CAPA : ENTIER <- 50
file : TABLEAU[CAPA] DE ENTIER
tete, queue, nb : ENTIER

PROCEDURE initialiser()
tete <- 0; queue <- 0; nb <- 0
FIN PROCEDURE

PROCEDURE enfiler(x : ENTIER)

SI nb < CAPA ALORS
file[queue] <- x
queue <- (queue + 1) MOD CAPA
nb <- nb + 1
SINON AFFICHER "Pleine" FIN SI
FIN PROCEDURE

FONCTION defiler() : ENTIER

SI nb > 0 ALORS
tete <- (tete + 1) MOD CAPA
nb <- nb - 1
RETOURNE file[(tete - 1 + CAPA) MOD CAPA]
SINON AFFICHER "Vide"; RETOURNE -1 FIN SI
FIN FONCTION

FONCTION teteVal() : ENTIER

RETOURNE file[tete]
FIN FONCTION

FONCTION estVideFile() : BOOLEEN

RETOURNE nb = 0
FIN FONCTION

FONCTION tailleFile() : ENTIER

RETOURNE nb
FIN FONCTION

250
Chapitre 12 : Introduction aux structures de données

Exercice 12.8 (Moyen)

Simuler une file d'attente : Simuler un guichet : les clients arrivent (enfiler) et sont
servis (defiler) aléatoirement. Afficher l'état de la file après 10 opérations.

ALGORITHME FileAttente
i, choix, clientNum : ENTIER
DÉBUT
initialiser()
clientNum <- 1
POUR i DE 1 A 10 FAIRE
choix <- ALÉATOIRE(1, 2) // 1=arrivée, 2=départ
SI choix = 1 ALORS
AFFICHER "Client ", clientNum, " arrive"
enfiler(clientNum)
clientNum <- clientNum + 1
SINON SI NON estVideFile() ALORS
AFFICHER "Client ", defiler(), " servi"
SINON
AFFICHER "Personne à servir"
FIN SI
AFFICHER "File (", tailleFile(), " personnes)"
FIN POUR
FIN

251
Chapitre 12 : Introduction aux structures de données

Exercice 12.9 (Moyen)

Deux piles pour faire une file : Implémenter une file en utilisant deux piles
(pileEntree et pileSortie). Enfiler = empiler sur pileEntree. Defiler = si pileSortie
vide, transférer tous les éléments de pileEntree vers pileSortie, puis dépiler de
pileSortie.

ALGORITHME FileAvecDeuxPiles
pileE, pileS : // deux piles standard

PROCEDURE enfilerFile(x : ENTIER)

empiler(pileE, x)
FIN PROCEDURE

FONCTION defilerFile() : ENTIER

SI estVide(pileS) ALORS
TANT QUE NON estVide(pileE) FAIRE
empiler(pileS, depiler(pileE))
FIN TANT QUE
FIN SI
SI NON estVide(pileS) ALORS
RETOURNE depiler(pileS)
SINON AFFICHER "Vide"; RETOURNE -1
FIN SI
FIN FONCTION

Principe : On inverse deux fois (avec les deux piles), ce qui revient à l'ordre
original FIFO.

252
Chapitre 12 : Introduction aux structures de données

Exercice 12.10 (Difficile)

Évaluation d'expression postfixée : Lire une expression en notation postfixée (ex:

"3 4 + 2 *" = (3+4)*2 = 14). Utiliser une pile pour évaluer.

ALGORITHME EvalPostfixe
expression : CHAINE; i : ENTIER
operande1, operande2, resultat : ENTIER
c : CARACTERE
DÉBUT
AFFICHER "Expression postfixe : " ; LIRE expression
POUR i DE 0 A LONGUEUR(expression) - 1 FAIRE
c <- CARACTERE_A(expression, i)
SI c >= '0' ET c <= '9' ALORS
empiler(CONVERTIR_ENTIER(c) -
CONVERTIR_ENTIER('0'))
SINON SI c = '+' ALORS
operande2 <- depiler(); operande1 <- depiler()
empiler(operande1 + operande2)
SINON SI c = '-' ALORS
operande2 <- depiler(); operande1 <- depiler()
empiler(operande1 - operande2)
SINON SI c = '*' ALORS
operande2 <- depiler(); operande1 <- depiler()
empiler(operande1 * operande2)
SINON SI c = '/' ALORS
operande2 <- depiler(); operande1 <- depiler()
empiler(operande1 DIV operande2)
FIN SI
FIN POUR
AFFICHER "Résultat : ", depiler()
FIN

Python :

253
Chapitre 12 : Introduction aux structures de données

def eval_postfixe(expr):
pile = []
for c in [Link](" ", ""):
if [Link](): [Link](int(c))
elif c == '+': b, a = [Link](), [Link]();
[Link](a+b)
elif c == '-': b, a = [Link](), [Link]();
[Link](a-b)
elif c == '*': b, a = [Link](), [Link]();
[Link](a*b)
elif c == '/': b, a = [Link](), [Link]();
[Link](a//b)
return pile[0]

print(eval_postfixe("34+2*")) # 14

254
Chapitre 12 : Introduction aux structures de données

Exercice 12.11 (Mini-projet)

Gestionnaire d'impression : Simuler une imprimante avec file d'attente. Chaque

document a un nom et un nombre de pages. Les documents sont traités en FIFO.
Afficher la progression ("Impression de X : page Y/Z").

255
Chapitre 12 : Introduction aux structures de données

ALGORITHME GestionnaireImpression
CONST MAX : ENTIER <- 50
noms : TABLEAU[MAX] DE CHAINE
pages : TABLEAU[MAX] DE ENTIER
tete, queue, nb : ENTIER
i, j : ENTIER

PROCEDURE ajouterDocument(nom : CHAINE, nbPages : ENTIER)

SI nb < MAX ALORS
noms[queue] <- nom; pages[queue] <- nbPages
queue <- (queue + 1) MOD MAX; nb <- nb + 1
FIN SI
FIN PROCEDURE

PROCEDURE imprimer()
i : ENTIER
SI nb > 0 ALORS
POUR i DE 1 A pages[tete] FAIRE
AFFICHER "Impression de ", noms[tete],
" : page ", i, "/", pages[tete]
FIN POUR
tete <- (tete + 1) MOD MAX; nb <- nb - 1
AFFICHER noms[tete], " terminé !"
FIN SI
FIN PROCEDURE

DÉBUT
tete <- 0; queue <- 0; nb <- 0
ajouterDocument("[Link]", 3)
ajouterDocument("[Link]", 2)
ajouterDocument("[Link]", 5)
TANT QUE nb > 0 FAIRE
imprimer()
FIN TANT QUE
FIN

256
Chapitre 12 : Introduction aux structures de données

Exercice 12.12 (Mini-projet - Difficile)

Historique de navigation (Pile) + File d'attente de téléchargement : Simulez un

navigateur web. Pile pour l'historique (page précédente/suivante). File pour les
téléchargements. Menu : visiter page, précédent, suivant, ajouter téléchargement,
voir téléchargements en cours, quitter.

257
Chapitre 12 : Introduction aux structures de données

ALGORITHME Navigateur
// --- Historique (Pile) ---
CONST HISTO_MAX : ENTIER <- 100
historique : TABLEAU[HISTO_MAX] DE CHAINE
sommetHisto : ENTIER <- -1
pageActuelle : CHAINE <- "accueil"

// --- Téléchargements (File) ---

CONST DL_MAX : ENTIER <- 50
downloads : TABLEAU[DL_MAX] DE CHAINE
teteDL, queueDL, nbDL : ENTIER

PROCEDURE visiterPage(url : CHAINE)

sommetHisto <- sommetHisto + 1
historique[sommetHisto] <- pageActuelle
pageActuelle <- url
AFFICHER "Page : ", pageActuelle
FIN PROCEDURE

PROCEDURE pagePrecedente()
SI sommetHisto >= 0 ALORS
pageActuelle <- historique[sommetHisto]
sommetHisto <- sommetHisto - 1
AFFICHER "Page : ", pageActuelle
SINON AFFICHER "Pas de page précédente" FIN SI
FIN PROCEDURE

PROCEDURE ajouterDownload(fichier : CHAINE)

SI nbDL < DL_MAX ALORS
downloads[queueDL] <- fichier
queueDL <- (queueDL + 1) MOD DL_MAX
nbDL <- nbDL + 1
FIN SI
FIN PROCEDURE

DÉBUT
teteDL <- 0; queueDL <- 0; nbDL <- 0
choix : ENTIER; url, fichier : CHAINE

REPETER
AFFICHER "\[Link] [Link] [Link] [Link]
[Link]"
AFFICHER "Choix : " ; LIRE choix

choix vaut
1: AFFICHER "URL : " ; LIRE url; visiterPage(url)

258
Chapitre 12 : Introduction aux structures de données

3: AFFICHER "Fichier : " ; LIRE fichier

ajouterDownload(fichier)
AFFICHER "Ajouté à la file"
4: AFFICHER "Téléchargements (", nbDL, "):"
POUR i DE 0 A nbDL - 1 FAIRE
AFFICHER "- ", downloads[(teteDL+i) MOD
DL_MAX]
FIN POUR
5: AFFICHER "Au revoir"
SINON: AFFICHER "Invalide"
JUSQU'A choix = 5
FIN

Python :

class Navigateur:
def __init__(self):
[Link] = []
[Link] = "accueil"
self.dl_file = []

def visiter(self, url):

[Link]([Link])
[Link] = url
print(f"Page : {[Link]}")

def precedent(self):
if [Link]:
[Link] = [Link]()
print(f"Page : {[Link]}")
else: print("Pas de precedent")

def ajout_dl(self, fichier):

self.dl_file.append(fichier)

def voir_dl(self):
print(f"Downloads : {self.dl_file}")

nav = Navigateur()
[Link]("[Link]")
[Link]("[Link]")
[Link]() # Retour à [Link]

Méthode : La pile pour l'historique est naturelle (LIFO = dernier visité =

premier retour). La file pour les téléchargements est naturelle aussi (FIFO =

259
Chapitre 12 : Introduction aux structures de données

premier demandé = premier téléchargé). Cet exercice combine les deux

structures fondamentales.

FÉLICITATIONS ! Vous avez terminé la Licence 1 !

Vous maîtrisez maintenant les fondements de l'algorithmique !

Chapitre 1 : Introduction à l'algorithmique

Chapitre 2 : Variables et constantes

Chapitre 3 : Types de données

Chapitre 4 : Entrées et sorties

Chapitre 5 : Opérateurs arithmétiques

Chapitre 6 : Conditions (SI, SINON, SINON SI)

Chapitre 7 : Boucles (POUR, TANT QUE, RÉPÉTER)

Chapitre 8 : Fonctions et procédures

Chapitre 9 : Tableaux à une dimension

Chapitre 10 : Chaînes de caractères

Chapitre 11 : Recherche séquentielle

Chapitre 12 : Introduction aux structures de données

Vous êtes prêt pour la Licence 2 ! Faites tous les exercices pour consolider vos
acquis.

260