Du 20 April 2026 au 24 April 2026

# Du 20 April 2026 au 24 April 2026 ## UA10 : Exécution des algorithmes ### Introduction Bienvenue dans cette leçon consacrée à l'exécution des algorithmes ! Dans le monde de l'informatique, un algorithme est comme une recette de cuisine : une suite d'instructions précises et ordonnées pour atteindre un but. Comprendre comment un ordinateur exécute ces instructions est fondamental pour pouvoir créer vos propres programmes et résoudre des problèmes de manière logique. Nous allons explorer les étapes que suit une machine pour transformer un algorithme en actions concrètes, en passant par les concepts de variables, de conditions et de boucles. ### Concepts Clés #### Qu'est-ce qu'un algorithme ? Un algorithme est une séquence finie d'instructions claires et non ambiguës, permettant de résoudre un problème ou d'effectuer une tâche. Chaque instruction doit être suffisamment simple pour être exécutée. Par exemple, une recette pour faire un gâteau est un algorithme : elle contient des étapes (mélanger les ingrédients, faire cuire, etc.) qui doivent être suivies dans un ordre précis. #### Principes d'exécution Lorsqu'un algorithme est exécuté par un ordinateur (ou interprété par un humain), les instructions sont généralement suivies dans l'ordre séquentiel, une par une. L'ordinateur "lit" et "exécute" chaque ligne de code. Il est crucial que les instructions soient bien ordonnées pour que le résultat final soit correct. #### Les Variables Les variables sont des emplacements nommés dans la mémoire de l'ordinateur où l'on peut stocker des informations (des données). Imaginez une variable comme une boîte étiquetée : vous pouvez y mettre un objet, le remplacer par un autre, ou regarder ce qu'il contient. Chaque variable a un **nom** (pour la distinguer des autres) et un **type** (pour définir le genre de données qu'elle peut contenir). * **Types de variables courants :** * **Entier (Integer)** : Pour les nombres entiers (ex: `5`, `-10`, `0`). * **Flottant (Float)** : Pour les nombres décimaux (ex: `3.14`, `-0.5`). * **Chaîne de caractères (String)** : Pour le texte (ex: `"Bonjour"`, `"UA10"`). * **Booléen (Boolean)** : Pour les valeurs `Vrai` ou `Faux` (True/False). * **Affectation :** C'est l'action de donner une valeur à une variable. On utilise souvent le symbole `<-` ou `=`. * Exemple : `age <- 16` (La variable `age` contient maintenant la valeur `16`). #### Les Instructions Conditionnelles (Si/Alors/Sinon) Les instructions conditionnelles permettent à un algorithme de prendre des décisions. L'exécution de certaines instructions dépend d'une condition. Si la condition est vraie, un bloc d'instructions est exécuté ; sinon, un autre bloc peut l'être (ou rien du tout). * **Structure générale :** ``` SI condition EST VRAIE ALORS // Instructions à exécuter si la condition est vraie SINON // Instructions à exécuter si la condition est fausse FIN_SI ``` * **Exemple :** ``` SI temperature > 25 ALORS AFFICHER "Il fait chaud !" SINON AFFICHER "La température est agréable." FIN_SI ``` #### Les Boucles (Pour et Tant Que) Les boucles sont des instructions qui permettent de répéter un bloc de code plusieurs fois. Elles sont essentielles pour automatiser les tâches répétitives. ##### La boucle `Pour` (For) Utilisée lorsque l'on sait à l'avance combien de fois on doit répéter les instructions. * **Structure générale :** ``` POUR variable DE debut À 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 ``` Ceci affichera : `1` `2` `3` `4` `5` ##### La boucle `Tant Que` (While) Utilisée lorsque l'on ne connaît pas à l'avance le nombre de répétitions. La boucle continue tant qu'une certaine condition reste vraie. * **Structure générale :** ``` TANT QUE condition EST VRAIE FAIRE // Instructions à répéter FIN_TANT_QUE ``` * **Exemple :** Demander un mot de passe tant qu'il n'est pas correct. ``` VARIABLE motDePasseSaisi EN CHAINE motDePasseSaisi <- "" TANT QUE motDePasseSaisi != "secret" FAIRE AFFICHER "Entrez le mot de passe :" LIRE motDePasseSaisi FIN_TANT_QUE AFFICHER "Accès autorisé." ``` ### Vocabulaire * **Algorithme** : Une suite d'instructions ordonnées et non ambiguës pour résoudre un problème. * **Instruction** : Une étape unique dans un algorithme. * **Exécution** : Le processus de suivi des instructions d'un algorithme par une machine ou un humain. * **Variable** : Un espace nommé en mémoire pour stocker une valeur qui peut changer durant l'exécution. * **Affectation** : L'action d'attribuer une valeur à une variable. * **Condition** : Une expression qui évalue à `Vrai` ou `Faux`, utilisée pour la prise de décision. * **Boucle** : Une structure de contrôle qui permet de répéter un bloc d'instructions plusieurs fois. * **Pseudocode** : Une manière informelle de décrire un algorithme sans utiliser la syntaxe d'un langage de programmation spécifique. ### Exemples #### Exemple 1 : Calcul de la somme de deux nombres ``` ALGORITHME SommeDeuxNombres VARIABLE nombre1, nombre2, somme EN ENTIER DEBUT AFFICHER "Entrez le premier nombre :" LIRE nombre1 AFFICHER "Entrez le deuxième nombre :" LIRE nombre2 somme <- nombre1 + nombre2 AFFICHER "La somme est : ", somme FIN ``` #### Exemple 2 : Vérifier si un nombre est pair ou impair ``` ALGORITHME PairOuImpair VARIABLE nombre EN ENTIER DEBUT AFFICHER "Entrez un nombre :" LIRE nombre SI (nombre MOD 2) = 0 ALORS // L'opérateur MOD donne le reste de la division AFFICHER nombre, " est un nombre pair." SINON AFFICHER nombre, " est un nombre impair." FIN_SI FIN ``` #### Exemple 3 : Table de multiplication par 7 ``` ALGORITHME TableDeSept VARIABLE i EN ENTIER DEBUT AFFICHER "Table de multiplication par 7 :" POUR i DE 1 À 10 FAIRE AFFICHER "7 x ", i, " = ", (7 * i) FIN_POUR FIN ``` ### Exercices 1. **Tracé d'exécution :** Donnez les valeurs successives des variables `a`, `b`, et `c` après l'exécution de l'algorithme suivant : ``` ALGORITHME ExerciceTrace VARIABLE a, b, c EN ENTIER DEBUT a <- 10 b <- 5 c <- a + b a <- c - b b <- a * 2 SI a > b ALORS c <- a SINON c <- b FIN_SI AFFICHER a, b, c FIN ``` 2. **Pseudocode :** Écrivez un algorithme en pseudocode qui demande à l'utilisateur son âge et affiche `"Vous êtes majeur"` s'il a 18 ans ou plus, et `"Vous êtes mineur"` sinon. ### Devoir à la maison 1. **Moyenne de notes :** Écrivez un algorithme en pseudocode qui demande à l'utilisateur d'entrer des notes (des nombres décimaux). L'utilisateur doit pouvoir entrer autant de notes qu'il le souhaite. La saisie des notes s'arrête lorsque l'utilisateur entre la valeur `-1`. L'algorithme doit ensuite calculer et afficher la moyenne de toutes les notes entrées (sans inclure le `-1` dans le calcul de la moyenne). 2. **Année bissextile :** Écrivez un algorithme en pseudocode qui demande une année à l'utilisateur et détermine si cette année est bissextile. Rappel : une année est bissextile si elle est divisible par 4, sauf si elle est divisible par 100 mais pas par 400. ### Résumé Cette leçon nous a permis de comprendre les fondations de l'exécution algorithmique : * Les algorithmes sont des séquences d'instructions précises. * L'exécution se fait généralement de manière séquentielle. * Les **variables** stockent et manipulent des données. * Les **conditions (Si/Alors/Sinon)** permettent aux algorithmes de prendre des décisions. * Les **boucles (Pour/Tant Que)** permettent de répéter des instructions, automatisant ainsi les tâches. La maîtrise de ces concepts est la clé pour construire des algorithmes efficaces et comprendre comment les ordinateurs fonctionnent. ## Du 27 April 2026 au 01 Mai 2026 ### Introduction à la Programmation et aux Algorithmes Bienvenue à cette série de cours sur l'introduction à la programmation et aux algorithmes! Durant cette semaine, nous allons explorer les concepts fondamentaux qui sont à la base de toute l'informatique moderne. Vous apprendrez ce qu'est un algorithme, comment il se transforme en programme, et quelles sont les briques élémentaires pour construire vos premières instructions logiques. Ces compétences sont essentielles pour comprendre comment fonctionnent les logiciels que nous utilisons tous les jours et pour commencer à créer les vôtres. ### 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. Imaginez une recette de cuisine: chaque étape est une instruction précise, et l'ensemble de ces étapes forme un algorithme pour préparer un plat. * **Caractéristiques d'un bon algorithme:** * **Fini:** Il doit se terminer après un nombre fini d'étapes. * **Déterminé:** Pour les mêmes entrées, il doit toujours produire les mêmes sorties. * **Non ambigu:** Chaque instruction doit être claire et interprétable d'une seule manière. * **Efficace:** Il doit résoudre le problème en un temps raisonnable et avec des ressources raisonnables. #### Qu'est-ce qu'un Programme? Un programme est la traduction d'un algorithme dans un langage que l'ordinateur peut comprendre et exécuter. Tandis qu'un algorithme est une idée ou une méthode, un programme est sa mise en œuvre concrète. Les langages de programmation (comme Python, Java, C++, etc.) sont les outils utilisés pour écrire ces programmes. * **Relation Algorithme - Programme:** L'algorithme est le 'quoi faire', et le programme est le 'comment le faire' pour l'ordinateur. #### Les Variables et les Types de Données Une variable est un emplacement nommé dans la mémoire de l'ordinateur qui peut stocker une valeur. Cette valeur peut changer au cours de l'exécution du programme. Chaque variable a un type de données qui détermine le genre de valeurs qu'elle peut contenir. * **Types de données courants:** * **Entier (Integer):** Nombres entiers (ex: 5, -10, 0). * **Réel (Float):** Nombres décimaux (ex: 3.14, -0.5, 100.0). * **Chaîne de caractères (String):** Séquences de caractères (ex: "Bonjour", "NomUtilisateur"). * **Booléen (Boolean):** Représente une valeur de vérité, soit `Vrai` (True) soit `Faux` (False). #### Instructions de Base Les programmes sont composés d'instructions qui disent à l'ordinateur quoi faire. * **Affectation:** Attribuer une valeur à une variable. Ex: `âge <-- 16` * **Affichage:** Montrer une information à l'utilisateur. Ex: `Afficher("Bonjour")` * **Saisie:** Demander une information à l'utilisateur. Ex: `lire(nom)` #### Structures Conditionnelles (Si... Alors... Sinon) Elles permettent au programme de prendre des décisions et d'exécuter différentes instructions en fonction d'une condition. La condition est une expression qui évalue à `Vrai` ou `Faux` (booléen). ```pseudocode SI condition EST VRAIE ALORS // Exécuter ces instructions SINON // Exécuter ces autres instructions FIN SI ``` #### Structures Répétitives (Boucles) Elles permettent d'exécuter un bloc d'instructions plusieurs fois. Il existe plusieurs types de boucles: * **Tant Que (While):** Répète un bloc d'instructions TANT QUE une condition est vraie. ```pseudocode TANT QUE condition EST VRAIE FAIRE // Exécuter ces instructions FIN TANT QUE ``` * **Pour (For):** Répète un bloc d'instructions un nombre de fois déterminé. ```pseudocode POUR chaque élément DANS une collection FAIRE // Exécuter ces instructions FIN POUR // Ou pour un nombre de répétitions POUR i DE 1 JUSQU'À N FAIRE // Exécuter ces instructions FIN POUR ``` ### Vocabulaire Clé * **Algorithme:** Suite d'instructions pour résoudre un problème. * **Programme:** Traduction d'un algorithme dans un langage informatique. * **Variable:** Conteneur nommé pour stocker des données en mémoire. * **Type de données:** Catégorie de valeurs qu'une variable peut contenir (entier, chaîne, etc.). * **Instruction:** Ordre simple donné à l'ordinateur. * **Conditionnelle:** Structure de contrôle qui exécute des blocs de code différents selon une condition. * **Boucle (Répétitive):** Structure de contrôle qui exécute un bloc de code plusieurs fois. * **Pseudocode:** Langage de description d'algorithmes proche du langage humain, indépendant de tout langage de programmation. ### Exemples Pratiques #### Exemple 1: Algorithme de Calcul de Moyenne Voici un algorithme simple pour calculer la moyenne de deux nombres: 1. **DEBUT** 2. Lire le premier nombre et le stocker dans la variable `nombre1`. 3. Lire le second nombre et le stocker dans la variable `nombre2`. 4. Calculer la somme: `somme <-- nombre1 + nombre2`. 5. Calculer la moyenne: `moyenne <-- somme / 2`. 6. Afficher la `moyenne`. 7. **FIN** #### Exemple 2: Utilisation d'une Conditionnelle (Pseudocode) Déterminer si un élève est majeur: ```pseudocode DEBUT LIRE âge SI âge >= 18 ALORS AFFICHER "Vous êtes majeur." SINON AFFICHER "Vous êtes mineur." FIN SI FIN ``` #### Exemple 3: Utilisation d'une Boucle (Pseudocode) Compter de 1 à 5 et afficher chaque nombre: ```pseudocode DEBUT POUR compteur DE 1 JUSQU'À 5 FAIRE AFFICHER compteur FIN POUR FIN ``` ### Exercices 1. Décrivez un algorithme pour allumer une lampe de chevet. Listez chaque étape précisément. 2. Quelle est la différence principale entre un algorithme et un programme? 3. Donnez un exemple de variable de type `réel` et un exemple de variable de type `chaîne de caractères`. 4. Écrivez un algorithme en pseudocode pour calculer le périmètre d'un carré, connaissant la longueur de son côté. Ensuite, traduisez-le pour afficher "Ceci est un carré." si le côté est positif, sinon "Le côté ne peut pas être négatif ou nul.". 5. **Exécution pas à pas:** Tracez l'exécution du pseudocode suivant et indiquez la valeur finale de `resultat`: ```pseudocode DEBUT compteur <-- 0 resultat <-- 10 TANT QUE compteur < 3 FAIRE resultat <-- resultat + 5 compteur <-- compteur + 1 FIN TANT QUE AFFICHER resultat FIN ``` ### Devoir 1. **Concevez un Algorithme:** Écrivez un algorithme en pseudocode qui demande à l'utilisateur d'entrer un nombre. Si le nombre est pair, l'algorithme doit afficher "Le nombre est pair.". S'il est impair, il doit afficher "Le nombre est impair.". (Indice: Vous pourriez utiliser l'opérateur modulo `%` pour vérifier la parité, par exemple \( n \% 2 = 0 \) pour un nombre pair.) 2. **Recherche:** Choisissez un langage de programmation (par exemple, Python, JavaScript ou Scratch) et recherchez quand il a été créé, à quoi il sert principalement et donnez un exemple simple d'un "Hello World!" écrit dans ce langage. ### Résumé Durant cette semaine, nous avons posé les bases de l'informatique en explorant les concepts d'algorithmes et de programmes. Nous avons appris qu'un **algorithme** est une série d'étapes claires pour résoudre un problème, et qu'un **programme** est sa traduction exécutable par un ordinateur. Nous avons découvert les **variables** et leurs **types de données**, essentiels pour stocker des informations. Enfin, nous avons étudié les **instructions de base** ainsi que les structures **conditionnelles (Si... Alors... Sinon)** et **répétitives (boucles Tant Que / Pour)**, qui permettent aux programmes de prendre des décisions et d'automatiser des tâches. Ces connaissances sont le point de départ de votre parcours dans le monde passionnant de la programmation! ## Du 04 Mai 2026 au 08 Mai 2026 ### Introduction Bienvenue à cette séance dédiée à l'introduction des algorithmes et à la programmation ! Dans le monde numérique d'aujourd'hui, tout fonctionne grâce à des instructions précises. Un ordinateur, une tablette ou un smartphone ne font qu'exécuter des ordres. Mais d'où viennent ces ordres ? Comment sont-ils conçus ? C'est ce que nous allons découvrir en explorant les concepts fondamentaux des algorithmes, ces "recettes" de résolution de problèmes, et comment ils sont ensuite transformés en programmes que nos machines peuvent comprendre et exécuter. ### 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'accomplir une tâche spécifique. Imaginez-le comme une recette de cuisine très détaillée : chaque étape est claire, ordonnée, et mène à un résultat précis. Les algorithmes sont partout autour de nous, pas seulement en informatique ! * **Caractéristiques principales d'un algorithme :** * **Fini :** Il doit se terminer après un nombre fini d'étapes. * **Déterministe :** Pour les mêmes entrées, il doit produire les mêmes sorties. * **Réalisable :** Chaque étape doit être réalisable. * **Précis :** Chaque instruction doit être claire et sans ambiguïté. * **Entrées :** Il reçoit des données (informations) pour fonctionner. * **Sorties :** Il produit un résultat ou une information. * **Exemples d'algorithmes dans la vie quotidienne :** * La recette de votre plat préféré. * Les instructions pour monter un meuble IKEA. * Le chemin le plus court pour aller de chez vous au collège. #### Représentation d'un Algorithme Pour communiquer un algorithme, on peut utiliser différentes méthodes : * **Le langage naturel :** Moins précis, mais utile pour une première ébauche. * **Le pseudo-code :** Un langage semi-formel, à mi-chemin entre le langage humain et le langage de programmation. Il utilise des mots-clés simples (`LIRE`, `ÉCRIRE`, `SI`, `ALORS`, `POUR`, `TANT QUE`) et une structure claire. * **Les organigrammes (Flowcharts) :** Une représentation graphique de l'algorithme, utilisant des symboles standards pour chaque type d'action (début/fin, entrée/sortie, traitement, décision). #### Structures Algorithmiques de Base Les algorithmes sont construits à partir de trois structures fondamentales : * **La Séquence :** Les instructions sont exécutées l'une après l'autre, dans l'ordre défini. C'est la structure la plus simple. *Exemple en pseudo-code :* ``` DÉBUT Instruction 1 Instruction 2 Instruction 3 FIN ``` * **La Sélection (ou Condition) :** Une instruction est exécutée (ou non) en fonction d'une condition. La condition est une expression qui peut être vraie ou fausse. *Exemple en pseudo-code :* ``` SI (condition est VRAIE) ALORS Faire ceci SINON Faire cela FIN SI ``` * **La Répétition (ou Boucle) :** Un bloc d'instructions est répété un certain nombre de fois, ou tant qu'une condition est vraie. *Exemple de boucle conditionnelle (TANT QUE) :* ``` TANT QUE (condition est VRAIE) FAIRE Répéter ces instructions FIN TANT QUE ``` *Exemple de boucle avec un nombre de répétitions connu (POUR) :* ``` POUR chaque élément dans la liste FAIRE Répéter ces instructions FIN POUR ``` #### Introduction à la Programmation Un **programme** est la traduction d'un algorithme dans un **langage de programmation** spécifique (comme Python, JavaScript, C++, etc.). L'ordinateur ne comprend pas directement le pseudo-code ; il a besoin d'instructions dans son propre langage. * **Variables :** Ce sont des emplacements nommés en mémoire pour stocker des données. Elles peuvent changer de valeur au cours de l'exécution du programme. En informatique, une variable est un peu comme une boîte étiquetée où l'on peut ranger une valeur. * Exemple : `age = 16`, `nom = "Alice"`. * **Types de données :** Les variables peuvent contenir différents types de données : * **Entier (Integer) :** Nombres entiers (\(10, -5, 0\)). * **Flottant (Float) :** Nombres décimaux (\(3.14, 0.5\)). * **Chaîne de caractères (String) :** Texte (\("Bonjour", "Seconde"\)). * **Booléen (Boolean) :** Vrai ou Faux (\(True, False\)). * **Opérateurs :** Symboles utilisés pour effectuer des opérations. * **Arithmétiques :** \(+,-,*,/, \%\) (addition, soustraction, multiplication, division, modulo). * **De comparaison :** \(==, !=, <, >, <=, >= \) (égal à, différent de, inférieur à, supérieur à, etc.). * **Logiques :** `ET` (AND), `OU` (OR), `NON` (NOT) pour combiner des conditions. ### Vocabulaire * **Algorithme :** Ensemble d'instructions ordonnées et finies pour résoudre un problème. * **Pseudo-code :** Langage de description d'algorithmes, proche du langage humain mais structuré. * **Organigramme (Flowchart) :** Représentation graphique d'un algorithme. * **Programme :** Traduction d'un algorithme dans un langage de programmation. * **Langage de programmation :** Un ensemble de règles et de symboles permettant d'écrire des programmes compréhensibles par un ordinateur. * **Variable :** Conteneur nommé pour stocker des données qui peuvent changer. * **Instruction :** Une commande unique dans un algorithme ou un programme. * **Séquence :** Exécution d'instructions dans l'ordre les unes après les autres. * **Condition :** Expression qui peut être vraie ou fausse et qui détermine le déroulement d'un algorithme. * **Boucle :** Structure qui permet de répéter un bloc d'instructions. ### Exemples #### Exemple 1 : Calculer la moyenne de deux nombres * **Algorithme en pseudo-code :** ``` DÉBUT LIRE nombre1 LIRE nombre2 moyenne = (nombre1 + nombre2) / 2 ÉCRIRE "La moyenne est : ", moyenne FIN ``` * **Traduction partielle en Python :** ```python nombre1 = float(input("Entrez le premier nombre : ")) nombre2 = float(input("Entrez le deuxième nombre : ")) moyenne = (nombre1 + nombre2) / 2 print("La moyenne est : ", moyenne) ``` #### Exemple 2 : Déterminer si un nombre est positif ou négatif * **Algorithme en pseudo-code :** ``` DÉBUT LIRE nombre SI nombre > 0 ALORS ÉCRIRE "Le nombre est positif." SINON SI nombre < 0 ALORS ÉCRIRE "Le nombre est négatif." SINON ÉCRIRE "Le nombre est zéro." FIN SI FIN ``` #### Exemple 3 : Afficher les nombres de 1 à 5 * **Algorithme en pseudo-code (boucle POUR) :** ``` DÉBUT POUR compteur DE 1 À 5 FAIRE ÉCRIRE compteur FIN POUR FIN ``` * **Traduction partielle en Python :** ```python for compteur in range(1, 6): print(compteur) ``` ### Exercices Répondez aux questions suivantes en utilisant du pseudo-code : 1. Écrivez un algorithme qui demande le prix d'un article et le nombre d'articles achetés, puis calcule et affiche le montant total à payer. 2. Écrivez un algorithme qui demande l'âge d'une personne et affiche "Majeur" si l'âge est \(18\) ans ou plus, et "Mineur" sinon. 3. Écrivez un algorithme qui affiche tous les nombres pairs de \(2\) à \(10\) inclus. ### Devoir 1. **Algorithme de la vie quotidienne :** Choisissez une tâche simple de votre quotidien (par exemple, "préparer un thé", "faire son lit", "traverser la rue") et écrivez l'algorithme correspondant en pseudo-code. Soyez le plus précis possible ! 2. **Algorithme du plus grand nombre :** Écrivez un algorithme en pseudo-code qui demande à l'utilisateur deux nombres, puis affiche lequel des deux nombres est le plus grand. Si les nombres sont égaux, il doit l'indiquer également. 3. **(Optionnel - Bonus) :** Si vous avez accès à un environnement Python (comme un éditeur en ligne ou installé sur votre ordinateur), essayez de traduire votre algorithme de l'exercice 2 en un petit programme Python fonctionnel. ### Résumé Durant cette séance, nous avons exploré les fondements des algorithmes et de la programmation. Nous avons appris qu'un algorithme est une suite d'instructions précises pour résoudre un problème, et qu'il peut être représenté par du pseudo-code ou des organigrammes. Nous avons également découvert les trois structures algorithmiques de base : la séquence, la sélection (condition) et la répétition (boucle). Enfin, nous avons abordé les bases de la programmation, en voyant comment un algorithme se traduit en code exécutable par une machine, en utilisant des variables et des opérateurs. Ces concepts sont la pierre angulaire de toute application informatique que vous utilisez !