Leçon 10 sur 20

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

Cours3 hComprendre la représentation et les opérations sur les chaînes.
Travaux dirigés3 hÉcrire et tracer des algorithmes de parcours et de validation.
Travaux pratiques3 hImplémenter des traitements textuels dans un langage de programmation.
Travail personnel2 hRé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"LettresTitre ou mot.
"2026"Chiffres stockés comme texteCode, année ou identifiant.
"Bonjour Youssef"Lettres et espaceMessage ou nom complet.
"info@mofidtech.fr"Lettres et symbolesAdresse électronique.
""Aucun caractèreChaî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ère1Une seule lettre.
"A"Chaîne1Chaîne contenant une lettre.
"AB"Chaîne2Deux caractères successifs.
""Chaîne0Chaî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 – t4
"bon jour"b – o – n – espace – j – o – u – r8
"A!"A – !2
""aucun caractère0

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èreALGORITH

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"15"Algor"
"Algorithmique"74"thmi"
"Maroc 2026"74"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" + " " + nomDépend de nomAjout 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"VraiMême contenu.
"chat" = "Chat"FauxLa casse diffère.
"chat" ≠ "chien"VraiContenu différent.
Minuscule("CHAT") = "chat"VraiNormalisation 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èresLongueur("abc") = 3
Extraire(s,p,n)Sous-chaîne de n caractères à partir de pExtraire("Maroc",2,3) = "aro"
Majuscule(s)Conversion en lettres majusculesMajuscule("Oui") = "OUI"
Minuscule(s)Conversion en lettres minusculesMinuscule("Oui") = "oui"
Position(s,c)Première position de c ou valeur spécialePosition("banane", "n") = 3
Remplacer(s,a,b)Remplacement d’un motifRemplacer("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

1aOui1
2lNon1
3gNon1
4oOui2
5rNon2
6iOui3
7tNon3
8hNon3
9mNon3
10eOui4
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 boucleAller jusqu’à Longueur(texte)+1Accès hors limites.
InitialisationOublier resultat <- ""Valeur indéterminée ou ancien contenu.
Mise à jourOublier i <- i+1 dans TantQueBoucle infinie.
CasseTester seulement les minusculesMajuscules non reconnues.
Chaîne videAccé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

115r = rVrai
224a = aVrai
Fin33Milieu atteintVrai
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

4o"o"
3g"og"
2l"ogl"
1a"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"2Un espace sépare deux mots.
"   bon   jour  "2Les espaces multiples sont ignorés.
"test"1Un seul groupe de caractères.
"    "0Aucun caractère non espace.
""0Chaî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_2026OuiCommence par une lettre et utilise des caractères autorisés.
2userNonCommence par un chiffre.
abNonTrop court.
user-nameNonLe tiret est interdit par les règles choisies.
user nameNonPré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"a2
"algorithmique"i2
"bonjour"z0
""a0

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

AB123456Valide
ab123456Invalide : premières lettres non majuscules
A1234567Invalide : deuxième caractère non alphabétique
AB12345Invalide : longueur 7
AB12C456Invalide : 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 absenttexte="chat", cible="z"Vérifier le cas non trouvé.
Longueur minimaleidentifiant de 3 caractèresTester la limite basse.
Longueur maximaleidentifiant de 20 caractèresTester la limite haute.

Erreurs fréquentes à éviter

Erreur

Pourquoi elle est problématique

Correction

Confondre "25" et 25La concaténation remplace l’addition.Convertir explicitement en nombre si nécessaire.
Oublier les espaces dans la longueurLes indices calculés deviennent faux.Considérer chaque espace comme un caractère.
Accéder à une chaîne videLe premier caractère n’existe pas.Tester Longueur(chaine) > 0.
Comparer sans normaliserLa casse produit de faux écarts.Utiliser Minuscule ou Majuscule selon le besoin.
Utiliser une mauvaise borneAccès hors limites ou dernier caractère ignoré.Parcourir de 1 à Longueur(chaine).
Oublier l’initialisation du résultatLa 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écautionIndices 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èreUnité textuelle individuelle : lettre, chiffre, espace ou symbole.
ChaîneSuite ordonnée de zéro, un ou plusieurs caractères.
Chaîne videChaîne de longueur zéro, notée "".
LongueurNombre de caractères d’une chaîne.
IndicePosition d’un caractère dans la chaîne.
ConcaténationAssemblage de chaînes dans un ordre déterminé.
Sous-chaînePortion continue extraite d’une chaîne.
CasseDistinction entre majuscules et minuscules.
PalindromeChaîne lisible de la même manière dans les deux sens.
OccurrenceApparition d’un caractère ou d’un motif.
NormalisationTransformation visant à rendre les comparaisons cohérentes.
ValidationContrô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.