Chaînes de caractères

Une chaîne de caractères est un tableau de caractères. Leur manipulation est analogue à celle d’un tableau à une
dimension. La fin de la chaîne de caractères est marquée par le caractère ‘\0’.

Exemple :
Algorithme qui lit une chaîne de caractères, affiche les cinq premiers caractères de la chaîne et tous les caractères
de la chaîne.

Algorithme
Début
var i : entier
ch[20] : chaîne de caractères
écrire("Donner une chaîne de caractères :")
lire(ch)
si (ch[0] != '\0')
alors i0
écrire("Les cinq premiers caractères de la chaîne : ")
tant que (i < 5 et ch[i] != '\0') faire
écrire(ch[i])
ii+1
ftq
i0
écrire("la chaine lue")
tant que (ch[i]) faire
écrire(ch[i])
ii+1
ftq
sinon écrire("La chaîne est vide")
fsi
fin

Exercice 1 :
Algorithme qui saisit une chaîne de caractères et affiche le nombre de 'e' et d'espaces dans la chaîne de
caractères.
Algorithme
const entier max=100
procedure compter(t[max] : string , var c1 : entier , var c2 : entier)
début
var i : entier
c1  0 ; c2  0 ; i  0
tant que (t[i]) faire
si (t[i]='e' ou t[i]='E') alors c1  c1 + 1 fsi
si (t[i]=' ') alors c2  c2 + 1 fsi
ii+1
ftq
fin
/* Algorithme principal */
début
var n , m : entier
t[max] : string
écrire("Donner une chaine de caractères : ")
lire(ch)
si (ch[i] != '\0')
compter (t , n , m)
écrire("Nombre de e dans la chaîne : ", n)
écrire("Nombre d'espaces dans la chaîne : ", m)
sinon écrire("Chaîne vide")
fsi
fin
Exercice 2 :
Algorithme qui retire les espaces d'une chaîne de caractères donnée.
Algorithme qui retire les espaces dans une autre chaîne de caractères :
const entier max=100
procedure etirer_espaces (t1[max] : string , var t2[max] : string)
début
var i , j : entier
i0;j0
tant que (t1[i] != '\0') faire
si (t1[i] != ' ')
t2[j]  t1[i]
jj+1
fsi
ii+1
ftq
t2[j]  '\0'
fin
/*Algorithme principal */
dédut
var t1[max] , t2[max] : string
écrire("Donner une chaîne de caractères : ")
lire(t1)
si (t1[0])
alors écrire("La chaîne lue : ")
écrire(t1)
retirer_espaces(t1 , t2)
écrire("La chaîne lue sans les espaces : ")
écrire(t2)
sinon écrire("Chaîne vide")
fsi
fin
Algorithme qui retire les espaces dans la même chaîne de caractères :
const entier max=100
procedure RetirerEspaces (var t[max] : string)
début
var i , j : entier
i0;j0
tant que (t[i] != '\0') faire
si (t[i] != ' ')
t[j]  t[i]
jj+1
fsi
ii+1
ftq
t[j]  '\0'
fin
/*Algorithme principal */
dédut
var v[max] : string
écrire("Donner une chaîne de caractères : )
lire(v)
si (v[0])
alors écrire("La chaîne lue : ")
écrire(v)
RetirerEspaces(v)
écrire("La chaîne lue sans les espaces : ")
écrire(v)
sinon écrire("Chaîne vide")
fsi
fin
Exercice 3 :
Algorithme qui permet de déterminer si un texte de n caractères contient dans l'ordre les lettres d'un mot de m
caractères.

Algoritme :
Const entier max = 100
fonction contenir(t[max] : string , mot[max] : string) : entier
début
var i, j, n, m : entier
n  strlen(t) – 1
m  strlen(mot) -1
i0 ; j0
tant que (i < =n et j <= m) faire
si (t[i] = mot[j])
alors j  j + 1
fsi
ii+1
ftq
si (j = m+1)
alors contenir  1
sinon contenir  0
fsi
fin
/* Algorithme principal */
début
var t[max], mot[max] : string
écrire("Donner une chaîne de caractères : ")
lire(t)
écrire("Donner un mot : ")
lire(mot)
si (t[0] != '\0' et mot[0] != '\0')
alors si (contenir(t , mot))
alors écrire("Le mot ", mot, " est caché dans le texte ", texte)
sinon écrire("Le mot ne se trouve pas dans le texte")
fsi
sinon écrire("le texte et le mot ne doivent pas être des chaînes vides")
fsi
fin

Exercice 4 :
Algorithme qui teste si un mot est un palindrome.
Un mot est un palindrome est un mot qui se lit de la même façon à l'endroit et à l'envers.
exemple : radar , elle
Algorithme :
const entier max = 100
fonction palindrome (t[max] : string) : entier
début
var i, j, pal : entier
i0
j  strlen(t) – 1
pal  1
tant que (i<j et pal) faire
si (t[i] = t[j])
alors i  i + 1
jj–1
sinon pal  0
fsi
ftq
palindrome  pal
fin
/* Algorithme principal */
début
var t[max] : string
écrire("Donner une chaîne de caractères : ")
lire(t)
si (t[0] != '\0')
alors si (palindrome(t))
alors écrire(t, " est un palindrome")
sinon écrire(t, " n'est pas un palindrome")
fsi
sinon écrire("La chaîne est vide")
fsi
fin

Exercice 5 :
Algorithme qui lit une chaîne de caractères et affiche le nombre d'occurrence des caractères qui se répètent
successivement dans la chaîne.
Exemple :
Chaîne lue : bxiiikkkkdccbbbe
Résultat affiché : 1b 1x 3i 4k 1d 2c 3b 1e

Algorithme
const entier max=100
procedure NbreOccurence (t[max] : string)
début
var i, n : entier
x : char
i0
tant que (t[i]) faire
x  t[i]
n 0
tant que (t[i] et x=t[i]) faire
nn+1
ii+1
ftq
écrire(n, x, ' ')
ftq
fin
/* Algorithme principal */
début
var ch[max] : string
écrire("Donner une chaîne de caractères : ")
lire(ch)
si (ch[0])
alors écrire("La chaîne ", ch, " contiendra : ")
NbreOccurence(ch)
sinon écrire("La chaîne est vide")
fsi
fin

Exercice 6 :
Algorithme qui calcule la fréquence de l'utilisation de chaque lettre de l'alphabet utilisé dans un texte donné.

Algorithme
const entier max = 200
car alphabet[52]={'a','b',……………………………….….,'z','A','B',……………………………………….'Z'}
procedure CalculeOccurrence(t[max] : string , var oc[26] : entier, var NbLettres : entier)
début
var i, j, c : entier
 pour i = 0 à 25 faire
oc[i]  0
fpour
i  0 ; Nblettres  0
tant que (t[i]) faire
j0
c0
tant que (j<26 et !c) faire
si (t[i] = alphabet[j] ou t[i] = alphabet[j + 26])
alors c  1
sinon j  j + 1
fsi
ftq
if (c)
alors oc[j]  oc[j] + 1
NbLettres  NbLettres + 1
fsi
i i + 1
ftq
fin

procedure AfficheOccurrence (oc[26] : entier)

début
var i : entier
pour i = 0 à 25 faire
si (oc[i])
alors écrire(alphabet[i] , oc[i])
fsi
fpour
fin

procedure AfficheFrequence (oc[26] : entier, NbLettres : entier)

début
var i : entier
pour i = 0 à 25 faire
si (oc[i])
alors écrire(alphabet[i] , oc[i]/NbLettres*100, " %")
fsi
fpour
fin

/* Algorithme principal */
début
var NbLettres : entier
t[max] : string
oc[26] : entier
écrire("Donner une chaîne de caractères : ")
lire(t)
si (t[0])
alors CalculeOccurence (t, oc, NbLettres)
écrire("Occurrence de l’utilisation de chaque lettre de l'alphabet")
écrire("Lettre de l'alphabet", "Occurrence de l’utilisation de la lettre")
AfficheOccurene (oc)
écrire("Fréquence de l’utilisation de chaque lettre de l'alphabet")
écrire("Lettre de l'alphabet", "Fréquence de l’utilisation de la lettre")
AfficheFrequence(oc, NbLettres)
sinon écrire("La chaîne est vide")
fsi
fin