Concaténation de chaînes de caractères

Introduction

Aujourd'hui, nous passons de l'analyse à la construction. L'objectif de cette leçon est de vous apprendre à construire une nouvelle chaîne de caractères en assemblant des caractères ou d'autres chaînes. Cette opération fondamentale s'appelle la concaténation.

Savoir construire des chaînes est essentiel. Cela vous permettra de formater des messages pour les afficher à un utilisateur (par exemple, "Bonjour Jean, vous avez 3 nouveaux messages"), de manipuler et réorganiser des données textuelles, ou de transformer une information d'un format à un autre. C'est une brique de base pour rendre vos algorithmes plus dynamiques et interactifs.

1. La concaténation : assembler des chaînes

La concaténation est l'action de mettre bout à bout deux ou plusieurs chaînes de caractères pour en former une nouvelle. L'opérateur le plus commun pour réaliser cette action, que ce soit en pseudo-code ou dans de nombreux langages de programmation, est le signe +.

Par exemple :

• "Bonjour" + " " + "le monde" donnera la nouvelle chaîne "Bonjour le monde".
• Si prenom ← "Alex", alors "Salut " + prenom donnera "Salut Alex".

Pour bien comprendre ce qui se passe, l'article suivant vous montre des exemples concrets de cette opération.

L'image ci-dessous illustre ce processus. Imaginez que chaine1 contienne "Salut" et chaine2 contienne "Mateo". La concaténation consiste à prendre les caractères de chaine2 et à les ajouter à la fin de chaine1.

Une règle importante : on ne mélange pas les types !

Une erreur fréquente chez les débutants est de vouloir concaténer une chaîne avec un nombre.
"Votre score est : " + 100
La plupart des langages refuseront cette opération car ils ne savent pas comment "additionner" du texte et un nombre. Il faut d'abord convertir le nombre en une chaîne de caractères.

En pseudo-code, nous utiliserons une fonction NombreVersChaine().
L'opération correcte serait donc :
"Votre score est : " + NombreVersChaine(100) ce qui produira bien la chaîne "Votre score est : 100".

L'article que vous avez commencé à lire montre exactement cette situation.

2. Construire une chaîne pas à pas

La véritable puissance de la concaténation se révèle lorsqu'on l'utilise à l'intérieur d'une boucle. Le principe est simple mais très efficace :

1. On initialise une chaîne de caractères vide.
2. On parcourt une autre structure (une autre chaîne, un tableau, etc.).
3. À chaque étape de la boucle, on ajoute un caractère ou une petite chaîne à notre chaîne en construction.

Exemple : Inverser une chaîne

C'est l'exemple classique pour illustrer cette technique. Pour inverser une chaîne comme "ALGO", nous allons :

1. Créer une chaîne vide inverse ← "".
2. Parcourir "ALGO" caractère par caractère ('A', 'L', 'G', 'O').
3. Pour chaque caractère, l'ajouter au début de inverse.
   • Après 'A' : inverse devient "A".
   • Après 'L' : inverse devient "L" + "A" -> "LA".
   • Après 'G' : inverse devient "G" + "LA" -> "GLA".
   • Après 'O' : inverse devient "O" + "GLA" -> "OGLA".

Le document suivant vous présente l'algorithme formel pour cette opération.

3. Construire une chaîne à partir de sous-chaînes

Parfois, on ne veut pas construire une chaîne caractère par caractère, mais en assemblant des morceaux plus gros, appelés sous-chaînes (ou substrings en anglais).

Pour cela, on utilise une fonction que l'on notera Sous_Chaine(chaine, index_debut, longueur). Elle extrait une partie de chaine en partant de index_debut sur une certaine longueur.

• Sous_Chaine("ALGORITHME", 0, 4) renverrait "ALGO".
• Sous_Chaine("ALGORITHME", 4, 6) renverrait "RITHME".

L'exercice suivant est un cas d'usage très parlant : inverser l'ordre du nom et du prénom.

4. À vous de pratiquer !

Votre préférence pour la pratique est un excellent atout. Mettons en application ces concepts avec deux exercices. Essayez de les résoudre sur papier avant de regarder la solution.

Exercice 1 : La fonction Miroir

En vous inspirant de l'algorithme d'inversion, écrivez une fonction Miroir(chaine_entree) qui retourne une nouvelle chaîne contenant les caractères de chaine_entree dans l'ordre inverse.

• Miroir("BONJOUR") doit retourner "RUOJNOB".
• Miroir("KAYAK") doit retourner "KAYAK".

Indice : L'algorithme est presque identique à celui que vous avez étudié. La seule différence est que le résultat doit être retourné par la fonction, et non affiché.

Fonction Miroir(chaine_entree : Chaîne) : Chaîne
Variables
  chaine_inverse : Chaîne
  caractere_courant : Caractère
  i : Entier
  
Début
  // 1. Initialiser une chaîne vide
  chaine_inverse ← ""
  
  // 2. Parcourir la chaîne d'entrée
  Pour i allant de 0 à Longueur(chaine_entree) - 1 Faire
    caractere_courant ← chaine_entree[i]
    
    // 3. Ajouter chaque caractère au début de la nouvelle chaîne
    chaine_inverse ← caractere_courant + chaine_inverse
  FinPour
  
  // 4. Retourner le résultat final
  Retourner chaine_inverse
Fin

Exercice 2 : Supprimer un caractère

Écrivez une fonction SupprimeOccurrences(chaine_originale, car_a_supprimer) qui retourne une nouvelle chaîne de caractères, identique à la chaîne originale, mais où toutes les occurrences du caractère car_a_supprimer ont été enlevées.

• SupprimeOccurrences("PROGRAMMATION", 'M') doit retourner "PROGRATION".
• SupprimeOccurrences("Bonjour le monde", 'o') doit retourner "Bnjur le mnde".

Indice : La logique est très similaire. Parcourez la chaîne originale caractère par caractère. Si le caractère courant est différent de celui à supprimer, alors concaténez-le à votre nouvelle chaîne.

Fonction SupprimeOccurrences(chaine_originale : Chaîne, car_a_supprimer : Caractère) : Chaîne
Variables
  nouvelle_chaine : Chaîne
  caractere_courant : Caractère
  i : Entier
  
Début
  // 1. Initialiser une chaîne vide
  nouvelle_chaine ← ""
  
  // 2. Parcourir la chaîne d'entrée
  Pour i allant de 0 à Longueur(chaine_originale) - 1 Faire
    caractere_courant ← chaine_originale[i]
    
    // 3. Ajouter le caractère seulement s'il est différent de celui à supprimer
    Si caractere_courant ≠ car_a_supprimer Alors
      nouvelle_chaine ← nouvelle_chaine + caractere_courant
    FinSi
  FinPour
  
  // 4. Retourner le résultat
  Retourner nouvelle_chaine
Fin

Conclusion

Excellent travail ! Vous maîtrisez maintenant une compétence essentielle : la construction de chaînes de caractères. En combinant la concaténation avec des boucles et des conditions, vous pouvez transformer, filtrer et créer n'importe quel type de texte.

Les points clés à retenir :

• La concaténation est l'assemblage de chaînes, réalisé le plus souvent avec l'opérateur +.
• Il est crucial de s'assurer que tous les éléments sont de type Chaîne avant de les concaténer. Utilisez une fonction comme NombreVersChaine() si besoin.
• Le patron algorithmique le plus courant consiste à initialiser une chaîne vide et à la construire progressivement à l'intérieur d'une boucle.
• L'extraction de sous-chaînes permet d'assembler des morceaux plus importants d'une chaîne existante.

Et après ?

Maintenant que vous savez analyser une chaîne (leçon précédente) et en construire de nouvelles (cette leçon), vous avez tous les outils pour résoudre des problèmes algorithmiques plus complexes basés sur le texte. Dans la prochaine leçon, nous mettrons tout cela en pratique pour résoudre des défis classiques, comme compter le nombre de voyelles dans une phrase ou vérifier si un mot est un palindrome. La fonction Miroir que vous avez écrite aujourd'hui sera particulièrement utile