# Tests et Chaînes de Caractères > [!video] Vidéo explicative > <iframe width="560" height="315" src="https://www.youtube.com/embed/7vAR0eFS92Q?si=SR22dTKvmLm8BY9N" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe> ## 1. Comparer des Chaînes de Caractères Une chaîne de caractères (ou *string*) est une séquence ordonnée de caractères. Elles sont utilisées pour représenter du texte. > [!definition] Chaîne de Caractères > Une chaîne de caractères est une suite finie et ordonnée de caractères. Elle est généralement délimitée par des guillemets simples ou doubles. > > ```pseudo-code > DECLARER MaChaine : CHAINE = "Bonjour le monde !" > ``` ### 3.1. Opérations Essentielles sur les Chaînes Les langages de programmation offrent des moyens fondamentaux pour interagir avec les chaînes de caractères. Pour ce cours, nous nous concentrons sur l'accès aux caractères individuels, l'extraction de sous-chaînes, et la comparaison. #### 3.1.1. Accès aux Caractères (Indexation) Chaque caractère d'une chaîne est accessible via son index, qui représente sa position dans la séquence. En programmation, l'indexation commence très souvent à $0$ pour le premier caractère. > [!note] Indexation 0-basée et longueur > Si une chaîne $S$ a $N$ caractères (sa longueur), ses index valides vont de $0$ à $N-1$. Le caractère à l'index $i$ est noté $S[i]$. La longueur d'une chaîne est souvent obtenue par une fonction `LONGUEUR(S)`. > Par exemple, pour la chaîne "PYTHON" ($N=6$): > - `P` est à l'index 0 ($S[0]$) > - `Y` est à l'index 1 ($S[1]$) > - `T` est à l'index 2 ($S[2]$) > - `H` est à l'index 3 ($S[3]$) > - `O` est à l'index 4 ($S[4]$) > - `N` est à l'index 5 ($S[5]$) ```pseudo-code mot : CHAINE = "PYTHON" premierCar : CARACTERE = mot[0] // premierCar vaudra 'P' troisiemeCar : CARACTERE = mot[2] // troisiemeCar vaudra 'T' tailleMot : ENTIER = LONGUEUR(mot) // tailleMot vaudra 6 dernierCar : CARACTERE = mot[tailleMot - 1] // dernierCar vaudra 'N' ``` > [!warning] Index hors limites (Index Out Of Bounds) > Tenter d'accéder à un index qui n'existe pas dans la chaîne (par exemple, `mot[6]` pour "PYTHON") peut provoquer une erreur d'exécution. Il est crucial de s'assurer que l'index utilisé est toujours valide (entre $0$ et $LONGUEUR(chaine)-1$). #### 3.1.2. Extraction de Sous-Chaîne L'extraction de sous-chaînes permet d'obtenir une nouvelle chaîne à partir d'une portion d'une chaîne existante. On spécifie généralement l'index de début et la longueur de la portion à extraire. > [!definition] Fonction SOUS_CHAINE > La fonction `SOUS_CHAINE(chaine, index_debut, longueur)` retourne une nouvelle chaîne contenant `longueur` caractères de `chaine`, en commençant à `index_debut`. > - `chaine`: La chaîne d'origine. > - `index_debut`: L'index du premier caractère à inclure dans la sous-chaîne (0-basé). > - `longueur`: Le nombre de caractères à extraire. ```pseudo-code phrase : CHAINE = "Apprendre la programmation" sousChaine1 : CHAINE = SOUS_CHAINE(phrase, 0, 9) // sousChaine1 vaudra "Apprendre" sousChaine2 : CHAINE = SOUS_CHAINE(phrase, 10, 2) // sousChaine2 vaudra "la" sousChaine3 : CHAINE = SOUS_CHAINE(phrase, 13, 13) // sousChaine3 vaudra "programmation" ``` > [!note] Cas particuliers et comportements > - Si `index_debut` est en dehors des limites valides de la chaîne, la fonction peut retourner une chaîne vide ou déclencher une erreur, selon le langage. > - Si la `longueur` demandée dépasse la fin de la chaîne à partir de `index_debut`, la sous-chaîne inclura tous les caractères disponibles jusqu'à la fin de la chaîne d'origine. > - Si `longueur` est $0$, une chaîne vide est retournée. #### 3.1.3. Comparaison de Chaînes Les chaînes peuvent être comparées pour l'égalité ou l'ordre. La comparaison d'ordre entre chaînes est appelée **comparaison lexicographique** (souvent perçue comme "alphabétique"). > [!definition] Ordre Lexicographique > Deux chaînes $S_1$ et $S_2$ sont comparées caractère par caractère de gauche à droite. > 1. Les chaînes sont comparées caractère par caractère à la même position $i$, en partant de $i=0$. > 2. Si à la première position $i$ où $S_1[i]$ et $S_2[i]$ sont différents, le caractère de $S_1[i]$ a une valeur numérique inférieure à $S_2[i]$ (selon leur code ASCII/Unicode), alors $S_1$ est considérée comme "inférieure" à $S_2$. Inversement, si $S_1[i]$ a une valeur supérieure, $S_1$ est "supérieure". > 3. Si les chaînes sont identiques jusqu'à la fin de la plus courte, la plus courte est considérée comme "inférieure" (par exemple, "pomme" est inférieure à "pommes"). > 4. Si toutes les paires de caractères correspondantes sont égales et que les chaînes ont la même longueur, elles sont considérées comme égales. > [!note] Base de la comparaison : Codes de caractères > L'ordre des caractères est déterminé par leur valeur numérique dans le jeu de caractères utilisé (par exemple, ASCII ou Unicode). > - En ASCII, les chiffres (`'0'` à `'9'`) ont des valeurs inférieures aux lettres majuscules (`'A'` à `'Z'`), qui ont elles-mêmes des valeurs inférieures aux lettres minuscules (`'a'` à `'z'`). > Exemple : `'0'` ($48$) < `'A'` ($65$) < `'a'` ($97$). > - Ainsi, "Apple" est lexicographiquement inférieure à "apple" car `'A'` ($65$) < `'a'` ($97$). ```pseudo-code s1 : CHAINE = "pomme" s2 : CHAINE = "poire" s3 : CHAINE = "Pomme" s4 : CHAINE = "pomme" s5 : CHAINE = "pommes" // Comparaison d'égalité SI (s1 == s2) ALORS // FAUX, car 'm' n'est pas égal à 'i' à l'index 2. SI (s1 != s2) ALORS // VRAI // Comparaison d'ordre SI (s1 < s2) ALORS // FAUX. s1[2] = 'm' (109), s2[2] = 'i' (105). 'm' > 'i', donc s1 > s2. SI (s1 > s2) ALORS // VRAI, car 'm' (109) vient après 'i' (105) en ASCII. SI (s1 == s3) ALORS // FAUX, car 'p' (minuscule) n'est pas égal à 'P' (majuscule). SI (s1 > s3) ALORS // VRAI, car 'p' (112) vient après 'P' (80) en ASCII. SI (s1 == s4) ALORS // VRAI, les chaînes sont identiques. SI (s1 < s5) ALORS // VRAI, car "pomme" est un préfixe de "pommes". ``` > [!tip] Importance de la casse > La comparaison lexicographique est **sensible à la casse** par défaut. "Apple" n'est pas la même chose que "apple", et leur ordre sera déterminé par la valeur ASCII/Unicode de leurs premiers caractères différents. Si une comparaison insensible à la casse est requise, il faut d'abord convertir les deux chaînes en majuscules ou minuscules (par exemple, `TO_MAJUSCULES(chaine)`) avant de les comparer. ## 4. Résumé Ce chapitre a couvert les fondamentaux des tests et des chaînes de caractères en algorithmique, en se concentrant sur des opérations spécifiques pour les chaînes : - Les **tests** (`SI`, `SINON`, `SINON_SI`) permettent de contrôler le flux d'exécution d'un algorithme en fonction de conditions booléennes, construites avec des opérateurs de comparaison et logiques. - Les **chaînes de caractères** sont des séquences de texte sur lesquelles on peut effectuer des opérations essentielles : - L'**accès aux caractères individuels** par leur index (généralement 0-basé), permettant d'examiner chaque composant textuel. - L'**extraction de sous-chaînes** pour isoler des portions de texte spécifiques, définies par un index de début et une longueur. - La **comparaison de chaînes** selon l'ordre lexicographique, pour évaluer l'égalité, l'inégalité ou l'ordre "alphabétique", en se basant sur la valeur numérique des caractères (ASCII/Unicode). La combinaison de ces deux concepts est essentielle pour écrire des algorithmes interactifs et robustes, capables de traiter et de réagir à des données textuelles de manière précise, une compétence que vous approfondirez avec des langages de programmation. ## 🗓️ Historique > **Dernière mise à jour :** `26 octobre 2025` > **Rédigé par :** [[Julien DUQUENNOY]]