EXERCICES CORRIGES SUR LES CHAINES DE CARACTERES

Miroir
Écrivez une fonction qui prend en argument une chaîne de caractères, la renverse sur elle-même
("toto!" a pour miroir ''otot") et retourne l'adresse de cette chaîne.
Prototype : char * miroir (char * s);

Solution:
Il faut déjà parcourir la chaîne pour accéder à son dernier caractère. Puis permuter les couples
de caractères symétriques en évitant de le faire deux fois, ce qui laisserait la chaîne inchangée.

char * miroir ( char * s)

{
int g, d; /* indice gauche et droit de parcours */
char c;
/* recherche de l'indice du dernier caractère, on peut utiliser strlen(s) - 1
for (d = 0; s[d ] !=0; ++ d)
;
for (g = 0, --d; g < d ; ++g, --d)
{
c = s[g];
s[g]=s[d];
s[d]=c;
}
return s;
}

1
Fréquence
Écrivez une fonction qui compte le nombre d'occurrences d'un caractère c dans une chaîne s.
La fonction pourra être récursive.
Prototype : int compte (char c, char * s);

Solution: On utilise un accumulateur dans la version itérative

int compte ( char c , char * s)
{
int i, cumul = 0;
for (i = 0; s[i ] != '\0 '; ++i)
{
if (s[i] == c)
++ cumul;
}
return cumul;
}

Une fonction récursive peut être écrite selon le principe suivant :

int compte2 ( char c , char * s)
{
if ( *s == '\0 ') /* soit s [0] == '\0 ' */
return 0;
if ( (* s == c )
return 1 + compte2 (c,s +1);
return 0 + compte2 (c,s +1);
}

/* avec un test ternaire ? : */

int compte3( char c , char * s)
{
if ( *s == '\0 ') /* soit s [0] == '\0 ' */
return 0;
return ( (* s == c )? 1 : 0) + compte2 (c,s +1);
}

2
Chercher/remplacer
Écrivez une fonction qui recherche dans une chaîne chaque caractère c pour le remplacer par un
caractère r et retourne l'adresse de la chaîne.
Prototype : char * cherche_remplace (char c, char r, char * s);

Solution:
C'est un parcours simple avec remplacement lorsque l'on tombe sur le caractère à remplacer :
char * cherche_remplace ( char c , char r , char * s)
{
int i;
for (i = 0; s[i ] != '\0 '; ++i)
{
if (s[i] == c)
s[i ]= r;
}
return s;
}

3
Conversion chaîne de caractères en entier
Écrivez une fonction qui prend en argument une chaîne de caractères représentant un entier en
décimal et retourne l'entier équivalent (entrée la chaîne "123", sortie l'entier 123).
On supposera que la chaîne est correcte et représente bien un entier.
Prototype : int chaine_vers_entier (char * s);

Solution:
Une chaîne représentant un entier est composée d'une suite de caractères chiffres (compris entre
'0' et '9'), éventuellement précédée d'une caractère '-' ou '+'.
L'entier correspondant à un caractère chiffre est égal à ce caractère moins le caractère '0'.
('2'-'0' donne 2).
S'il y a un signe, on le mémorise sous le forme d'une variable valant −1 ou +1. Puis, on accumule
dans un résultat le nombre représenté selon le principe suivant :
pour chaque chiffre, on multiplie par 10 la valeur accumulée et on ajoute la valeur du chiffre.
En fin de calcul, on retourne le résultat multiplié par le signe.

int chaine_vers_entier ( char * s) Note : c'est ainsi que les fontions atoi
{ (conversion d'une chaîne en int ) et atol
int i = 0 , signe = 1 , res = 0; (conversion
if (s[i] == '+') d'une chaîne en long ) de la librairie libc opèrent.
++i; Elles permettent également la conversion
else if (s[i] == '-') d'une chaîne exprimant un nombre en base 8
{ (commençant par un 0) ou en base 16
signe = -1; (commençant
++i; par 0x ou 0X). De plus, elles interrompent le
} calcul lorsqu'elles parviennent à un caractère
non
for ( ; s[i] != '\0 '; ++i ) autorisé et retournent le résultat courant.
{
res = res * 10 + (s[i] – '0');
}
return signe * res;
}