Logique de programmation : algorithmes du quotidien sur chaînes de caractères

Objectif : manipuler du texte comme des données

Une chaîne de caractères (texte) peut être traitée comme une suite de symboles : lettres, espaces, ponctuation, chiffres, accents. En logique de programmation, on manipule une chaîne comme on manipule une liste : on peut mesurer sa longueur, la parcourir caractère par caractère, construire une nouvelle chaîne, détecter des motifs simples et compter des éléments.

Notions pratiques sur les chaînes

Dans ce chapitre, on adopte des règles explicites (vous pourrez les modifier selon vos besoins) : (1) La casse (maj/min) est ignorée quand on compare des lettres. (2) Les espaces et la ponctuation peuvent être soit conservés, soit ignorés selon l’exercice. (3) Les accents : on choisit de les traiter comme des lettres distinctes (ex. « é » n’est pas « e ») sauf si l’exercice précise une normalisation.

Longueur d’une chaîne

La longueur est le nombre de caractères. Attention : selon les environnements, certains caractères spéciaux (emoji, lettres composées) peuvent compter différemment. Ici, on reste sur des phrases usuelles (lettres latines, accents, ponctuation).

longueur(texte) -> nombre de caractères (espaces inclus)

Exemple : « Salut ! » contient 7 caractères (S a l u t espace !).

Parcours caractère par caractère

Parcourir une chaîne consiste à lire chaque caractère dans l’ordre. C’est la base pour compter, filtrer, transformer.

Continuez dans notre application.

Vous pouvez écouter le livre audio écran éteint, recevoir un certificat gratuit pour ce cours et accéder également à 5 000 autres cours en ligne gratuits.

Ou poursuivez votre lecture ci-dessous...

Téléchargez l'application

pour chaque caractère c dans texte : traiter(c)

Deux techniques fréquentes : (1) parcours direct (caractère par caractère), (2) parcours par index (i de 0 à longueur-1) si vous avez besoin de regarder le caractère précédent/suivant.

Construire une nouvelle chaîne

On construit souvent un nouveau texte en ajoutant des caractères ou des morceaux au fur et à mesure.

resultat = ""  // chaîne vide au départ
pour chaque caractère c :
  si condition : resultat = resultat + c

Astuce logique : séparez la décision (garder/remplacer) de l’action (ajouter au résultat).

Détection de motifs simples

Un motif simple peut être : « ce caractère est une lettre », « ce caractère est un espace », « ce mot est interdit », « les deux extrémités correspondent ». On peut aussi chercher une sous-chaîne, mais dans ce chapitre on privilégie des règles simples et explicites.

Comptage

Compter revient à incrémenter un compteur quand une condition est vraie.

compteur = 0
pour chaque élément :
  si condition : compteur = compteur + 1

Règles utilitaires (références pour les exercices)

Jeu de voyelles choisi

Pour les exercices de voyelles/consonnes, on choisit l’ensemble suivant (minuscules) : a, e, i, o, u, y et leurs variantes accentuées courantes : à â ä, é è ê ë, î ï, ô ö, ù û ü, ÿ. On ignore la casse en convertissant au préalable en minuscules.

VOYELLES = {a, à, â, ä, e, é, è, ê, ë, i, î, ï, o, ô, ö, u, ù, û, ü, y, ÿ}

Définition de « lettre »

Règle simple : on considère comme lettres les caractères a–z et les lettres accentuées listées ci-dessus, plus c, ç, n, ñ… (selon votre besoin). Pour rester cohérent et testable, dans les exercices ci-dessous on comptera comme lettres : (1) les voyelles de VOYELLES, (2) les consonnes parmi les lettres latines de base a–z, plus ç. Tout le reste (espaces, apostrophes, tirets, ponctuation, chiffres) est « non-lettre ».

Gestion de la casse

Quand on compare des lettres, on convertit d’abord en minuscules : texte_min = minuscules(texte).

Gestion des espaces et de la ponctuation

Selon l’exercice : (1) soit on ignore espaces/ponctuation pour l’analyse, (2) soit on les conserve dans le résultat (ex. filtrage), (3) soit on les utilise comme séparateurs (ex. initiales). Chaque exercice précise sa règle.

Exercice 25 — Compter voyelles et consonnes dans une phrase

Énoncé

Écrire un algorithme qui prend une phrase et retourne : nombre de voyelles, nombre de consonnes. Règles choisies : (1) on ignore la casse, (2) on ignore tout ce qui n’est pas une lettre (espaces, ponctuation, chiffres), (3) les voyelles sont celles de l’ensemble VOYELLES défini plus haut, (4) une consonne est une lettre qui n’est pas une voyelle.

Étapes

• Mettre la phrase en minuscules.
• Initialiser nb_voyelles = 0, nb_consonnes = 0.
• Parcourir chaque caractère c de la phrase.
• Si c est une voyelle, incrémenter nb_voyelles.
• Sinon si c est une lettre (selon votre règle), incrémenter nb_consonnes.
• Sinon : ne rien faire (ponctuation, espace…).

Pseudo-code

fonction compter_voyelles_consonnes(phrase):
  p = minuscules(phrase)
  nb_v = 0
  nb_c = 0
  pour chaque caractère c dans p:
    si c dans VOYELLES:
      nb_v = nb_v + 1
    sinon si est_lettre(c):
      nb_c = nb_c + 1
  retourner (nb_v, nb_c)

fonction est_lettre(c):
  // règle simple et testable
  si c entre 'a' et 'z': retourner vrai
  si c == 'ç': retourner vrai
  si c dans VOYELLES: retourner vrai
  retourner faux

Tests (accents, ponctuation, espaces)

Remarque de logique : si vous souhaitez traiter « y » comme consonne dans certains contextes, retirez-le de VOYELLES et vos tests doivent changer en conséquence.

Exercice 26 — Vérifier si une chaîne est un palindrome (version simple)

Énoncé

Écrire un algorithme qui indique si une chaîne est un palindrome. Règles choisies (version simple) : (1) on ignore la casse, (2) on ignore les espaces, (3) on ne retire pas la ponctuation (donc « kayak! » n’est pas palindrome), (4) on ne normalise pas les accents (donc « é » ≠ « e »).

Étapes (méthode par filtrage + comparaison)

• Mettre la chaîne en minuscules.
• Construire une nouvelle chaîne s en gardant uniquement les caractères qui ne sont pas des espaces.
• Comparer s avec son inverse (ou comparer symétriquement les extrémités).

Pseudo-code (comparaison symétrique)

fonction est_palindrome_simple(texte):
  t = minuscules(texte)
  s = ""
  pour chaque caractère c dans t:
    si c != ' ':
      s = s + c

  i = 0
  j = longueur(s) - 1
  tant que i < j:
    si s[i] != s[j]:
      retourner faux
    i = i + 1
    j = j - 1
  retourner vrai

Tests (espaces, casse, ponctuation, accents)

Variante possible (non appliquée ici) : ignorer aussi la ponctuation. Dans ce cas, il faut définir précisément quels caractères sont supprimés.

Exercice 27 — Extraire des initiales à partir d’un nom complet

Énoncé

Écrire un algorithme qui prend un nom complet et retourne ses initiales en majuscules, séparées par des points. Règles choisies : (1) les mots sont séparés par un ou plusieurs espaces, (2) on ignore les espaces en début/fin et les espaces multiples, (3) les traits d’union sont traités comme séparateurs (ex. « Jean-Pierre » → J.P.), (4) les apostrophes ne séparent pas (ex. « d'Artagnan » → D. si on considère « d'Artagnan » comme un seul mot, ou D.A. si on choisit de séparer ; ici on choisit de ne pas séparer sur apostrophe), (5) on conserve les lettres accentuées comme lettres.

Étapes (parcours + détection de début de mot)

• Nettoyer la chaîne : on peut travailler directement sans supprimer, en détectant les débuts de mots.
• Définir un état au_debut = vrai (on est au début d’un mot).
• Parcourir chaque caractère c.
• Si c est un séparateur (espace ou tiret), alors au_debut = vrai.
• Sinon, si au_debut est vrai et c est une lettre, ajouter majuscule(c) + « . » au résultat, puis mettre au_debut = faux.
• Sinon continuer (on est au milieu d’un mot).

Pseudo-code

fonction initiales(nom_complet):
  res = ""
  au_debut = vrai
  pour chaque caractère c dans nom_complet:
    si c == ' ' ou c == '-':
      au_debut = vrai
    sinon:
      si au_debut == vrai et est_lettre(c):
        res = res + majuscule(c) + "."
        au_debut = faux
      sinon:
        // on reste dans le mot
        rien
  retourner res

Tests (espaces multiples, tirets, accents, apostrophes)

Si vous préférez séparer sur apostrophe, ajoutez ' à la liste des séparateurs et adaptez les tests (d'Artagnan → D.A.).

Exercice 28 — Remplacer des mots interdits par « *** » (filtrage basique)

Énoncé

Écrire un algorithme qui remplace certains mots interdits dans une phrase par « *** ». Règles choisies : (1) comparaison insensible à la casse, (2) on remplace uniquement des mots entiers, pas des sous-parties (ex. mot interdit « chat » ne doit pas censurer « chaton »), (3) la ponctuation est conservée, (4) les séparateurs de mots sont : espace et ponctuation simple (.,;:!?()"), (5) les accents ne sont pas normalisés (donc « méchant » et « mechant » sont différents sauf si vous ajoutez une normalisation).

Idée : tokeniser en mots + séparateurs

Pour remplacer des mots entiers tout en conservant la ponctuation, une approche simple consiste à parcourir la phrase et à construire des « jetons » : des séquences de lettres (un mot) et des séquences de non-lettres (séparateurs). On ne remplace que les jetons qui sont des mots.

Étapes

• Préparer la liste des mots interdits en minuscules (ex. ["idiot", "nul"]).
• Parcourir la phrase caractère par caractère.
• Construire un jeton courant courant et un type type (MOT ou SEP).
• Quand le type change (lettre → non-lettre ou l’inverse), finaliser le jeton : si c’est un MOT et qu’il est interdit (en minuscules), ajouter « *** » au résultat, sinon ajouter le jeton original.
• À la fin, finaliser le dernier jeton.

Pseudo-code

fonction filtrer_mots_interdits(phrase, interdits):
  // interdits : liste de mots en minuscules
  res = ""
  courant = ""
  type = ""  // "MOT" ou "SEP"

  pour chaque caractère c dans phrase:
    estMot = est_lettre(c)
    nouveauType = si estMot alors "MOT" sinon "SEP"

    si type == "":
      type = nouveauType

    si nouveauType != type:
      // finaliser le jeton courant
      si type == "MOT" et minuscules(courant) dans interdits:
        res = res + "***"
      sinon:
        res = res + courant
      courant = ""
      type = nouveauType

    courant = courant + c

  // finaliser le dernier jeton
  si courant != "":
    si type == "MOT" et minuscules(courant) dans interdits:
      res = res + "***"
    sinon:
      res = res + courant

  retourner res

Tests (casse, ponctuation, mots entiers, accents)

Si vous souhaitez normaliser les accents (traiter « mechant » comme « méchant »), vous devez définir une fonction de normalisation (ex. remplacer é→e, è→e, ê→e, etc.) et l’appliquer à la fois aux interdits et aux mots extraits avant comparaison.