UA 13 : Pratique d’activités algorithmiques

# UA 13 : Pratique d’activités algorithmiques ## Notion de structure de contrôle ### Introduction Bienvenue dans cette leçon sur les structures de contrôle ! En informatique, un programme est une suite d'instructions que l'ordinateur doit exécuter. Mais pour que nos programmes soient "intelligents" et puissent s'adapter à différentes situations, ils ont besoin de prendre des décisions et de répéter des actions. C'est là que les structures de contrôle entrent en jeu. Elles nous permettent de contrôler l'ordre dans lequel les instructions sont exécutées. ### Concepts Clés #### Qu'est-ce qu'un Algorithme et un Programme ? Un **algorithme** est une série d'étapes claires et non ambiguës pour résoudre un problème ou accomplir une tâche. C'est comme une recette de cuisine ! Un **programme** est la traduction de cet algorithme dans un langage que l'ordinateur peut comprendre et exécuter. #### Les Structures de Contrôle : Définition et Types Les structures de contrôle sont des éléments fondamentaux des algorithmes et des programmes qui déterminent l'ordre d'exécution des instructions. Elles permettent de : * Exécuter les instructions les unes après les autres (séquence). * Choisir quelle instruction exécuter en fonction d'une condition (alternative). * Répéter un bloc d'instructions plusieurs fois (répétition). #### 1. Structure Séquentielle C'est la structure la plus simple. Les instructions sont exécutées les unes après les autres, dans l'ordre où elles sont écrites. C'est le comportement par défaut de tout programme. *Exemple :* 1. Prendre un verre. 2. Verser de l'eau. 3. Boire l'eau. #### 2. Structure Alternative (Conditionnelle) Cette structure permet à un programme de prendre des décisions. Un bloc d'instructions est exécuté **seulement si une certaine condition est vraie**. Sinon (si la condition est fausse), un autre bloc d'instructions peut être exécuté, ou rien du tout. * **Le "Si...Alors" simple :** ``` Si (condition est VRAIE) Alors Faire ceci Fin Si ``` * **Le "Si...Alors...Sinon" :** ``` Si (condition est VRAIE) Alors Faire ceci Sinon Faire cela Fin Si ``` Une **condition** est une question à laquelle on peut répondre par Vrai ou Faux (oui ou non). Par exemple : \( âge \ge 18 \) (l'âge est-il supérieur ou égal à 18 ?). #### 3. Structure Répétitive (Boucle) Cette structure permet de répéter un ensemble d'instructions plusieurs fois. C'est très utile pour automatiser des tâches répétitives. * **La boucle "Tant que" (condition d'entrée) :** Les instructions sont répétées **tant que** la condition est vraie. La condition est vérifiée avant chaque répétition. ``` Tant que (condition est VRAIE) Faire Répéter ces instructions Fin Tant que ``` * **La boucle "Pour" (nombre de répétitions connu) :** Les instructions sont répétées un nombre de fois défini à l'avance. ``` Pour (compteur allant de début à fin) Faire Répéter ces instructions Fin Pour ``` ### Vocabulaire * **Algorithme** : Une séquence d'instructions claires pour résoudre un problème. * **Programme** : La traduction d'un algorithme dans un langage informatique exécutable. * **Instruction** : Une commande simple donnée à l'ordinateur. * **Structure de contrôle** : Mécanisme qui détermine l'ordre d'exécution des instructions. * **Structure séquentielle** : Instructions exécutées dans l'ordre. * **Structure alternative / Conditionnelle** : Exécution d'instructions en fonction d'une condition. * **Condition** : Une expression qui peut être Vraie ou Fausse (ex: \( nombre > 10 \)). * **Structure répétitive / Boucle** : Répétition d'un bloc d'instructions. * **Itération** : Une seule exécution du bloc d'instructions à l'intérieur d'une boucle. ### Exemples Pratiques #### Exemple 1 : Vérifier l'âge (Structure Alternative) ``` Demander l'âge de la personne Si (âge >= 18) Alors Afficher "Vous êtes majeur." Sinon Afficher "Vous êtes mineur." Fin Si ``` #### Exemple 2 : Compte à rebours (Structure Répétitive - Pour) ``` Pour compteur allant de 5 à 1 (par pas de -1) Faire Afficher compteur Fin Pour Afficher "Décollage !" ``` #### Exemple 3 : Attendre une réponse (Structure Répétitive - Tant que) ``` réponse_valide = FAUX Tant que (réponse_valide est FAUX) Faire Demander à l'utilisateur : "Voulez-vous continuer (O/N) ?" Si (réponse est "O") Alors Afficher "Continuons !" réponse_valide = VRAI Sinon Si (réponse est "N") Alors Afficher "Terminé." réponse_valide = VRAI Sinon Afficher "Réponse invalide. Veuillez entrer O ou N." Fin Si Fin Tant que ``` ### Exercices 1. **Identifier les structures :** Pour chaque scénario ci-dessous, indiquez s'il s'agit d'une structure séquentielle, alternative ou répétitive (ou une combinaison). * a) Lire une recette, préparer les ingrédients, cuisiner le plat, servir. * b) Si j'ai faim, je mange ; sinon, je bois de l'eau. * c) Mélanger la pâte 50 fois. * d) Tant que la porte est fermée, essayer de l'ouvrir. 2. **Écrire un algorithme simple (pseudocode) :** Écrivez un algorithme qui demande un nombre à l'utilisateur et affiche "Ce nombre est positif" s'il est supérieur à zéro, et "Ce nombre est négatif ou nul" sinon. 3. **Boucle simple :** Écrivez un algorithme qui affiche tous les nombres pairs de 2 à 10 inclus. ### Devoir 1. **Algorithme de validation :** Écrivez un algorithme qui demande à un utilisateur son mot de passe. Si le mot de passe est "secret123", afficher "Accès autorisé". Sinon, afficher "Accès refusé" et redemander le mot de passe. L'utilisateur a droit à 3 tentatives maximum. Après 3 tentatives échouées, le programme doit afficher "Compte bloqué" et s'arrêter. 2. **Calcul de moyenne :** Écrivez un algorithme qui demande 5 notes à l'utilisateur, calcule leur moyenne et affiche : "Très bien" si la moyenne est supérieure ou égale à 15, "Bien" si elle est entre 10 et 14 (inclus), et "Insuffisant" si elle est inférieure à 10. ### Résumé Nous avons exploré les trois types fondamentaux de structures de contrôle qui permettent de créer des programmes dynamiques et intelligents : * Les **structures séquentielles** : Les instructions s'exécutent dans l'ordre. * Les **structures alternatives** (Si...Alors...Sinon) : Le programme prend des décisions basées sur des conditions (Vrai/Faux). * Les **structures répétitives** (Tant que, Pour) : Le programme répète des actions un certain nombre de fois ou tant qu'une condition est vraie. La maîtrise de ces structures est essentielle pour créer des algorithmes efficaces et des programmes fonctionnels. ## Utilisation des structures de contrôle alternatives ### Introduction Imagine que tu construis un robot et que tu veux qu'il prenne des décisions. Par exemple, si le chemin est bloqué, il doit tourner à gauche ; sinon, il peut continuer tout droit. En informatique, c'est exactement ce que nous faisons avec les **structures de contrôle alternatives**. Elles permettent à un programme de choisir différentes actions en fonction de certaines conditions. C'est comme un carrefour où le programme décide quelle route prendre! ### Concepts Clés #### Qu'est-ce qu'une structure de contrôle ? Un algorithme est une suite d'instructions à exécuter. Les **structures de contrôle** sont des outils qui nous aident à organiser ces instructions. Elles déterminent l'ordre dans lequel les instructions sont exécutées. Il existe plusieurs types, mais aujourd'hui, nous allons nous concentrer sur les structures alternatives. #### Qu'est-ce qu'une structure de contrôle alternative ? Une structure de contrôle alternative permet à un algorithme d'exécuter un bloc d'instructions *seulement si* une certaine **condition** est vraie, ou d'exécuter un autre bloc d'instructions si la condition est fausse. C'est la base de la *prise de décision* dans les programmes. #### La structure "Si... Alors..." (If... Then...) C'est la forme la plus simple de décision. Une action est effectuée *uniquement si* une condition est vraie. S'il n'y a pas de condition ou si elle est fausse, l'action est simplement ignorée, et le programme continue. * **Principe :** ``` SI (condition est vraie) ALORS Action A FIN SI ``` * **Exemple :** * Si tu as une bonne note, alors tes parents te félicitent. * En pseudo-code : ``` SI (Note > 15) ALORS Afficher "Félicitations !" FIN SI ``` #### La structure "Si... Alors... Sinon..." (If... Then... Else...) Cette structure est plus complète. Elle permet de choisir entre deux blocs d'actions : un si la condition est vraie, et un autre si la condition est fausse. * **Principe :** ``` SI (condition est vraie) ALORS Action A (si la condition est vraie) SINON Action B (si la condition est fausse) FIN SI ``` * **Exemple :** * Si le temps est beau, alors nous irons au parc, sinon nous resterons à la maison. * En pseudo-code : ``` SI (Météo == "Beau") ALORS Afficher "Allons au parc !" SINON Afficher "Restons à la maison." FIN SI ``` #### Conditions Une condition est une expression qui peut être évaluée comme vraie ou fausse. Elle utilise souvent des opérateurs de comparaison : * `==` (égal à) : \( 5 == 5 \) est vrai * `!=` (différent de) : \( 5 != 10 \) est vrai * `>` (supérieur à) : \( 10 > 5 \) est vrai * `<` (inférieur à) : \( 5 < 10 \) est vrai * `>=` (supérieur ou égal à) : \( 10 >= 10 \) est vrai * `<=` (inférieur ou égal à) : \( 5 <= 10 \) est vrai ### Vocabulaire * **Algorithme :** Une séquence d'instructions logiques et précises pour résoudre un problème ou accomplir une tâche. * **Condition :** Une affirmation qui peut être vraie ou fausse et qui détermine le chemin que prend l'algorithme. * **Structure de contrôle :** Un élément d'un algorithme qui gère l'ordre d'exécution des instructions. * **Alternative :** Type de structure de contrôle qui permet au programme de prendre des décisions et de choisir entre plusieurs chemins d'exécution basés sur des conditions. ### Exemples #### Exemple 1 : Vérifier l'âge pour regarder un film Un site web doit vérifier si un utilisateur est majeur (18 ans ou plus) pour lui donner accès à un film. ``` DEMANDER l'âge de l'utilisateur LIRE AgeUtilisateur SI (AgeUtilisateur >= 18) ALORS AFFICHER "Accès au film autorisé." SINON AFFICHER "Accès refusé. Vous devez avoir 18 ans ou plus." FIN SI ``` #### Exemple 2 : Donner la mention d'un élève Un professeur veut afficher si un élève est admis ou doit redoubler en fonction de sa moyenne. ``` DEMANDER la moyenne de l'élève LIRE MoyenneEleve SI (MoyenneEleve >= 10) ALORS AFFICHER "L'élève est admis." SINON AFFICHER "L'élève doit redoubler." FIN SI ``` ### Exercices 1. **Exercice 1 : Nombre positif ou négatif** Écris un algorithme qui demande un nombre à l'utilisateur. Si le nombre est supérieur à 0, l'algorithme doit afficher "Le nombre est positif". Sinon (s'il est zéro ou négatif), il doit afficher "Le nombre est négatif ou nul". 2. **Exercice 2 : Article en promotion** Écris un algorithme qui demande le prix d'un article. Si le prix est inférieur à 50 euros, l'algorithme doit afficher "C'est une bonne affaire !". Sinon, il doit afficher "Le prix est standard." ### Devoir #### Devoir 1 : Température extérieure Écris un algorithme qui demande à l'utilisateur la température extérieure actuelle (en degrés Celsius). L'algorithme doit ensuite afficher un message approprié : * Si la température est strictement supérieure à 25°C, afficher "Il fait chaud !". * Si la température est entre 15°C et 25°C (inclus), afficher "La température est agréable." * Sinon (si elle est strictement inférieure à 15°C), afficher "Il fait frais." ### Résumé Les structures de contrôle alternatives sont essentielles en informatique pour permettre aux programmes de prendre des décisions. Nous avons vu deux formes principales : * **`Si... Alors...` :** Exécute une action seulement si une condition est vraie. * **`Si... Alors... Sinon...` :** Exécute une action si la condition est vraie, et une *autre* action si la condition est fausse. Ces structures utilisent des **conditions** (des expressions qui sont soit vraies, soit fausses) pour guider le programme. La maîtrise de ces structures te permettra de créer des programmes beaucoup plus intelligents et réactifs ! ## Utilisation des structures de contrôle itératives ### Introduction Bienvenue à cette leçon sur les structures de contrôle itératives ! En informatique, un programme exécute des instructions. Parfois, nous avons besoin de répéter la même instruction ou le même ensemble d'instructions plusieurs fois. C'est là qu'interviennent les structures itératives, aussi appelées boucles. Elles nous permettent de faire des tâches répétitives de manière efficace, sans avoir à écrire le même code encore et encore. Imaginez devoir écrire 100 fois "Bonjour" ; une boucle le fait en quelques lignes ! ### Concepts Clés #### Qu'est-ce qu'une itération ? L'itération signifie la répétition. En programmation, une itération est l'exécution répétée d'un bloc de code. Chaque passage dans la boucle est une itération. #### Pourquoi utiliser les boucles ? * **Efficacité :** Réduire la quantité de code à écrire. * **Automatisation :** Exécuter des tâches répétitives sans intervention humaine. * **Flexibilité :** Adapter le nombre de répétitions en fonction de conditions ou de données. #### Types de structures itératives Il existe plusieurs types de boucles, chacune adaptée à des situations différentes. ##### 1. La boucle `POUR` (ou `FOR`) La boucle `POUR` est utilisée lorsque vous connaissez à l'avance le nombre de fois que vous voulez répéter un bloc d'instructions. Elle utilise généralement une variable de contrôle qui change à chaque itération. * **Quand l'utiliser :** Pour parcourir une liste d'éléments, compter de 1 à 10, répéter une action un nombre fixe de fois. * **Structure générale (en pseudo-code) :** ``` POUR chaque [variable] DE [début] À [fin] FAIRE // Instructions à répéter FIN POUR ``` * **Exemple :** Afficher les nombres de 1 à 5. ``` POUR i DE 1 À 5 FAIRE AFFICHER i FIN POUR ``` ##### 2. La boucle `TANT QUE` (ou `WHILE`) La boucle `TANT QUE` est utilisée lorsque vous ne connaissez pas à l'avance le nombre de répétitions. Elle continue à s'exécuter tant qu'une certaine condition reste vraie. La condition est vérifiée *avant* chaque exécution du bloc de code. Si la condition est fausse dès le début, le code de la boucle ne sera jamais exécuté. * **Quand l'utiliser :** Attendre qu'un utilisateur entre une valeur spécifique, chercher un élément jusqu'à ce qu'il soit trouvé, répéter jusqu'à ce qu'une condition soit remplie. * **Structure générale (en pseudo-code) :** ``` TANT QUE [condition est VRAIE] FAIRE // Instructions à répéter FIN TANT QUE ``` * **Exemple :** Demander un mot de passe jusqu'à ce qu'il soit correct. ``` VARIABLE motDePasseCorrect EST FAUX VARIABLE motDePasseEntre TANT QUE motDePasseCorrect EST FAUX FAIRE DEMANDER "Entrez le mot de passe :" À motDePasseEntre SI motDePasseEntre EST ÉGAL À "secret" ALORS motDePasseCorrect EST VRAI FIN SI FIN TANT QUE AFFICHER "Mot de passe correct !" ``` ##### 3. La boucle `RÉPÉTER... JUSQU'À` (ou `DO-WHILE`/`REPEAT-UNTIL`) Cette boucle est similaire à `TANT QUE`, mais la condition est vérifiée *après* l'exécution du bloc de code. Cela signifie que le code à l'intérieur de la boucle sera toujours exécuté au moins une fois, quelle que soit la condition initiale. * **Quand l'utiliser :** Lorsque vous voulez vous assurer qu'une action est effectuée au moins une fois, comme afficher un menu et demander un choix. * **Structure générale (en pseudo-code) :** ``` RÉPÉTER // Instructions à répéter JUSQU'À CE QUE [condition soit VRAIE] ``` * **Exemple :** Demander à l'utilisateur un nombre entre 1 et 10. ``` VARIABLE nombreChoisi RÉPÉTER DEMANDER "Choisissez un nombre entre 1 et 10 :" À nombreChoisi JUSQU'À CE QUE (nombreChoisi >= 1 ET nombreChoisi <= 10) AFFICHER "Vous avez choisi : ", nombreChoisi ``` #### Les boucles infinies Une boucle infinie est une boucle qui ne se termine jamais parce que sa condition de sortie n'est jamais remplie. Cela peut faire planter un programme. Il est très important de s'assurer que la condition de votre boucle deviendra fausse à un moment donné (pour `TANT QUE`) ou vraie (pour `RÉPÉTER... JUSQU'À`). ### Vocabulaire * **Itération (ou Boucle) :** Processus de répétition d'un bloc d'instructions. * **Algorithme :** Suite logique d'instructions pour résoudre un problème. * **Condition :** Expression logique (vraie ou fausse) qui détermine si une boucle doit continuer ou s'arrêter. * **Variable de contrôle :** Variable utilisée pour gérer le nombre d'itérations d'une boucle (`POUR`). * **Pseudo-code :** Langage simplifié et structuré pour décrire un algorithme avant de le coder dans un langage de programmation. ### Exemples Voici quelques exemples concrets d'utilisation des boucles en pseudo-code. #### Exemple 1 : Compter jusqu'à 10 (Boucle `POUR`) ``` // Algorithme pour afficher les nombres de 1 à 10 POUR compteur DE 1 À 10 FAIRE AFFICHER compteur FIN POUR ``` #### Exemple 2 : Calculer la somme des nombres de 1 à 5 (Boucle `POUR`) ``` // Algorithme pour calculer la somme des nombres de 1 à 5 VARIABLE somme EST 0 POUR i DE 1 À 5 FAIRE somme EST somme + i FIN POUR AFFICHER "La somme est : ", somme // Affiche 15 ``` #### Exemple 3 : Saisir des notes jusqu'à ce que la moyenne soit suffisante (Boucle `TANT QUE`) ``` // Algorithme pour saisir des notes jusqu'à obtenir une moyenne de 10 VARIABLE noteEstSuffisante EST FAUX VARIABLE note TANT QUE noteEstSuffisante EST FAUX FAIRE DEMANDER "Entrez une note (sur 20) :" À note SI note >= 10 ALORS noteEstSuffisante EST VRAI AFFICHER "Bravo, votre note est suffisante !" SINON AFFICHER "Votre note n'est pas suffisante. Réessayez !" FIN SI FIN TANT QUE ``` ### Exercices Répondez aux questions et rédigez les algorithmes en pseudo-code. 1. **Question :** Quel type de boucle utiliseriez-vous pour afficher votre nom 20 fois ? Expliquez pourquoi. 2. **Exercice :** Écrivez un algorithme utilisant une boucle `POUR` qui affiche tous les nombres pairs de 2 à 10 (inclus). 3. **Exercice :** Écrivez un algorithme utilisant une boucle `TANT QUE` qui demande à l'utilisateur d'entrer un nombre. Le programme doit continuer à demander un nombre tant que l'utilisateur n'entre pas le nombre 7. Une fois le 7 entré, le programme affiche "Vous avez trouvé le nombre secret !". 4. **Exercice :** Écrivez un algorithme utilisant une boucle `RÉPÉTER... JUSQU'À` qui demande à l'utilisateur d'entrer son âge. Le programme doit continuer à demander l'âge tant que l'âge entré n'est pas un nombre positif (supérieur à 0). ### Devoirs à la maison 1. **Algorithme de compte à rebours :** Écrivez un algorithme en pseudo-code qui utilise une boucle `POUR` pour afficher un compte à rebours de 10 à 0, en affichant "Décollage !" à la fin. 2. **Somme de nombres positifs :** Écrivez un algorithme qui demande à l'utilisateur d'entrer des nombres. La boucle doit s'arrêter dès que l'utilisateur entre un nombre négatif. À la fin, l'algorithme doit afficher la somme de tous les nombres positifs qui ont été entrés. 3. **Recherche et comparaison :** Faites une petite recherche sur internet pour trouver comment les boucles `POUR` et `TANT QUE` sont implémentées dans un langage de programmation comme Python ou Scratch. Essayez de trouver des exemples de code et notez les différences avec le pseudo-code que nous avons vu. ### Résumé Les boucles sont des outils fondamentaux en programmation pour gérer les répétitions d'instructions. Nous avons découvert trois types principaux : * La boucle `POUR` est idéale lorsque le nombre de répétitions est connu à l'avance. * La boucle `TANT QUE` exécute un bloc de code tant qu'une condition reste vraie, en vérifiant la condition au début de chaque itération. * La boucle `RÉPÉTER... JUSQU'À` exécute le bloc de code au moins une fois, puis vérifie la condition à la fin de chaque itération. Maîtriser ces structures vous permettra d'écrire des programmes plus puissants, plus concis et plus efficaces ! N'oubliez jamais de veiller à ce que vos boucles aient une condition de sortie claire pour éviter les boucles infinies. ## Résolution d’un problème grâce à un algorithme ### 1. Introduction Bienvenue dans cette leçon sur la résolution de problèmes grâce aux algorithmes ! Dans le monde de l'informatique, mais aussi dans notre vie de tous les jours, nous sommes constamment confrontés à des problèmes. Un algorithme est comme une recette de cuisine : une série d'instructions claires et précises pour arriver à un résultat souhaité. Apprendre à créer des algorithmes est une compétence essentielle pour comprendre comment les ordinateurs "pensent" et comment nous pouvons leur donner des ordres pour accomplir des tâches. ### 2. Concepts Clés #### Qu'est-ce qu'un problème ? Un problème est une situation ou une question à laquelle il faut trouver une solution. Par exemple, "Comment traverser la rue en toute sécurité ?" ou "Comment calculer la moyenne de mes notes ?". #### Qu'est-ce qu'un algorithme ? Un **algorithme** est une suite finie et non ambiguë d'instructions claires et ordonnées, permettant de résoudre un problème donné. Il doit être compréhensible par celui qui va l'exécuter (un humain ou un ordinateur) et toujours aboutir à un résultat en un temps fini. #### Les caractéristiques d'un bon algorithme * **Précis :** Chaque instruction doit être claire et ne laisser aucune place à l'interprétation. Par exemple, "Mélange la farine" n'est pas assez précis ; "Mélange la farine et les œufs jusqu'à obtenir une pâte homogène" est mieux. * **Non ambigu :** Il ne doit y avoir qu'une seule façon de comprendre et d'exécuter chaque étape. * **Fini :** L'algorithme doit se terminer après un nombre fini d'étapes. Il ne doit pas tourner en boucle indéfiniment. * **Effectif :** Chaque instruction doit pouvoir être exécutée concrètement. Il ne doit pas y avoir d'instructions impossibles à réaliser. #### Étapes pour créer un algorithme Pour construire un algorithme qui résout un problème, voici les étapes à suivre : 1. **Analyse du problème :** Comprendre exactement ce que l'on doit résoudre. Identifier les informations de départ (les **entrées**) et le résultat que l'on attend (les **sorties**). 2. **Décomposition :** Si le problème est complexe, le diviser en plusieurs problèmes plus petits et plus simples à résoudre. 3. **Définition des étapes :** Écrire la séquence d'instructions logiques nécessaires pour passer des entrées aux sorties. 4. **Représentation :** Exprimer l'algorithme en langage naturel, en pseudo-code ou avec un organigramme. 5. **Test et validation :** Vérifier que l'algorithme fonctionne correctement avec différents exemples. Si ce n'est pas le cas, il faut le corriger (débugger). ### 3. Vocabulaire * **Algorithme :** Suite d'instructions pour résoudre un problème. * **Problème :** Situation nécessitant une solution. * **Instruction :** Une action simple et précise à réaliser. * **Séquence :** L'ordre dans lequel les instructions sont exécutées. * **Entrée (Input) :** Les informations ou données que l'algorithme reçoit au départ. * **Sortie (Output) :** Le résultat ou les informations que l'algorithme produit à la fin. ### 4. Exemples #### Exemple 1 : Allumer une lampe **Problème :** La lampe est éteinte et je veux l'allumer. **Algorithme :** 1. Vérifier si la lampe est branchée. 2. Si la lampe n'est pas branchée, la brancher. 3. Appuyer sur l'interrupteur de la lampe. #### Exemple 2 : Calculer la somme de deux nombres **Problème :** Calculer la somme de deux nombres donnés. **Entrées :** Deux nombres, que l'on peut appeler \(A\) et \(B\). **Sortie :** La somme de \(A\) et \(B\). **Algorithme :** 1. Demander le premier nombre (\(A\)). 2. Demander le deuxième nombre (\(B\)). 3. Calculer la somme : \(Somme = A + B\). 4. Afficher le résultat de la somme. ### 5. Exercices #### Exercice 1 : Algorithme du matin Écrivez un algorithme détaillé pour décrire votre routine du matin, du réveil jusqu'à votre départ pour le collège. Assurez-vous que chaque étape est précise et non ambiguë. #### Exercice 2 : Acheter une baguette Vous voulez acheter une baguette à la boulangerie. Écrivez un algorithme qui décrit toutes les étapes nécessaires, depuis le moment où vous décidez d'y aller jusqu'à votre retour à la maison avec la baguette. #### Exercice 3 : Identifier Entrées/Sorties Pour le problème "Calculer la moyenne de 3 notes", quelles seraient les **entrées** et la **sortie** ? ### 6. Devoirs #### Devoir 1 : Algorithme de recherche Imaginez que vous devez trouver un mot précis dans un dictionnaire. Décrivez un algorithme qui vous permettrait de trouver ce mot le plus rapidement possible. #### Devoir 2 : Problème et algorithme Pensez à un petit problème que vous rencontrez souvent dans votre vie quotidienne (par exemple, ranger votre chambre, préparer votre sac pour le collège, trouver un objet perdu). Décrivez ce problème, puis créez un algorithme pour le résoudre. Identifiez clairement les entrées et les sorties de votre algorithme. ### 7. Résumé Dans cette leçon, nous avons appris qu'un **algorithme** est une séquence d'instructions claires et précises pour résoudre un problème. Il est essentiel qu'un algorithme soit précis, non ambigu, fini et effectif. Nous avons vu les étapes clés pour créer un algorithme : analyser le problème, le décomposer, définir les étapes, le représenter et enfin le tester. Cette compétence est fondamentale en informatique et très utile pour organiser notre pensée au quotidien !