Opérations sur les Chaînes de Caractères

Introduction

Aujourd'hui, nous allons mettre en pratique toutes les compétences que vous avez acquises sur les chaînes de caractères. L'objectif est de parcourir une chaîne pour analyser son contenu et résoudre des problèmes spécifiques. C'est une compétence fondamentale en algorithmique, qui combine la manipulation de tableaux (car une chaîne est un tableau de caractères), les boucles et les conditions.

Nous allons nous concentrer sur deux problèmes classiques :

1. Compter les occurrences d'un certain type de caractère, comme les voyelles.
2. Vérifier une propriété de la chaîne entière, par exemple si elle est un palindrome.

Maîtriser ces techniques est une étape clé vers votre objectif d'écrire du "code clean", car cela vous entraîne à décomposer un problème en une séquence logique d'opérations simples.

Le patron de base : parcourir pour analyser

La plupart des problèmes d'analyse de chaînes de caractères reposent sur un patron algorithmique simple et répétitif. Il est essentiel de bien le comprendre.

1. Initialiser une ou plusieurs variables pour stocker le résultat (par exemple, un compteur à zéro, un booléen à Vrai).
2. Parcourir la chaîne de caractères du début à la fin, caractère par caractère, à l'aide d'une boucle Pour.
3. À l'intérieur de la boucle, pour chaque caractère, effectuer un test (une condition Si...) pour vérifier s'il possède la propriété recherchée.
4. Si la condition est remplie, mettre à jour la ou les variables de résultat (par exemple, incrémenter le compteur).
5. Une fois la boucle terminée, le résultat final est stocké dans vos variables.

La ressource suivante introduit ces concepts de base.

Problème 1 : Compter les voyelles

Appliquons ce patron à un premier problème concret : comment compter le nombre de voyelles dans une phrase ?

Avant de commencer, nous devons définir des règles claires :

• Est-ce que 'y' est une voyelle ? Pour nos exercices, nous l'inclurons.
• Comment gérer la casse ? "A" est-il une voyelle au même titre que "a" ? La solution la plus simple est de tout convertir en minuscules avant de commencer le comptage.
• Que faire des espaces, de la ponctuation, des chiffres ? Nous devons simplement les ignorer.

L'exercice suivant met en pratique exactement cette logique, en fournissant un pseudo-code détaillé.

Voici une version simplifiée de cet algorithme, qui se concentre uniquement sur les voyelles :

Fonction CompterVoyelles(phrase : Chaîne) : Entier
Variables
  nb_voyelles : Entier
  phrase_minuscules : Chaîne
  c : Caractère
  i : Entier

Début
  nb_voyelles ← 0
  phrase_minuscules ← MettreEnMinuscules(phrase) // Étape de préparation

  Pour i allant de 0 à Longueur(phrase_minuscules) - 1 Faire
    c ← phrase_minuscules[i]
    
    // Le cœur de la logique : la condition
    Si c = 'a' OU c = 'e' OU c = 'i' OU c = 'o' OU c = 'u' OU c = 'y' Alors
      nb_voyelles ← nb_voyelles + 1
    FinSi
  FinPour

  Retourner nb_voyelles
Fin

Problème 2 : Vérifier si un mot est un palindrome

Un palindrome est un mot qui se lit de la même manière dans les deux sens, comme "KAYAK" ou "ELLE". Comment un algorithme peut-il vérifier cela ?

Il existe plusieurs approches. Nous allons en voir deux.

Approche 1 : Comparaison avec deux pointeurs

C'est la méthode la plus efficace. L'idée est de comparer les lettres symétriquement, en se déplaçant des extrémités vers le centre.

1. On utilise deux indices : gauche qui commence à 0 (le début) et droite qui commence à Longueur(mot) - 1 (la fin).
2. Tant que l'indice gauche est inférieur à l'indice droite, on compare les caractères mot[gauche] et mot[droite].
3. Si, à un moment, les deux caractères sont différents, le mot n'est pas un palindrome. On peut arrêter et retourner Faux.
4. S'ils sont identiques, on rapproche les indices du centre : gauche ← gauche + 1 et droite ← droite - 1.
5. Si la boucle se termine sans qu'on ait jamais trouvé de différence, cela signifie que le mot est un palindrome, et on retourne Vrai.

Le document suivant contient une excellente implémentation de cette logique.

Approche 2 : Inverser et comparer

Cette deuxième approche est très intéressante car elle réutilise ce que nous avons vu dans la leçon précédente. Vous souvenez-vous de la fonction Miroir que vous avez conçue ?

La logique est la suivante :

1. Prendre le mot d'entrée.
2. Créer une version inversée de ce mot.
3. Comparer le mot original avec sa version inversée.
4. S'ils sont identiques, alors c'est un palindrome !

Fonction EstPalindrome_v2(mot : Chaîne) : Booléen
Variables
  mot_inverse : Chaîne

Début
  // On réutilise la logique de la fonction Miroir de la leçon précédente
  mot_inverse ← Miroir(mot)

  Si mot = mot_inverse Alors
    Retourner Vrai
  Sinon
    Retourner Faux
  FinSi
Fin

Cette méthode montre un principe très important en programmation : la modularité. En décomposant un problème (EstPalindrome) en sous-problèmes déjà résolus (Miroir), on aboutit à un algorithme plus simple et plus lisible.

À vous de pratiquer !

Pour consolider ces acquis, essayez de résoudre le problème suivant. Prenez une feuille et un crayon, et écrivez l'algorithme en pseudo-code.

Problème : Écrire une fonction CompteCaractere(chaine, caractere_a_chercher) qui prend une chaîne et un caractère en entrée, et qui retourne le nombre de fois que ce caractère apparaît dans la chaîne. La recherche doit être sensible à la casse (par exemple, 'a' est différent de 'A').

• Exemple 1 : CompteCaractere("Bonjour le monde", 'o') devrait retourner 3.
• Exemple 2 : CompteCaractere("Algorithmique", 'A') devrait retourner 1.
• Exemple 3 : CompteCaractere("Mississippi", 's') devrait retourner 4.

Indice : La logique est extrêmement similaire à celle de l'algorithme pour compter les voyelles.

Fonction CompteCaractere(chaine : Chaîne, caractere_a_chercher : Caractère) : Entier
Variables
  compteur : Entier
  caractere_courant : Caractère
  i : Entier
  
Début
  // 1. Initialiser le compteur
  compteur ← 0
  
  // 2. Parcourir la chaîne
  Pour i allant de 0 à Longueur(chaine) - 1 Faire
    caractere_courant ← chaine[i]
    
    // 3. Comparer le caractère courant avec celui qu'on cherche
    Si caractere_courant = caractere_a_chercher Alors
      // 4. Mettre à jour le résultat si la condition est vraie
      compteur ← compteur + 1
    FinSi
  FinPour
  
  // 5. Retourner le résultat final
  Retourner compteur
Fin

Conclusion

Félicitations ! Vous avez terminé le module sur les tableaux et les chaînes de caractères. Vous êtes maintenant capable non seulement de manipuler des tableaux et des chaînes, mais aussi de les utiliser pour résoudre des problèmes concrets en appliquant une logique de parcours et d'analyse.

Points clés à retenir de cette leçon :

• Le patron "parcourir pour analyser" (initialiser, boucler, tester, mettre à jour) est une technique fondamentale.
• Ce patron permet de résoudre une multitude de problèmes comme le comptage d'éléments (voyelles, mots, etc.).
• Pour des problèmes comme la vérification d'un palindrome, plusieurs stratégies existent (deux pointeurs, inversion). Choisir la bonne approche fait partie de la compétence algorithmique.
• Il est crucial de définir des règles claires (gestion de la casse, des espaces, etc.) avant d'écrire l'algorithme pour éviter toute ambiguïté.

Et après ?

Dans les exercices de cette leçon, nous avons commencé à écrire nos algorithmes sous forme de Fonction, comme CompterVoyelles ou EstPalindrome. C'est une façon d'isoler une tâche dans un bloc de code réutilisable.

La prochaine leçon inaugurera un nouveau module entièrement dédié à ce concept : Fonctions et Modularité. Nous allons apprendre formellement à définir nos propres blocs de code, à leur donner des entrées (paramètres) et à en obtenir des sorties (valeurs de retour). C'est une étape absolument essentielle pour organiser vos futurs programmes et écrire du code réellement "propre" et efficace.