UA10 : Exécution des algorithmes

# UA10 : Exécution des algorithmes ## Généralités sur les algorithmes ### Introduction Bienvenue à cette première leçon sur les algorithmes ! Dans le monde numérique d'aujourd'hui, les algorithmes sont partout, des applications de votre smartphone aux systèmes qui gèrent le trafic aérien. Mais qu'est-ce qu'un algorithme exactement ? C'est le sujet que nous allons explorer. Nous allons apprendre ce qu'ils sont, à quoi ils servent, et comment ils nous aident à résoudre des problèmes complexes de manière structurée et logique. ### Concepts Clés #### Qu'est-ce qu'un algorithme ? Un **algorithme** est une séquence finie et non ambiguë d'instructions ou d'opérations permettant de résoudre un problème ou d'obtenir un résultat. C'est comme une recette de cuisine : elle vous donne des étapes précises à suivre pour arriver à un plat final. En informatique, ces "recettes" sont destinées à être exécutées par une machine. ##### Caractéristiques d'un algorithme : * **Fini :** Il doit se terminer après un nombre limité d'étapes. * **Déterministe :** Pour les mêmes données d'entrée, il doit toujours produire les mêmes résultats. * **Non ambigu :** Chaque instruction doit être claire et interprétable d'une seule manière. Il n'y a pas de place pour l'interprétation. * **Effectif :** Chaque étape doit pouvoir être réalisée concrètement (par un humain ou une machine). #### Pourquoi utiliser des algorithmes ? Les algorithmes sont la base de toute l'informatique et de la programmation. Ils nous permettent de : * **Automatiser des tâches :** Répéter des opérations sans intervention humaine. * **Résoudre des problèmes complexes :** Décomposer un gros problème en petites étapes gérables. * **Économiser du temps et de l'énergie :** En laissant les machines faire le travail rapidement et efficacement. #### Algorithme vs. Programme Il est important de distinguer ces deux termes : * Un **algorithme** est une idée abstraite, une logique, une séquence d'étapes pour résoudre un problème, indépendamment de tout langage de programmation. * Un **programme** est l'implémentation concrète d'un algorithme dans un langage de programmation spécifique (comme Python, Java, C++, etc.). C'est l'algorithme traduit dans un langage que l'ordinateur peut comprendre et exécuter. #### Représentation d'un algorithme Pour écrire un algorithme, on utilise souvent : * Le **langage naturel** : Description des étapes en français (ou autre langue). * Le **pseudo-code** : Une manière structurée d'écrire des algorithmes qui ressemble à un langage de programmation, mais qui n'est pas lié à un langage spécifique. Il utilise des mots clés simples (comme `LIRE`, `AFFICHER`, `SI...ALORS...FINSI`, `TANT QUE...FAIRE...FINTANTQUE`). * Les **organigrammes** : Des diagrammes visuels qui utilisent des symboles standardisés pour représenter les différentes étapes et le flux logique de l'algorithme. ### Vocabulaire * **Algorithme :** Séquence finie d'instructions pour résoudre un problème. * **Instruction :** Une action ou une opération unique à effectuer. * **Séquence :** L'ordre dans lequel les instructions sont exécutées. * **Déterminisme :** Caractéristique d'un algorithme qui produit toujours le même résultat pour les mêmes entrées. * **Pseudo-code :** Langage semi-formel pour décrire un algorithme, indépendant d'un langage de programmation. * **Programme :** Algorithme écrit dans un langage de programmation spécifique pour être exécuté par un ordinateur. * **Exécution :** L'action d'un ordinateur de suivre les instructions d'un programme. ### Exemples #### Exemple 1 : Algorithme de la vie courante (Préparer un café instantané) 1. Prendre une tasse. 2. Mettre une cuillère de café instantané dans la tasse. 3. Faire bouillir de l'eau. 4. Verser l'eau bouillante dans la tasse. 5. Ajouter du sucre (facultatif). 6. Ajouter du lait (facultatif). 7. Mélanger. #### Exemple 2 : Algorithme simple en pseudo-code (Calculer la somme de deux nombres) ```pseudo-code ALGORITHME SommeDeDeuxNombres VARIABLES nombre1, nombre2, somme : ENTIER DEBUT AFFICHER "Veuillez entrer le premier nombre : " LIRE nombre1 AFFICHER "Veuillez entrer le deuxième nombre : " LIRE nombre2 somme ← nombre1 + nombre2 AFFICHER "La somme des deux nombres est : ", somme FIN ``` *Explication :* Cet algorithme demande à l'utilisateur deux nombres, les additionne et affiche le résultat. Chaque étape est claire et non ambiguë. ### Exercices 1. **Question :** Expliquez avec vos propres mots ce qu'est un algorithme et donnez un exemple tiré de votre quotidien (autre que ceux vus en cours). 2. **Question :** Quelle est la différence fondamentale entre un algorithme et un programme informatique ? 3. **Exercice pratique :** Écrivez un algorithme en pseudo-code pour calculer le produit (la multiplication) de trois nombres. L'algorithme devra demander les trois nombres à l'utilisateur et afficher le résultat. ### Devoirs 1. **Exercice de pseudo-code :** Écrivez un algorithme en pseudo-code qui demande à l'utilisateur son âge et affiche ensuite si la personne est majeure (18 ans ou plus) ou mineure. 2. **Recherche :** Faites une brève recherche sur l'histoire des algorithmes. Qui était Al-Khwarizmi et quel est son lien avec le mot "algorithme" ? Préparez-vous à partager vos découvertes en classe. ### Résumé Pour conclure, un algorithme est une séquence d'instructions claires et finies pour résoudre un problème. Il est la logique derrière toute tâche automatisée et constitue la base de la programmation informatique. Un programme est la traduction concrète d'un algorithme dans un langage compréhensible par une machine. Comprendre les algorithmes est une compétence fondamentale en informatique et pour la résolution de problèmes en général. Nous avons appris leurs caractéristiques principales, leur utilité et comment les représenter, notamment avec le pseudo-code. Pensez-y comme aux plans détaillés avant de construire un bâtiment : les algorithmes sont ces plans pour nos systèmes numériques. ## Introduction aux algorithmes Partie 2 ### Introduction Bienvenue à cette deuxième partie de notre leçon sur les algorithmes ! Dans la première partie, nous avons découvert ce qu'est un algorithme : une séquence d'instructions claires et précises pour résoudre un problème. Aujourd'hui, nous allons plonger plus en profondeur dans la manière dont ces algorithmes fonctionnent et s'exécutent. Nous explorerons les éléments fondamentaux qui les composent, comme les variables et les types d'instructions, et comment ces éléments interagissent pour donner vie à une solution. ### Concepts Clés #### Rappel : Qu'est-ce qu'un algorithme ? Un algorithme est une suite finie et non ambiguë d'instructions permettant de résoudre un problème donné. Il doit être: * **Fini:** Il doit se terminer après un nombre limité d'étapes. * **Déterminé:** Pour les mêmes entrées, il doit produire les mêmes sorties. * **Effectif:** Chaque instruction doit pouvoir être exécutée en un temps fini. #### Les variables Pour qu'un algorithme puisse manipuler des données (nombres, textes, etc.), il a besoin de **variables**. Une variable est un espace de stockage nommé en mémoire qui peut contenir une valeur. Pensez-y comme une boîte étiquetée où vous pouvez ranger et récupérer différentes informations. * **Nom de la variable:** L'étiquette de la boîte (ex: `age`, `nom`, `temperature`). * **Valeur de la variable:** Le contenu de la boîte (ex: `18`, `"Alice"`, `25.5`). * **Type de la variable:** La nature des données que la variable peut contenir. Les types courants incluent: * **Entier:** Nombres entiers (ex: 5, -10). * **Réel (ou Flottant):** Nombres à virgule (ex: 3.14, -0.5). * **Chaîne de caractères:** Texte (ex: "Bonjour", "Mon nom"). * **Booléen:** Vrai ou Faux (ex: VRAI, FAUX). #### Les instructions de base ##### L'affectation L'affectation est l'instruction qui consiste à donner une valeur à une variable ou à modifier sa valeur actuelle. On utilise généralement le symbole `<-` (ou parfois `=`) pour l'affectation. **Syntaxe:** `Nom_variable <- Valeur` **Exemples:** * `age <- 20` (La variable `age` contient maintenant la valeur `20`) * `message <- "Bienvenue"` (La variable `message` contient la chaîne de caractères "Bienvenue") * `nombre1 <- 10` * `nombre2 <- 5` * `somme <- nombre1 + nombre2` (La variable `somme` contient maintenant `15`) ##### Les entrées/sorties Ces instructions permettent à l'algorithme d'interagir avec l'utilisateur ou le monde extérieur. * **Instruction d'entrée (LIRE):** Permet à l'algorithme de demander une information à l'utilisateur et de la stocker dans une variable. * **Syntaxe:** `LIRE Nom_variable` * **Exemple:** `AFFICHER "Quel est votre nom ?"` `LIRE nomUtilisateur` * **Instruction de sortie (AFFICHER):** Permet à l'algorithme d'afficher un message ou le contenu d'une variable à l'utilisateur. * **Syntaxe:** `AFFICHER "Message"` ou `AFFICHER Nom_variable` * **Exemple:** `prenom <- "Alice"` `AFFICHER "Bonjour "` `AFFICHER prenom` (Affichera "Bonjour Alice") #### Les structures de contrôle Les algorithmes ne sont pas toujours une simple suite linéaire d'instructions. Souvent, ils doivent prendre des décisions ou répéter des actions. C'est là que les structures de contrôle interviennent. ##### Les structures conditionnelles (SI... ALORS... SINON...) Ces structures permettent à l'algorithme d'exécuter différentes actions en fonction d'une condition. La condition est une expression qui peut être évaluée à VRAI ou FAUX. **Syntaxe générale:** ``` SI Condition ALORS // Instructions à exécuter si la Condition est VRAIE SINON // Instructions à exécuter si la Condition est FAUSSE FIN SI ``` Le bloc `SINON` est facultatif. **Exemple:** Vérifier si un âge permet de voter. ``` LIRE age SI age >= 18 ALORS AFFICHER "Vous pouvez voter." SINON AFFICHER "Vous n'êtes pas encore majeur pour voter." FIN SI ``` ##### Les structures répétitives (Les boucles) Les boucles permettent de répéter un bloc d'instructions plusieurs fois. ###### Boucle TANT QUE (WHILE) La boucle `TANT QUE` répète un bloc d'instructions tant qu'une condition reste VRAIE. La condition est vérifiée *avant* chaque exécution du bloc. **Syntaxe générale:** ``` TANT QUE Condition FAIRE // Instructions à répéter FIN TANT QUE ``` **Exemple:** Compter de 1 à 5. ``` compteur <- 1 TANT QUE compteur <= 5 FAIRE AFFICHER compteur compteur <- compteur + 1 FIN TANT QUE AFFICHER "Fin du compte." ``` ###### Boucle POUR (FOR) La boucle `POUR` est utilisée lorsque l'on connaît à l'avance le nombre de répétitions. Elle utilise souvent un compteur qui varie d'une valeur de départ à une valeur d'arrivée. **Syntaxe générale:** ``` POUR variable DE debut A fin PAS DE pas FAIRE // Instructions à répéter FIN POUR ``` Le `PAS DE pas` est facultatif ; s'il n'est pas précisé, le pas est de 1. **Exemple:** Afficher un message 3 fois. ``` POUR i DE 1 A 3 FAIRE AFFICHER "Bonjour, ceci est la répétition " + i FIN POUR ``` ### Vocabulaire * **Algorithme:** Suite finie et non ambiguë d'instructions pour résoudre un problème. * **Variable:** Espace de stockage nommé en mémoire pour une valeur. * **Affectation:** Opération qui attribue une valeur à une variable. * **Instruction:** Commande simple et élémentaire exécutée par l'algorithme. * **Entrée:** Donnée fournie à l'algorithme (souvent par l'utilisateur). * **Sortie:** Résultat ou message affiché par l'algorithme. * **Condition:** Expression qui est évaluée à VRAI ou FAUX et guide le flux d'exécution. * **Boucle:** Structure de contrôle qui permet de répéter un ensemble d'instructions. * **Itération:** Une seule exécution du bloc d'instructions à l'intérieur d'une boucle. ### Exemples #### Exemple 1: Calcul de la somme de deux nombres ``` ALGORITHME SommeDeDeuxNombres VARIABLES nombre1, nombre2, resultat : ENTIER DEBUT AFFICHER "Entrez le premier nombre : " LIRE nombre1 AFFICHER "Entrez le deuxième nombre : " LIRE nombre2 resultat <- nombre1 + nombre2 AFFICHER "La somme est : " + resultat FIN ``` #### Exemple 2: Vérifier si un nombre est positif ou négatif ``` ALGORITHME VerifierSigne VARIABLES nombre : ENTIER DEBUT 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: Calcul de la moyenne de trois notes ``` ALGORITHME CalculMoyenne VARIABLES note1, note2, note3, moyenne : REEL DEBUT 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 ``` La formule de la moyenne est \( M = \frac{N_1 + N_2 + N_3}{3} \). ### Exercices 1. **Question 1:** Décrivez en vos propres mots ce qu'est une variable et pourquoi elle est essentielle dans un algorithme. 2. **Question 2:** Écrivez un algorithme qui demande à l'utilisateur son année de naissance et affiche l'âge qu'il aura à la fin de l'année en cours (prenez l'année courante comme 2024). 3. **Question 3:** Quel sera l'affichage de l'algorithme suivant ? ``` ALGORITHME Mystere VARIABLES x : ENTIER DEBUT x <- 0 TANT QUE x < 3 FAIRE x <- x + 1 AFFICHER x FIN TANT QUE AFFICHER "Fini !" FIN ``` 4. **Question 4:** Modifiez l'algorithme de la Question 3 pour qu'il affiche les nombres de 5 à 1 en utilisant une boucle `POUR`. ### Devoirs 1. **Exercice 1:** Écrivez un algorithme qui demande un prix hors taxes et le taux de TVA (par exemple, 20%), puis affiche le prix toutes taxes comprises (TTC). Le calcul est \( TTC = PrixHT \times (1 + TauxTVA) \). 2. **Exercice 2:** Écrivez un algorithme qui demande un mot à l'utilisateur et affiche "Ce mot est court." s'il contient 5 lettres ou moins, et "Ce mot est long." s'il contient plus de 5 lettres. (Considérez que vous avez une fonction `LONGUEUR(mot)` qui renvoie le nombre de lettres du mot). 3. **Exercice 3:** Écrivez un algorithme qui demande à l'utilisateur de saisir 5 nombres, puis affiche la somme de ces 5 nombres. (Utilisez une boucle pour lire les nombres). ### Résumé Dans cette partie, nous avons approfondi l'exécution des algorithmes en explorant leurs composants fondamentaux : * Les **variables** sont des espaces nommés pour stocker des données de différents types (entier, réel, chaîne, booléen). * L'**affectation** (`<-`) permet de donner ou modifier la valeur d'une variable. * Les **entrées (`LIRE`)** et **sorties (`AFFICHER`)** assurent l'interaction avec l'utilisateur. * Les **structures conditionnelles (`SI... ALORS... SINON...`)** permettent de prendre des décisions. * Les **structures répétitives (boucles `TANT QUE` et `POUR`)** permettent d'exécuter des blocs d'instructions plusieurs fois. Comprendre ces concepts est essentiel pour pouvoir créer et analyser des algorithmes plus complexes. Vous avez maintenant les bases pour commencer à écrire vos propres algorithmes simples ! ## Structures de contrôle ### Structures de contrôle #### Introduction Bienvenue à cette leçon sur les structures de contrôle en algorithmique. En programmation, il est rarement suffisant d'exécuter des instructions les unes après les autres. Souvent, nous avons besoin que notre programme prenne des décisions, répète des actions ou ignore certaines parties du code selon des conditions spécifiques. C'est là que les **structures de contrôle** entrent en jeu. Elles nous permettent de contrôler le **flux d'exécution** d'un algorithme, c'est-à-dire l'ordre dans lequel les instructions sont exécutées. Maîtriser ces structures est fondamental pour écrire des programmes complexes et efficaces. #### Concepts Clés ##### 1. La Structure Séquentielle La structure séquentielle est la plus simple et la plus fondamentale. Les instructions sont exécutées dans l'ordre où elles sont écrites, du début à la fin. C'est le comportement par défaut de tout algorithme. * **Principe** : Une instruction est exécutée après l'autre, sans saut ni répétition. * **Exemple** : ```pseudo-code DEBUT LIRE nombre1 LIRE nombre2 resultat = nombre1 + nombre2 ECRIRE resultat FIN ``` ##### 2. Les Structures Conditionnelles (Structures de Choix) Les structures conditionnelles permettent d'exécuter un bloc d'instructions *uniquement si* une certaine condition est vraie. Elles sont cruciales pour que les programmes puissent prendre des décisions. ###### a. La structure "Si... Alors..." Exécute un bloc d'instructions si la condition est vraie. * **Pseudo-code** : ```pseudo-code SI (condition) ALORS // Instructions à exécuter si la condition est vraie FINSI ``` * **Exemple** : ```pseudo-code SI (age >= 18) ALORS ECRIRE "Vous êtes majeur" FINSI ``` ###### b. La structure "Si... Alors... Sinon..." Exécute un bloc d'instructions si la condition est vraie, et un autre bloc si elle est fausse. * **Pseudo-code** : ```pseudo-code SI (condition) ALORS // Instructions si la condition est vraie SINON // Instructions si la condition est fausse FINSI ``` * **Exemple** : ```pseudo-code SI (note >= 10) ALORS ECRIRE "Admis" SINON ECRIRE "Refusé" FINSI ``` ###### c. Conditions Complexes et Opérateurs Logiques Les conditions peuvent être combinées à l'aide d'opérateurs logiques : * **ET (AND)** : Les deux conditions doivent être vraies. * **OU (OR)** : Au moins une des conditions doit être vraie. * **NON (NOT)** : Inverse la valeur de vérité d'une condition. * **Exemple** : \( (age > 18) \text{ ET } (permis == \text{vrai}) \) ##### 3. Les Structures Répétitives (Boucles) Les structures répétitives, ou boucles, permettent d'exécuter un bloc d'instructions plusieurs fois, soit un nombre défini de fois, soit tant qu'une condition est vraie (ou fausse). ###### a. La boucle "Tant que... Faire..." (While) Le bloc d'instructions est exécuté **tant que** la condition est vraie. La condition est testé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** : ```pseudo-code TANT QUE (condition) FAIRE // Instructions à répéter FINTANTQUE ``` * **Exemple** : ```pseudo-code compteur = 0 TANT QUE (compteur < 5) FAIRE ECRIRE "Bonjour" compteur = compteur + 1 FINTANTQUE ``` ###### b. La boucle "Répéter... Jusqu'à ce que..." (Repeat-Until) Le bloc d'instructions est exécuté **au moins une fois**, puis répété **jusqu'à ce que** la condition devienne vraie. La condition est testée *après* chaque exécution du bloc. * **Pseudo-code** : ```pseudo-code REPETER // Instructions à répéter JUSQU'A CE QUE (condition) ``` * **Exemple** : ```pseudo-code reponse = "" REPETER ECRIRE "Voulez-vous rejouer ? (oui/non)" LIRE reponse JUSQU'A CE QUE (reponse == "oui" OU reponse == "non") ``` ###### c. La boucle "Pour... De... à... Faire..." (For) Cette boucle est utilisée lorsque le nombre d'itérations est connu à l'avance. Elle est souvent utilisée pour parcourir des séquences ou pour répéter une action un nombre fixe de fois. * **Pseudo-code** : ```pseudo-code POUR variable DE valeur_debut A valeur_fin FAIRE // Instructions à répéter FINPOUR ``` * **Exemple** : ```pseudo-code POUR i DE 1 A 10 FAIRE ECRIRE i FINPOUR ``` * **Note sur les sommes** : Vous verrez parfois des boucles utilisées pour calculer des sommes comme celle-ci : \[ Somme = \sum_{i=1}^{N} i \] où N est un entier. Cela signifie additionner tous les nombres de 1 à N. #### Vocabulaire * **Algorithme** : Séquence d'instructions précises et non ambiguës pour résoudre un problème. * **Flux d'exécution** : Ordre dans lequel les instructions d'un programme sont exécutées. * **Structure de contrôle** : Mécanisme qui modifie le flux d'exécution d'un programme (séquentiel, conditionnel, répétitif). * **Séquentiel** : Exécution des instructions l'une après l'autre. * **Conditionnel** : Exécution d'instructions soumises à une condition (Si... Alors...). * **Répétitif (Boucle)** : Exécution répétée d'un bloc d'instructions (Tant que, Répéter, Pour). * **Condition** : Expression logique qui évalue à vrai ou faux, déterminant la suite de l'exécution. * **Itération** : Une seule exécution du corps d'une boucle. * **Opérateur logique** : Symbole utilisé pour combiner ou modifier des conditions (ET, OU, NON). #### Exemples 1. **Calcul de la moyenne de deux nombres (Séquentiel)** ```pseudo-code DEBUT LIRE note1 LIRE note2 moyenne = (note1 + note2) / 2 ECRIRE "La moyenne est : " + moyenne FIN ``` 2. **Vérification de l'admissibilité (Conditionnel)** ```pseudo-code DEBUT LIRE age SI (age >= 16) ALORS ECRIRE "Vous pouvez passer le code" SINON ECRIRE "Vous ne pouvez pas encore passer le code" FINSI FIN ``` 3. **Compter à rebours (Répétitif - Pour)** ```pseudo-code DEBUT POUR i DE 10 A 1 (pas de -1) FAIRE ECRIRE i FINPOUR ECRIRE "Décollage !" FIN ``` 4. **Saisie sécurisée d'un mot de passe (Répétitif - Tant que)** ```pseudo-code mot_de_passe_correct = "secret" mot_de_passe_saisi = "" TANT QUE (mot_de_passe_saisi != mot_de_passe_correct) FAIRE ECRIRE "Veuillez entrer le mot de passe : " LIRE mot_de_passe_saisi SI (mot_de_passe_saisi != mot_de_passe_correct) ALORS ECRIRE "Mot de passe incorrect. Réessayez." FINSI FINTANTQUE ECRIRE "Accès autorisé !" ``` #### Exercices 1. **Quel type de structure ?** Pour chacun des scénarios suivants, indiquez quelle structure de contrôle (séquentielle, conditionnelle, répétitive) serait la plus appropriée : * Calculer la TVA sur un prix donné. * Afficher un message de bienvenue si l'utilisateur est connecté, sinon un message de connexion. * Demander à l'utilisateur un nombre entre 1 et 10 jusqu'à ce qu'il en entre un valide. * Afficher tous les nombres pairs de 0 à 100. 2. **Écrivez le pseudo-code :** Écrivez un algorithme en pseudo-code qui demande à l'utilisateur deux nombres, puis affiche le plus grand des deux. Si les nombres sont égaux, il doit l'indiquer. 3. **Trace d'exécution :** Quel sera le résultat de l'exécution de l'algorithme suivant ? ```pseudo-code nombre = 3 TANT QUE (nombre < 10) FAIRE ECRIRE nombre nombre = nombre + 2 FINTANTQUE ``` #### Devoir Maison 1. **Jeu de devinette :** Écrivez un algorithme en pseudo-code qui : * Génère un nombre aléatoire entre 1 et 100 (simulez-le si vous n'avez pas de fonction `ALEATOIRE`). * Demande à l'utilisateur de deviner ce nombre. * Indique si la proposition est trop grande ou trop petite. * Continue de demander jusqu'à ce que l'utilisateur trouve le bon nombre. * Affiche le nombre de tentatives. 2. **Table de multiplication :** Écrivez un algorithme qui demande un nombre à l'utilisateur et affiche sa table de multiplication de 1 à 10. 3. **Calcul de factorielle :** La factorielle d'un nombre entier positif \( n \), notée \( n! \), est le produit de tous les entiers positifs inférieurs ou égaux à \( n \). Par exemple, \( 5! = 5 imes 4 imes 3 imes 2 imes 1 = 120 \). Écrivez un algorithme qui demande un nombre \( n \) à l'utilisateur et calcule sa factorielle. Gérer le cas où \( n = 0 \) (rappel : \( 0! = 1 \)). #### Résumé Nous avons exploré les trois grandes catégories de structures de contrôle qui sont les piliers de la logique de programmation : * **Séquentielle** : Les instructions s'exécutent l'une après l'autre, dans l'ordre. * **Conditionnelle** (`Si... Alors...`) : Permet de prendre des décisions et d'exécuter du code différemment selon qu'une condition est vraie ou fausse. * **Répétitive** (`Tant que...`, `Répéter... Jusqu'à ce que...`, `Pour...`) : Permet d'exécuter un bloc de code plusieurs fois, soit un nombre connu ou inconnu à l'avance. La maîtrise de ces structures est essentielle pour créer des algorithmes qui peuvent résoudre des problèmes complexes en s'adaptant à différentes situations et en automatisant des tâches répétitives. Continuez à pratiquer la rédaction de pseudo-code pour renforcer votre compréhension ! ## Organigramme # Organigramme\n\n## Introduction\nBienvenue dans cette leçon dédiée aux organigrammes ! En informatique, un algorithme est une suite d'instructions précises pour résoudre un problème. Pour mieux comprendre et concevoir ces algorithmes, il est souvent utile de les représenter visuellement. L'organigramme est un outil graphique puissant qui nous aide à visualiser le déroulement logique d'un programme, étape par étape.\n\n## Concepts Clés\n\n### Qu'est-ce qu'un organigramme ?\nUn organigramme est une représentation graphique d'un algorithme ou d'un processus. Il utilise des symboles standardisés pour illustrer les différentes étapes, les décisions et le flux d'exécution. L'objectif est de rendre la logique d'un programme facile à comprendre et à analyser.\n\n### Symboles de l'organigramme\nLes organigrammes utilisent des symboles spécifiques, chacun ayant une signification particulière :\n\n* **Début/Fin (Terminator)**\n * **Forme :** Ovale ou rectangle arrondi.\n * **Représente :** Le point de départ et le point d'arrivée de l'algorithme.\n * **Exemples :** `DÉBUT`, `FIN`.\n\n* **Traitement (Process)**\n * **Forme :** Rectangle.\n * **Représente :** Une action, un calcul, une affectation de valeur (par exemple, \( A = B + C \)).\n * **Exemples :** `Calculer la somme`, `Affecter 0 à compteur`.\n\n* **Entrée/Sortie (Input/Output)**\n * **Forme :** Parallélogramme.\n * **Représente :** La lecture de données fournies par l'utilisateur (entrée) ou l'affichage de résultats (sortie).\n * **Exemples :** `LIRE nombre`, `AFFICHER résultat`.\n\n* **Décision/Condition (Decision)**\n * **Forme :** Losange.\n * **Représente :** Un choix ou une condition à évaluer. Il y a toujours deux chemins de sortie : un si la condition est vraie (Oui) et un autre si elle est fausse (Non).\n * **Exemples :** `Si nombre > 0 ?`, `Est-ce que A est égal à B ?`.\n\n* **Flèche de liaison (Flowline)**\n * **Forme :** Flèche.\n * **Représente :** Indique le sens du déroulement des opérations dans l'organigramme.\n\n### Structures de contrôle de base\nLes organigrammes peuvent représenter différentes manières d'organiser les instructions :\n\n* **Séquence**\n * **Description :** Les instructions s'exécutent les unes après les autres, dans l'ordre où elles apparaissent.\n\n* **Conditionnelle (Alternative)**\n * **Description :** Une condition est testée, et selon que la condition est vraie ou fausse, un bloc d'instructions est exécuté ou un autre (ou rien si la condition est fausse pour une structure 'si' simple).\n\n* **Répétitive (Boucle)**\n * **Description :** Un ensemble d'instructions est répété plusieurs fois, tant qu'une certaine condition est vraie ou jusqu'à ce qu'une condition devienne vraie.\n\n### Comment créer un organigramme ?\nPour construire un organigramme efficacement :\n\n1. **Définissez le problème :** Comprenez clairement ce que l'algorithme doit faire.\n2. **Identifiez les étapes clés :** Listez les actions principales à réaliser.\n3. **Déterminez les entrées et sorties :** Quelles données sont nécessaires ? Quels résultats doivent être produits ?\n4. **Repérez les décisions et les répétitions :** Y a-t-il des choix à faire ou des actions à répéter ?\n5. **Utilisez les symboles appropriés :** Dessinez chaque étape avec le bon symbole.\n6. **Reliez les symboles :** Utilisez des flèches pour montrer le flux logique des opérations.\n\n## Vocabulaire\n\n* **Algorithme :** Suite finie et non ambiguë d'instructions pour résoudre un problème donné.\n* **Organigramme :** Représentation graphique d'un algorithme.\n* **Séquence :** Ordre linéaire d'exécution des instructions.\n* **Condition :** Énoncé qui peut être évalué comme vrai ou faux, et qui détermine le chemin d'exécution.\n* **Boucle (ou itération) :** Répétition d'un bloc d'instructions tant qu'une condition est remplie ou un certain nombre de fois.\n* **Variable :** Espace nommé dans la mémoire de l'ordinateur utilisé pour stocker une valeur qui peut changer au cours de l'exécution de l'algorithme.\n\n## Exemples\n\n### Exemple 1: Calcul de la somme de deux nombres\nCeci est un algorithme simple pour additionner deux nombres et afficher le résultat.\n\n* DÉBUT (Ovale)\n* LIRE `nombre1` (Parallélogramme)\n* LIRE `nombre2` (Parallélogramme)\n* `somme = nombre1 + nombre2` (Rectangle)\n* AFFICHER `somme` (Parallélogramme)\n* FIN (Ovale)\n\n### Exemple 2: Vérifier si un nombre est positif\nCet algorithme vérifie si un nombre saisi par l'utilisateur est positif.\n\n* DÉBUT (Ovale)\n* LIRE `nombre` (Parallélogramme)\n* `SI nombre > 0 ?` (Losange)\n * **Oui :** AFFICHER