Table des matières

PROGRAMME DE COURS D'ALGORITHME NIVEAU 1.....................................................2

Module 1 : Introduction à l'algorithmique....................................................3
Module 2 : Les bases de la logique algorithmique......................................6
Module 3 : Écriture et représentation des algorithmes............................10
Module 4 : Les opérations de base en algorithmique...............................14
Module 5 : Résolution de problèmes simples.............................................19
Module 6 : Initiation aux tableaux et boucles imbriquées.......................24
Module 7 : Initiation aux fonctions et procédures.....................................29
Module 8 : Projets pratiques.........................................................................33
Module 9 : Évaluation et conclusion............................................................39
PROGRAMME DE COURS D'ALGORITHME NIVEAU 2...................................................42
Module 1 : Rappel et consolidation des bases...........................................43
Module 2 : Structures conditionnelles avancées.......................................47
Module 3 : Les tableaux multidimensionnels.............................................52
Module 4 : Les algorithmes de tri et de recherche....................................57
Module 5 : La récursivité............................................................................... 62
Module 6 : Structures de données simples.................................................67
Module 7 : Gestion des chaînes de caractères...........................................72
Module 8 : Problèmes algorithmiques classiques......................................76
Module 9 : Projets pratiques.........................................................................81
Module 10 : Évaluation finale et perspectives...........................................85
PROGRAMME DE COURS
D'ALGORITHME NIVEAU 1
Module 1 : Introduction à l'algorithmique

Durée : 2 heures

1. Définition et importance des algorithmes

 Définition :
Un algorithme est une suite finie et ordonnée d'instructions permettant
de résoudre un problème ou d'accomplir une tâche. Il est indépendant
de tout langage de programmation et décrit une méthode pour
atteindre un objectif.
Exemple : Une recette de cuisine est un algorithme qui décrit les
étapes pour préparer un plat.
 Importance :
o Les algorithmes sont au cœur de l'informatique et de la
technologie moderne.
o Ils permettent d'automatiser des tâches complexes, de traiter
des données, de prendre des décisions et de résoudre des
problèmes de manière efficace.
o Ils sont utilisés dans divers domaines : intelligence artificielle,
réseaux sociaux, moteurs de recherche, médecine, finance, etc.

2. Différence entre algorithme, programme et logiciel

 Algorithme :
o Description abstraite et conceptuelle des étapes pour résoudre
un problème.
o Peut être exprimé en langage naturel, en pseudo-code ou sous
forme de schémas (organigrammes).
o Exemple : Algorithme pour trier une liste de nombres.
 Programme :
o Implémentation concrète d'un algorithme dans un langage de
programmation spécifique (Python, Java, C++, etc.).
o Utilise des syntaxes et des règles propres au langage choisi.
o Exemple : Code Python pour trier une liste.
 Logiciel :
o Ensemble de programmes et de ressources (interfaces, bases de
données, etc.) qui fonctionnent ensemble pour offrir une solution
complète à un utilisateur.
o Exemple : Une application de gestion de bibliothèque (composée
de plusieurs programmes).
3. Notions de problème et de solution algorithmique

 Problème :
Une situation ou une question nécessitant une réponse ou une
résolution.
Exemple : Comment trouver le plus court chemin entre deux points sur
une carte ?
 Solution algorithmique :
Une méthode systématique pour résoudre le problème, décrite sous
forme d'étapes claires et précises.
o Caractéristiques d'une bonne solution algorithmique :
 Correcte : Elle résout le problème de manière exacte.
 Efficace : Elle utilise les ressources (temps, mémoire) de
manière optimale.
 Compréhensible : Elle est claire et facile à suivre.
Exemple : Algorithme de Dijkstra pour trouver le plus court
chemin dans un graphe.

4. Exemples simples d'algorithmes dans la vie quotidienne

 Faire du thé :
1. Faire bouillir de l'eau.
2. Mettre un sachet de thé dans une tasse.
3. Verser l'eau bouillante dans la tasse.
4. Attendre 3 minutes.
5. Retirer le sachet de thé.
6. Ajouter du sucre ou du lait si désiré.
 Trouver un livre dans une bibliothèque :
1. Aller à la section correspondante (roman, science, etc.).
2. Chercher le livre par ordre alphabétique (auteur ou titre).
3. Vérifier si le livre est disponible.
4. Emprunter ou noter la référence.
 Trier des vêtements par couleur :
1. Prendre un vêtement.
2. Identifier sa couleur.
3. Le placer dans le tas correspondant (rouge, bleu, vert, etc.).
4. Répéter jusqu'à ce que tous les vêtements soient triés.
 Rechercher un contact dans un répertoire téléphonique :
1. Ouvrir le répertoire.
2. Parcourir les noms par ordre alphabétique.
3. Trouver le nom recherché.
4. Lire le numéro associé.
5. Conclusion

 Les algorithmes sont des outils fondamentaux pour résoudre des

problèmes de manière structurée et efficace.
 Ils sont omniprésents dans notre vie quotidienne et dans les systèmes
informatiques.
 Comprendre les bases de l'algorithmique est essentiel pour aborder la
programmation et l'informatique en général.
Module 2 : Les bases de la logique algorithmique

Durée : 4 heures

1. Les notions de séquence, décision et répétition

 Séquence :
Une séquence est une suite d'instructions exécutées les unes après les
autres, dans l'ordre où elles sont écrites.
Exemple :

Exemple

1. Allumer l'ordinateur.
2. Ouvrir un navigateur web.
3. Accéder à un site internet.
 Décision :
Une décision permet de choisir entre plusieurs actions en fonction
d'une condition.
Exemple :
Exemple

Si (il pleut) alors :

Prendre un parapluie.
Sinon :
Sortir sans parapluie.
 Répétition :
Une répétition permet d'exécuter une action plusieurs fois, tant qu'une
condition est remplie.
Exemple :
Exemple

Tant que (la bouteille n'est pas pleine) :

Remplir la bouteille d'eau.

2. Les structures conditionnelles (si...alors...sinon)

 Structure simple (si...alors) :

Exécute une action uniquement si une condition est vraie.
Exemple :

Exemple

Si (l'utilisateur est connecté) alors :

 Afficher "Bienvenue".
 Structure alternative (si...alors...sinon) :
Permet de choisir entre deux actions en fonction de la condition.
Exemple :
Exemple

Si (âge >= 18) alors :

Afficher "Majeur".
Sinon :
Afficher "Mineur".
 Structure complexe (si imbriqués) :
Permet de gérer plusieurs conditions.
Exemple :
Exemple

Si (note >= 16) alors :

Afficher "Très bien".
Sinon, si (note >= 12) alors :
Afficher "Bien".
Sinon :
Afficher "À améliorer".

3. Les structures itératives (tant que, pour)

 Boucle "tant que" :

Répète une action tant qu'une condition est vraie.
Exemple :

Exemple

Tant que (somme < 100) :

Ajouter 10 à somme.
 Boucle "pour" :
Répète une action un nombre précis de fois.
Exemple :
Exemple

Pour i allant de 1 à 5 :
Afficher "Bonjour".
 Différence entre "tant que" et "pour" :
o "Tant que" est utilisé lorsque le nombre d'itérations n'est pas
connu à l'avance.
o "Pour" est utilisé lorsque le nombre d'itérations est fixe.

4. Introduction aux variables et aux types de données

  Variable :
Une variable est un espace mémoire nommé qui stocke une valeur
pouvant changer pendant l'exécution d'un programme.
Exemple :

Exemple

age = 25
nom = "Alice"
 Types de données :
o Entier (int) : Nombre entier (exemple : 42, -3).
o Réel (float) : Nombre à virgule flottante (exemple : 3.14, -0.5).
o Chaîne de caractères (string) : Texte (exemple : "Bonjour",
"Python").
o Booléen (bool) : Valeur vraie (True) ou fausse (False).
 Exemple :
Exemple

age = 30 # Entier
prix = 19.99 # Réel
nom = "Jean" # Chaîne de caractères
est_connecte = True # Booléen

5. Notion de constante

 Définition :
Une constante est une valeur fixe qui ne change pas pendant
l'exécution du programme. Elle est souvent utilisée pour des valeurs
connues et immuables.
Exemple :

Exemple

PI = 3.14159
TAUX_TVA = 0.20
 Différence entre variable et constante :
o Une variable peut changer de valeur.
o Une constante conserve la même valeur tout au long du
programme.

6. Exemples pratiques

 Exemple 1 : Calcul de la moyenne

Exemple
 note1 = 15
note2 = 12
moyenne = (note1 + note2) / 2
Afficher "La moyenne est :", moyenne
 Exemple 2 : Vérification d'un mot de passe
Exemple

mot_de_passe = "1234"
Si (mot_de_passe == "1234") alors :
Afficher "Accès autorisé."
Sinon :
Afficher "Accès refusé."
 Exemple 3 : Boucle pour afficher les nombres de 1 à 10
Exemple

Pour i allant de 1 à 10 :
Afficher i

7. Conclusion

 Les structures de base (séquence, décision, répétition) sont

essentielles pour construire des algorithmes.
 Les variables et les types de données permettent de stocker et
manipuler des informations.
 Les constantes sont utiles pour définir des valeurs fixes.
Module 3 : Écriture et représentation des algorithmes

Durée : 4 heures

1. Syntaxe de base pour décrire un algorithme

 Objectif :
Décrire un algorithme de manière claire et structurée, en utilisant une
syntaxe simple et compréhensible.
 Éléments clés :
o Instructions : Actions à exécuter (exemple : "Afficher", "Lire",
"Calculer").
o Variables : Espaces mémoire pour stocker des données
(exemple : nom, âge).
o Conditions : Structures de décision (exemple : si...alors...sinon).
o Boucles : Structures de répétition (exemple : tant que, pour).
 Exemple de syntaxe :
Exemple

Début
Afficher "Entrez votre nom :"
Lire nom
Si (nom == "Alice") alors :
Afficher "Bonjour Alice !"
Sinon :
Afficher "Bonjour étranger !"
Fin

2. Les outils de représentation

a) Pseudocode

 Définition :
Le pseudocode est une description informelle d'un algorithme, proche
d'un langage de programmation mais sans respecter une syntaxe
stricte.
 Avantages :
o Facile à comprendre.
o Indépendant des langages de programmation.
 Exemple :
Exemple

Début
Afficher "Entrez un nombre :"
 Lire nombre
Si (nombre > 0) alors :
Afficher "Le nombre est positif."
Sinon si (nombre < 0) alors :
Afficher "Le nombre est négatif."
Sinon :
Afficher "Le nombre est nul."
Fin

b) Organigrammes (ou diagrammes de flux)

 Définition :
Un organigramme est une représentation visuelle d'un algorithme,
utilisant des symboles standardisés pour décrire les étapes et les
décisions.
 Symboles courants :
o Ovale : Début ou fin de l'algorithme.
o Rectangle : Action ou traitement.
o Losange : Condition ou décision.
o Flèches : Flux d'exécution.
 Exemple d'organigramme :
o Début → "Entrez un nombre" → Condition "nombre > 0 ?" → Oui →
"Positif" → Fin.
o Condition "nombre > 0 ?" → Non → Condition "nombre < 0 ?" →
Oui → "Négatif" → Fin.
o Condition "nombre < 0 ?" → Non → "Nul" → Fin.

3. Exercices pratiques : création d’organigrammes simples

a) Exercice 1 : Vérification d'un mot de passe

 Énoncé :
Créez un organigramme pour vérifier si un mot de passe entré par
l'utilisateur est correct.
 Solution :
1. Début.
2. Afficher "Entrez le mot de passe :".
3. Lire mot_de_passe.
4. Si (mot_de_passe == "1234") alors :
 Afficher "Accès autorisé."
5. Sinon :
 Afficher "Accès refusé."
6. Fin.

b) Exercice 2 : Calcul de la somme des nombres de 1 à N

  Énoncé :
Créez un organigramme pour calculer la somme des nombres de 1 à N,
où N est un nombre entré par l'utilisateur.
 Solution :
1. Début.
2. Afficher "Entrez un nombre N :".
3. Lire N.
4. Initialiser somme = 0 et i = 1.
5. Tant que (i <= N) :
 Ajouter i à somme.
 Incrémenter i de 1.
6. Afficher "La somme est :", somme.
7. Fin.

c) Exercice 3 : Trouver le maximum de deux nombres

 Énoncé :
Créez un organigramme pour trouver le plus grand de deux nombres
entrés par l'utilisateur.
 Solution :
1. Début.
2. Afficher "Entrez le premier nombre :".
3. Lire nombre1.
4. Afficher "Entrez le deuxième nombre :".
5. Lire nombre2.
6. Si (nombre1 > nombre2) alors :
 Afficher "Le maximum est :", nombre1.
7. Sinon :
 Afficher "Le maximum est :", nombre2.
8. Fin.

4. Conclusion

 Le pseudocode et les organigrammes sont des outils essentiels pour

décrire et visualiser des algorithmes.
 Ils permettent de communiquer des idées de manière claire et
structurée, avant de passer à l'implémentation en code.
 La pratique régulière de ces outils améliore la compréhension et la
conception des algorithmes.
Module 4 : Les opérations de base en algorithmique

Durée : 4 heures

1. Les opérations arithmétiques

 Addition (+):
Permet d'ajouter deux valeurs.
Exemple :

Exemple

résultat = 5 + 3 # résultat = 8
 Soustraction (-):
Permet de soustraire une valeur d'une autre.
Exemple :
Exemple

résultat = 10 - 4 # résultat = 6
 Multiplication (*):
Permet de multiplier deux valeurs.
Exemple :
Exemple

résultat = 7 * 2 # résultat = 14
 Division (/):
Permet de diviser une valeur par une autre.
Exemple :
Exemple

résultat = 20 / 5 # résultat = 4
 Division entière (//) et modulo (%):
o Division entière : Retourne le quotient entier d'une division.
Exemple :

Exemple

résultat = 10 // 3 # résultat = 3
o Modulo : Retourne le reste d'une division.
Exemple :
Exemple

résultat = 10 % 3 # résultat = 1
2. Les opérations logiques

 ET (AND):
Retourne Vrai si toutes les conditions sont vraies.
Exemple :

Exemple

Si (âge >= 18 ET nom == "Alice") alors :

Afficher "Accès autorisé."
 OU (OR):
Retourne Vrai si au moins une condition est vraie.
Exemple :
Exemple

Si (note >= 16 OU participation == "excellente") alors :

Afficher "Félicitations."
 NON (NOT):
Inverse la valeur d'une condition.
Exemple :
Exemple

Si (NON est_connecté) alors :

Afficher "Veuillez vous connecter."
 Table de vérité :
A B A ET B A OU B NON A
Vrai Vrai Vrai Vrai Faux
Fau
Vrai Faux Vrai Faux
x
Faux Vrai Faux Vrai Vrai
Fau
Faux Faux Faux Vrai
x

3. Priorité des opérateurs

 Règles de priorité :
L'ordre d'évaluation des opérations est déterminé par leur priorité.
o Parenthèses () : Priorité la plus élevée.
o Multiplication *, Division /, Division entière //, Modulo %.
o Addition +, Soustraction -.
o Opérateurs logiques : NON > ET > OU.
 Exemple :
Exemple

résultat = 5 + 3 * 2 # résultat = 11 (car 3 * 2 est évalué en premier)

 résultat = (5 + 3) * 2 # résultat = 16 (car les parenthèses sont prioritaires)

4. Lecture et écriture (interaction avec l'utilisateur)

 Lecture (entrée utilisateur) :

Permet de récupérer des données saisies par l'utilisateur.
Exemple en pseudocode :

Exemple

Afficher "Entrez votre âge :"

Lire âge
 Écriture (affichage de résultats) :
Permet d'afficher des informations à l'utilisateur.
Exemple en pseudocode :
Exemple

Afficher "Votre âge est :", âge

 Exemple complet :
Exemple

Début
Afficher "Entrez un nombre :"
Lire nombre
carré = nombre * nombre
Afficher "Le carré de", nombre, "est", carré
Fin

5. Exercices pratiques

a) Exercice 1 : Calcul de la moyenne

 Énoncé :
Écrivez un algorithme qui demande à l'utilisateur trois notes et affiche
leur moyenne.
 Solution :
Exemple

Début
Afficher "Entrez la première note :"
Lire note1
Afficher "Entrez la deuxième note :"
Lire note2
Afficher "Entrez la troisième note :"
Lire note3
moyenne = (note1 + note2 + note3) / 3
Afficher "La moyenne est :", moyenne
 Fin

b) Exercice 2 : Vérification d'un nombre pair

 Énoncé :
Écrivez un algorithme qui demande un nombre à l'utilisateur et affiche
s'il est pair ou impair.
 Solution :
Exemple

Début
Afficher "Entrez un nombre :"
Lire nombre
Si (nombre % 2 == 0) alors :
Afficher "Le nombre est pair."
Sinon :
Afficher "Le nombre est impair."
Fin

c) Exercice 3 : Calcul du prix TTC

 Énoncé :
Écrivez un algorithme qui demande un prix HT et un taux de TVA à
l'utilisateur, puis calcule et affiche le prix TTC.
 Solution :
Exemple

Début
Afficher "Entrez le prix HT :"
Lire prix_ht
Afficher "Entrez le taux de TVA (en %) :"
Lire taux_tva
tva = prix_ht * (taux_tva / 100)
prix_ttc = prix_ht + tva
Afficher "Le prix TTC est :", prix_ttc
Fin

6. Conclusion

 Les opérations arithmétiques et logiques sont fondamentales pour

manipuler des données et prendre des décisions.
 La priorité des opérateurs garantit l'exactitude des calculs.
 L'interaction avec l'utilisateur (lecture et écriture) est essentielle pour
créer des programmes utiles et interactifs.
Module 5 : Résolution de problèmes simples

Durée : 6 heures

1. Algorithmes de calcul

a) Somme

 Objectif : Calculer la somme d'une série de nombres.

 Exemple :
Exemple

Début
somme = 0
Pour i allant de 1 à 5 :
Afficher "Entrez le nombre", i, ":"
Lire nombre
somme = somme + nombre
Afficher "La somme est :", somme
Fin

b) Moyenne

 Objectif : Calculer la moyenne d'une série de nombres.

 Exemple :
Exemple

Début
somme = 0
compteur = 0
Répéter :
Afficher "Entrez un nombre (ou 0 pour terminer) :"
Lire nombre
Si (nombre != 0) alors :
somme = somme + nombre
compteur = compteur + 1
Jusqu'à (nombre == 0)
Si (compteur > 0) alors :
moyenne = somme / compteur
Afficher "La moyenne est :", moyenne
Sinon :
Afficher "Aucun nombre saisi."
Fin

c) Maximum

 Objectif : Trouver le plus grand nombre dans une série.

 Exemple :
 Exemple

Début
maximum = -∞ // Initialisation à une valeur très petite
Répéter :
Afficher "Entrez un nombre (ou 0 pour terminer) :"
Lire nombre
Si (nombre != 0 ET nombre > maximum) alors :
maximum = nombre
Jusqu'à (nombre == 0)
Afficher "Le maximum est :", maximum
Fin

d) Minimum

 Objectif : Trouver le plus petit nombre dans une série.

 Exemple :
Exemple

Début
minimum = +∞ // Initialisation à une valeur très grande
Répéter :
Afficher "Entrez un nombre (ou 0 pour terminer) :"
Lire nombre
Si (nombre != 0 ET nombre < minimum) alors :
minimum = nombre
Jusqu'à (nombre == 0)
Afficher "Le minimum est :", minimum
Fin

2. Problèmes classiques

a) Échange de valeurs entre deux variables

 Objectif : Permuter les valeurs de deux variables.

 Exemple :
Exemple

Début
Afficher "Entrez la valeur de A :"
Lire A
Afficher "Entrez la valeur de B :"
Lire B
temp = A // Variable temporaire
A=B
B = temp
Afficher "Après échange, A =", A, "et B =", B
Fin

b) Vérification d’un nombre pair ou impair

  Objectif : Déterminer si un nombre est pair ou impair.
 Exemple :
Exemple

Début
Afficher "Entrez un nombre :"
Lire nombre
Si (nombre % 2 == 0) alors :
Afficher "Le nombre est pair."
Sinon :
Afficher "Le nombre est impair."
Fin

c) Recherche dans une liste simple

 Objectif : Trouver si une valeur donnée est présente dans une liste.
 Exemple :
Exemple

Début
liste = [5, 10, 15, 20, 25]
Afficher "Entrez un nombre à rechercher :"
Lire nombre_recherché
trouvé = Faux
Pour chaque élément dans liste :
Si (élément == nombre_recherché) alors :
trouvé = Vrai
Sortir de la boucle
Si (trouvé) alors :
Afficher "Le nombre est dans la liste."
Sinon :
Afficher "Le nombre n'est pas dans la liste."
Fin

3. Mise en pratique avec des exercices

a) Exercice 1 : Calcul de la factorielle

 Énoncé :
Écrivez un algorithme pour calculer la factorielle d'un nombre N (N! = 1
× 2 × 3 × ... × N).
 Solution :
Exemple

Début
Afficher "Entrez un nombre N :"
Lire N
factorielle = 1
Pour i allant de 1 à N :
 factorielle = factorielle * i
Afficher "La factorielle de", N, "est", factorielle
Fin

b) Exercice 2 : Vérification d'un palindrome

 Énoncé :
Écrivez un algorithme pour vérifier si un mot est un palindrome (se lit
de la même manière à l'endroit et à l'envers).
 Solution :
Exemple

Début
Afficher "Entrez un mot :"
Lire mot
inversé = ""
Pour i allant de la longueur(mot) - 1 à 0 :
inversé = inversé + mot[i]
Si (mot == inversé) alors :
Afficher "Le mot est un palindrome."
Sinon :
Afficher "Le mot n'est pas un palindrome."
Fin

c) Exercice 3 : Recherche du plus grand diviseur commun (PGCD)

 Énoncé :
Écrivez un algorithme pour calculer le PGCD de deux nombres en
utilisant l'algorithme d'Euclide.
 Solution :
Exemple

Début
Afficher "Entrez le premier nombre :"
Lire A
Afficher "Entrez le deuxième nombre :"
Lire B
Tant que (B != 0) :
temp = B
B=A%B
A = temp
Afficher "Le PGCD est :", A
Fin

4. Conclusion

 Les algorithmes de calcul (somme, moyenne, maximum, minimum)

sont des bases essentielles en programmation.
 Les problèmes classiques (échange de valeurs, vérification de parité,
recherche dans une liste) permettent de développer une logique
algorithmique solide.
 La pratique régulière d'exercices variés renforce la compréhension et la
capacité à résoudre des problèmes.
Module 6 : Initiation aux tableaux et boucles imbriquées

Durée : 6 heures

1. Introduction aux tableaux (unidimensionnels)

a) Définition

 Un tableau est une structure de données qui permet de stocker

plusieurs valeurs de même type dans une seule variable.
 Les éléments d'un tableau sont accessibles via un indice (position).
 Exemple :
Exemple

notes = [15, 12, 18, 10] # Un tableau de 4 éléments

b) Avantages des tableaux

 Permettent de gérer des collections de données de manière organisée.

 Facilitent les opérations répétitives sur des ensembles de valeurs.

c) Déclaration et initialisation

 En pseudocode :

Exemple

Déclarer tableau[taille] // Exemple : tableau[5]

 Exemple d'initialisation :
Exemple

notes = [15, 12, 18, 10, 14]

2. Parcours de tableaux avec des boucles

a) Parcours simple

 Utilisation d'une boucle pour pour accéder à chaque élément du

tableau.
 Exemple :
Exemple

Début
notes = [15, 12, 18, 10, 14]
 Pour i allant de 0 à 4 :
Afficher "Note", i + 1, ":", notes[i]
Fin

b) Parcours avec une boucle tant que

 Utilisation d'une boucle tant que pour parcourir le tableau.

 Exemple :
Exemple

Début
notes = [15, 12, 18, 10, 14]
i=0
Tant que (i < 5) :
Afficher "Note", i + 1, ":", notes[i]
i=i+1
Fin

3. Somme et moyenne des éléments d’un tableau

a) Calcul de la somme

 Parcourir le tableau et accumuler la somme des éléments.

 Exemple :
Exemple

Début
notes = [15, 12, 18, 10, 14]
somme = 0
Pour i allant de 0 à 4 :
somme = somme + notes[i]
Afficher "La somme des notes est :", somme
Fin

b) Calcul de la moyenne

 Diviser la somme des éléments par le nombre d'éléments.

 Exemple :
Exemple

Début
notes = [15, 12, 18, 10, 14]
somme = 0
Pour i allant de 0 à 4 :
somme = somme + notes[i]
moyenne = somme / 5
Afficher "La moyenne des notes est :", moyenne
Fin
4. Boucles imbriquées pour des tableaux simples

a) Définition

 Une boucle imbriquée est une boucle à l'intérieur d'une autre boucle.
 Utile pour parcourir des structures multidimensionnelles ou effectuer
des opérations complexes.

b) Exemple : Recherche de doublons dans un tableau

 Vérifier si un tableau contient des éléments en double.

 Exemple :
Exemple

Début
tableau = [5, 10, 15, 10, 20]
doublon = Faux
Pour i allant de 0 à 4 :
Pour j allant de i + 1 à 4 :
Si (tableau[i] == tableau[j]) alors :
doublon = Vrai
Sortir des boucles
Si (doublon) alors :
Afficher "Le tableau contient des doublons."
Sinon :
Afficher "Le tableau ne contient pas de doublons."
Fin

c) Exemple : Affichage d'une table de multiplication

 Utiliser des boucles imbriquées pour générer une table de

multiplication.
 Exemple :
Exemple

Début
Pour i allant de 1 à 10 :
Pour j allant de 1 à 10 :
Afficher i, "x", j, "=", i * j
Afficher "" // Saut de ligne après chaque ligne de la table
Fin

5. Mise en pratique avec des exercices

a) Exercice 1 : Recherche du maximum dans un tableau

 Énoncé :
Écrivez un algorithme pour trouver la valeur maximale dans un tableau.
  Solution :
Exemple

Début
tableau = [15, 12, 18, 10, 14]
maximum = tableau[0]
Pour i allant de 1 à 4 :
Si (tableau[i] > maximum) alors :
maximum = tableau[i]
Afficher "La valeur maximale est :", maximum
Fin

b) Exercice 2 : Inversion d'un tableau

 Énoncé :
Écrivez un algorithme pour inverser l'ordre des éléments d'un tableau.
 Solution :
Exemple

Début
tableau = [15, 12, 18, 10, 14]
Pour i allant de 0 à 2 : // Échanger les éléments jusqu'au milieu
temp = tableau[i]
tableau[i] = tableau[4 - i]
tableau[4 - i] = temp
Afficher "Tableau inversé :", tableau
Fin

c) Exercice 3 : Recherche d'un élément dans un tableau

 Énoncé :
Écrivez un algorithme pour vérifier si un élément donné est présent
dans un tableau.
 Solution :
Exemple

Début
tableau = [15, 12, 18, 10, 14]
Afficher "Entrez un nombre à rechercher :"
Lire nombre_recherché
trouvé = Faux
Pour i allant de 0 à 4 :
Si (tableau[i] == nombre_recherché) alors :
trouvé = Vrai
Sortir de la boucle
Si (trouvé) alors :
Afficher "Le nombre est dans le tableau."
Sinon :
Afficher "Le nombre n'est pas dans le tableau."
Fin
6. Conclusion

 Les tableaux sont des structures de données essentielles pour gérer

des collections de valeurs.
 Les boucles permettent de parcourir et manipuler efficacement les
tableaux.
 Les boucles imbriquées sont utiles pour résoudre des problèmes plus
complexes.
Module 7 : Initiation aux fonctions et procédures

Durée : 4 heures

1. Introduction aux sous-programmes (fonctions et procédures)

a) Définition

 Fonction :
Un sous-programme qui effectue une tâche spécifique et retourne une
valeur.
Exemple : Une fonction pour calculer la somme de deux nombres.
 Procédure :
Un sous-programme qui effectue une tâche spécifique mais ne retourne
pas de valeur.
Exemple : Une procédure pour afficher un message.

b) Avantages des sous-programmes

 Modularité : Diviser un programme en petits modules réutilisables.

 Réutilisabilité : Éviter la duplication de code.
 Lisibilité : Rendre le code plus clair et plus facile à maintenir.

2. Paramètres d’entrée et de sortie

a) Paramètres d’entrée

 Données passées à une fonction ou une procédure pour qu'elle les

utilise.
 Exemple :
Exemple

Fonction Additionner(a, b) :
Retourner a + b

b) Paramètres de sortie

 Valeur(s) retournée(s) par une fonction.

 Exemple :
Exemple

résultat = Additionner(5, 3) # résultat = 8

c) Exemple de procédure avec paramètres

  Une procédure peut aussi prendre des paramètres mais ne retourne
rien.
 Exemple :
Exemple

Procédure AfficherMessage(message) :
Afficher message

3. Appel de fonctions dans un algorithme

a) Appel simple

 Utiliser une fonction dans un algorithme pour obtenir un résultat.

 Exemple :
Exemple

Début
x=5
y=3
somme = Additionner(x, y)
Afficher "La somme est :", somme
Fin

b) Appel de procédure

 Exécuter une procédure pour effectuer une action.

 Exemple :
Exemple

Début
AfficherMessage("Bonjour le monde !")
Fin

4. Exercices pratiques : création de fonctions simples

a) Exercice 1 : Fonction pour calculer la moyenne

 Énoncé :
Écrivez une fonction qui prend trois nombres en entrée et retourne leur
moyenne.
 Solution :
Exemple

Fonction CalculerMoyenne(a, b, c) :
Retourner (a + b + c) / 3
 Début
Afficher "La moyenne est :", CalculerMoyenne(10, 15, 20)
Fin

b) Exercice 2 : Procédure pour afficher un tableau

 Énoncé :
Écrivez une procédure qui prend un tableau en entrée et affiche ses
éléments.
 Solution :
Exemple

Procédure AfficherTableau(tableau) :
Pour chaque élément dans tableau :
Afficher élément

Début
notes = [15, 12, 18, 10, 14]
AfficherTableau(notes)
Fin

c) Exercice 3 : Fonction pour vérifier un nombre premier

 Énoncé :
Écrivez une fonction qui vérifie si un nombre est premier.
 Solution :
Exemple

Fonction EstPremier(n) :
Si (n < 2) alors :
Retourner Faux
Pour i allant de 2 à n - 1 :
Si (n % i == 0) alors :
Retourner Faux
Retourner Vrai

Début
Afficher "7 est premier ?", EstPremier(7)
Afficher "10 est premier ?", EstPremier(10)
Fin

d) Exercice 4 : Fonction pour calculer la factorielle

 Énoncé :
Écrivez une fonction pour calculer la factorielle d'un nombre N (N! = 1
× 2 × 3 × ... × N).
 Solution :
Exemple

Fonction Factorielle(n) :
 Si (n == 0) alors :
Retourner 1
résultat = 1
Pour i allant de 1 à n :
résultat = résultat * i
Retourner résultat

Début
Afficher "5! =", Factorielle(5)
Fin

5. Conclusion

 Les fonctions et procédures permettent de structurer et modulariser un

programme.
 Elles améliorent la réutilisabilité, la lisibilité et la maintenance du code.
 Les paramètres d'entrée et de sortie rendent les sous-programmes
flexibles et puissants.
Module 8 : Projets pratiques

Durée : 6 heures

1. Mise en application des concepts étudiés

 Ce module vise à consolider les connaissances acquises en

algorithmique à travers des projets concrets.
 Les projets permettront de pratiquer :
o Les structures de contrôle (séquences, conditions, boucles).
o Les tableaux et les boucles imbriquées.
o Les fonctions et procédures.
o La gestion des entrées/sorties.

2. Réalisation de petits projets

a) Projet 1 : Calculatrice simple

 Objectif :
Créer une calculatrice qui effectue des opérations de base (addition,
soustraction, multiplication, division).
 Fonctionnalités :
o Demander à l'utilisateur de choisir une opération.
o Lire deux nombres en entrée.
o Afficher le résultat de l'opération choisie.
 Exemple de structure :
Exemple

Début
Afficher "Choisissez une opération :"
Afficher "1. Addition"
Afficher "2. Soustraction"
Afficher "3. Multiplication"
Afficher "4. Division"
Lire choix
Afficher "Entrez le premier nombre :"
Lire a
Afficher "Entrez le deuxième nombre :"
Lire b
Si (choix == 1) alors :
résultat = a + b
Sinon si (choix == 2) alors :
résultat = a - b
Sinon si (choix == 3) alors :
résultat = a * b
 Sinon si (choix == 4) alors :
Si (b != 0) alors :
résultat = a / b
Sinon :
Afficher "Erreur : division par zéro."
Fin
Afficher "Le résultat est :", résultat
Fin

b) Projet 2 : Tri d’une liste d’entiers

 Objectif :
Implémenter un algorithme de tri (ex. : tri à bulles) pour ordonner une
liste d'entiers.
 Fonctionnalités :
o Lire une liste d'entiers en entrée.
o Trier la liste en ordre croissant.
o Afficher la liste triée.
 Exemple de structure :
Exemple

Début
Afficher "Entrez le nombre d'éléments :"
Lire n
Déclarer liste[n]
Pour i allant de 0 à n - 1 :
Afficher "Entrez l'élément", i + 1, ":"
Lire liste[i]
// Tri à bulles
Pour i allant de 0 à n - 1 :
Pour j allant de 0 à n - i - 2 :
Si (liste[j] > liste[j + 1]) alors :
temp = liste[j]
liste[j] = liste[j + 1]
liste[j + 1] = temp
Afficher "Liste triée :", liste
Fin

c) Projet 3 : Conversion d'unités

 Objectif :
Créer un programme pour convertir des unités (température, monnaie,
etc.).
 Fonctionnalités :
o Demander à l'utilisateur de choisir le type de conversion.
o Lire la valeur à convertir.
o Afficher le résultat de la conversion.
 Exemple de structure :
Exemple
 Début
Afficher "Choisissez une conversion :"
Afficher "1. Celsius vers Fahrenheit"
Afficher "2. Fahrenheit vers Celsius"
Afficher "3. Euros vers Dollars"
Afficher "4. Dollars vers Euros"
Lire choix
Si (choix == 1 ou choix == 2) alors :
Afficher "Entrez la température :"
Lire température
Si (choix == 1) alors :
résultat = (température * 9/5) + 32
Afficher température, "°C =", résultat, "°F"
Sinon :
résultat = (température - 32) * 5/9
Afficher température, "°F =", résultat, "°C"
Sinon si (choix == 3 ou choix == 4) alors :
Afficher "Entrez le montant :"
Lire montant
Si (choix == 3) alors :
résultat = montant * 1.18 // Taux de change fictif
Afficher montant, "€ =", résultat, "$"
Sinon :
résultat = montant / 1.18
Afficher montant, "$ =", résultat, "€"
Sinon :
Afficher "Choix invalide."
Fin

3. Présentation des projets en groupe ou individuellement

a) Objectifs de la présentation

 Expliquer le fonctionnement de l'algorithme.

 Démontrer les résultats obtenus.
 Répondre aux questions des autres participants.

b) Conseils pour la présentation

 Utiliser des exemples concrets pour illustrer le projet.

 Montrer les entrées/sorties du programme.
 Expliquer les choix algorithmiques (ex. : pourquoi un tri à bulles ?).

c) Évaluation

 Clarté de la présentation.
 Fonctionnalité du projet.
 Qualité du code (structure, commentaires, etc.).
4. Conclusion

 Les projets pratiques permettent de renforcer les compétences en

algorithmique.
 Ils encouragent la créativité et la résolution de problèmes.
 La présentation des projets favorise la communication et le partage des
connaissances.
Module 9 : Évaluation et conclusion

Durée : 2 heures

1. Évaluation des compétences

a) QCM pour évaluer les connaissances théoriques

 Objectif :
Vérifier la compréhension des concepts théoriques abordés dans le
cours.
 Exemples de questions :
1. Qu'est-ce qu'un algorithme ?
a) Un langage de programmation
b) Une suite d'instructions pour résoudre un problème
c) Un type de donnée
2. Quelle structure permet de répéter une action plusieurs fois ?
a) Condition
b) Boucle
c) Variable
3. Quel est le résultat de l'opération 5 % 2 ?
a) 2
b) 1
c) 0
4. Quelle boucle est utilisée lorsque le nombre d'itérations est
connu à l'avance ?
a) tant que
b) pour
c) si
5. Quelle est la différence entre une fonction et une procédure ?
a) Une fonction retourne une valeur, une procédure non
b) Une procédure retourne une valeur, une fonction non
c) Aucune différence

b) Résolution de problèmes pour évaluer les compétences pratiques

 Objectif :
Tester la capacité à appliquer les concepts algorithmiques pour
résoudre des problèmes concrets.
 Exemples de problèmes :
1. Écrivez un algorithme pour calculer la somme des nombres pairs
entre 1 et 100.
2. Écrivez une fonction qui prend un tableau en entrée et retourne
son élément maximum.
 3. Créez un algorithme pour vérifier si une chaîne de caractères est
un palindrome.
4. Écrivez un programme qui convertit une température de Celsius
en Fahrenheit.

2. Synthèse du cours

a) Récapitulatif des concepts clés

 Algorithmique :
o Définition et importance des algorithmes.
o Structures de contrôle (séquence, décision, répétition).
o Variables, types de données et constantes.
 Tableaux et boucles :
o Manipulation des tableaux unidimensionnels.
o Utilisation des boucles imbriquées.
 Fonctions et procédures :
o Définition et appel de sous-programmes.
o Paramètres d'entrée et de sortie.
 Projets pratiques :
o Application des concepts à des problèmes réels.
o Présentation et communication des résultats.

b) Conseils pour aller plus loin en algorithmique

 Pratique régulière :
o Résoudre des problèmes sur des plateformes comme LeetCode,
HackerRank ou CodinGame.
o Participer à des défis de programmation.
 Apprentissage de langages de programmation :
o Python, Java, C++ pour mettre en pratique les algorithmes.
 Approfondissement des concepts :
o Structures de données avancées (listes chaînées, arbres,
graphes).
o Algorithmes de tri et de recherche avancés (tri rapide, recherche
binaire).
o Complexité algorithmique (notation Big O).
 Projets personnels :
o Développer des applications simples (gestion de tâches,
calculatrice scientifique).
o Contribuer à des projets open source.

3. Conclusion
 Ce cours a permis de poser les bases de l'algorithmique, en couvrant
les concepts essentiels et en les appliquant à des problèmes concrets.
 La pratique continue et l'exploration de sujets avancés sont
essentielles pour maîtriser l'algorithmique et la programmation.
 Les compétences acquises ouvrent la voie à des opportunités dans des
domaines variés, tels que le développement logiciel, la science des
données et l'intelligence artificielle.
PROGRAMME DE COURS
D'ALGORITHME NIVEAU 2
Module 1 : Rappel et consolidation des bases

Durée : 3 heures

1. Rappel des concepts fondamentaux

a) Variables

 Définition :
Une variable est un espace mémoire nommé qui stocke une valeur
pouvant changer pendant l'exécution d'un programme.
 Types de données courants :
o Entier (int) : Exemple : age = 25
o Réel (float) : Exemple : prix = 19.99
o Chaîne de caractères (string) : Exemple : nom = "Alice"
o Booléen (bool) : Exemple : est_connecte = True

b) Conditions

 Structure si...alors...sinon :
Permet d'exécuter des actions en fonction d'une condition.
Exemple :

Exemple

Si (age >= 18) alors :

Afficher "Majeur"
Sinon :
Afficher "Mineur"

c) Boucles

 Boucle pour :
Répète une action un nombre précis de fois.
Exemple :

Exemple

Pour i allant de 1 à 5 :
Afficher "Bonjour"
 Boucle tant que :
Répète une action tant qu'une condition est vraie.
Exemple :
Exemple
 Tant que (somme < 100) :
Ajouter 10 à somme

2. Révision sur les tableaux unidimensionnels

a) Définition

 Un tableau est une structure de données qui stocke plusieurs valeurs

de même type dans une seule variable.
 Exemple :
Exemple

notes = [15, 12, 18, 10, 14]

b) Accès aux éléments

 Les éléments d'un tableau sont accessibles via un indice (position).

 Exemple :
Exemple

Afficher notes[0] # Affiche 15

c) Parcours d'un tableau

 Utilisation d'une boucle pour parcourir tous les éléments.

 Exemple :
Exemple

Pour i allant de 0 à 4 :
Afficher notes[i]

d) Opérations courantes

 Somme des éléments :

Exemple

somme = 0
Pour i allant de 0 à 4 :
somme = somme + notes[i]
 Recherche d'un élément :
Exemple

trouvé = Faux
Pour i allant de 0 à 4 :
Si (notes[i] == 18) alors :
trouvé = Vrai
 Sortir de la boucle

3. Exemples pratiques pour consolider les acquis du niveau 1

a) Exercice 1 : Calcul de la moyenne des notes

 Énoncé :
Écrivez un algorithme qui calcule la moyenne des notes d'un tableau.
 Solution :
Exemple

Début
notes = [15, 12, 18, 10, 14]
somme = 0
Pour i allant de 0 à 4 :
somme = somme + notes[i]
moyenne = somme / 5
Afficher "La moyenne est :", moyenne
Fin

b) Exercice 2 : Recherche du maximum dans un tableau

 Énoncé :
Écrivez un algorithme pour trouver la valeur maximale dans un tableau.
 Solution :
Exemple

Début
notes = [15, 12, 18, 10, 14]
maximum = notes[0]
Pour i allant de 1 à 4 :
Si (notes[i] > maximum) alors :
maximum = notes[i]
Afficher "La valeur maximale est :", maximum
Fin

c) Exercice 3 : Vérification d'un nombre pair ou impair

 Énoncé :
Écrivez un algorithme qui vérifie si un nombre est pair ou impair.
 Solution :
Exemple

Début
Afficher "Entrez un nombre :"
Lire nombre
Si (nombre % 2 == 0) alors :
Afficher "Le nombre est pair."
Sinon :
 Afficher "Le nombre est impair."
Fin

d) Exercice 4 : Inversion d'un tableau

 Énoncé :
Écrivez un algorithme pour inverser l'ordre des éléments d'un tableau.
 Solution :
Exemple

Début
notes = [15, 12, 18, 10, 14]
Pour i allant de 0 à 2 : // Échanger les éléments jusqu'au milieu
temp = notes[i]
notes[i] = notes[4 - i]
notes[4 - i] = temp
Afficher "Tableau inversé :", notes
Fin

4. Conclusion

 Ce module a permis de revoir et consolider les bases essentielles de

l'algorithmique.
 Les concepts de variables, conditions, boucles et tableaux sont
fondamentaux pour aborder des problèmes plus complexes.
 La pratique régulière est essentielle pour maîtriser ces concepts et
progresser en programmation.
Module 2 : Structures conditionnelles avancées

Durée : 3 heures

1. Imbrication de conditions (si...sinon imbriqués)

a) Définition

 Les conditions imbriquées permettent de gérer des décisions

complexes en plaçant une condition à l'intérieur d'une autre.
 Exemple :
Exemple

Si (condition1) alors :
Si (condition2) alors :
Action1
Sinon :
Action2
Sinon :
Action3

b) Exemple pratique

 Énoncé :
Écrivez un algorithme pour déterminer si un nombre est positif, négatif
ou nul.
 Solution :
Exemple

Début
Afficher "Entrez un nombre :"
Lire nombre
Si (nombre > 0) alors :
Afficher "Le nombre est positif."
Sinon :
Si (nombre < 0) alors :
Afficher "Le nombre est négatif."
Sinon :
Afficher "Le nombre est nul."
Fin

2. Utilisation de conditions multiples avec opérateurs logiques (ET,

OU, NON)

a) Opérateurs logiques
  ET (AND) :
Retourne Vrai si toutes les conditions sont vraies.
Exemple :

Exemple

Si (age >= 18 ET nom == "Alice") alors :

Afficher "Accès autorisé."
 OU (OR) :
Retourne Vrai si au moins une condition est vraie.
Exemple :
Exemple

Si (note >= 16 OU participation == "excellente") alors :

Afficher "Félicitations."
 NON (NOT) :
Inverse la valeur d'une condition.
Exemple :
Exemple

Si (NON est_connecté) alors :

Afficher "Veuillez vous connecter."

b) Exemple pratique

 Énoncé :
Écrivez un algorithme pour vérifier si un nombre est compris entre 10
et 20.
 Solution :
Exemple

Début
Afficher "Entrez un nombre :"
Lire nombre
Si (nombre >= 10 ET nombre <= 20) alors :
Afficher "Le nombre est compris entre 10 et 20."
Sinon :
Afficher "Le nombre n'est pas compris entre 10 et 20."
Fin

3. Études de cas

a) Validation de saisie utilisateur

 Objectif :
S'assurer que les données entrées par l'utilisateur sont valides.
 Exemple :
 Exemple

Début
Répéter :
Afficher "Entrez un nombre entre 1 et 100 :"
Lire nombre
Jusqu'à (nombre >= 1 ET nombre <= 100)
Afficher "Nombre valide :", nombre
Fin

b) Calculs conditionnels

 Objectif :
Effectuer des calculs en fonction de conditions spécifiques.
 Exemple :
Exemple

Début
Afficher "Entrez votre âge :"
Lire age
Si (age < 18) alors :
tarif = 10
Sinon si (age >= 18 ET age <= 60) alors :
tarif = 20
Sinon :
tarif = 15
Afficher "Le tarif est :", tarif
Fin

4. Exercices pratiques : résoudre des problèmes à plusieurs cas

possibles

a) Exercice 1 : Calcul de la note finale

 Énoncé :
Écrivez un algorithme pour calculer la note finale d'un étudiant en
fonction de ses notes de contrôle continu et d'examen.
o Si la moyenne est supérieure ou égale à 16, afficher "Très bien".
o Si la moyenne est entre 12 et 15, afficher "Bien".
o Si la moyenne est entre 10 et 11, afficher "Passable".
o Sinon, afficher "Insuffisant".
 Solution :
Exemple

Début
Afficher "Entrez la note de contrôle continu :"
Lire cc
Afficher "Entrez la note d'examen :"
Lire exam
 moyenne = (cc + exam) / 2
Si (moyenne >= 16) alors :
Afficher "Très bien"
Sinon si (moyenne >= 12 ET moyenne < 16) alors :
Afficher "Bien"
Sinon si (moyenne >= 10 ET moyenne < 12) alors :
Afficher "Passable"
Sinon :
Afficher "Insuffisant"
Fin

b) Exercice 2 : Gestion des droits d'accès

 Énoncé :
Écrivez un algorithme pour gérer les droits d'accès en fonction du rôle
de l'utilisateur (admin, utilisateur, invité).
o Un admin a accès à toutes les fonctionnalités.
o Un utilisateur a accès à certaines fonctionnalités.
o Un invité a un accès limité.
 Solution :
Exemple

Début
Afficher "Entrez votre rôle (admin, utilisateur, invité) :"
Lire rôle
Si (rôle == "admin") alors :
Afficher "Accès complet."
Sinon si (rôle == "utilisateur") alors :
Afficher "Accès partiel."
Sinon si (rôle == "invité") alors :
Afficher "Accès limité."
Sinon :
Afficher "Rôle non reconnu."
Fin

c) Exercice 3 : Calcul de la réduction

 Énoncé :
Écrivez un algorithme pour calculer une réduction en fonction du
montant d'achat.
o Si le montant est supérieur à 100 €, appliquer une réduction de
10 %.
o Si le montant est entre 50 € et 100 €, appliquer une réduction de
5 %.
o Sinon, aucune réduction.
 Solution :
Exemple

Début
 Afficher "Entrez le montant d'achat :"
Lire montant
Si (montant > 100) alors :
réduction = montant * 0.10
Sinon si (montant >= 50 ET montant <= 100) alors :
réduction = montant * 0.05
Sinon :
réduction = 0
montant_final = montant - réduction
Afficher "Montant final :", montant_final
Fin

5. Conclusion

 Les structures conditionnelles avancées permettent de gérer des

décisions complexes et des cas multiples.
 L'imbrication de conditions et l'utilisation d'opérateurs logiques rendent
les algorithmes plus flexibles et puissants.
 La pratique régulière d'exercices variés renforce la compréhension et la
capacité à résoudre des problèmes complexes.
Module 3 : Les tableaux multidimensionnels

Durée : 4 heures

1. Introduction aux tableaux à deux dimensions

a) Définition

 Un tableau à deux dimensions (2D) est une structure de données qui

organise les éléments en lignes et colonnes.
 Exemple :
Exemple

matrice = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]

b) Accès aux éléments

 Les éléments sont accessibles via deux indices : un pour la ligne et un

pour la colonne.
 Exemple :
Exemple

Afficher matrice[1][2] # Affiche 6

c) Initialisation

 En pseudocode :

Exemple

Déclarer matrice[lignes][colonnes]
 Exemple :
Exemple

matrice = [
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]
]

2. Parcours et manipulation de tableaux multidimensionnels

a) Parcours simple

 Utilisation de boucles imbriquées pour parcourir les lignes et les

colonnes.
 Exemple :
Exemple

Pour i allant de 0 à 2 :
Pour j allant de 0 à 2 :
Afficher matrice[i][j]

b) Manipulation des éléments

 Modification des valeurs dans un tableau 2D.

 Exemple :
Exemple

Pour i allant de 0 à 2 :
Pour j allant de 0 à 2 :
matrice[i][j] = i + j

3. Applications : matrices, grilles (exemple : jeu de morpion)

a) Matrices

 Les tableaux 2D sont souvent utilisés pour représenter des matrices en

mathématiques.
 Exemple : Addition de deux matrices.
Exemple

Début
matrice1 = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
matrice2 = [
[9, 8, 7],
[6, 5, 4],
[3, 2, 1]
]
résultat = [
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]
]
Pour i allant de 0 à 2 :
Pour j allant de 0 à 2 :
résultat[i][j] = matrice1[i][j] + matrice2[i][j]
 Afficher résultat
Fin

b) Grilles (exemple : jeu de morpion)

 Les tableaux 2D sont utilisés pour représenter des grilles, comme dans
un jeu de morpion.
 Exemple : Initialisation d'une grille de morpion.
Exemple

Début
grille = [
[" ", " ", " "],
[" ", " ", " "],
[" ", " ", " "]
]
Afficher grille
Fin

4. Exercices

a) Exercice 1 : Somme des lignes et colonnes

 Énoncé :
Écrivez un algorithme pour calculer la somme de chaque ligne et de
chaque colonne d'une matrice.
 Solution :
Exemple

Début
matrice = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
Pour i allant de 0 à 2 :
somme_ligne = 0
Pour j allant de 0 à 2 :
somme_ligne = somme_ligne + matrice[i][j]
Afficher "Somme de la ligne", i + 1, ":", somme_ligne
Pour j allant de 0 à 2 :
somme_colonne = 0
Pour i allant de 0 à 2 :
somme_colonne = somme_colonne + matrice[i][j]
Afficher "Somme de la colonne", j + 1, ":", somme_colonne
Fin

b) Exercice 2 : Recherche d’un élément spécifique

  Énoncé :
Écrivez un algorithme pour rechercher un élément spécifique dans une
matrice et afficher sa position.
 Solution :
Exemple

Début
matrice = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
Afficher "Entrez l'élément à rechercher :"
Lire élément
trouvé = Faux
Pour i allant de 0 à 2 :
Pour j allant de 0 à 2 :
Si (matrice[i][j] == élément) alors :
Afficher "Élément trouvé à la position (", i + 1, ",", j + 1, ")"
trouvé = Vrai
Sortir des boucles
Si (NON trouvé) alors :
Afficher "Élément non trouvé."
Fin

c) Exercice 3 : Transposition d'une matrice

 Énoncé :
Écrivez un algorithme pour transposer une matrice (échanger les lignes
et les colonnes).
 Solution :
Exemple

Début
matrice = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
transposée = [
[0, 0, 0],
[0, 0, 0],
[0, 0, 0]
]
Pour i allant de 0 à 2 :
Pour j allant de 0 à 2 :
transposée[j][i] = matrice[i][j]
Afficher "Matrice transposée :", transposée
Fin
5. Conclusion

 Les tableaux multidimensionnels sont des outils puissants pour

organiser et manipuler des données complexes.
 Ils sont largement utilisés dans des domaines comme les
mathématiques, les jeux et les simulations.
 La pratique régulière d'exercices permet de maîtriser leur utilisation et
de résoudre des problèmes variés.
Module 4 : Les algorithmes de tri et de recherche

Durée : 6 heures

1. Algorithmes de tri classiques

a) Tri par sélection

 Principe :
Sélectionner le plus petit élément et l'échanger avec le premier, puis
répéter pour le reste du tableau.
 Exemple :
Exemple

Début
Pour i allant de 0 à n - 2 :
min_index = i
Pour j allant de i + 1 à n - 1 :
Si (tableau[j] < tableau[min_index]) alors :
min_index = j
Échanger tableau[i] et tableau[min_index]
Fin
 Complexité : O(n²) dans tous les cas.

b) Tri par insertion

 Principe :
Insérer chaque élément à sa place dans la partie déjà triée du tableau.
 Exemple :
Exemple

Début
Pour i allant de 1 à n - 1 :
clé = tableau[i]
j=i-1
Tant que (j >= 0 ET tableau[j] > clé) :
tableau[j + 1] = tableau[j]
j=j-1
tableau[j + 1] = clé
Fin
 Complexité : O(n²) dans le pire cas, O(n) dans le meilleur cas (tableau
déjà trié).

c) Tri à bulles (bubble sort)

  Principe :
Comparer les éléments adjacents et les échanger si nécessaire, répéter
jusqu'à ce que le tableau soit trié.
 Exemple :
Exemple

Début
Pour i allant de 0 à n - 2 :
Pour j allant de 0 à n - i - 2 :
Si (tableau[j] > tableau[j + 1]) alors :
Échanger tableau[j] et tableau[j + 1]
Fin
 Complexité : O(n²) dans le pire cas, O(n) dans le meilleur cas (tableau
déjà trié).

2. Algorithmes de recherche

a) Recherche linéaire

 Principe :
Parcourir le tableau élément par élément jusqu'à trouver la valeur
recherchée.
 Exemple :
Exemple

Début
trouvé = Faux
Pour i allant de 0 à n - 1 :
Si (tableau[i] == valeur) alors :
trouvé = Vrai
Sortir de la boucle
Si (trouvé) alors :
Afficher "Élément trouvé à l'indice", i
Sinon :
Afficher "Élément non trouvé."
Fin
 Complexité : O(n) dans le pire cas.

b) Recherche dichotomique (sur tableau trié)

 Principe :
Diviser le tableau en deux parties et éliminer la moitié qui ne contient
pas la valeur recherchée.
 Exemple :
Exemple

Début
gauche = 0
 droite = n - 1
trouvé = Faux
Tant que (gauche <= droite) :
milieu = (gauche + droite) // 2
Si (tableau[milieu] == valeur) alors :
trouvé = Vrai
Sortir de la boucle
Sinon si (tableau[milieu] < valeur) alors :
gauche = milieu + 1
Sinon :
droite = milieu - 1
Si (trouvé) alors :
Afficher "Élément trouvé à l'indice", milieu
Sinon :
Afficher "Élément non trouvé."
Fin
 Complexité : O(log n) dans le pire cas.

3. Comparaison des performances (temps d'exécution)

Meilleur Pire Cas

Algorithme
cas cas moyen
Tri par sélection O(n²) O(n²) O(n²)
Tri par insertion O(n) O(n²) O(n²)
Tri à bulles O(n) O(n²) O(n²)
Recherche linéaire O(1) O(n) O(n)
Recherche O(log
O(1) O(log n)
dichotomique n)

4. Exercices pratiques : implémenter et tester chaque méthode

a) Exercice 1 : Implémentation du tri par sélection

 Énoncé :
Écrivez un algorithme pour trier un tableau en utilisant le tri par
sélection.
 Solution :
Exemple

Début
Pour i allant de 0 à n - 2 :
min_index = i
Pour j allant de i + 1 à n - 1 :
Si (tableau[j] < tableau[min_index]) alors :
min_index = j
Échanger tableau[i] et tableau[min_index]
Fin
b) Exercice 2 : Implémentation du tri par insertion

 Énoncé :
Écrivez un algorithme pour trier un tableau en utilisant le tri par
insertion.
 Solution :
Exemple

Début
Pour i allant de 1 à n - 1 :
clé = tableau[i]
j=i-1
Tant que (j >= 0 ET tableau[j] > clé) :
tableau[j + 1] = tableau[j]
j=j-1
tableau[j + 1] = clé
Fin

c) Exercice 3 : Implémentation du tri à bulles

 Énoncé :
Écrivez un algorithme pour trier un tableau en utilisant le tri à bulles.
 Solution :
Exemple

Début
Pour i allant de 0 à n - 2 :
Pour j allant de 0 à n - i - 2 :
Si (tableau[j] > tableau[j + 1]) alors :
Échanger tableau[j] et tableau[j + 1]
Fin

d) Exercice 4 : Implémentation de la recherche linéaire

 Énoncé :
Écrivez un algorithme pour rechercher un élément dans un tableau en
utilisant la recherche linéaire.
 Solution :
Exemple

Début
trouvé = Faux
Pour i allant de 0 à n - 1 :
Si (tableau[i] == valeur) alors :
trouvé = Vrai
Sortir de la boucle
Si (trouvé) alors :
Afficher "Élément trouvé à l'indice", i
Sinon :
Afficher "Élément non trouvé."
 Fin

e) Exercice 5 : Implémentation de la recherche dichotomique

 Énoncé :
Écrivez un algorithme pour rechercher un élément dans un tableau trié
en utilisant la recherche dichotomique.
 Solution :
Exemple

Début
gauche = 0
droite = n - 1
trouvé = Faux
Tant que (gauche <= droite) :
milieu = (gauche + droite) // 2
Si (tableau[milieu] == valeur) alors :
trouvé = Vrai
Sortir de la boucle
Sinon si (tableau[milieu] < valeur) alors :
gauche = milieu + 1
Sinon :
droite = milieu - 1
Si (trouvé) alors :
Afficher "Élément trouvé à l'indice", milieu
Sinon :
Afficher "Élément non trouvé."
Fin

5. Conclusion

 Les algorithmes de tri et de recherche sont fondamentaux en

informatique.
 Chaque algorithme a ses avantages et inconvénients en termes de
complexité et de performance.
 La pratique régulière permet de comprendre leurs mécanismes et de
choisir le bon algorithme en fonction du problème.
Module 5 : La récursivité

Durée : 5 heures

1. Notion de fonction récursive

a) Définition

 Une fonction récursive est une fonction qui s'appelle elle-même pour
résoudre un problème.
 Elle se compose de deux parties :
o Cas de base : Condition d'arrêt qui termine la récursion.
o Cas récursif : Appel de la fonction avec un problème plus petit.

b) Exemple simple

 Calcul de la factorielle :

Exemple

Fonction Factorielle(n) :
Si (n == 0) alors :
Retourner 1
Sinon :
Retourner n * Factorielle(n - 1)

2. Cas simples de récursivité

a) Calcul de factorielle

 Définition :
La factorielle d'un nombre entier positif n (notée n!) est le produit de
tous les entiers de 1 à n.
 Exemple :
Exemple

Fonction Factorielle(n) :
Si (n == 0) alors :
Retourner 1
Sinon :
Retourner n * Factorielle(n - 1)

b) Suite de Fibonacci
  Définition :
La suite de Fibonacci est une séquence où chaque nombre est la
somme des deux précédents (0, 1, 1, 2, 3, 5, 8, ...).
 Exemple :
Exemple

Fonction Fibonacci(n) :
Si (n == 0) alors :
Retourner 0
Sinon si (n == 1) alors :
Retourner 1
Sinon :
Retourner Fibonacci(n - 1) + Fibonacci(n - 2)

3. Applications pratiques

a) Recherche dans un arbre

 Définition :
La récursivité est souvent utilisée pour parcourir des structures
arborescentes (ex. : arbres binaires).
 Exemple :
Exemple

Fonction ParcoursArbre(noeud) :
Si (noeud != NULL) alors :
Afficher noeud.valeur
ParcoursArbre(noeud.gauche)
ParcoursArbre(noeud.droite)

b) Résolution de problèmes avec backtracking

 Définition :
Le backtracking est une technique de résolution de problèmes qui
explore toutes les solutions possibles en revenant en arrière si une
solution partielle est invalide.
 Exemple :
Exemple

Fonction RésoudreSudoku(grille) :
Si (grille est complète) alors :
Retourner Vrai
Pour chaque case vide :
Pour chaque nombre de 1 à 9 :
Si (nombre est valide dans la case) alors :
grille[case] = nombre
Si (RésoudreSudoku(grille)) alors :
Retourner Vrai
 grille[case] = 0 // Annuler l'affectation
Retourner Faux

4. Analyse des avantages et inconvénients de la récursivité

a) Avantages

 Simplicité : Les solutions récursives sont souvent plus simples et plus

lisibles.
 Diviser pour régner : Permet de diviser un problème complexe en
sous-problèmes plus simples.

b) Inconvénients

 Performance : Peut entraîner une surcharge due aux appels répétés

de la fonction.
 Limites de la pile : Risque de dépassement de la pile d'appels (stack
overflow) pour des récursions profondes.

5. Exercices pratiques

a) Exercice 1 : Calcul de la puissance d'un nombre

 Énoncé :
Écrivez une fonction récursive pour calculer abab.
 Solution :
Exemple

Fonction Puissance(a, b) :
Si (b == 0) alors :
Retourner 1
Sinon :
Retourner a * Puissance(a, b - 1)

b) Exercice 2 : Recherche dans un tableau trié

 Énoncé :
Écrivez une fonction récursive pour rechercher un élément dans un
tableau trié en utilisant la recherche dichotomique.
 Solution :
Exemple

Fonction RechercheDichotomique(tableau, valeur, gauche, droite) :

Si (gauche > droite) alors :
Retourner -1
milieu = (gauche + droite) // 2
 Si (tableau[milieu] == valeur) alors :
Retourner milieu
Sinon si (tableau[milieu] < valeur) alors :
Retourner RechercheDichotomique(tableau, valeur, milieu + 1, droite)
Sinon :
Retourner RechercheDichotomique(tableau, valeur, gauche, milieu - 1)

c) Exercice 3 : Calcul du PGCD

 Énoncé :
Écrivez une fonction récursive pour calculer le PGCD de deux nombres
en utilisant l'algorithme d'Euclide.
 Solution :
Exemple

Fonction PGCD(a, b) :
Si (b == 0) alors :
Retourner a
Sinon :
Retourner PGCD(b, a % b)

d) Exercice 4 : Parcours d'un arbre binaire

 Énoncé :
Écrivez une fonction récursive pour parcourir un arbre binaire en ordre
infixe (gauche, racine, droite).
 Solution :
Exemple

Fonction ParcoursInfixe(noeud) :
Si (noeud != NULL) alors :
ParcoursInfixe(noeud.gauche)
Afficher noeud.valeur
ParcoursInfixe(noeud.droite)

6. Conclusion

 La récursivité est un outil puissant pour résoudre des problèmes

complexes en les divisant en sous-problèmes plus simples.
 Elle est particulièrement utile pour les structures arborescentes et les
problèmes de backtracking.
 Cependant, il est important de comprendre ses limites en termes de
performance et de gestion de la pile d'appels.
Module 6 : Structures de données simples

Durée : 6 heures

1. Introduction aux listes, files et piles

a) Listes

 Définition :
Une liste est une collection ordonnée d'éléments qui peuvent être
accédés par leur position (indice).
 Caractéristiques :
o Accès direct aux éléments via un indice.
o Taille dynamique (peut augmenter ou diminuer).

b) Files (FIFO : First In, First Out)

 Définition :
Une file est une structure de données où le premier élément ajouté est
le premier à être retiré.
 Opérations principales :
o Enfiler : Ajouter un élément à la fin.
o Défiler : Retirer l'élément au début.

c) Piles (LIFO : Last In, First Out)

 Définition :
Une pile est une structure de données où le dernier élément ajouté est
le premier à être retiré.
 Opérations principales :
o Empiler : Ajouter un élément au sommet.
o Dépiler : Retirer l'élément au sommet.

2. Utilisation et manipulation de ces structures de données

a) Listes

 Ajout :

Exemple

liste = [1, 2, 3]
liste.append(4) # Ajoute 4 à la fin
  Suppression :
Exemple

liste.remove(2) # Supprime l'élément 2

 Parcours :
Exemple

Pour élément dans liste :

Afficher élément

b) Files

 Enfiler :

Exemple

file = []
file.append(1) # Ajoute 1 à la fin
file.append(2) # Ajoute 2 à la fin
 Défiler :
Exemple

élément = file.pop(0) # Retire et retourne le premier élément

c) Piles

 Empiler :

Exemple

pile = []
pile.append(1) # Ajoute 1 au sommet
pile.append(2) # Ajoute 2 au sommet
 Dépiler :
Exemple

élément = pile.pop() # Retire et retourne l'élément au sommet

3. Applications pratiques

a) Gestion de tâches (piles)

 Objectif :
Utiliser une pile pour gérer une liste de tâches à effectuer.
 Exemple :
Exemple
 tâches = []
tâches.append("Tâche 1") # Ajouter une tâche
tâches.append("Tâche 2")
tâche_actuelle = tâches.pop() # Retirer la dernière tâche ajoutée
Afficher "Tâche en cours :", tâche_actuelle

b) File d'attente (files)

 Objectif :
Utiliser une file pour gérer une file d'attente.
 Exemple :
Exemple

file_attente = []
file_attente.append("Personne 1") # Ajouter une personne à la file
file_attente.append("Personne 2")
personne_actuelle = file_attente.pop(0) # Retirer la première personne
Afficher "Personne traitée :", personne_actuelle

4. Exercices : implémentation de simulateurs simples

a) Exercice 1 : Gestion d’une file d’attente à une caisse

 Énoncé :
Écrivez un algorithme pour simuler une file d'attente à une caisse. Les
clients arrivent et sont servis dans l'ordre d'arrivée.
 Solution :
Exemple

Début
file_attente = []
Répéter :
Afficher "Entrez le nom du client (ou 'fin' pour terminer) :"
Lire nom
Si (nom != "fin") alors :
file_attente.append(nom)
Jusqu'à (nom == "fin")
Tant que (file_attente n'est pas vide) :
client = file_attente.pop(0)
Afficher "Client traité :", client
Fin

b) Exercice 2 : Gestion d’une pile de documents

 Énoncé :
Écrivez un algorithme pour simuler une pile de documents à traiter. Le
dernier document ajouté est le premier à être traité.
 Solution :
Exemple
 Début
pile_documents = []
Répéter :
Afficher "Entrez le nom du document (ou 'fin' pour terminer) :"
Lire document
Si (document != "fin") alors :
pile_documents.append(document)
Jusqu'à (document == "fin")
Tant que (pile_documents n'est pas vide) :
doc_actuel = pile_documents.pop()
Afficher "Document traité :", doc_actuel
Fin

c) Exercice 3 : Liste de courses

 Énoncé :
Écrivez un algorithme pour gérer une liste de courses. L'utilisateur peut
ajouter, supprimer et afficher les éléments de la liste.
 Solution :
Exemple

Début
liste_courses = []
Répéter :
Afficher "1. Ajouter un article"
Afficher "2. Supprimer un article"
Afficher "3. Afficher la liste"
Afficher "4. Quitter"
Lire choix
Si (choix == 1) alors :
Afficher "Entrez l'article à ajouter :"
Lire article
liste_courses.append(article)
Sinon si (choix == 2) alors :
Afficher "Entrez l'article à supprimer :"
Lire article
Si (article dans liste_courses) alors :
liste_courses.remove(article)
Sinon :
Afficher "Article non trouvé."
Sinon si (choix == 3) alors :
Afficher "Liste de courses :", liste_courses
Jusqu'à (choix == 4)
Fin

5. Conclusion

 Les listes, files et piles sont des structures de données fondamentales

en programmation.
 Elles sont utilisées dans de nombreuses applications pratiques, comme
la gestion de tâches, les files d'attente et les piles de documents.
 La compréhension de ces structures permet de résoudre des problèmes
complexes de manière efficace.
Module 7 : Gestion des chaînes de caractères

Durée : 3 heures

1. Manipulation avancée des chaînes

a) Découpage

 Définition :
Le découpage permet d'extraire une sous-chaîne à partir d'une chaîne
de caractères.
 Exemple :
Exemple

chaîne = "Bonjour le monde"

sous_chaîne = chaîne[0:7] # Extrait "Bonjour"

b) Recherche

 Définition :
La recherche permet de trouver la position d'une sous-chaîne dans une
chaîne.
 Exemple :
Exemple

position = chaîne.find("monde") # Retourne 12

c) Remplacement

 Définition :
Le remplacement permet de remplacer une sous-chaîne par une autre.
 Exemple :
Exemple

nouvelle_chaîne = chaîne.replace("monde", "tout le monde") # "Bonjour le tout le

monde"

2. Analyse des caractères

a) Voyelles et consonnes

 Définition :
Les voyelles sont les lettres a, e, i, o, u. Les consonnes sont toutes les
autres lettres de l'alphabet.
  Exemple :
Exemple

voyelles = "aeiouAEIOU"
Pour caractère dans chaîne :
Si (caractère dans voyelles) alors :
Afficher "Voyelle :", caractère
Sinon si (caractère est une lettre) alors :
Afficher "Consonne :", caractère

b) Espaces et autres caractères

 Définition :
Les espaces et autres caractères (ponctuation, chiffres) peuvent être
analysés séparément.
 Exemple :
Exemple

Pour caractère dans chaîne :

Si (caractère == " ") alors :
Afficher "Espace"
Sinon si (caractère est un chiffre) alors :
Afficher "Chiffre :", caractère
Sinon si (caractère est une ponctuation) alors :
Afficher "Ponctuation :", caractère

3. Exercices

a) Exercice 1 : Vérifier si une chaîne est un palindrome

 Énoncé :
Écrivez un algorithme pour vérifier si une chaîne de caractères est un
palindrome (se lit de la même manière à l'endroit et à l'envers).
 Solution :
Exemple

Début
Afficher "Entrez une chaîne :"
Lire chaîne
chaîne_inversée = chaîne[::-1] # Inverse la chaîne
Si (chaîne == chaîne_inversée) alors :
Afficher "La chaîne est un palindrome."
Sinon :
Afficher "La chaîne n'est pas un palindrome."
Fin

b) Exercice 2 : Compter les occurrences d’un mot dans une phrase

  Énoncé :
Écrivez un algorithme pour compter le nombre d'occurrences d'un mot
dans une phrase.
 Solution :
Exemple

Début
Afficher "Entrez une phrase :"
Lire phrase
Afficher "Entrez un mot :"
Lire mot
occurrences = 0
Pour chaque mot_phrase dans phrase.split() :
Si (mot_phrase == mot) alors :
occurrences = occurrences + 1
Afficher "Le mot", mot, "apparaît", occurrences, "fois."
Fin

c) Exercice 3 : Compter les voyelles et consonnes

 Énoncé :
Écrivez un algorithme pour compter le nombre de voyelles et de
consonnes dans une chaîne de caractères.
 Solution :
Exemple

Début
Afficher "Entrez une chaîne :"
Lire chaîne
voyelles = "aeiouAEIOU"
nb_voyelles = 0
nb_consonnes = 0
Pour caractère dans chaîne :
Si (caractère dans voyelles) alors :
nb_voyelles = nb_voyelles + 1
Sinon si (caractère est une lettre) alors :
nb_consonnes = nb_consonnes + 1
Afficher "Nombre de voyelles :", nb_voyelles
Afficher "Nombre de consonnes :", nb_consonnes
Fin

d) Exercice 4 : Remplacer les espaces par des tirets

 Énoncé :
Écrivez un algorithme pour remplacer tous les espaces dans une chaîne
par des tirets.
 Solution :
Exemple

Début
 Afficher "Entrez une chaîne :"
Lire chaîne
nouvelle_chaîne = chaîne.replace(" ", "-")
Afficher "Nouvelle chaîne :", nouvelle_chaîne
Fin

4. Conclusion

 La gestion des chaînes de caractères est essentielle pour manipuler du

texte en programmation.
 Les opérations de découpage, recherche et remplacement permettent
de traiter efficacement les chaînes.
 L'analyse des caractères (voyelles, consonnes, espaces) est utile pour
des tâches spécifiques comme la validation ou le traitement de texte.
Module 8 : Problèmes algorithmiques classiques

Durée : 6 heures

1. Résolution de problèmes bien connus

a) Problème du voyageur de commerce (TSP, introduction)

 Définition :
Le problème du voyageur de commerce consiste à trouver le chemin le
plus court pour visiter un ensemble de villes une seule fois et revenir à
la ville de départ.
 Approche :
o Force brute : Essayer toutes les permutations possibles
(complexité : O(n!)).
o Algorithmes d'approximation : Utiliser des heuristiques pour
trouver une solution proche de l'optimum.
 Exemple :
Exemple

Début
villes = ["A", "B", "C", "D"]
distances = {
("A", "B"): 10,
("A", "C"): 15,
("A", "D"): 20,
("B", "C"): 35,
("B", "D"): 25,
("C", "D"): 30
}
chemin_optimal = TSP_ForceBrute(villes, distances)
Afficher "Chemin optimal :", chemin_optimal
Fin

b) Problème des tours de Hanoï

 Définition :
Le problème des tours de Hanoï consiste à déplacer une pile de disques
d'une tour à une autre en respectant les règles suivantes :
o Un seul disque peut être déplacé à la fois.
o Un disque ne peut être placé sur un disque plus petit.
 Approche récursive :
o Déplacer n-1 disques de la tour source à la tour intermédiaire.
o Déplacer le dernier disque de la tour source à la tour destination.
o Déplacer les n-1 disques de la tour intermédiaire à la tour
destination.
  Exemple :
Exemple

Fonction ToursDeHanoï(n, source, destination, intermédiaire) :

Si (n == 1) alors :
Afficher "Déplacer le disque 1 de", source, "à", destination
Sinon :
ToursDeHanoï(n - 1, source, intermédiaire, destination)
Afficher "Déplacer le disque", n, "de", source, "à", destination
ToursDeHanoï(n - 1, intermédiaire, destination, source)

Début
ToursDeHanoï(3, "A", "C", "B")
Fin

c) Calcul du PGCD avec l’algorithme d’Euclide

 Définition :
Le PGCD (Plus Grand Commun Diviseur) de deux nombres est le plus
grand entier qui divise les deux nombres sans laisser de reste.
 Algorithme d'Euclide :
o Si b = 0, alors PGCD(a, b) = a.
o Sinon, PGCD(a, b) = PGCD(b, a % b).
 Exemple :
Exemple

Fonction PGCD(a, b) :
Si (b == 0) alors :
Retourner a
Sinon :
Retourner PGCD(b, a % b)

Début
Afficher "PGCD de 48 et 18 :", PGCD(48, 18)
Fin

2. Exercices : appliquer ces concepts pour résoudre des variantes

a) Exercice 1 : Variante du TSP avec contraintes

 Énoncé :
Écrivez un algorithme pour résoudre une variante du TSP où certaines
villes doivent être visitées avant d'autres.
 Solution :
Exemple

Début
villes = ["A", "B", "C", "D"]
 distances = {
("A", "B"): 10,
("A", "C"): 15,
("A", "D"): 20,
("B", "C"): 35,
("B", "D"): 25,
("C", "D"): 30
}
contraintes = [("A", "B"), ("C", "D")] # A doit être visité avant B, C avant D
chemin_optimal = TSP_Contraintes(villes, distances, contraintes)
Afficher "Chemin optimal avec contraintes :", chemin_optimal
Fin

b) Exercice 2 : Tours de Hanoï avec 4 tours

 Énoncé :
Écrivez un algorithme pour résoudre le problème des tours de Hanoï
avec 4 tours au lieu de 3.
 Solution :
Exemple

Fonction ToursDeHanoï4(n, source, destination, intermédiaire1, intermédiaire2) :

Si (n == 1) alors :
Afficher "Déplacer le disque 1 de", source, "à", destination
Sinon :
ToursDeHanoï4(n - 1, source, intermédiaire1, intermédiaire2, destination)
Afficher "Déplacer le disque", n, "de", source, "à", destination
ToursDeHanoï4(n - 1, intermédiaire1, destination, intermédiaire2, source)

Début
ToursDeHanoï4(3, "A", "D", "B", "C")
Fin

c) Exercice 3 : PGCD de plusieurs nombres

 Énoncé :
Écrivez un algorithme pour calculer le PGCD de plusieurs nombres en
utilisant l'algorithme d'Euclide.
 Solution :
Exemple

Fonction PGCD_Multiple(nombres) :
pgcd_temp = nombres[0]
Pour i allant de 1 à longueur(nombres) - 1 :
pgcd_temp = PGCD(pgcd_temp, nombres[i])
Retourner pgcd_temp

Début
nombres = [48, 18, 24]
Afficher "PGCD de", nombres, ":", PGCD_Multiple(nombres)
Fin
d) Exercice 4 : Tours de Hanoï avec affichage graphique

 Énoncé :
Écrivez un algorithme pour résoudre le problème des tours de Hanoï et
afficher chaque étape sous forme graphique.
 Solution :
Exemple

Fonction AfficherTours(tours) :
Pour chaque tour dans tours :
Afficher "Tour", tour, ":", tours[tour]

Fonction ToursDeHanoïGraphique(n, source, destination, intermédiaire, tours) :

Si (n == 1) alors :
disque = tours[source].pop()
tours[destination].append(disque)
AfficherTours(tours)
Sinon :
ToursDeHanoïGraphique(n - 1, source, intermédiaire, destination, tours)
disque = tours[source].pop()
tours[destination].append(disque)
AfficherTours(tours)
ToursDeHanoïGraphique(n - 1, intermédiaire, destination, source, tours)

Début
tours = {
"A": [3, 2, 1],
"B": [],
"C": []
}
ToursDeHanoïGraphique(3, "A", "C", "B", tours)
Fin

3. Conclusion

 Les problèmes algorithmiques classiques comme le TSP, les tours de

Hanoï et le calcul du PGCD sont des défis fondamentaux en
informatique.
 Ils permettent de comprendre des concepts clés comme la récursivité,
les heuristiques et les algorithmes d'optimisation.
 La résolution de variantes de ces problèmes renforce la compréhension
et la capacité à adapter les solutions à des contextes différents.
Module 9 : Projets pratiques

Durée : 6 heures

1. Réalisation de mini-projets en groupe ou individuellement

a) Tri et recherche dans une base de données fictive

 Objectif :
Créer une base de données fictive (par exemple, une liste de livres ou
d'étudiants) et implémenter des fonctionnalités de tri et de recherche.
 Fonctionnalités :
o Ajouter, supprimer et afficher des éléments.
o Trier les éléments par un critère (ex. : titre, auteur, année).
o Rechercher un élément spécifique (ex. : par titre ou ID).
 Exemple de structure :
Exemple

Début
base_de_données = [
{"id": 1, "titre": "Livre A", "auteur": "Auteur X", "année": 2000},
{"id": 2, "titre": "Livre B", "auteur": "Auteur Y", "année": 1995},
{"id": 3, "titre": "Livre C", "auteur": "Auteur Z", "année": 2010}
]
Fonction TrierParAnnée(base) :
Retourner trier(base, clé="année")
Fonction RechercherParTitre(base, titre) :
Pour élément dans base :
Si (élément["titre"] == titre) alors :
Retourner élément
Retourner NULL
Fin

b) Jeu de morpion ou de devinette (implémentation basique)

 Objectif :
Implémenter un jeu simple comme le morpion ou un jeu de devinette.
 Fonctionnalités :
o Morpion :
 Afficher une grille 3x3.
 Permettre à deux joueurs de jouer à tour de rôle.
 Vérifier les conditions de victoire.
o Devinette :
 Générer un nombre aléatoire.
 Permettre à l'utilisateur de deviner le nombre en un

nombre limité de tentatives.
 Donner des indices (trop grand, trop petit).
 Exemple de structure (Morpion) :
Exemple

Début
grille = [
[" ", " ", " "],
[" ", " ", " "],
[" ", " ", " "]
]
joueur = "X"
Tant que (non Victoire(grille)) :
AfficherGrille(grille)
Afficher "Tour du joueur", joueur
Lire ligne, colonne
Si (grille[ligne][colonne] == " ") alors :
grille[ligne][colonne] = joueur
joueur = "O" si joueur == "X" sinon "X"
Sinon :
Afficher "Case déjà occupée."
Afficher "Le joueur", joueur, "a gagné !"
Fin

c) Simulateur de gestion de file ou de pile

 Objectif :
Implémenter un simulateur pour gérer une file d'attente ou une pile de
tâches.
 Fonctionnalités :
o File d'attente :
 Ajouter des éléments à la fin.
 Retirer des éléments du début.
 Afficher l'état actuel de la file.
o Pile de tâches :
 Ajouter des tâches au sommet.
 Retirer des tâches du sommet.
 Afficher l'état actuel de la pile.
 Exemple de structure (File d'attente) :
Exemple

Début
file = []
Répéter :
Afficher "1. Ajouter un élément"
Afficher "2. Retirer un élément"
Afficher "3. Afficher la file"
Afficher "4. Quitter"
 Lire choix
Si (choix == 1) alors :
Afficher "Entrez l'élément à ajouter :"
Lire élément
file.append(élément)
Sinon si (choix == 2) alors :
Si (file n'est pas vide) alors :
élément = file.pop(0)
Afficher "Élément retiré :", élément
Sinon :
Afficher "La file est vide."
Sinon si (choix == 3) alors :
Afficher "File actuelle :", file
Jusqu'à (choix == 4)
Fin

2. Présentation des projets à la fin du module

a) Objectifs de la présentation

 Expliquer le fonctionnement du projet.

 Démontrer les résultats obtenus.
 Répondre aux questions des autres participants.

b) Conseils pour la présentation

 Utiliser des exemples concrets pour illustrer le projet.

 Montrer les entrées/sorties du programme.
 Expliquer les choix algorithmiques et les défis rencontrés.

c) Évaluation

 Clarté de la présentation.
 Fonctionnalité du projet.
 Qualité du code (structure, commentaires, etc.).

3. Conclusion

 Les projets pratiques permettent de consolider les compétences en

algorithmique et en programmation.
 Ils encouragent la créativité et la résolution de problèmes en contexte
réel.
 La présentation des projets favorise la communication et le partage des
connaissances.
Module 10 : Évaluation finale et perspectives

Durée : 2 heures

1. Évaluation des acquis par des exercices pratiques

a) Objectif :

 Tester les compétences acquises en algorithmique à travers des

exercices pratiques.
 Évaluer la capacité à résoudre des problèmes en utilisant les concepts
étudiés.

b) Exercices proposés :

Exercice 1 : Tri et recherche

 Énoncé :
Écrivez un algorithme pour trier un tableau d'entiers en utilisant le tri
par insertion, puis recherchez un élément spécifique en utilisant la
recherche dichotomique.
 Solution attendue :
Exemple

Début
tableau = [34, 7, 23, 32, 5, 62]
// Tri par insertion
Pour i allant de 1 à longueur(tableau) - 1 :
clé = tableau[i]
j=i-1
Tant que (j >= 0 ET tableau[j] > clé) :
tableau[j + 1] = tableau[j]
j=j-1
tableau[j + 1] = clé
// Recherche dichotomique
Fonction RechercheDichotomique(tableau, valeur) :
gauche = 0
droite = longueur(tableau) - 1
Tant que (gauche <= droite) :
milieu = (gauche + droite) // 2
Si (tableau[milieu] == valeur) alors :
Retourner milieu
Sinon si (tableau[milieu] < valeur) alors :
gauche = milieu + 1
Sinon :
droite = milieu - 1
Retourner -1
Afficher "Tableau trié :", tableau
Afficher "Position de 32 :", RechercheDichotomique(tableau, 32)
 Fin

Exercice 2 : Gestion d'une pile

 Énoncé :
Écrivez un algorithme pour simuler une pile de documents. L'utilisateur
peut ajouter, retirer et afficher les documents.
 Solution attendue :
Exemple

Début
pile = []
Répéter :
Afficher "1. Ajouter un document"
Afficher "2. Retirer un document"
Afficher "3. Afficher la pile"
Afficher "4. Quitter"
Lire choix
Si (choix == 1) alors :
Afficher "Entrez le document à ajouter :"
Lire document
pile.append(document)
Sinon si (choix == 2) alors :
Si (pile n'est pas vide) alors :
document = pile.pop()
Afficher "Document retiré :", document
Sinon :
Afficher "La pile est vide."
Sinon si (choix == 3) alors :
Afficher "Pile actuelle :", pile
Jusqu'à (choix == 4)
Fin

Exercice 3 : Palindrome

 Énoncé :
Écrivez un algorithme pour vérifier si une chaîne de caractères est un
palindrome.
 Solution attendue :
Exemple

Début
Afficher "Entrez une chaîne :"
Lire chaîne
chaîne_inversée = chaîne[::-1]
Si (chaîne == chaîne_inversée) alors :
Afficher "La chaîne est un palindrome."
Sinon :
Afficher "La chaîne n'est pas un palindrome."
Fin
2. Réflexion sur les applications concrètes de l’algorithmique

a) Applications dans la vie quotidienne

 Recherche et tri : Moteurs de recherche, gestion de bases de

données.
 Gestion des files et piles : Systèmes d'exploitation, gestion des
tâches.
 Résolution de problèmes : Optimisation des ressources,
planification.

b) Applications dans les domaines professionnels

 Informatique : Développement de logiciels, intelligence artificielle.

 Finance : Algorithmes de trading, gestion des risques.
 Santé : Analyse de données médicales, modélisation.

3. Conseils pour approfondir : introduction à la programmation et

structures de données avancées

a) Introduction à la programmation

 Langages recommandés :
o Python : Facile à apprendre, largement utilisé en algorithmique.
o Java : Orienté objet, utilisé dans de nombreuses applications.
o C++ : Performant, utilisé pour les applications système.
 Ressources :
o Cours en ligne (Coursera, edX, OpenClassrooms).
o Livres ("Apprendre à programmer avec Python", "Algorithmes en
C++").

b) Structures de données avancées

 Listes chaînées :
o Permettent des insertions et suppressions efficaces.
 Arbres :
o Utilisés pour les recherches hiérarchiques (ex. : arbres binaires
de recherche).
 Graphes :
o Représentent des relations complexes entre des éléments.
 Tables de hachage :
o Permettent des recherches rapides.

c) Projets pour approfondir

  Créer un gestionnaire de tâches : Utiliser des piles et des files.
 Développer un jeu simple : Implémenter des algorithmes de
recherche et de tri.
 Analyser des données : Utiliser des algorithmes pour traiter des
ensembles de données.

4. Conclusion

 Ce module a permis d'évaluer les compétences acquises en

algorithmique et de réfléchir à leurs applications concrètes.
 Les conseils pour approfondir ouvrent la voie à des études plus
poussées en programmation et en structures de données.
 La pratique continue et l'exploration de nouveaux défis sont
essentielles pour progresser en informatique.