Chapitre 10 — Chaînes de caractères
Représenter, parcourir et transformer des informations textuelles
Fiche pédagogique du chapitre
Objectifs d’apprentissage
À la fin de ce chapitre, l’étudiant devra être capable de :
- définir une chaîne de caractères et distinguer une chaîne d’un caractère isolé ;
- déterminer la longueur d’une chaîne et repérer un caractère à l’aide de son indice ;
- lire et afficher correctement une information textuelle ;
- concaténer, comparer et extraire des portions de chaînes ;
- convertir un texte en majuscules ou en minuscules ;
- parcourir une chaîne caractère par caractère ;
- compter des caractères ou des voyelles ;
- rechercher et remplacer un caractère ;
- supprimer les espaces d’une chaîne ;
- vérifier si un mot ou une phrase est un palindrome ;
- inverser une chaîne et compter ses mots ;
- valider un identifiant selon des règles données ;
- contrôler un mot de passe à l’aide de critères simples.
Prérequis
- connaître les variables, les constantes et les types de données simples ;
- maîtriser les structures conditionnelles et répétitives ;
- savoir utiliser les tableaux à une dimension ;
- savoir construire une expression logique ;
- savoir tracer manuellement l’exécution d’un algorithme.
Plan du chapitre
10.1 Définition
10.2 Opérations élémentaires
10.3 Parcours d’une chaîne
10.4 Algorithmes classiques
Applications, travaux dirigés, corrigés et synthèse
Organisation pédagogique indicative
Activité | Durée indicative | Objectif principal |
|---|---|---|
| Cours | 3 h | Comprendre la représentation et les opérations sur les chaînes. |
| Travaux dirigés | 3 h | Écrire et tracer des algorithmes de parcours et de validation. |
| Travaux pratiques | 3 h | Implémenter des traitements textuels dans un langage de programmation. |
| Travail personnel | 2 h | Résoudre des exercices de recherche, transformation et contrôle. |
| Idée centrale : une chaîne de caractères est une suite ordonnée de caractères. La plupart des traitements textuels reposent sur un parcours, une comparaison et la construction progressive d’un résultat. |
Introduction aux chaînes de caractères
Les programmes ne manipulent pas uniquement des nombres. Ils traitent aussi des noms, des adresses, des messages, des identifiants, des mots de passe, des commandes, des réponses à des formulaires ou encore le contenu de fichiers. Toutes ces informations sont représentées sous forme de chaînes de caractères.
Une chaîne peut être considérée comme une suite ordonnée de caractères. Chaque caractère possède une position, appelée indice. Les structures répétitives permettent de visiter successivement les caractères afin de les compter, les comparer, les rechercher ou les transformer.
Les chaînes ressemblent aux tableaux à une dimension, mais elles possèdent des opérations propres au texte : concaténation, extraction, conversion de casse et comparaison lexicographique. Selon le langage utilisé, une chaîne peut être modifiable ou immuable. En pseudo-code, nous privilégierons des opérations indépendantes du langage.
| Convention utilisée : les indices vont de 1 à Longueur(chaine). Certains langages commencent à l’indice 0 ; la traduction doit alors adapter les bornes. |
10.1 Définition
10.1.1 Chaîne de caractères
Une chaîne de caractères est une suite finie et ordonnée de caractères. Elle peut contenir des lettres, des chiffres, des espaces, des signes de ponctuation et des symboles. Une chaîne est généralement placée entre guillemets afin de la distinguer du nom d’une variable.
Exemple de chaîne | Contenu | Usage possible |
|---|---|---|
| "Algorithmique" | Lettres | Titre ou mot. |
| "2026" | Chiffres stockés comme texte | Code, année ou identifiant. |
| "Bonjour Youssef" | Lettres et espace | Message ou nom complet. |
| "info@mofidtech.fr" | Lettres et symboles | Adresse électronique. |
| "" | Aucun caractère | Chaîne vide. |
| Attention : la chaîne "25" n’est pas automatiquement le nombre 25. Pour effectuer une addition numérique, une conversion de type peut être nécessaire. |
10.1.2 Caractère et chaîne
Un caractère représente une seule unité textuelle, par exemple 'A', '7' ou '?'. Une chaîne peut contenir zéro, un ou plusieurs caractères. La distinction est importante, car certaines opérations attendent un caractère et d’autres une chaîne.
Écriture | Type | Longueur | Interprétation |
|---|---|---|---|
| 'A' | Caractère | 1 | Une seule lettre. |
| "A" | Chaîne | 1 | Chaîne contenant une lettre. |
| "AB" | Chaîne | 2 | Deux caractères successifs. |
| "" | Chaîne | 0 | Chaîne vide. |
10.1.3 Longueur
La longueur d’une chaîne est le nombre de caractères qu’elle contient. Les espaces et les signes de ponctuation comptent comme des caractères. La fonction Longueur(chaine) renvoie un entier supérieur ou égal à zéro.
Chaîne | Décomposition | Longueur |
|---|---|---|
| "chat" | c – h – a – t | 4 |
| "bon jour" | b – o – n – espace – j – o – u – r | 8 |
| "A!" | A – ! | 2 |
| "" | aucun caractère | 0 |
Calcul de la longueur
| n <- Longueur(texte) Écrire("La chaîne contient ", n, " caractères") |
Une chaîne vide possède une longueur nulle. Avant d’accéder au premier ou au dernier caractère, il faut donc vérifier que sa longueur est strictement positive.
10.1.4 Caractère individuel
Un caractère individuel peut être lu à partir de sa position. Cette opération permet d’examiner la première lettre d’un nom, le dernier caractère d’une phrase ou chaque symbole d’un identifiant.
| texte <- "ALGO" Écrire(texte[1]) // A Écrire(texte[3]) // G Écrire(texte[Longueur(texte)]) // O | |
| Cas limite : l’accès à texte[1] est impossible lorsque texte est vide. De même, un indice inférieur à 1 ou supérieur à la longueur est invalide. |
10.1.5 Indice d’un caractère
L’indice indique la position d’un caractère dans la chaîne. Avec la convention adoptée, le premier caractère a l’indice 1 et le dernier a l’indice Longueur(chaine).
Indice | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 |
|---|---|---|---|---|---|---|---|---|
| Caractère | A | L | G | O | R | I | T | H |
Dans la chaîne « ALGORITHME », le caractère d’indice 4 est O. La position d’une valeur ne doit pas être confondue avec la valeur elle-même : l’indice 4 est un entier, tandis que 'O' est un caractère.
10.1.6 Sous-chaîne
Une sous-chaîne est une portion continue d’une chaîne. Elle est définie par une position de départ et une longueur, ou par deux bornes selon le langage. Par exemple, Extraire("ALGORITHME", 1, 4) renvoie "ALGO".
Chaîne source | Départ | Nombre de caractères | Résultat |
|---|---|---|---|
| "Algorithmique" | 1 | 5 | "Algor" |
| "Algorithmique" | 7 | 4 | "thmi" |
| "Maroc 2026" | 7 | 4 | "2026" |
10.1.7 Représentation et encodage
Chaque caractère est représenté en mémoire par un code numérique. Les systèmes modernes utilisent généralement Unicode, qui permet de représenter les lettres accentuées, l’arabe, les symboles scientifiques et de nombreuses écritures. L’algorithme doit éviter de supposer que tous les caractères sont limités à l’alphabet anglais.
Dans une première approche, nous considérerons qu’un accès à chaine[i] fournit un caractère logique. Dans certains langages, les emojis ou certains symboles composés peuvent nécessiter un traitement particulier ; cette question dépend de l’encodage et dépasse le niveau introductif du chapitre.
10.2 Opérations élémentaires
10.2.1 Lecture et affichage
L’instruction Lire permet de saisir une chaîne et l’instruction Écrire permet de l’afficher. La saisie peut concerner un mot unique ou une ligne complète. Une lecture limitée au premier espace ne convient pas pour un nom complet ou une phrase.
| Variables nomComplet : Chaîne Début Écrire("Saisir le nom complet : ") LireLigne(nomComplet) Écrire("Bonjour ", nomComplet) Fin | |
| Bonne pratique : utiliser une lecture de ligne lorsque la valeur peut contenir des espaces. Vérifier ensuite si la chaîne est vide ou constituée uniquement d’espaces. |
10.2.2 Concaténation
La concaténation assemble plusieurs chaînes pour former une nouvelle chaîne. Elle est souvent notée avec l’opérateur + ou avec une fonction Concatener. Elle ne réalise aucune addition numérique.
| prenom <- "Sara" nom <- "Amrani" nomComplet <- prenom + " " + nom Écrire(nomComplet) // Sara Amrani |
Expression | Résultat | Observation |
|---|---|---|
| "Algo" + "rithme" | "Algorithme" | Assemblage direct. |
| "Note : " + "15" | "Note : 15" | Les deux valeurs sont textuelles. |
| "2" + "3" | "23" | Ce n’est pas le nombre 5. |
| "Bonjour" + " " + nom | Dépend de nom | Ajout explicite d’un espace. |
Lorsque le résultat est construit dans une boucle, il faut initialiser la chaîne résultat à la chaîne vide avant la première concaténation.
10.2.3 Comparaison
Deux chaînes peuvent être comparées pour vérifier leur égalité ou pour établir un ordre. La comparaison d’égalité exige généralement que les caractères soient identiques et placés dans le même ordre. Elle peut être sensible à la casse.
Comparaison | Résultat possible | Explication |
|---|---|---|
| "chat" = "chat" | Vrai | Même contenu. |
| "chat" = "Chat" | Faux | La casse diffère. |
| "chat" ≠ "chien" | Vrai | Contenu différent. |
| Minuscule("CHAT") = "chat" | Vrai | Normalisation avant comparaison. |
L’ordre lexicographique compare les caractères de gauche à droite. Dès qu’une différence apparaît, l’ordre des caractères détermine le résultat. Pour classer des noms de manière conviviale, il est recommandé de normaliser la casse et de tenir compte des accents selon les règles du langage.
| Si Minuscule(reponse) = "oui" Alors Écrire("Réponse acceptée") Sinon Écrire("Réponse différente de oui") FinSi |
10.2.4 Extraction
L’extraction récupère une portion d’une chaîne sans nécessairement modifier la chaîne d’origine. Elle peut servir à isoler un préfixe, un suffixe, une année ou une partie d’un code.
| code <- "INFO-2026-015" filiere <- Extraire(code, 1, 4) annee <- Extraire(code, 6, 4) numero <- Extraire(code, 11, 3) |
Variable | Valeur obtenue |
|---|---|
| filiere | "INFO" |
| annee | "2026" |
| numero | "015" |
| Validation nécessaire : la position de départ et la longueur demandée doivent rester dans les limites de la chaîne. Une extraction invalide peut provoquer une erreur ou renvoyer un résultat inattendu. |
10.2.5 Conversion en majuscules ou minuscules
Les fonctions Majuscule et Minuscule produisent une version normalisée du texte. Elles sont utiles pour comparer des réponses sans tenir compte de la casse, compter les voyelles ou présenter un nom de manière uniforme.
| texte <- "AlgoRithmique" Écrire(Majuscule(texte)) // ALGORITHMIQUE Écrire(Minuscule(texte)) // algorithmique |
La conversion de casse ne supprime pas les espaces et ne corrige pas l’orthographe. Elle transforme seulement les lettres qui possèdent une variante majuscule ou minuscule.
10.2.6 Opérations utiles complémentaires
Opération | Rôle | Exemple |
|---|---|---|
| Longueur(s) | Nombre de caractères | Longueur("abc") = 3 |
| Extraire(s,p,n) | Sous-chaîne de n caractères à partir de p | Extraire("Maroc",2,3) = "aro" |
| Majuscule(s) | Conversion en lettres majuscules | Majuscule("Oui") = "OUI" |
| Minuscule(s) | Conversion en lettres minuscules | Minuscule("Oui") = "oui" |
| Position(s,c) | Première position de c ou valeur spéciale | Position("banane", "n") = 3 |
| Remplacer(s,a,b) | Remplacement d’un motif | Remplacer("2025", "5", "6") = "2026" |
10.3 Parcours d’une chaîne
10.3.1 Principe général du parcours
Parcourir une chaîne consiste à examiner ses caractères dans un ordre déterminé. Le parcours complet de gauche à droite utilise une boucle allant de 1 à la longueur de la chaîne.
| Pour i allant de 1 à Longueur(chaine) Faire caractere <- chaine[i] // Traiter caractere FinPour |
La variable i représente la position courante. La valeur chaine[i] est le caractère traité. Avant la boucle, il faut initialiser les compteurs, indicateurs ou chaînes résultats utilisés par le traitement.
10.3.2 Compter les caractères
La longueur fournit directement le nombre total de caractères. Un parcours devient utile lorsque l’on souhaite compter seulement les caractères répondant à une condition, par exemple les lettres, les chiffres ou les espaces.
| Algorithme CompterChiffres Variables texte : Chaîne i, compteur : Entier Début LireLigne(texte) compteur <- 0 Pour i allant de 1 à Longueur(texte) Faire Si texte[i] >= '0' ET texte[i] <= '9' Alors compteur <- compteur + 1 FinSi FinPour Écrire(compteur) Fin |
Pour la chaîne « Salle B12 », le résultat est 2, car seuls les caractères '1' et '2' sont des chiffres.
10.3.3 Compter les voyelles
Pour compter les voyelles, on normalise d’abord la casse afin d’éviter de tester séparément les majuscules et les minuscules. On parcourt ensuite la chaîne et on incrémente un compteur lorsque le caractère appartient à l’ensemble des voyelles.
| Algorithme CompterVoyelles Variables texte : Chaîne i, nbVoyelles : Entier c : Caractère Début LireLigne(texte) texte <- Minuscule(texte) nbVoyelles <- 0 Pour i allant de 1 à Longueur(texte) Faire c <- texte[i] Si c = 'a' OU c = 'e' OU c = 'i' OU c = 'o' OU c = 'u' OU c = 'y' Alors nbVoyelles <- nbVoyelles + 1 FinSi FinPour Écrire(nbVoyelles) Fin |
i | Caractère | Est une voyelle ? | Compteur après traitement |
|---|---|---|---|
| 1 | a | Oui | 1 |
| 2 | l | Non | 1 |
| 3 | g | Non | 1 |
| 4 | o | Oui | 2 |
| 5 | r | Non | 2 |
| 6 | i | Oui | 3 |
| 7 | t | Non | 3 |
| 8 | h | Non | 3 |
| 9 | m | Non | 3 |
| 10 | e | Oui | 4 |
| Extension possible : selon la langue et les objectifs, on peut inclure les voyelles accentuées telles que é, è, ê, à ou ù. |
10.3.4 Rechercher un caractère
Une recherche peut répondre à plusieurs besoins : savoir si le caractère existe, trouver sa première position, sa dernière position ou toutes ses occurrences. Le traitement doit préciser le résultat attendu.
| Algorithme PremierePosition Variables texte : Chaîne cible : Caractère i, position : Entier Début LireLigne(texte) Lire(cible) position <- 0 i <- 1 TantQue i <= Longueur(texte) ET position = 0 Faire Si texte[i] = cible Alors position <- i Sinon i <- i + 1 FinSi FinTantQue Si position = 0 Alors Écrire("Caractère absent") Sinon Écrire("Première position : ", position) FinSi Fin |
La valeur 0 sert ici de convention pour signifier « non trouvé », puisque les indices valides commencent à 1. Dans un langage utilisant des indices à partir de 0, une autre valeur spéciale, souvent -1, est fréquemment utilisée.
10.3.5 Remplacer un caractère
Le remplacement consiste à produire une chaîne dans laquelle chaque occurrence d’un caractère est remplacée par un autre. Lorsque les chaînes sont immuables, on construit progressivement une nouvelle chaîne.
| Algorithme RemplacerCaractere Variables texte, resultat : Chaîne ancien, nouveau : Caractère i : Entier Début LireLigne(texte) Lire(ancien, nouveau) resultat <- "" Pour i allant de 1 à Longueur(texte) Faire Si texte[i] = ancien Alors resultat <- resultat + nouveau Sinon resultat <- resultat + texte[i] FinSi FinPour Écrire(resultat) Fin |
Exemple : remplacer 'a' par '*' dans « banane » produit « b*n*ne ». La chaîne originale peut rester inchangée.
10.3.6 Supprimer les espaces
Pour supprimer tous les caractères espace, on copie uniquement les caractères différents de l’espace dans une chaîne résultat. Il faut distinguer cette opération du nettoyage des espaces inutiles, qui conserverait un seul espace entre les mots.
| Algorithme SupprimerEspaces Variables texte, resultat : Chaîne i : Entier Début LireLigne(texte) resultat <- "" Pour i allant de 1 à Longueur(texte) Faire Si texte[i] <> ' ' Alors resultat <- resultat + texte[i] FinSi FinPour Écrire(resultat) Fin |
Entrée | Sortie |
|---|---|
| "bon jour" | "bonjour" |
| " A B " | "AB" |
| "sans_espace" | "sans_espace" |
| "" | "" |
10.3.7 Parcours inverse
Le parcours inverse commence au dernier caractère et se termine au premier. Il sert notamment à inverser une chaîne ou à comparer les extrémités d’un mot.
| Pour i allant de Longueur(texte) à 1 avec un pas de -1 Faire Écrire(texte[i]) FinPour |
10.3.8 Invariants et erreurs fréquentes
Point à vérifier | Erreur fréquente | Conséquence |
|---|---|---|
| Bornes de la boucle | Aller jusqu’à Longueur(texte)+1 | Accès hors limites. |
| Initialisation | Oublier resultat <- "" | Valeur indéterminée ou ancien contenu. |
| Mise à jour | Oublier i <- i+1 dans TantQue | Boucle infinie. |
| Casse | Tester seulement les minuscules | Majuscules non reconnues. |
| Chaîne vide | Accéder directement à texte[1] | Erreur d’exécution. |
10.4 Algorithmes classiques
10.4.1 Vérification d’un palindrome
Un palindrome est une chaîne qui se lit de la même manière de gauche à droite et de droite à gauche. Des exemples simples sont « radar », « kayak » et « elle ». Une vérification stricte tient compte de la casse et des espaces ; une vérification normalisée peut les ignorer.
Méthode 1 : comparer les caractères symétriques. Le premier caractère est comparé au dernier, le deuxième à l’avant-dernier, et ainsi de suite jusqu’au milieu.
| Algorithme EstPalindrome Variables texte : Chaîne gauche, droite : Entier palindrome : Booléen Début LireLigne(texte) texte <- Minuscule(texte) gauche <- 1 droite <- Longueur(texte) palindrome <- Vrai TantQue gauche < droite ET palindrome Faire Si texte[gauche] <> texte[droite] Alors palindrome <- Faux Sinon gauche <- gauche + 1 droite <- droite - 1 FinSi FinTantQue Écrire(palindrome) Fin |
Étape | gauche | droite | Comparaison | Résultat provisoire |
|---|---|---|---|---|
| 1 | 1 | 5 | r = r | Vrai |
| 2 | 2 | 4 | a = a | Vrai |
| Fin | 3 | 3 | Milieu atteint | Vrai |
| Normalisation avancée : pour une phrase, on peut convertir en minuscules et supprimer les espaces et la ponctuation avant la comparaison. Ainsi « Ésope reste ici et se repose » peut être traité selon les règles choisies. |
10.4.2 Inversion d’une chaîne
Inverser une chaîne consiste à produire une nouvelle chaîne contenant les caractères dans l’ordre opposé. La méthode la plus directe parcourt la chaîne de la fin vers le début.
| Algorithme InverserChaine Variables texte, inverse : Chaîne i : Entier Début LireLigne(texte) inverse <- "" Pour i allant de Longueur(texte) à 1 avec un pas de -1 Faire inverse <- inverse + texte[i] FinPour Écrire(inverse) Fin |
i | Caractère ajouté | inverse |
|---|---|---|
| 4 | o | "o" |
| 3 | g | "og" |
| 2 | l | "ogl" |
| 1 | a | "ogla" |
10.4.3 Comptage des mots
Une définition simple considère qu’un mot est une suite non vide de caractères séparée par un ou plusieurs espaces. Pour gérer plusieurs espaces successifs, on compte le passage d’un espace vers un caractère non espace.
| Algorithme CompterMots Variables texte : Chaîne i, nbMots : Entier dansMot : Booléen Début LireLigne(texte) nbMots <- 0 dansMot <- Faux Pour i allant de 1 à Longueur(texte) Faire Si texte[i] <> ' ' ET NON dansMot Alors nbMots <- nbMots + 1 dansMot <- Vrai SinonSi texte[i] = ' ' Alors dansMot <- Faux FinSi FinPour Écrire(nbMots) Fin |
Entrée | Nombre de mots | Justification |
|---|---|---|
| "cours algorithmique" | 2 | Un espace sépare deux mots. |
| " bon jour " | 2 | Les espaces multiples sont ignorés. |
| "test" | 1 | Un seul groupe de caractères. |
| " " | 0 | Aucun caractère non espace. |
| "" | 0 | Chaîne vide. |
10.4.4 Validation d’un identifiant
Un identifiant peut être soumis à des règles simples : longueur minimale, premier caractère alphabétique, caractères suivants limités aux lettres, chiffres et trait de soulignement. Les règles exactes doivent être définies avant l’écriture de l’algorithme.
- la longueur doit être comprise entre 3 et 20 caractères ;
- le premier caractère doit être une lettre ;
- les autres caractères doivent être des lettres, des chiffres ou le caractère _ ;
- les espaces et les signes de ponctuation sont interdits.
| Algorithme IdentifiantValide Variables id : Chaîne i : Entier valide : Booléen Début Lire(id) valide <- Longueur(id) >= 3 ET Longueur(id) <= 20 Si valide Alors valide <- EstLettre(id[1]) FinSi i <- 2 TantQue i <= Longueur(id) ET valide Faire Si NON (EstLettre(id[i]) OU EstChiffre(id[i]) OU id[i] = '_') Alors valide <- Faux FinSi i <- i + 1 FinTantQue Écrire(valide) Fin |
Identifiant | Valide ? | Motif |
|---|---|---|
| user_2026 | Oui | Commence par une lettre et utilise des caractères autorisés. |
| 2user | Non | Commence par un chiffre. |
| ab | Non | Trop court. |
| user-name | Non | Le tiret est interdit par les règles choisies. |
| user name | Non | Présence d’un espace. |
10.4.5 Vérification d’un mot de passe
La validation d’un mot de passe consiste à vérifier des règles de forme. Elle ne mesure pas à elle seule la sécurité réelle du mot de passe. Pour l’exercice, nous imposons une longueur minimale et la présence de plusieurs catégories de caractères.
- au moins 8 caractères ;
- au moins une lettre majuscule ;
- au moins une lettre minuscule ;
- au moins un chiffre ;
- aucun espace.
| Algorithme MotDePasseValide Variables mdp : Chaîne i : Entier majuscule, minuscule, chiffre, espace : Booléen Début Lire(mdp) majuscule <- Faux minuscule <- Faux chiffre <- Faux espace <- Faux Pour i allant de 1 à Longueur(mdp) Faire Si EstMajuscule(mdp[i]) Alors majuscule <- Vrai SinonSi EstMinuscule(mdp[i]) Alors minuscule <- Vrai SinonSi EstChiffre(mdp[i]) Alors chiffre <- Vrai SinonSi mdp[i] = ' ' Alors espace <- Vrai FinSi FinPour Si Longueur(mdp) >= 8 ET majuscule ET minuscule ET chiffre ET NON espace Alors Écrire("Mot de passe conforme") Sinon Écrire("Mot de passe non conforme") FinSi Fin | |
| Sécurité réelle : dans une application, un mot de passe ne doit jamais être stocké en clair. Il doit être traité par un mécanisme de hachage adapté. Ce chapitre étudie uniquement la validation algorithmique de sa forme. |
Applications guidées
Application 1 — Normaliser une réponse utilisateur
On souhaite accepter les réponses « oui », « Oui », « OUI » ou toute autre combinaison de casse. La solution convertit la réponse en minuscules avant la comparaison.
| Lire(reponse) reponse <- Minuscule(reponse) Si reponse = "oui" Alors Écrire("Confirmation enregistrée") Sinon Écrire("Réponse non reconnue") FinSi |
Jeux d’essai : « OUI » donne une confirmation ; « Oui » donne une confirmation ; « non » donne une réponse non reconnue ; la chaîne vide doit être refusée.
Application 2 — Compter les occurrences d’un caractère
L’algorithme compte le nombre de fois qu’un caractère cible apparaît dans un texte. La comparaison peut être sensible ou insensible à la casse selon les besoins.
| compteur <- 0 Pour i allant de 1 à Longueur(texte) Faire Si texte[i] = cible Alors compteur <- compteur + 1 FinSi FinPour Écrire(compteur) |
Texte | Cible | Résultat |
|---|---|---|
| "banane" | a | 2 |
| "algorithmique" | i | 2 |
| "bonjour" | z | 0 |
| "" | a | 0 |
Application 3 — Nettoyer les espaces multiples
On souhaite supprimer les espaces au début et à la fin, puis conserver un seul espace entre deux mots. La variable espacePrecedent mémorise si le dernier caractère ajouté était un espace.
| resultat <- "" espacePrecedent <- Vrai Pour i allant de 1 à Longueur(texte) Faire Si texte[i] <> ' ' Alors resultat <- resultat + texte[i] espacePrecedent <- Faux SinonSi NON espacePrecedent Alors resultat <- resultat + ' ' espacePrecedent <- Vrai FinSi FinPour Si Longueur(resultat) > 0 ET resultat[Longueur(resultat)] = ' ' Alors resultat <- Extraire(resultat, 1, Longueur(resultat)-1) FinSi |
Pour l’entrée « cours d algorithmique », le résultat devient « cours d algorithmique ».
Application 4 — Extraire le domaine d’une adresse électronique
À partir d’une adresse contenant exactement un caractère @, on cherche la position de @ puis on extrait la partie située après ce caractère.
| position <- PremierePosition(email, '@') Si position > 1 ET position < Longueur(email) Alors domaine <- Extraire(email, position + 1, Longueur(email) - position) Écrire(domaine) Sinon Écrire("Adresse invalide") FinSi |
Adresse | Résultat |
|---|---|
| "user@example.com" | "example.com" |
| "contact@mofidtech.fr" | "mofidtech.fr" |
| "@domaine.fr" | Adresse invalide : partie locale vide. |
| "user@" | Adresse invalide : domaine vide. |
Application 5 — Masquer une partie d’un identifiant
Pour protéger une information lors de l’affichage, on peut conserver les quatre derniers caractères et remplacer les précédents par des astérisques.
| Si Longueur(code) <= 4 Alors masque <- code Sinon masque <- "" Pour i allant de 1 à Longueur(code)-4 Faire masque <- masque + "*" FinPour masque <- masque + Extraire(code, Longueur(code)-3, 4) FinSi Écrire(masque) |
Exemple : « AB12345678 » devient « ******5678 ». Ce masquage est destiné à l’affichage ; il ne remplace pas la protection et le stockage sécurisé des données.
Travaux dirigés
Exercice 1 — Longueur et indices
Pour la chaîne « programmation », donner sa longueur, son premier caractère, son dernier caractère et les caractères d’indices 4 et 8. Indiquer les indices invalides parmi 0, 1, 13, 14 et 20.
Exercice 2 — Comparaison normalisée
Écrire un algorithme qui lit deux mots et indique s’ils sont identiques sans tenir compte des majuscules et des minuscules.
Exercice 3 — Compter des catégories
Écrire un algorithme qui lit une chaîne et affiche séparément le nombre de lettres, de chiffres, d’espaces et d’autres caractères.
Exercice 4 — Première et dernière occurrence
Écrire un algorithme qui recherche la première et la dernière position d’un caractère dans une chaîne. Afficher un message lorsque le caractère est absent.
Exercice 5 — Suppression ciblée
Écrire un algorithme qui supprime toutes les occurrences d’un caractère choisi par l’utilisateur.
Exercice 6 — Palindrome normalisé
Écrire un algorithme qui vérifie si une phrase est un palindrome en ignorant les espaces et la casse.
Exercice 7 — Validation d’un code étudiant
Un code étudiant doit respecter la forme deux lettres majuscules suivies de six chiffres. Écrire l’algorithme de validation et proposer au moins cinq jeux d’essai.
Exercice 8 — Fréquence des voyelles
Écrire un algorithme qui compte séparément les occurrences de a, e, i, o, u et y dans une chaîne, sans tenir compte de la casse.
Exercice 9 — Initiales d’un nom complet
Écrire un algorithme qui extrait les initiales d’un nom complet. Les mots peuvent être séparés par plusieurs espaces. Exemple : « Ahmed Ben Ali » produit « ABA ».
Exercice 10 — Mot le plus long
Écrire un algorithme qui détermine le mot le plus long d’une phrase. En cas d’égalité, conserver le premier mot rencontré.
Corrigés indicatifs
Corrigé 1 — Longueur et indices
La chaîne « programmation » contient 13 caractères. Le premier est 'p', le dernier est 'n', le caractère d’indice 4 est 'g' et celui d’indice 8 est 'm'. Les indices valides sont compris entre 1 et 13 ; 0, 14 et 20 sont donc invalides.
Corrigé 2 — Comparaison normalisée
| Lire(mot1, mot2) Si Minuscule(mot1) = Minuscule(mot2) Alors Écrire("Identiques") Sinon Écrire("Différents") FinSi |
Corrigé 3 — Compter des catégories
| nbLettres <- 0 nbChiffres <- 0 nbEspaces <- 0 nbAutres <- 0 Pour i allant de 1 à Longueur(texte) Faire Si EstLettre(texte[i]) Alors nbLettres <- nbLettres + 1 SinonSi EstChiffre(texte[i]) Alors nbChiffres <- nbChiffres + 1 SinonSi texte[i] = ' ' Alors nbEspaces <- nbEspaces + 1 Sinon nbAutres <- nbAutres + 1 FinSi FinPour |
Corrigé 4 — Première et dernière occurrence
| premiere <- 0 derniere <- 0 Pour i allant de 1 à Longueur(texte) Faire Si texte[i] = cible Alors Si premiere = 0 Alors premiere <- i FinSi derniere <- i FinSi FinPour Si premiere = 0 Alors Écrire("Absent") Sinon Écrire(premiere, derniere) FinSi |
Corrigé 5 — Suppression ciblée
| resultat <- "" Pour i allant de 1 à Longueur(texte) Faire Si texte[i] <> cible Alors resultat <- resultat + texte[i] FinSi FinPour Écrire(resultat) |
Corrigé 6 — Palindrome normalisé
| normalise <- "" Pour i allant de 1 à Longueur(phrase) Faire Si phrase[i] <> ' ' Alors normalise <- normalise + Minuscule(phrase[i]) FinSi FinPour gauche <- 1 droite <- Longueur(normalise) valide <- Vrai TantQue gauche < droite ET valide Faire Si normalise[gauche] <> normalise[droite] Alors valide <- Faux Sinon gauche <- gauche + 1 droite <- droite - 1 FinSi FinTantQue |
Corrigé 7 — Validation d’un code étudiant
| valide <- Longueur(code) = 8 Si valide Alors valide <- EstMajuscule(code[1]) ET EstMajuscule(code[2]) FinSi i <- 3 TantQue i <= 8 ET valide Faire Si NON EstChiffre(code[i]) Alors valide <- Faux FinSi i <- i + 1 FinTantQue |
Code | Résultat attendu |
|---|---|
| AB123456 | Valide |
| ab123456 | Invalide : premières lettres non majuscules |
| A1234567 | Invalide : deuxième caractère non alphabétique |
| AB12345 | Invalide : longueur 7 |
| AB12C456 | Invalide : lettre dans la partie numérique |
Corrigé 8 — Fréquence des voyelles
On initialise six compteurs à zéro, on convertit le texte en minuscules, puis une structure Selon incrémente le compteur associé au caractère courant.
| Selon texte[i] Faire Cas 'a' : nbA <- nbA + 1 Cas 'e' : nbE <- nbE + 1 Cas 'i' : nbI <- nbI + 1 Cas 'o' : nbO <- nbO + 1 Cas 'u' : nbU <- nbU + 1 Cas 'y' : nbY <- nbY + 1 FinSelon |
Corrigé 9 — Initiales
| initiales <- "" debutMot <- Vrai Pour i allant de 1 à Longueur(nomComplet) Faire Si nomComplet[i] <> ' ' ET debutMot Alors initiales <- initiales + Majuscule(nomComplet[i]) debutMot <- Faux SinonSi nomComplet[i] = ' ' Alors debutMot <- Vrai FinSi FinPour |
Corrigé 10 — Mot le plus long
Une solution simple ajoute un espace artificiel à la fin de la phrase afin de traiter le dernier mot comme les autres. La variable motCourant est construite caractère par caractère. Lorsqu’un espace est rencontré, sa longueur est comparée à celle de motMax.
| phrase <- phrase + " " motCourant <- "" motMax <- "" Pour i allant de 1 à Longueur(phrase) Faire Si phrase[i] <> ' ' Alors motCourant <- motCourant + phrase[i] Sinon Si Longueur(motCourant) > Longueur(motMax) Alors motMax <- motCourant FinSi motCourant <- "" FinSi FinPour Écrire(motMax) |
Jeux d’essai recommandés
Les algorithmes textuels doivent être testés sur des entrées variées. Une chaîne visuellement simple peut contenir des espaces, des majuscules, des accents ou des symboles qui modifient le résultat.
Catégorie | Exemple | Objectif du test |
|---|---|---|
| Chaîne vide | "" | Vérifier les accès et les résultats nuls. |
| Un seul caractère | "A" | Tester les bornes et les palindromes minimaux. |
| Tout en minuscules | "algorithmique" | Cas courant. |
| Mélange de casse | "AlgoRITHME" | Vérifier la normalisation. |
| Espaces multiples | " bon jour " | Tester le comptage de mots et le nettoyage. |
| Chiffres et symboles | "A12-B_6" | Tester les catégories de caractères. |
| Accents | "Électronique" | Vérifier le traitement des lettres accentuées. |
| Caractère absent | texte="chat", cible="z" | Vérifier le cas non trouvé. |
| Longueur minimale | identifiant de 3 caractères | Tester la limite basse. |
| Longueur maximale | identifiant de 20 caractères | Tester la limite haute. |
Erreurs fréquentes à éviter
Erreur | Pourquoi elle est problématique | Correction |
|---|---|---|
| Confondre "25" et 25 | La concaténation remplace l’addition. | Convertir explicitement en nombre si nécessaire. |
| Oublier les espaces dans la longueur | Les indices calculés deviennent faux. | Considérer chaque espace comme un caractère. |
| Accéder à une chaîne vide | Le premier caractère n’existe pas. | Tester Longueur(chaine) > 0. |
| Comparer sans normaliser | La casse produit de faux écarts. | Utiliser Minuscule ou Majuscule selon le besoin. |
| Utiliser une mauvaise borne | Accès hors limites ou dernier caractère ignoré. | Parcourir de 1 à Longueur(chaine). |
| Oublier l’initialisation du résultat | La construction est incorrecte. | Initialiser à "" avant la boucle. |
| Compter les mots avec espaces+1 | Échec avec chaîne vide ou espaces multiples. | Détecter les débuts de mots. |
| Modifier pendant un parcours sans précaution | Indices décalés ou caractères sautés. | Construire une nouvelle chaîne. |
Synthèse du chapitre
- Chaîne : suite finie et ordonnée de caractères.
- Longueur : nombre total de caractères, espaces inclus.
- Indice : position d’un caractère ; il doit rester dans les bornes.
- Concaténation : assemblage de plusieurs chaînes.
- Comparaison : égalité ou ordre, éventuellement après normalisation de la casse.
- Extraction : récupération d’une portion de chaîne.
- Parcours : visite successive des caractères à l’aide d’une boucle.
- Recherche : détection d’une présence ou d’une position.
- Transformation : construction d’un nouveau texte par remplacement, suppression ou inversion.
- Validation : vérification systématique de règles de forme.
- Robustesse : prise en compte des chaînes vides, des espaces multiples, de la casse et des caractères spéciaux.
| Méthode générale : définir précisément les règles, normaliser le texte lorsque cela est nécessaire, initialiser les variables, parcourir la chaîne sans dépasser ses bornes, puis tester les cas normaux, limites et incorrects. |
Glossaire
Terme | Définition |
|---|---|
| Caractère | Unité textuelle individuelle : lettre, chiffre, espace ou symbole. |
| Chaîne | Suite ordonnée de zéro, un ou plusieurs caractères. |
| Chaîne vide | Chaîne de longueur zéro, notée "". |
| Longueur | Nombre de caractères d’une chaîne. |
| Indice | Position d’un caractère dans la chaîne. |
| Concaténation | Assemblage de chaînes dans un ordre déterminé. |
| Sous-chaîne | Portion continue extraite d’une chaîne. |
| Casse | Distinction entre majuscules et minuscules. |
| Palindrome | Chaîne lisible de la même manière dans les deux sens. |
| Occurrence | Apparition d’un caractère ou d’un motif. |
| Normalisation | Transformation visant à rendre les comparaisons cohérentes. |
| Validation | Contrôle du respect d’un ensemble de règles. |
Auto-évaluation
Je sais… | Oui | À revoir |
|---|---|---|
| distinguer un caractère d’une chaîne. | ☐ | ☐ |
| calculer une longueur et utiliser un indice valide. | ☐ | ☐ |
| concaténer et comparer des chaînes. | ☐ | ☐ |
| extraire une sous-chaîne. | ☐ | ☐ |
| parcourir une chaîne avec une boucle. | ☐ | ☐ |
| compter les voyelles ou les occurrences. | ☐ | ☐ |
| rechercher et remplacer un caractère. | ☐ | ☐ |
| inverser une chaîne et détecter un palindrome. | ☐ | ☐ |
| compter correctement les mots malgré les espaces multiples. | ☐ | ☐ |
| valider un identifiant ou un mot de passe selon des règles. | ☐ | ☐ |
Conclusion
Les chaînes de caractères constituent une structure essentielle de l’algorithmique. Leur traitement combine les notions étudiées dans les chapitres précédents : variables, conditions, boucles, tableaux, tests et validation. Une bonne maîtrise des parcours textuels prépare à la manipulation de fichiers, aux formulaires, à la recherche d’informations et à de nombreuses applications de programmation.
Dans les chapitres suivants, les fonctions et les procédures permettront d’isoler ces traitements dans des modules réutilisables, par exemple une fonction de validation d’identifiant, une fonction de comptage ou une fonction de normalisation.