UA5 : Exécution des algorithmes (partie 2/2)

## Écriture et exécution d’un algorithme ### Introduction Bienvenue dans cette leçon fondamentale sur les algorithmes ! Que tu t'en rendes compte ou non, les algorithmes sont partout autour de nous, de la façon dont ton téléphone trie tes contacts à la manière dont une recette de cuisine te guide pour préparer un plat. En informatique, un algorithme est le cœur de toute tâche que l'ordinateur doit accomplir. Dans ce cours, nous allons apprendre à écrire ces suites d'instructions et à comprendre comment elles sont exécutées. ### 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 donné. C'est comme une recette de cuisine détaillée : chaque étape doit être claire, précise et réalisable. * **Clarté et Précision :** Chaque instruction doit être facile à comprendre et ne laisser aucune place à l'interprétation. * **Finitude :** Un algorithme doit toujours se terminer après un nombre fini d'étapes. * **Déterminisme :** Pour les mêmes données d'entrée, un algorithme doit toujours produire le même résultat. * **Entrées (Inputs) :** Les données que l'algorithme reçoit pour travailler. * **Sorties (Outputs) :** Le ou les résultats que l'algorithme produit. #### Les Étapes pour Créer un Algorithme La création d'un algorithme suit généralement un processus logique : 1. **Comprendre le Problème :** Bien définir ce que l'on veut résoudre ou la tâche à accomplir. Quelles sont les entrées ? Quels sont les résultats attendus ? 2. **Concevoir l'Algorithme :** Imaginer les étapes nécessaires. On peut utiliser des schémas (organigrammes) ou du pseudocode pour cela. 3. **Écrire l'Algorithme :** Traduire la conception en pseudocode ou directement dans un langage de programmation. 4. **Tester et Déboguer :** Vérifier que l'algorithme fonctionne correctement avec différentes données. Corriger les erreurs (appelées "bugs"). #### Le Pseudocode Le pseudocode est un moyen de décrire un algorithme en utilisant un langage simple et structuré, proche du langage naturel, sans se soucier des règles syntaxiques d'un langage de programmation spécifique. Il nous aide à planifier notre logique avant d'écrire du code réel. ##### Structures de base en Pseudocode : * **Déclaration de variables :** Réservation d'un espace pour stocker des informations. `DÉCLARER nom_variable DE TYPE type_donnée` *Exemple :* `DÉCLARER age DE TYPE ENTIER` * **Affectation :** Donner une valeur à une variable. `variable <-- valeur` *Exemple :* `age <-- 16` * **Entrée / Sortie :** Interagir avec l'utilisateur ou afficher des informations. `LIRE variable` (pour obtenir une entrée de l'utilisateur) `AFFICHER message_ou_variable` (pour montrer un résultat) * **Structures Conditionnelles (Choix) :** Exécuter des instructions différentes selon une condition. `SI condition ALORS` ` instructions_si_vrai` `SINON` ` instructions_si_faux` `FIN SI` * **Structures Répétitives (Boucles) :** Exécuter un bloc d'instructions plusieurs fois. * **TANT QUE :** Répète tant qu'une condition est vraie. `TANT QUE condition FAIRE` ` instructions_à_répéter` `FIN TANT QUE` * **POUR :** Répète un nombre défini de fois. `POUR variable DE debut À fin FAIRE` ` instructions_à_répéter` `FIN POUR` #### Exécution d’un Algorithme (Tracer) Tracer un algorithme signifie le suivre pas à pas, manuellement, pour comprendre son fonctionnement et vérifier les valeurs des variables à chaque étape. C'est une méthode essentielle pour déboguer et s'assurer que l'algorithme fait bien ce qu'on attend de lui. * **Tableau de Tracage :** Souvent, on utilise un tableau pour noter les valeurs des variables au fur et à mesure de l'exécution. ### Vocabulaire * **Algorithme :** Suite d'instructions ordonnées pour résoudre un problème. * **Pseudocode :** Langage simplifié pour écrire un algorithme, indépendant de tout langage de programmation. * **Variable :** Conteneur nommé qui stocke une valeur qui peut changer pendant l'exécution de l'algorithme. * **Instruction :** Une seule commande ou opération dans un algorithme. * **Séquence :** L'ordre dans lequel les instructions sont exécutées. * **Condition :** Expression qui peut être vraie ou fausse, utilisée pour prendre des décisions (ex: `age > 18`). * **Boucle (Répétition) :** Une structure qui permet d'exécuter un bloc d'instructions plusieurs fois. * **Entrée (Input) :** Les données que l'utilisateur ou le système fournit à l'algorithme. * **Sortie (Output) :** Les informations ou résultats produits par l'algorithme et affichés à l'utilisateur. * **Exécution (Tracer) :** Le processus de suivre les étapes d'un algorithme pour comprendre ou vérifier son fonctionnement. ### Exemples #### Exemple 1 : Calculer la somme de deux nombres **Problème :** Demander deux nombres à l'utilisateur, calculer leur somme et afficher le résultat. ```pseudocode ALGORITHME SommeDeDeuxNombres DÉCLARER nombre1 DE TYPE ENTIER DÉCLARER nombre2 DE TYPE ENTIER DÉCLARER somme DE TYPE ENTIER AFFICHER "Veuillez entrer le premier nombre : " LIRE nombre1 AFFICHER "Veuillez entrer le deuxième nombre : " LIRE nombre2 somme <-- nombre1 + nombre2 AFFICHER "La somme est : ", somme FIN ALGORITHME ``` **Traçage (Exemple avec `nombre1 = 5`, `nombre2 = 3`) :** | Étape | `nombre1` | `nombre2` | `somme` | Sortie | | :-------------- | :-------- | :-------- | :------ | :--------------------- | | Début | indéfini | indéfini | indéfini| | | LIRE nombre1 (5)| 5 | indéfini | indéfini| "Veuillez entrer le premier nombre : "| | LIRE nombre2 (3)| 5 | 3 | indéfini| "Veuillez entrer le deuxième nombre : "| | somme <-- 5 + 3 | 5 | 3 | 8 | | | AFFICHER somme | 5 | 3 | 8 | "La somme est : 8" | | Fin | | | | | #### Exemple 2 : Déterminer si un nombre est positif, négatif ou zéro **Problème :** Demander un nombre à l'utilisateur et lui dire s'il est positif, négatif ou zéro. ```pseudocode ALGORITHME TypeDeNombre DÉCLARER nombre DE TYPE ENTIER AFFICHER "Veuillez entrer 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 ALGORITHME ``` **Traçage (Exemple avec `nombre = -7`) :** | Étape | `nombre` | Condition `nombre > 0` | Condition `nombre < 0` | Sortie | | :-------------- | :------- | :--------------------- | :--------------------- | :-------------------------- | | Début | indéfini | | | | | LIRE nombre (-7)| -7 | Faux (-7 n'est pas > 0)| | "Veuillez entrer un nombre : "| | SI -7 > 0 ALORS | -7 | Faux | | | | SINON SI -7 < 0 | -7 | | Vrai | | | AFFICHER | -7 | | | "Le nombre est négatif." | | Fin | | | | | #### Exemple 3 : Compter de 1 à 5 **Problème :** Afficher les nombres de 1 à 5. ```pseudocode ALGORITHME CompterDeUnACinq DÉCLARER compteur DE TYPE ENTIER POUR compteur DE 1 À 5 FAIRE AFFICHER compteur FIN POUR FIN ALGORITHME ``` **Traçage :** | Étape | `compteur` | Sortie | | :------------------- | :--------- | :----- | | Début | indéfini | | | POUR compteur DE 1 à 5| 1 | | | AFFICHER compteur | 1 | 1 | | POUR compteur DE 1 à 5| 2 | | | AFFICHER compteur | 2 | 2 | | POUR compteur DE 1 à 5| 3 | | | AFFICHER compteur | 3 | 3 | | POUR compteur DE 1 à 5| 4 | | | AFFICHER compteur | 4 | 4 | | POUR compteur DE 1 à 5| 5 | | | AFFICHER compteur | 5 | 5 | | Fin | | | ### Exercices 1. **Algorithme d'aire de rectangle :** Écris un algorithme en pseudocode qui demande la longueur et la largeur d'un rectangle à l'utilisateur, calcule son aire, puis affiche le résultat. 2. **Algorithme d'éligibilité au vote :** Écris un algorithme en pseudocode qui demande l'âge d'une personne et affiche si elle est "Majeure" (18 ans ou plus) ou "Mineure". 3. **Tracer un algorithme :** Trace l'algorithme suivant avec `x = 10` et `y = 4`. Quel sera le résultat final affiché ? ```pseudocode ALGORITHME ExerciceTrace DÉCLARER x DE TYPE ENTIER DÉCLARER y DE TYPE ENTIER DÉCLARER resultat DE TYPE ENTIER resultat <-- x + y SI resultat > 15 ALORS resultat <-- resultat - 5 SINON resultat <-- resultat * 2 FIN SI AFFICHER resultat FIN ALGORITHME ``` ### Devoir à la maison 1. **Salutation personnalisée :** Écris un algorithme en pseudocode qui demande le nom de l'utilisateur, puis affiche un message de salutation personnalisé (par exemple, "Bonjour [Nom] !"). 2. **Moyenne de trois nombres :** Écris un algorithme en pseudocode qui demande trois nombres à l'utilisateur, calcule leur moyenne, puis affiche cette moyenne. 3. **Compter à rebours :** Écris un algorithme en pseudocode qui affiche les nombres de 10 à 1, en utilisant une boucle. ### Résumé Dans cette leçon, nous avons appris que les algorithmes sont des ensembles d'instructions précises et finies pour résoudre un problème. Nous avons découvert l'importance du pseudocode comme outil de conception et de planification, nous permettant de structurer nos pensées avant d'écrire du code. Enfin, nous avons pratiqué le traçage, une méthode essentielle pour comprendre l'exécution pas à pas d'un algorithme et vérifier sa logique. Maîtriser l'écriture et l'exécution d'algorithmes est une compétence fondamentale qui te servira de base solide pour la programmation ! ## Programmation en langage C ### Introduction Bienvenue dans le monde de la programmation en langage C ! Le C est un langage de programmation puissant et polyvalent, créé dans les années 1970 par Dennis Ritchie. Il est largement utilisé pour développer des systèmes d'exploitation, des compilateurs, des jeux, des pilotes de périphériques et de nombreux autres types de logiciels. Apprendre le C vous donnera une compréhension fondamentale du fonctionnement des ordinateurs et des bases de la programmation, ce qui est essentiel pour tout futur programmeur. Dans cette leçon, nous allons explorer les concepts de base de la programmation en C, depuis la structure d'un programme simple jusqu'à l'utilisation de variables, d'opérateurs et de structures de contrôle. ### Concepts Clés #### Qu'est-ce que le langage C ? Le C est un langage de programmation de haut niveau, mais il offre également des capacités de manipulation de bas niveau (proches du matériel). Il est connu pour sa rapidité et son efficacité. Il est à la base de nombreux autres langages comme le C++ et Java. #### Structure de base d'un programme C Chaque programme C a une structure fondamentale. Voici les éléments clés : * **Directives de préprocesseur (`#include`)** : Ces lignes indiquent au compilateur d'inclure des fichiers d'en-tête (bibliothèques) qui contiennent des fonctions prédéfinies. Par exemple, `#include <stdio.h>` inclut la bibliothèque d'entrée/sortie standard. * **Fonction `main()`** : C'est le point d'entrée de tout programme C. L'exécution du programme commence toujours à partir de cette fonction. Elle est définie comme `int main() { ... }`. * **Corps de la fonction** : Le code à exécuter est placé entre les accolades `{}` de la fonction `main()`. * **Instructions** : Chaque instruction se termine par un point-virgule (`;`). * **Commentaires** : Permettent d'expliquer le code. Ils sont ignorés par le compilateur. Il existe deux types : * Commentaires sur une seule ligne : `// Ceci est un commentaire` * Commentaires sur plusieurs lignes : `/* Ceci est un commentaire sur plusieurs lignes */` ```c #include <stdio.h> // Inclut la bibliothèque standard d'entrée/sortie int main() { // Fonction principale où le programme commence printf("Bonjour, monde !\n"); // Affiche "Bonjour, monde !" à l'écran return 0; // Indique que le programme s'est exécuté sans erreur } ``` #### Variables et Types de Données Une variable est un emplacement nommé dans la mémoire de l'ordinateur qui peut stocker des données. Chaque variable doit avoir un type de données qui spécifie le type de valeurs qu'elle peut stocker. * **Déclaration de variable** : `type nom_variable;` * **Initialisation de variable** : `type nom_variable = valeur;` ##### Types de données fondamentaux : * `int` : Pour les nombres entiers (ex: `10`, `-5`, `0`). * `float` : Pour les nombres décimaux à virgule flottante (précision simple) (ex: `3.14`, `-0.5`). * `double` : Pour les nombres décimaux à virgule flottante (précision double) (plus précis que `float`). * `char` : Pour un seul caractère (ex: `'A'`, `'z'`, `'5'`). * `void` : Indique l'absence de type ou de valeur. ```c int age = 18; float prix = 19.99; char initiale = 'J'; double pi = 3.1415926535; ``` #### Entrées/Sorties (Input/Output) * **`printf()`** : Utilisée pour afficher des informations à l'écran (sortie). * Syntaxe : `printf("Chaîne de format", variables...);` * **Spécificateurs de format** : * `%d` ou `%i` : pour `int` * `%f` : pour `float` ou `double` * `%c` : pour `char` * `%s` : pour une chaîne de caractères (que nous verrons plus tard) * `\n` : saut de ligne ```c int nombre = 10; printf("Le nombre est : %d\n", nombre); printf("Salut tout le monde !\n"); ``` * **`scanf()`** : Utilisée pour lire des données saisies par l'utilisateur (entrée). * Syntaxe : `scanf("Chaîne de format", &variable);` * Le symbole `&` est l'opérateur d'adresse, il est nécessaire pour `scanf()` pour indiquer où stocker la valeur lue. ```c int annee; printf("Quelle est votre annee de naissance ? "); scanf("%d", &annee); printf("Vous etes ne en : %d\n", annee); ``` #### Opérateurs Les opérateurs sont des symboles qui effectuent des opérations sur des variables et des valeurs. * **Opérateurs arithmétiques** : * `+` : Addition * `-` : Soustraction * `*` : Multiplication * `/` : Division (attention aux entiers : `5 / 2` donne `2`) * `%` : Modulo (reste de la division entière) (ex: \( 5 \% 2 = 1 \)) * **Opérateurs de comparaison (relationnels)** : * `==` : Égal à * `!=` : Différent de * `<` : Inférieur à * `>` : Supérieur à * `<=` : Inférieur ou égal à * `>=` : Supérieur ou égal à * **Opérateurs logiques** : * `&&` (ET logique) : Vrai si les deux conditions sont vraies. * `||` (OU logique) : Vrai si au moins une condition est vraie. * `!` (NON logique) : Inverse la valeur de vérité d'une condition. * **Opérateurs d'affectation** : * `=` : Affectation simple (ex: `x = 5;`) * `+=`, `-=`, `*=`, `/=`, `%=` : Affectations composées (ex: `x += 2;` est équivalent à `x = x + 2;`) #### Structures de Contrôle Elles permettent de contrôler le flux d'exécution d'un programme. ##### Instructions Conditionnelles (Décision) * **`if`, `else if`, `else`** : Exécutent des blocs de code différents en fonction de conditions. ```c int note = 12; if (note >= 10) { printf("Reussi !\n"); } else { printf("Echoue !\n"); } ``` * **`switch`** : Utilisée pour choisir parmi plusieurs blocs de code en fonction de la valeur d'une expression. ```c char grade = 'B'; switch (grade) { case 'A': printf("Excellent\n"); break; case 'B': printf("Bien\n"); break; default: printf("A revoir\n"); } ``` ##### Boucles (Répétition) * **`for`** : Répète un bloc de code un nombre spécifié de fois. * Syntaxe : `for (initialisation; condition; incrémentation) { ... }` ```c for (int i = 0; i < 5; i++) { printf("Iteration %d\n", i); } ``` * **`while`** : Répète un bloc de code tant qu'une condition est vraie. * Syntaxe : `while (condition) { ... }` ```c int compteur = 0; while (compteur < 3) { printf("Compteur: %d\n", compteur); compteur++; } ``` * **`do-while`** : Similaire à `while`, mais garantit que le bloc de code est exécuté au moins une fois. * Syntaxe : `do { ... } while (condition);` ```c int j = 0; do { printf("J est : %d\n", j); j++; } while (j < 1); ``` ### Vocabulaire * **Compilateur** : Un programme qui traduit le code source (écrit par l'humain) en code machine (exécutable par l'ordinateur). * **Code source** : Le texte d'un programme écrit dans un langage de programmation. * **Exécutable** : Le programme compilé, prêt à être exécuté par l'ordinateur. * **Variable** : Un nom donné à un emplacement de stockage en mémoire pour une donnée. * **Type de données** : Catégorise le type de valeur qu'une variable peut contenir (entier, décimal, caractère, etc.). * **Syntaxe** : L'ensemble des règles qui définissent la structure correcte des instructions dans un langage de programmation. * **Fonction** : Un bloc de code réutilisable qui effectue une tâche spécifique. * **Fichier d'en-tête (Header file)** : Un fichier contenant des déclarations de fonctions et de macros, généralement avec l'extension `.h` (ex: `stdio.h`). * **Instruction** : Une commande unique qui effectue une action. * **Opérateur** : Un symbole qui indique une opération à effectuer sur une ou plusieurs valeurs (opérandes). ### Exemples #### Exemple 1: Mon premier programme C ```c #include <stdio.h> int main() { printf("Ceci est mon premier programme en C !\n"); return 0; } ``` #### Exemple 2: Calcul de la somme de deux nombres ```c #include <stdio.h> int main() { int nombre1, nombre2, somme; printf("Entrez le premier nombre : "); scanf("%d", &nombre1); printf("Entrez le second nombre : "); scanf("%d", &nombre2); somme = nombre1 + nombre2; printf("La somme de %d et %d est : %d\n", nombre1, nombre2, somme); return 0; } ``` #### Exemple 3: Vérifier si un nombre est pair ou impair ```c #include <stdio.h> int main() { int nombre; printf("Entrez un nombre entier : "); scanf("%d", &nombre); if (nombre % 2 == 0) { printf("Le nombre %d est pair.\n", nombre); } else { printf("Le nombre %d est impair.\n", nombre); } return 0; } ``` #### Exemple 4: Afficher les nombres de 1 à 5 avec une boucle `for` ```c #include <stdio.h> int main() { printf("Affichage des nombres de 1 a 5 :\n"); for (int i = 1; i <= 5; i++) { printf("%d\n", i); } return 0; } ``` ### Exercices 1. **Expliquez le rôle de la fonction `main()` dans un programme C.** 2. **Quelle est la différence entre `%d` et `%f` dans la fonction `printf()` ?** 3. **Écrivez le code C pour déclarer une variable `double` nommée `rayon` et l'initialiser à `2.5`.** 4. **Complétez le programme ci-dessous pour qu'il demande à l'utilisateur son nom et l'affiche ensuite.** ```c #include <stdio.h> int main() { // Déclarez une variable pour stocker le nom (utilisez char pour l'instant) // ... printf("Quel est votre nom ? "); // Lisez le nom de l'utilisateur // ... printf("Bonjour, %s !\n", nom_utilisateur); // Supposons que votre variable s'appelle nom_utilisateur return 0; } ``` 5. **Quel sera le résultat de l'opération `15 % 4` ?** ### Devoirs 1. **Programme de Calcul de la Superficie d'un Cercle** : Écrivez un programme C qui demande à l'utilisateur le rayon d'un cercle, calcule sa superficie et affiche le résultat. Utilisez la formule \[ \text{Superficie} = \pi \times \text{rayon}^2 \] où \( \pi \approx 3.14159 \). 2. **Convertisseur de Température** : Écrivez un programme C qui demande à l'utilisateur une température en degrés Celsius, puis la convertit et l'affiche en degrés Fahrenheit. La formule de conversion est \[ F = C \times \frac{9}{5} + 32 \]. 3. **Vérificateur d'Âge** : Écrivez un programme C qui demande l'âge de l'utilisateur. Si l'âge est supérieur ou égal à 18, affichez "Vous êtes majeur.". Sinon, affichez "Vous êtes mineur.". 4. **Compteur Simple** : Écrivez un programme C qui utilise une boucle `while` pour afficher tous les nombres de 10 à 1 en ordre décroissant. ### Résumé Dans cette leçon, nous avons couvert les bases essentielles de la programmation en C. Nous avons appris que : * Un programme C commence toujours par la fonction `main()`. Les directives `#include` sont utilisées pour inclure des bibliothèques. * Les variables stockent des données et doivent avoir un type (`int`, `float`, `char`, `double`). * `printf()` est utilisée pour l'affichage et `scanf()` pour la saisie de données. * Les opérateurs (`+`, `-`, `*`, `/`, `%`, `==`, `&&`, etc.) effectuent des opérations sur les données. * Les structures de contrôle (`if-else`, `switch`, `for`, `while`, `do-while`) permettent de diriger le flux d'exécution du programme. La maîtrise de ces concepts fondamentaux est cruciale pour construire des programmes plus complexes. Continuez à pratiquer en écrivant et en testant vos propres codes !