ALGORITHMIQUE GENERALE

# ALGORITHMIQUE GENERALE ## Structures Algorithmiques ### Introduction Bienvenue dans cette leçon sur les structures algorithmiques ! L'algorithmique est l'art de résoudre des problèmes de manière logique et structurée. C'est la base de toute la programmation informatique. Un algorithme est comme une recette de cuisine : une suite d'instructions claires et précises qui, une fois exécutées, mènent à un résultat souhaité. Comprendre comment structurer un algorithme est essentiel pour développer des solutions efficaces et fiables. Dans ce cours, nous allons explorer les briques fondamentales qui composent tout algorithme : les variables, les types de données, les opérations, et surtout, les différentes manières d'organiser les instructions, que nous appelons les structures de contrôle. ### Concepts Clés #### Qu'est-ce qu'un Algorithme ? Un algorithme est une suite finie et non ambiguë d'instructions ou d'opérations permettant de résoudre un problème donné. Il doit être : * **Fini :** Il doit se terminer après un nombre fini d'étapes. * **Clair et précis :** Chaque instruction doit être non ambiguë. * **Efficace :** Il doit être le plus rapide et le moins gourmand en ressources possible. * **Général :** Il doit pouvoir résoudre une catégorie de problèmes, pas un seul cas particulier. #### Les Variables et les Types de Données ##### Les Variables Une variable est un espace de stockage nommé en mémoire qui peut contenir une valeur. Imaginez une boîte étiquetée : l'étiquette est le nom de la variable, et ce que vous mettez à l'intérieur est sa valeur. La valeur d'une variable peut changer au cours de l'exécution de l'algorithme. * **Nom de la variable :** Un identifiant unique pour la reconnaître (ex: `age`, `prixHT`, `nomUtilisateur`). * **Valeur :** La donnée stockée dans la variable à un instant donné. ##### Les Types de Données Le type de données spécifie la nature de la valeur que peut contenir une variable. Il détermine les opérations que l'on peut effectuer sur cette variable. Voici les types de données les plus courants : * **Entier (Integer) :** Pour les nombres entiers, positifs ou négatifs, sans partie décimale (ex: 5, -10, 0, 1500). * **Réel (Real / Float) :** Pour les nombres décimaux (ex: 3.14, -0.5, 99.99). * **Caractère (Char) :** Pour une seule lettre, chiffre ou symbole (ex: 'A', '?', '7'). * **Chaîne de caractères (String) :** Pour du texte, une séquence de caractères (ex: "Bonjour", "Algorithmique", "Rue de la Paix"). * **Booléen (Boolean) :** Pour des valeurs logiques, qui peuvent être soit VRAI (True) soit FAUX (False). Utile pour les conditions. #### Les Opérations Les opérations permettent de manipuler les données contenues dans les variables. ##### Opérations Arithmétiques Utilisées pour les calculs numériques : * **Addition :** `+` (Ex: \( 5 + 3 = 8 \)) * **Soustraction :** `-` (Ex: \( 10 - 4 = 6 \)) * **Multiplication :** `*` (Ex: \( 2 * 6 = 12 \)) * **Division :** `/` (Ex: \( 15 / 3 = 5 \)) * **Modulo :** `%` (ou `MOD`) - Donne le reste d'une division entière (Ex: \( 10 \% 3 = 1 \) car \( 10 = 3 \times 3 + 1 \)) ##### Opérations de Comparaison (Relationnelles) Permettent de comparer deux valeurs et retournent un résultat booléen (VRAI ou FAUX) : * **Égal à :** `=` ou `==` (Ex: \( 7 = 7 \) est VRAI) * **Différent de :** `<>` ou `!=` (Ex: \( 5 \neq 3 \) est VRAI) * **Inférieur à :** `<` (Ex: \( 4 < 9 \) est VRAI) * **Supérieur à :** `>` (Ex: \( 12 > 10 \) est VRAI) * **Inférieur ou égal à :** `<=` (Ex: \( 5 \le 5 \) est VRAI) * **Supérieur ou égal à :** `>=` (Ex: \( 8 \ge 6 \) est VRAI) ##### Opérations Logiques Utilisées pour combiner des expressions booléennes : * **ET (AND) :** VRAI si toutes les conditions sont VRAIES. (Ex: \( (A > 0) \text{ ET } (B < 10) \)) * **OU (OR) :** VRAI si au moins une condition est VRAIE. (Ex: \( (age < 18) \text{ OU } (etudiant = \text{VRAI}) \)) * **NON (NOT) :** Inverse la valeur d'une condition. (Ex: \( \text{NON } (majeur) \) est VRAI si `majeur` est FAUX) #### Les Structures de Contrôle Les structures de contrôle définissent l'ordre dans lequel les instructions de l'algorithme sont exécutées. Elles sont les piliers de la logique d'un algorithme. ##### La Structure Séquentielle C'est la structure la plus simple. Les instructions sont exécutées dans l'ordre où elles apparaissent, une après l'autre, du début à la fin de l'algorithme. ```pseudo-code DÉBUT Instruction 1 Instruction 2 Instruction 3 FIN ``` ##### La Structure Conditionnelle (Si...Alors...Sinon) Permet d'exécuter un bloc d'instructions si une condition est vraie, et éventuellement un autre bloc si elle est fausse. C'est le principe du choix. ```pseudo-code SI (condition) ALORS // Instructions exécutées si la condition est VRAIE SINON // Instructions exécutées si la condition est FAUSSE FIN_SI ``` * **Variante `SI...ALORS` sans `SINON` :** Si la condition est vraie, les instructions sont exécutées ; sinon, rien ne se passe et l'algorithme continue. * **Variante `SI...ALORS...SINON SI...SINON` :** Permet de gérer plusieurs conditions successives. ##### La Structure Répétitive (Boucles) Permet de répéter un bloc d'instructions plusieurs fois. C'est très utile pour automatiser des tâches répétitives. ###### Boucle TANT QUE (While) La boucle `TANT QUE` répète un bloc d'instructions tant qu'une condition reste vraie. La condition est évaluée **avant** chaque exécution du bloc. Si la condition est fausse dès le départ, le bloc ne sera jamais exécuté. ```pseudo-code TANT QUE (condition) FAIRE // Instructions à répéter FIN_TANT_QUE ``` ###### Boucle POUR (For) La boucle `POUR` est utilisée lorsque l'on connaît le nombre exact de répétitions à l'avance. Elle utilise une variable de comptage qui prend des valeurs successives dans un intervalle donné. ```pseudo-code POUR variable DE début À fin FAIRE // Instructions à répéter FIN_POUR ``` ###### Boucle FAIRE TANT QUE (Do While / Répéter Jusqu'à) Cette boucle est similaire à `TANT QUE`, mais la condition est évaluée **après** l'exécution du bloc d'instructions. Cela garantit que le bloc sera exécuté au moins une fois. ```pseudo-code RÉPÉTER // Instructions à répéter JUSQU'À (condition) // Le bloc est répété tant que la condition est FAUSSE, et s'arrête quand elle devient VRAIE. // Ou, dans d'autres notations : FAIRE ... TANT QUE (condition) // Le bloc est répété tant que la condition est VRAIE. ``` ### Vocabulaire * **Algorithme :** Suite finie et non ambiguë d'instructions pour résoudre un problème. * **Variable :** Espace de stockage nommé pour une valeur qui peut changer. * **Type de données :** Catégorie d'une donnée (entier, réel, chaîne, booléen). * **Opération :** Action effectuée sur des données (arithmétique, logique, de comparaison). * **Structure de contrôle :** Mécanisme qui détermine l'ordre d'exécution des instructions. * **Structure Séquentielle :** Exécution des instructions dans l'ordre linéaire. * **Structure Conditionnelle :** Exécution d'instructions selon qu'une condition est vraie ou fausse (Si...Alors...Sinon). * **Structure Répétitive (Boucle) :** Exécution répétée d'un bloc d'instructions (Tant Que, Pour, Répéter Jusqu'à). * **Itération :** Une seule exécution du corps d'une boucle. * **Condition :** Expression logique qui évalue à Vrai ou Faux, utilisée pour les structures conditionnelles et répétitives. ### Exemples #### Exemple 1: Calcul de la moyenne de deux nombres (Séquentiel) ```pseudo-code ALGORITHME CalculMoyenne VARIABLES nombre1 : RÉEL nombre2 : RÉEL moyenne : RÉEL DÉBUT AFFICHER "Entrez le premier nombre :" LIRE nombre1 AFFICHER "Entrez le deuxième nombre :" LIRE nombre2 moyenne <- (nombre1 + nombre2) / 2 AFFICHER "La moyenne est : ", moyenne FIN ``` #### Exemple 2: Vérifier si un nombre est positif, négatif ou nul (Conditionnel) ```pseudo-code ALGORITHME VerifierSigne VARIABLES nombre : ENTIER 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 zéro." FIN_SI FIN ``` #### Exemple 3: Compter de 1 à 5 (Répétitif - POUR) ```pseudo-code ALGORITHME CompterJusquaCinq VARIABLES i : ENTIER DÉBUT POUR i DE 1 À 5 FAIRE AFFICHER i FIN_POUR FIN ``` #### Exemple 4: Demander un mot de passe jusqu'à ce qu'il soit correct (Répétitif - TANT QUE) ```pseudo-code ALGORITHME EntreeSecurisee VARIABLES motDePasseSaisi : CHAINE_DE_CARACTERES motDePasseCorrect : CONSTANTE CHAINE_DE_CARACTERES = "secret" DÉBUT AFFICHER "Veuillez entrer le mot de passe :" LIRE motDePasseSaisi TANT QUE motDePasseSaisi <> motDePasseCorrect FAIRE AFFICHER "Mot de passe incorrect. Réessayez :" LIRE motDePasseSaisi FIN_TANT_QUE AFFICHER "Accès autorisé !" FIN ``` ### Exercices 1. **Exercice 1 (Conditionnel) :** Écrivez un algorithme qui demande l'âge de l'utilisateur et affiche "Majeur" si l'âge est 18 ans ou plus, et "Mineur" sinon. 2. **Exercice 2 (Répétitif - POUR) :** Écrivez un algorithme qui calcule et affiche la somme de tous les nombres entiers de 1 à 100 (inclu). 3. **Exercice 3 (Types de données) :** Quel est le type de données le plus approprié pour stocker les informations suivantes ? * Un prénom : * Une note scolaire (sur 20, pouvant être décimale) : * L'état d'une ampoule (allumée ou éteinte) : * Le nombre d'élèves dans une classe : ### Devoir à la Maison 1. **Devoir 1 (Conditionnel) :** Écrivez un algorithme qui demande trois nombres à l'utilisateur et affiche le plus grand des trois. 2. **Devoir 2 (Répétitif - TANT QUE) :** Écrivez un algorithme qui demande à l'utilisateur de saisir des nombres. L'algorithme doit continuer à demander des nombres tant que l'utilisateur n'entre pas 0. Une fois 0 saisi, l'algorithme doit afficher la somme de tous les nombres saisis (sans inclure le 0). 3. **Devoir 3 (Combiné) :** Un magasin propose une réduction de 10% sur le montant total des achats si celui-ci dépasse 100 euros. Écrivez un algorithme qui demande le montant total des achats du client et affiche le montant final à payer après application éventuelle de la réduction. ### Résumé Dans cette leçon, nous avons parcouru les fondements de l'algorithmique. Vous avez appris que : * Un **algorithme** est une suite d'instructions pour résoudre un problème. * Les **variables** et leurs **types de données** (entier, réel, chaîne, booléen) sont essentiels pour stocker et manipuler des informations. * Les **opérations** (arithmétiques, de comparaison, logiques) permettent d'effectuer des calculs et de prendre des décisions. * Les **structures de contrôle** sont les architectes de la logique algorithmique : * La **structure séquentielle** exécute les instructions une à une. * La **structure conditionnelle** (`SI...ALORS...SINON`) permet de faire des choix. * Les **structures répétitives** (`TANT QUE`, `POUR`, `RÉPÉTER JUSQU'À`) automatisent les tâches répétitives. Maîtriser ces concepts est la première étape cruciale pour devenir un bon penseur algorithmique et, à terme, un programmeur efficace. Continuez à pratiquer en résolvant des problèmes ! ## Les tableaux ### Introduction Bienvenue dans cette leçon sur les tableaux en algorithmique ! Les tableaux sont des structures de données fondamentales et très utilisées en programmation. Ils nous permettent de stocker plusieurs informations de même type sous un seul nom, ce qui simplifie grandement l'organisation et la manipulation des données. Imaginez que vous ayez une liste de notes d'élèves ou une série de mesures : au lieu de créer une variable pour chaque note ou chaque mesure, un tableau vous permet de les regrouper de manière efficace. Dans ce cours, nous allons explorer ce qu'est un tableau, comment le déclarer, y accéder et le parcourir. ### Concepts Clés #### Qu'est-ce qu'un tableau ? Un tableau (ou *array* en anglais) est une collection ordonnée d'éléments de *même type*. Ces éléments sont stockés de manière contiguë en mémoire, ce qui signifie qu'ils sont placés les uns à côté des autres. Cela rend l'accès aux données très rapide et efficace. * **Homogénéité :** Tous les éléments d'un tableau doivent être du même type (par exemple, tous des entiers, tous des réels, ou tous des chaînes de caractères). * **Taille Fixe :** Dans la plupart des langages de programmation étudiés à votre niveau, la taille d'un tableau est définie lors de sa déclaration et ne peut pas être modifiée par la suite. Si vous avez besoin de plus d'espace, vous devrez créer un nouveau tableau. * **Indexation :** Chaque élément d'un tableau est identifié par un numéro unique appelé **index**. Cet index représente la position de l'élément dans le tableau. L'index du premier élément est généralement `0` (zéro) dans la plupart des langages de programmation (Python, Java, C++, JavaScript...). L'index du dernier élément est donc `taille - 1`. #### Déclaration et Initialisation d'un tableau Avant d'utiliser un tableau, il faut le déclarer. La déclaration spécifie le type des éléments que le tableau contiendra et sa taille. Dans un pseudo-code, cela peut ressembler à : ``` ALGORITHME ExempleTableau VARIABLES notes : TABLEAU D'ENTIERS [5] // Déclare un tableau de 5 entiers noms : TABLEAU DE CHAÎNES [10] // Déclare un tableau de 10 chaînes de caractères DEBUT // ... FIN ``` L'initialisation consiste à donner des valeurs aux éléments du tableau. Vous pouvez le faire lors de la déclaration ou après : ``` VARIABLES nombres : TABLEAU D'ENTIERS [3] = {10, 20, 30} // Initialisation à la déclaration temperature : TABLEAU DE RÉELS [4] DEBUT temperature[0] <- 20.5 temperature[1] <- 21.0 temperature[2] <- 19.8 temperature[3] <- 22.3 // ... FIN ``` #### Accès aux éléments d'un tableau Pour lire ou modifier un élément spécifique d'un tableau, vous utilisez le nom du tableau suivi de l'index de l'élément entre crochets `[]` (ou parfois des parenthèses `()` selon le pseudo-code ou langage). * **Lecture :** Pour obtenir la valeur d'un élément. ``` valeur <- monTableau[index] ``` * **Écriture (ou Modification) :** Pour assigner une nouvelle valeur à un élément. ``` monTableau[index] <- nouvelleValeur ``` **Exemple :** ``` VARIABLES notes : TABLEAU D'ENTIERS [3] DEBUT notes[0] <- 15 // La première note est 15 notes[1] <- 12 // La deuxième note est 12 notes[2] <- 18 // La troisième note est 18 AFFICHER("La première note est : ", notes[0]) // Affichera 15 AFFICHER("La deuxième note est : ", notes[1]) // Affichera 12 notes[0] <- 16 // La première note est modifiée à 16 AFFICHER("La nouvelle première note est : ", notes[0]) // Affichera 16 FIN ``` #### Parcours d'un tableau Parcourir un tableau signifie visiter chaque élément, généralement du premier au dernier. L'opération de parcours est très courante et se fait généralement à l'aide d'une **boucle**. La boucle `POUR` (ou `for` en anglais) est la plus adaptée car elle permet de faire varier l'index automatiquement. ``` VARIABLES tableauExemple : TABLEAU D'ENTIERS [4] = {10, 20, 30, 40} i : ENTIER DEBUT POUR i DE 0 À 3 FAIRE AFFICHER("Élément à l'index ", i, " : ", tableauExemple[i]) FIN POUR FIN ``` Ce programme affichera : ``` Élément à l'index 0 : 10 Élément à l'index 1 : 20 Élément à l'index 2 : 30 Élément à l'index 3 : 40 ``` #### Tableaux à plusieurs dimensions (Matrices) Un tableau peut avoir plus d'une dimension. Le plus courant après un tableau à une dimension est le tableau à deux dimensions, souvent appelé **matrice**. Une matrice est comme un tableau de tableaux, organisée en lignes et en colonnes. * **Déclaration :** ``` matrice : TABLEAU D'ENTIERS [3][4] // Une matrice de 3 lignes et 4 colonnes ``` * **Accès :** On utilise deux index, un pour la ligne et un pour la colonne. ``` matrice[ligne][colonne] <- valeur valeur <- matrice[ligne][colonne] ``` **Exemple (Matrice 2x2) :** ``` VARIABLES matriceA : TABLEAU D'ENTIERS [2][2] i, j : ENTIER DEBUT matriceA[0][0] <- 1 matriceA[0][1] <- 2 matriceA[1][0] <- 3 matriceA[1][1] <- 4 POUR i DE 0 À 1 FAIRE POUR j DE 0 À 1 FAIRE AFFICHER("matriceA[", i, "][", j, "] : ", matriceA[i][j]) FIN POUR FIN POUR FIN ``` ### Vocabulaire * **Tableau (Array) :** Structure de données qui stocke une collection ordonnée d'éléments du même type. * **Élément (Element) :** Une valeur individuelle stockée dans le tableau. * **Index (Index) :** Le numéro de position d'un élément dans un tableau, commençant généralement à 0. * **Taille (Size) :** Le nombre total d'éléments qu'un tableau peut contenir. * **Type :** La nature des données stockées (par exemple, ENTIER, RÉEL, CHAÎNE DE CARACTÈRES, BOOLÉEN). * **Parcours (Traversal) :** L'opération de visite séquentielle de chaque élément d'un tableau, généralement avec une boucle. * **Matrice (Matrix) :** Un tableau à deux dimensions, organisé en lignes et en colonnes. ### Exemples #### Exemple 1 : Saisir et afficher les notes d'une classe ``` ALGORITHME GestionNotes VARIABLES nbEleves : ENTIER notes : TABLEAU DE RÉELS [100] // Un tableau pour stocker jusqu'à 100 notes i : ENTIER DEBUT AFFICHER("Combien d'élèves y a-t-il dans la classe ? (max 100) : ") LIRE(nbEleves) // Saisie des notes POUR i DE 0 À nbEleves - 1 FAIRE AFFICHER("Entrez la note de l'élève ", i + 1, " : ") LIRE(notes[i]) FIN POUR AFFICHER("\n--- Notes des élèves ---") // Affichage des notes POUR i DE 0 À nbEleves - 1 FAIRE AFFICHER("Élève ", i + 1, " : ", notes[i]) FIN POUR FIN ``` #### Exemple 2 : Calculer la moyenne des températures journalières ``` ALGORITHME MoyenneTemperatures VARIABLES temperatures : TABLEAU DE RÉELS [7] // Températures des 7 jours de la semaine somme : RÉEL <- 0 moyenne : RÉEL i : ENTIER DEBUT AFFICHER("Saisie des températures journalières (sur 7 jours) :") POUR i DE 0 À 6 FAIRE AFFICHER("Température du jour ", i + 1, " : ") LIRE(temperatures[i]) somme <- somme + temperatures[i] FIN POUR moyenne <- somme / 7 AFFICHER("\n--- Résultat ---") AFFICHER("La somme des températures est : ", somme) AFFICHER("La moyenne des températures est : ", moyenne) FIN ``` ### Exercices 1. **Trouver le Maximum :** Écrivez un algorithme qui déclare un tableau de 5 entiers, demande à l'utilisateur de les remplir, puis trouve et affiche le plus grand nombre présent dans le tableau. * _Indices :_ Initialisez une variable `maximum` avec la première valeur du tableau, puis parcourez le reste du tableau en comparant chaque élément à `maximum`. 2. **Affichage Inversé :** Écrivez un algorithme qui demande à l'utilisateur de saisir 4 mots (chaînes de caractères) dans un tableau, puis affiche ces mots dans l'ordre inverse de leur saisie. * _Indices :_ Parcourez le tableau en commençant par le dernier index et en allant jusqu'au premier. ### Devoir 1. **Somme des Pairs et Impairs :** Écrivez un algorithme qui déclare un tableau de 10 entiers. Demandez à l'utilisateur de remplir ce tableau. Ensuite, calculez et affichez la somme de tous les nombres pairs du tableau et la somme de tous les nombres impairs du tableau séparément. 2. **Recherche d'Élément :** Écrivez un algorithme qui déclare un tableau de 6 entiers (par exemple, `{5, 12, 3, 20, 8, 15}`). Demandez à l'utilisateur de saisir un nombre. L'algorithme devra indiquer si ce nombre est présent dans le tableau et, si oui, à quel(s) index(es) il se trouve. 3. **Défi (Matrice) :** Écrivez un algorithme qui déclare une matrice carrée de 3x3 entiers. Demandez à l'utilisateur de remplir cette matrice ligne par ligne. Ensuite, calculez et affichez la somme des éléments de la diagonale principale (les éléments où l'index de ligne est égal à l'index de colonne, par exemple `matrice[0][0]`, `matrice[1][1]`, `matrice[2][2]`). ### Résumé Dans cette leçon, nous avons découvert les tableaux, des structures de données essentielles pour organiser des collections d'informations de même type. Nous avons appris que les éléments d'un tableau sont accessibles via un **index** (commençant généralement à 0) et que leur **taille** est souvent fixe. Nous avons vu comment **déclarer** et **initialiser** un tableau, **accéder** à ses éléments, et comment les **parcourir** efficacement à l'aide de boucles. Enfin, nous avons eu un aperçu des tableaux à deux dimensions (matrices), qui sont utiles pour représenter des données structurées en lignes et colonnes. La maîtrise des tableaux est une étape cruciale pour l'écriture d'algorithmes plus complexes et plus puissants. Continuez à pratiquer pour solidifier vos connaissances ! ## Programmes et sous-programmes ### Introduction Bienvenue dans cette leçon sur les programmes et les sous-programmes ! En informatique, un programme est une séquence d'instructions que l'ordinateur exécute pour accomplir une tâche spécifique. Mais que se passe-t-il si une partie de notre programme doit être répétée plusieurs fois, ou si le programme devient trop complexe ? C'est là que les **sous-programmes** entrent en jeu. Ils nous permettent de diviser un grand problème en plus petits, de rendre notre code plus organisé, plus facile à lire et à maintenir, et surtout, de réutiliser des blocs de code. Cette leçon vous expliquera comment concevoir et utiliser ces outils essentiels. ### Concepts clés #### Qu'est-ce qu'un programme ? Un **programme** est un ensemble structuré d'instructions écrites dans un langage de programmation. Ces instructions sont exécutées de manière séquentielle (les unes après les autres) par un ordinateur pour réaliser un objectif donné. Un programme peut être simple (afficher "Bonjour le monde") ou très complexe (un jeu vidéo, un système d'exploitation). #### Pourquoi utiliser des sous-programmes ? Les sous-programmes, aussi appelés fonctions ou procédures, sont des blocs de code conçus pour accomplir une tâche spécifique. Ils offrent plusieurs avantages : * **Modularité :** Ils permettent de diviser un grand programme en plusieurs petites parties gérables. Chaque sous-programme gère une tâche précise, ce qui simplifie la conception et la compréhension du programme global. * **Réutilisabilité :** Une fois écrit, un sous-programme peut être appelé (utilisé) plusieurs fois à différents endroits du programme, sans avoir à réécrire le même code. Cela économise du temps et réduit les erreurs. * **Lisibilité et maintenance :** Un code organisé en sous-programmes est plus facile à lire et à comprendre. Si une erreur est détectée ou si une modification est nécessaire, il est plus simple d'identifier la partie du code concernée. * **Abstraction :** On peut utiliser un sous-programme sans nécessairement savoir comment il fonctionne en interne, mais seulement ce qu'il fait. #### Types de sous-programmes Il existe principalement deux types de sous-programmes : ##### 1. Les Procédures (ou Routines) * Une procédure est un bloc d'instructions qui exécute une tâche spécifique. * **Elle ne retourne pas de valeur explicite** au programme principal ou à la partie du code qui l'a appelée. Son objectif est d'effectuer une action (afficher un message, modifier l'état d'un objet, etc.). * Exemple : une procédure pour afficher un message de bienvenue. ##### 2. Les Fonctions * Une fonction est aussi un bloc d'instructions qui exécute une tâche spécifique. * **Elle retourne une valeur** au programme qui l'a appelée. Cette valeur est le résultat du traitement effectué par la fonction. * Exemple : une fonction qui calcule la somme de deux nombres et retourne ce résultat. #### Paramètres et arguments Les sous-programmes peuvent interagir avec le reste du programme en recevant des informations et en en renvoyant (pour les fonctions). * **Paramètres :** Ce sont des variables définies dans la *déclaration* du sous-programme. Ils agissent comme des "placeholders" pour les données que le sous-programme va recevoir. * **Arguments :** Ce sont les *valeurs réelles* que l'on passe au sous-programme lors de son *appel*. Ces valeurs sont affectées aux paramètres correspondants. Exemple : ```pseudocode // Déclaration de la fonction avec des paramètres 'a' et 'b' FONCTION CalculerSomme(a, b) : retourner a + b FIN FONCTION // Appel de la fonction avec les arguments 5 et 3 resultat = CalculerSomme(5, 3) // '5' est l'argument pour 'a', '3' pour 'b' ``` #### Variables locales et globales La portée d'une variable détermine où elle peut être accessible dans un programme. * **Variables locales :** Une variable locale est déclarée à l'intérieur d'un sous-programme. Elle n'est accessible et n'existe que dans ce sous-programme. Elle est "oubliée" une fois que le sous-programme a fini son exécution. * **Variables globales :** Une variable globale est déclarée en dehors de tout sous-programme, généralement au début du programme principal. Elle est accessible et peut être modifiée par n'importe quel sous-programme du programme. L'utilisation excessive de variables globales est souvent déconseillée car elle peut rendre le code plus difficile à suivre et à déboguer. ### Vocabulaire * **Programme :** Séquence d'instructions pour un ordinateur. * **Sous-programme :** Bloc de code autonome et réutilisable qui effectue une tâche spécifique. * **Procédure :** Sous-programme qui exécute une action et ne retourne pas de valeur. * **Fonction :** Sous-programme qui exécute une action et retourne une valeur. * **Paramètre :** Variable utilisée dans la définition d'un sous-programme pour recevoir une valeur. * **Argument :** La valeur réelle passée à un paramètre lors de l'appel d'un sous-programme. * **Modularité :** Principe de conception qui consiste à diviser un système en modules indépendants et interchangeables. * **Réutilisabilité :** Capacité d'un composant de code à être utilisé dans plusieurs programmes ou plusieurs fois dans le même programme. * **Variable locale :** Variable dont la portée est limitée à un sous-programme. * **Variable globale :** Variable accessible depuis n'importe quelle partie du programme. ### Exemples #### Exemple 1 : Procédure simple ```pseudocode PROCEDURE AfficherMessageBienvenue() : AFFICHER("Bonjour ! Bienvenue dans notre programme.") FIN PROCEDURE // Programme principal DEBUT PROGRAMME AfficherMessageBienvenue() // Appel de la procédure AFFICHER("Le programme continue ici.") FIN PROGRAMME // Sortie : // Bonjour ! Bienvenue dans notre programme. // Le programme continue ici. ``` #### Exemple 2 : Fonction avec paramètres et retour de valeur ```pseudocode FONCTION CalculerProduit(nombre1, nombre2) : RESULTAT = nombre1 * nombre2 retourner RESULTAT FIN FONCTION // Programme principal DEBUT PROGRAMME valeur1 = 10 valeur2 = 5 produitObtenu = CalculerProduit(valeur1, valeur2) // Appel de la fonction AFFICHER("Le produit de ", valeur1, " et ", valeur2, " est : ", produitObtenu) FIN PROGRAMME // Sortie : // Le produit de 10 et 5 est : 50 ``` #### Exemple 3 : Variables locales et globales ```pseudocode // Variable globale messageGlobal = "Je suis un message global." PROCEDURE ModifierEtAfficher() // Variable locale messageLocal = "Je suis un message local." AFFICHER(messageLocal) AFFICHER(messageGlobal) // Accès à la variable globale messageGlobal = "Le message global a été modifié par la procédure." FIN PROCEDURE // Programme principal DEBUT PROGRAMME AFFICHER("Au début : ", messageGlobal) ModifierEtAfficher() AFFICHER("Après la procédure : ", messageGlobal) // AFFICHER(messageLocal) // Ceci provoquerait une erreur car messageLocal est locale à la procédure FIN PROGRAMME // Sortie : // Au début : Je suis un message global. // Je suis un message local. // Je suis un message global. // Après la procédure : Le message global a été modifié par la procédure. ``` ### Exercices 1. **Différence :** Expliquez avec vos propres mots la différence essentielle entre une procédure et une fonction. 2. **Créer une procédure :** Écrivez la pseudo-code d'une procédure nommée `AfficherNomEtAge` qui prend en paramètres un `nom` et un `age` et affiche un message comme "Bonjour [nom], vous avez [age] ans." 3. **Créer une fonction :** Écrivez la pseudo-code d'une fonction nommée `EstPair` qui prend un nombre entier en paramètre et retourne `VRAI` s'il est pair, et `FAUX` s'il est impair. (Rappel : un nombre est pair si le reste de sa division par 2 est 0). 4. **Portée des variables :** Dans le programme principal, déclarez une variable `compteur` initialisée à 0. Écrivez une procédure `IncrementerCompteur` qui incrémente ce `compteur`. Quel type de variable doit être `compteur` pour que la procédure puisse le modifier ? ### Devoirs 1. **Calculatrice simple :** Écrivez un programme complet (en pseudo-code) qui demande à l'utilisateur deux nombres et l'opération à effectuer (+, -, ", /). Utilisez des fonctions séparées pour chaque opération (par exemple, `Addition(a, b)`, `Soustraction(a, b)`, etc.). Le programme principal doit appeler la fonction appropriée et afficher le résultat. 2. **Conversion de température :** Créez une fonction `CelsiusVersFahrenheit(celsius)` qui prend une température en degrés Celsius en paramètre et retourne sa valeur équivalente en degrés Fahrenheit. La formule est \[ F = C \times 1.8 + 32 \]. Ensuite, créez une autre fonction `FahrenheitVersCelsius(fahrenheit)` qui fait l'inverse \[ C = (F - 32) / 1.8 \]. Écrivez un petit programme qui utilise ces deux fonctions pour convertir des valeurs données par l'utilisateur. ### Résumé Dans cette leçon, nous avons exploré l'importance des programmes structurés et le rôle crucial des sous-programmes. Nous avons appris que les **procédures** exécutent des tâches sans retourner de valeur, tandis que les **fonctions** effectuent des calculs et retournent une valeur. L'utilisation de **paramètres** et d'**arguments** permet aux sous-programmes d'être flexibles et réutilisables. Enfin, la distinction entre **variables locales** et **variables globales** est essentielle pour comprendre la portée et la visibilité des données dans un programme. Maîtriser ces concepts vous permettra d'écrire des programmes plus organisés, plus efficaces et plus faciles à maintenir.