Module 1 : Introduction et Notions de Base

Ce premier bloc pose les fondations de la logique informatique.

Concept d'algorithme : Histoire, définition et critères d'efficacité d'un algorithme.

Structure générale : En-tête, déclarations, et corps du programme (Début / Fin).
Pseudo-code : Utilisation d'un langage de description indépendant des langages de
programmation.
Variables et constantes : Types de données de base (entier, réel, caractère, chaîne,
booléen).
Instructions de base : L'affectation (stockage), la lecture (entrées) et l'écriture (sorties).

Module 2 : Les Structures de Contrôle

Ces structures permettent de casser la linéarité du code pour créer des logiques intelligentes.

Structures conditionnelles : Instructions Si / Sinon / FinSi et structures à choix multiples

(Selon).
Structures itératives (Boucles) : Comprendre quand et comment répéter des actions.
Boucle Pour (nombre d'itérations connu à l'avance).
Boucle Tant Que (condition de fin évaluée au début).
Boucle Répéter ... Jusqu'à (condition de fin évaluée à la fin).

Module 3 : Les Structures de Données Linéaires

Ce module aborde la gestion de collections de données en mémoire.

Tableaux unidimensionnels (Vecteurs) : Déclaration, parcours, insertion et suppression

d'éléments.
Tableaux bidimensionnels (Matrices) : Représentation de grilles de données.
Chaînes de caractères : Manipulation avancée et fonctions de traitement de texte.

Module 4 : Modularité (Fonctions et Procédures)

Apprendre à découper un problème complexe en sous-problèmes plus simples et réutilisables.

Définition : Différence fondamentale entre une fonction (qui retourne une valeur) et une
procédure.
Paramètres : Passage de paramètres par valeur (copie) ou par référence (adresse).
 Portée des variables : Variables locales à un module versus variables globales au
programme.

Module 5 : Algorithmes Fondamentaux

Mise en pratique des compétences à travers des problèmes classiques de l'informatique.

Algorithmes de recherche : Recherche séquentielle (linéaire) et recherche dichotomique

(dans un tableau trié).
Algorithmes de tri : Tri par sélection, tri à bulles et tri par insertion.

Module 6 : Complexité et Concepts Avancés

Pour les étudiants de niveau intermédiaire à avancé.

Introduction à la complexité : Notion de performance (notations Grand O) en temps et en

espace.
Récursivité : Concevoir des fonctions qui s'appellent elles-mêmes.

Module 1 : Introduction et Notions de Base

Ce premier bloc pose les fondations de la logique informatique.

1. Concept d'algorithme
Un algorithme est une suite finie et non ambiguë d'instructions permettant de résoudre un
problème ou d'accomplir une tâche. Le mot vient du mathématicien persan Al-Khwarizmi.

Critères d'efficacité : Un bon algorithme doit être correct (donner le bon résultat), fini
(s'arrêter après un temps raisonnable) et efficace (optimiser l'usage de la mémoire et du
processeur).

2. Structure générale & Pseudo-code

Le pseudo-code est un langage informel qui ressemble à du code mais qui est écrit en français
pour rester universel.

Plaintext

Algorithme Nom_Du_Programme
Variables
// Déclaration des variables ici
Début
 // Corps du programme : instructions
Fin

3. Variables, Constantes et Instructions de base

Types de données : Entier (ex: 42), Réel (ex: 3.14), Caractère (ex: 'A'), Chaîne (ex:
"Bonjour"), Booléen ( Vrai ou Faux ).
Affectation ( <- ) : Stocke une valeur dans une variable.
Lecture ( Lire ) : Récupère une donnée saisie par l'utilisateur.
Écriture ( Écrire ) : Affiche une information à l'écran.

💡 Exercices - Module 1
Exercice 1 : Permutation de deux variables

Énoncé : Écrire un algorithme qui demande à l'utilisateur deux nombres dans des variables A
et B , puis qui permute leurs valeurs (le contenu de A passe dans B et inversement) et les
affiche.

Indice : Vous aurez besoin d'une troisième variable "gobelet" (temporel).

Plaintext

Algorithme Permutation
Variables
A, B, Temp : Entier
Début
Écrire("Entrez la valeur de A : ")
Lire(A)
Écrire("Entrez la valeur de B : ")
Lire(B)

// Logique de permutation
Temp <- A
A <- B
B <- Temp

Écrire("Après permutation, A = ", A, " et B = ", B)

Fin

Module 2 : Les Structures de Contrôle

Ces structures permettent de casser la linéarité du code pour créer des logiques intelligentes.
1. Structures conditionnelles
Permettent d'exécuter des blocs de code différents selon qu'une condition soit vraie ou fausse.

Si / Sinon : Utilisé pour des choix binaires ou simples.

Selon : Idéal pour éviter des Si imbriqués lorsqu'on teste plusieurs valeurs d'une même
variable.

2. Structures itératives (Boucles)

Boucle Pour : On sait exactement combien de fois on veut répéter l'action.
Boucle Tant Que : On vérifie la condition avant d'entrer dans la boucle. Si la condition est
fausse dès le départ, le code ne s'exécute jamais.
Boucle Répéter ... Jusqu'à : On exécute le code au moins une fois, car la condition est
vérifiée à la fin.

💡 Exercices - Module 2
Exercice 1 : Le juste prix (Boucle Tant Que)

Énoncé : Écrire un algorithme qui définit un nombre secret (par exemple 42 ). Il demande
ensuite à l'utilisateur de deviner ce nombre tant que sa réponse n'est pas correcte.

Plaintext

Algorithme JustePrix
Variables
Secret, Essai : Entier
Début
Secret <- 42
Écrire("Devinez le nombre secret : ")
Lire(Essai)

TantQue Essai <> Secret Faire

Si Essai < Secret Alors
Écrire("C'est plus grand !")
Sinon
Écrire("C'est plus petit !")
FinSi
Écrire("Réessayez : ")
Lire(Essai)
FinTantQue
 Écrire("Bravo ! Vous avez trouvé.")
Fin

Exercice 2 : Calcul de moyenne (Boucle Pour)

Énoncé : Écrire un algorithme qui demande à l'utilisateur de saisir 5 notes, puis calcule et
affiche leur moyenne.

Plaintext

Algorithme CalculMoyenne
Variables
i : Entier
Note, Somme, Moyenne : Réel
Début
Somme <- 0
Pour i AlantDe 1 À 5 Faire
Écrire("Entrez la note numéro ", i, " : ")
Lire(Note)
Somme <- Somme + Note
FinPour
Moyenne <- Somme / 5
Écrire("La moyenne de la classe est : ", Moyenne)
Fin

Module 3 : Les Structures de Données Linéaires

Ce module aborde la gestion de collections de données en mémoire sous un seul nom de
variable.

1. Tableaux unidimensionnels (Vecteurs)

Un tableau est une suite de cases de même type, accessibles par un indice (généralement de
1 à N ou de 0 à N-1).

Exemple : MonTableau : Tableau[1..10] de Entier

2. Tableaux bidimensionnels (Matrices)

Une grille avec des lignes et des colonnes. Pour accéder à une case, il faut fournir deux indices
: Tableau[ligne, colonne] .

3. Chaînes de caractères
Une chaîne est techniquement un tableau de caractères. On peut mesurer sa longueur, extraire
des sous-chaînes ou concaténer (fusionner) deux chaînes.

💡 Exercices - Module 3
Exercice 1 : Recherche du maximum dans un tableau

Énoncé : Écrire un algorithme qui cherche la valeur maximale présente dans un tableau de 10
entiers préalablement rempli.

Plaintext

Algorithme MaxTableau
Variables
T : Tableau[1..10] de Entier
i, Max : Entier
Début
// Remplissage fictif pour l'exercice
// ... supposons le tableau déjà rempli ...

Max <- T[1] // On suppose que le premier est le plus grand

Pour i AllantDe 2 À 10 Faire
Si T[i] > Max Alors
Max <- T[i]
FinSi
FinPour

Écrire("Le nombre le plus grand est : ", Max)

Fin

Module 4 : Modularité (Fonctions et Procédures)

Apprendre à découper un problème complexe en sous-problèmes plus simples et réutilisables.

1. Fonctions vs Procédures
Fonction : Effectue des calculs et renvoie obligatoirement une valeur unique via
l'instruction Retourner .
Procédure : Effectue une série d'actions (comme un affichage) mais ne renvoie aucune
valeur.

2. Passage de paramètres
Par Valeur : Le module reçoit une copie de la variable. Modifier le paramètre dans le
module ne change pas la variable d'origine.
 Par Référence (ou Variable) : Le module reçoit l'adresse de la variable. Toute modification
impacte directement la variable d'origine.

💡 Exercices - Module 4
Exercice 1 : Fonction de calcul de TVA

Énoncé : Créer une fonction nommée CalculerTTC qui prend en paramètre un prix Hors Taxe
(Réel) et un taux de TVA (Réel, ex: 0.20 pour 20%), et qui retourne le prix TTC. Écrivez le
programme principal qui l'utilise.

Plaintext

Fonction CalculerTTC(prixHT : Réel, tauxTVA : Réel) : Réel

Début
Retourner prixHT * (1 + tauxTVA)
FinFonction

Algorithme Principal
Variables
PrixAchat, PrixFinal : Réel
Début
Écrire("Entrez le prix HT : ")
Lire(PrixAchat)
// Appel de la fonction avec un taux fixe de 20%
PrixFinal <- CalculerTTC(PrixAchat, 0.20)
Écrire("Le prix TTC est de : ", PrixFinal)
Fin

Module 5 : Algorithmes Fondamentaux

Mise en pratique des compétences à travers des problèmes classiques de l'informatique.

1. Algorithmes de recherche
Séquentielle : On regarde chaque case l'une après l'autre. Fonctionne sur tous les
tableaux.
Dichotomique : Utilisable uniquement sur un tableau trié. On coupe le tableau en deux à
chaque étape, ce qui est extrêmement rapide.

2. Algorithmes de tri
Tri à bulles : On compare les éléments adjacents et on les permute s'ils sont dans le
mauvais ordre.
 Tri par sélection : On cherche le plus petit élément du tableau et on le place au début, puis
on recommence pour le reste.

💡 Exercices - Module 5
Exercice 1 : Le Tri à Bulles

Énoncé : Écrire un algorithme permettant de trier un tableau T de N entiers dans l'ordre

croissant en utilisant la méthode du tri à bulles.

Plaintext

Algorithme TriABulles
Variables
T : Tableau[1..N] de Entier
i, j, Temp : Entier
Début
Pour i AllantDe 1 À N-1 Faire
Pour j AllantDe 1 À N-i Faire
Si T[j] > T[j+1] Alors
// Permutation
Temp <- T[j]
T[j] <- T[j+1]
T[j+1] <- Temp
FinSi
FinPour
FinPour
Fin

Module 6 : Complexité et Concepts Avancés

Pour les étudiants de niveau intermédiaire à avancé.

1. Introduction à la complexité (Notation Grand O)

La complexité mesure l'évolution du temps d'exécution ou de l'espace mémoire requis quand le
volume de données n augmente.

O(1) : Temps constant (Ex: accéder à une case de tableau).

O(n) : Temps linéaire (Ex: recherche séquentielle).
O(n )
2
: Temps quadratique (Ex: tri à bulles, boucles imbriquées).

2. Récursivité
Une fonction récursive est une fonction qui s'appelle elle-même. Elle requiert obligatoirement :
 1. Un cas de base (condition d'arrêt pour éviter une boucle infinie).
2. Un cas récursif (l'appel vers soi-même avec une donnée simplifiée).

💡 Exercices - Module 6
Exercice 1 : La Factorielle récursive

Énoncé : En mathématiques, la factorielle d'un nombre n (notée n!) est le produit de tous les
entiers de 1 à n.

Par définition : 0! = 1 et n! = n × (n − 1)!.

Écrire la fonction récursive Factorielle(n : Entier) : Entier .

Plaintext

Fonction Factorielle(n : Entier) : Entier

Début
// Cas de base (Condition d'arrêt)
Si n = 0 Alors
Retourner 1
// Cas récursif
Sinon
Retourner n * Factorielle(n - 1)
FinSi
FinFonction

🏬 Étude de cas : Gestion des Ventes d'un Magasin

📋 Énoncé et Problématique
Une boutique de vêtements souhaite analyser ses performances de ventes de la journée. Le
responsable du magasin dispose d'un tableau contenant les montants de chaque transaction
(en euros). Il vous demande de concevoir un système automatisé pour :

1. Calculer le chiffre d'affaires total de la journée.

2. Identifier la meilleure vente effectuée.
3. Filtrer et isoler dans un nouveau tableau toutes les ventes dites "Premium" (supérieures
ou égales à 100 €).
4. Trier les ventes par ordre décroissant pour le rapport de fin de journée.

🛠️ Spécifications Techniques
Le programme principal manipulera un tableau de départ nommé Ventes contenant N
éléments (par exemple N = 5).

Vous devez structurer votre code de manière modulaire en créant :

Une fonction CalculerCA qui retourne le total des ventes.

Une fonction TrouverMax qui retourne la plus grande vente.
Une procédure FiltrerPremium qui remplit un tableau secondaire avec les ventes ≥ 100 €.
Une procédure TrierVentes qui trie le tableau principal.

💻 Solution Complète en Pseudo-Code

1. Les Modules (Fonctions et Procédures)

Plaintext

// 1. Fonction pour calculer le Chiffre d'Affaires

Fonction CalculerCA(T : Tableau de Réel, taille : Entier) : Réel
Variables
i : Entier
Total : Réel
Début
Total <- 0
Pour i AllantDe 1 À taille Faire
Total <- Total + T[i]
FinPour
Retourner Total
FinFonction

// 2. Fonction pour trouver la vente maximale

Fonction TrouverMax(T : Tableau de Réel, taille : Entier) : Réel
Variables
i : Entier
Max : Réel
Début
Max <- T[1]
Pour i AllantDe 2 À taille Faire
Si T[i] > Max Alors
Max <- T[i]
FinSi
FinPour
Retourner Max
FinFonction

// 3. Procédure pour filtrer les ventes Premium (Passage par référence pour
 modifier le tableau résultat)
Procédure FiltrerPremium(T_Source : Tableau de Réel, taille_S : Entier, Var T_Dest
: Tableau de Réel, Var taille_D : Entier)
Variables
i : Entier
Début
taille_D <- 0 // Compteur pour le tableau de destination
Pour i AllantDe 1 À taille_S Faire
Si T_Source[i] >= 100.0 Alors
taille_D <- taille_D + 1
T_Dest[taille_D] <- T_Source[i]
FinSi
FinPour
FinProcédure

// 4. Procédure de Tri par Sélection Décroissant

Procédure TrierVentes(Var T : Tableau de Réel, taille : Entier)
Variables
i, j, PosMax : Entier
Temp : Réel
Début
Pour i AllantDe 1 À taille - 1 Faire
PosMax <- i
Pour j AllantDe i + 1 À taille Faire
Si T[j] > T[PosMax] Alors
PosMax <- j
FinSi
FinPour
// Permutation
Temp <- T[i]
T[i] <- T[PosMax]
T[PosMax] <- Temp
FinPour
FinProcédure

2. Programme Principal

Plaintext

Algorithme GestionMagasin
Variables
Ventes : Tableau[1..5] de Réel
VentesPremium : Tableau[1..5] de Réel
i, NbPremium : Entier
CA, MeilleureVente : Réel
Début
 // Remplissage initial des ventes de la journée
Ventes[1] <- 45.50
Ventes[2] <- 120.00
Ventes[3] <- 85.00
Ventes[4] <- 320.00
Ventes[5] <- 15.20

// 1. Calcul et affichage du Chiffre d'Affaires

CA <- CalculerCA(Ventes, 5)
Écrire("Chiffre d'affaires du jour : ", CA, " €")

// 2. Recherche de la meilleure vente

MeilleureVente <- TrouverMax(Ventes, 5)
Écrire("Meilleure vente : ", MeilleureVente, " €")

// 3. Extraction des ventes Premium

FiltrerPremium(Ventes, 5, VentesPremium, NbPremium)
Écrire("Nombre de ventes Premium (>= 100€) : ", NbPremium)
Pour i AllantDe 1 À NbPremium Faire
Écrire(" - Vente Premium ", i, " : ", VentesPremium[i], " €")
FinPour

// 4. Tri du tableau principal et affichage

TrierVentes(Ventes, 5)
Écrire("Liste de toutes les ventes triées par ordre décroissant :")
Pour i AllantDe 1 À 5 Faire
Écrire(" Vente ", i, " : ", Ventes[i], " €")
FinPour
Fin

📊 Analyse de la complexité de l'étude de cas

Calcul du CA et recherche du maximum : Ces deux opérations parcourent le tableau une
seule fois de manière linéaire. La complexité en temps est donc de O(n).
Filtrage des ventes Premium : Un seul parcours également, complexité de O(n) en
temps. En espace, elle nécessite l'allocation d'un second tableau de taille maximale n, soit
O(n).

Tri par sélection : Cet algorithme utilise deux boucles imbriquées pour ordonner les
éléments. Sa complexité est dite quadratique, notée O(n ). C'est suffisant pour 5 ou 100
2

ventes, mais cela deviendrait lent si la boutique enregistrait des millions de transactions par
jour !