Écrire l'algorithme de la fonction majuscule qui permet de transformer une chaine de caractères quelconque en son équivalent majuscule.

fonction majuscule (entrée : phrase est une chaine de car) retourne une chaine de car
données
  Resultat est une chaine de car
  IndexCar est un entier
début
  Resultat <-- ""
  pour IndexCar <-- 1 à longueur (phrase) faire
     Resultat <-- Resultat + CarMajuscule(phrase[IndexCar])
  fin pour
  retourner Resultat
fin

fonction CarMajuscule (UnCar est un caractère) retourne un caractère
donnée
  Resultat est un caractère
début
  Resultat <-- UnCar
  si ((UnCar >= 'a') ET (UnCar <= "z")) alors
    Resultat <-- CodeCar(CodeAscii(UnCar) - CodeAscii("a") + CodeAscii("A")
  sinon
    si ((UnCar = "à") OU (UnCar = "â") OU (UnCar = "ä") OU
        (UnCar = "À") OU (UnCar = "Â") OU (UnCar = "Ä")) alors
      Resultat <-- "A"
    sinon
      si ((UnCar = "é") OU (UnCar = "è") OU (UnCar = "ë") OU (UnCar = "ê") OU
          (UnCar = "É") OU (UnCar = "È") OU (UnCar = "Ë") OU (UnCar = "Ê")) alors
        Resultat <-- "E"
      sinon
        // continuer le même principe avec les i, o, u, c (cédille), les tilde...
      fin si
    fin si
  fin si
fin

Écrire l'algorithme de la fonction CompterMots qui permet de savoir combien de mots sont contenus dans une chaine de caractères quelconque.

fonction CompterMots (entrée : phrase est une chaine de car) retourne ue chaine de car

Le principe de base est simple : il suffit de compter les espaces et d'ajouter 1 pour connaître le nombre de mots. En pratique, cette méthode se heurte à plusieurs problèmes :

• Les symboles de ponctuation ne doivent pas être considérés comme des mots
• L'apostrophe sépare deux mots sans qu'il y ait d'espace
• Il peut y avoir plusieurs espaces consécutifs, des espaces en tête de phrase ou encore en fin de phrase

Avant de compter les espaces (et d'ajouter 1) il faut donc résoudre tous ces problèmes en mettant en oeuvre successivement les traitements suivants :

1. Passer la phrase en majuscule (cela permettra de supprimer tous les accents) ;
2. Remplacer tous les caractères qui ne sont pas des caractères alphabétiques par des espaces (cela permet de supprimer tous les symboles de ponctuation (apostrophe comprise) ;
3. Supprimer tous les caractères "espace" qui pourraient se trouver en début de phrase ;
4. Supprimer tous les caractères "espace" qui pourraient se trouver en fin de phrase ;
5. Supprimer tous les espaces consécutifs pour n'en garder qu'un seul ;
6. Le nombre de mots est donc maintenant égal au nombre d'espaces + 1.

L'étape 1 est déjà résolue par la fonction Majuscule ci-dessus.
L'étape 2 nécessite une fonction VirerPonctuation (entrée : phrase est une chaine de car) qui retourne une chaine de car
L'étape 3 nécessite une fonction VirerEspacesDebut (entrée : phrase est une chaine de car) qui retourne une chaine de car
L'étape 4 nécessite une fonction VirerEspacesFin (entrée : phrase est une chaine de car) qui retourne une chaine de car
L'étape 5 nécessite une fonction VirerEspacesConsecutifs (entrée : phrase est une chaine de car) qui retourne une chaine de car

L'étape 6 correspond à la fonction CompterMots qui est demandée :

fonction CompterMots (entrée : phrase est une chaine de car) retourne un entier
données
  PhraseTmp est une chaine de car
  Resultat est un entier
début
  PhraseTmp <-- Majuscule (phrase)
  PhraseTmp <-- VirerPonctuation (PhraseTmp)
  PhraseTmp <-- VirerEspacesDebut (PhraseTmp)
  PhraseTmp <-- VirerEspacesFin (PhraseTmp)
  PhraseTmp <-- VirerEspacesConsecutifs (PhraseTmp)

  Resultat <-- 0
  pour indexCar <-- 1 à longueur(phraseTmp) faire
    si (phraseTmp[IndexCar] = " ") alors
      Resultat <-- Resultat + 1
    fin si
  fin pour

  retourner (Resultat +1)
fin

fonction VirerPonctuation (entrée : phrase est une chaine de car) retourne une chaine de car
donnée
   indexCar est un entier
début
  pour indexCar <-- 1 à longueur (phrase) faire
    si pas ((phrase[indexCar] >= "A") ET (phrase[indexCar] <= "Z")) alors
      phrase[indexCar] <-- " "
    fin si
  fin pour
  retourner phrase
fin

fonction VirerEspacesDebut (entrée : phrase est une chaine de car) retourne une chaine de car
début
  si (phrase <> "") alors
    répéter
      si (phrase[1] = " ") alors
        effacerCar (phrase, 1)
      fin si
    jusqu'à ((phrase = "") OU (phrase[1] <> " "))
  fin si
  retourner phrase
fin

Si on utilise une structure TANT QUE, il est possible de simplifier l'écriture de l'algorithme précédent (l'écriture rouge indique ce qu'il faudra modifier pour écrire la fonction VirerEspacesFin) :

fonction VirerEspacesDebut (entrée : phrase est une chaine de car) retourne une chaine de car
début
  tant que ((phrase <> "") ET (phrase[1] = " ")) faire
    effacerCar (phrase, 1)
  fin tant que
  retourner phrase
fin

La procédure effacerCar permet d'effacer un caractère à l'intérieur d'une chaine de caractères. Si le numéro du caractère à effacer n'est pas compris entre 1 et la taille de la chaine de caractères, aucun caractère ne sera supprimé.

procédure effacerCar (entrée/sortie : phrase est une chaine de car
                      entrée        : numCar est un entier)
données
  phraseTmp est une chaine de car
  indexCar est un entier
début
  phraseTmp <-- ""
  pour indexCar <-- 1 à longueur(phrase) faire
    si (indexCar <> numCar) alors
      phraseTmp <-- phraseTmp + phrase[indexCar]
    fin si
  fin pour
  phrase <-- phraseTmp
fin

La fonction VirerEspacesFin utilise le même principe que la fonction VirerEspacesDebut, seul l'algorithme mettant en oeuvre la structure TANT QUE est donné ici (l'écriture rouge montre les différence par rapport à la fonction VirerEspaceDebut) :

fonction VirerEspacesFin (entrée : phrase est une chaine de car) retourne une chaine de car
début
  tant que ((phrase <> "") ET (phrase[longueur(phrase)] = " ")) faire
    effacerCar (phrase, longueur(phrase))
  fin tant que
  retourner phrase
fin

Fonction VirerEspacesConsecutifs

Correction faite en classe

fonction vireresepaceconsecutif (entrée : phrase est une chaine de car) retourne une chaine de car
données
  indexCar est un entier
debut
  indexcar <-- 1

  tant que ((phrase <> "") et (indexCar < longueur(phrase))) faire
    si (phrase[indexcar] = " ") alors
      tant que (indexcar < longueur(phrase)) et (phrase[indexcar+1]=" ") alors
        effacerCar(phrase,indexcar+1)
      fin tant que
    fin si
    indexcar <-- indexcar + 1
  fin tant que

  retourner phrase
fin

Il est possible de simplifier l'écriture de l'algo précédent

fonction VirerEspacesConsecutifs (entrée : phrase est une chaine de car) retourne une chaine de car
donnée
  indexCar est un entier
début
  indexCar <-- 1
  tant que (indexCar < longueur(phrase)) faire
    si ((phrase[indexCar] = " ") ET (phrase[indexCar + 1] = " ")) alors
      effacerCar (phrase, indexCar + 1)
    sinon
      indexCar <-- indexCar + 1
    fin si
  fin tant que

  retourner phrase
fin

Un palindrome est une phrase qui peut se lire dans les deux sens (de gauche à droite ou de droite à gauche) :

Elle
Laval
Ésope reste ici et se repose

Écrire l'algorithme de la fonction EstPalindrome qui vérifie sir une chaine de caractères quelconque contient un palindrome :

fonction EstPalindrome (entrée : phrase est une chaine de car) retourne un booléen